b65b205fbc
The fmemopen implementation does not account the file position correctly in
append mode. The following example shows the failure:
===
int main ()
{
char buf[10] = "test";
FILE *fp = fmemopen (buf, 10, "a+");
fseek (fp, 0, SEEK_SET);
int gr;
if ((gr = getc (fp)) != 't' ||
(gr = getc (fp)) != 'e' ||
(gr = getc (fp)) != 's' ||
(gr = getc (fp)) != 't' ||
(gr = getc (fp)) != EOF)
{
printf ("%s: getc failed returned %i\n", __FUNCTION__, gr);
return 1;
}
return 0;
}
===
This is due both how read and write operation update the buffer position,
taking in consideration buffer lenght instead of maximum position defined
by the open mode. This patch fixes it and also fixes fseek not returning
EINVAL for invalid whence modes.
Tested on x86_64 and i686.
[BZ #20012]
* libio/fmemopen.c (fmemopen_read): Use buffer maximum position, not
length to calculate the buffer to read.
(fmemopen_write): Set the buffer position based on bytes written.
(fmemopen_seek): Return EINVAL for invalid whence modes.
323 lines
8.0 KiB
C
323 lines
8.0 KiB
C
/* fmemopen tests for append and read mode.
|
|
Copyright (C) 2015-2016 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with the GNU C Library; if not, see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
|
|
static void
|
|
print_buffer (const char *s, size_t n)
|
|
{
|
|
size_t i;
|
|
printf ("{");
|
|
for (i=0; i<n; ++i)
|
|
{
|
|
printf ("0x%02X (%c)", s[i], s[i]);
|
|
if (i != n)
|
|
printf (", ");
|
|
}
|
|
}
|
|
|
|
/* This test check append mode initial position (a/a+) based on POSIX defition
|
|
(BZ#6544 and BZ#13151). */
|
|
static int
|
|
do_test_write_append (const char *mode)
|
|
{
|
|
char buf[32] = "testing buffer";
|
|
char exp[32] = "testing bufferXX";
|
|
|
|
FILE *fp = fmemopen (buf, sizeof (buf), mode);
|
|
|
|
fflush (fp);
|
|
fprintf (fp, "X");
|
|
fseek (fp, 0, SEEK_SET);
|
|
fprintf (fp, "X");
|
|
fclose (fp);
|
|
|
|
if (strcmp (buf, exp) != 0)
|
|
{
|
|
printf ("%s: check failed: %s != %s\n", __FUNCTION__, buf, exp);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* This test check append mode initial position (a/a+) based on POSIX defition
|
|
(BZ#6544 and BZ#13151) for buffer without null byte end. */
|
|
static int
|
|
do_test_write_append_without_null (const char *mode)
|
|
{
|
|
char buf[] = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 };
|
|
char exp[] = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 };
|
|
|
|
/* If '\0' is not found in buffer, POSIX states that SEEK_SET should be
|
|
the size argument. */
|
|
FILE *fp = fmemopen (buf, sizeof (buf) - 2, "a");
|
|
|
|
fflush (fp);
|
|
fputc (0x70, fp);
|
|
fseek (fp, 0, SEEK_SET);
|
|
fputc (0x70, fp);
|
|
fputc (0x70, fp);
|
|
fclose (fp);
|
|
|
|
/* POSIX also states that a write operation on the stream shall not advance
|
|
the current buffer size beyond the size given in fmemopen, so the string
|
|
should be same. */
|
|
if (memcmp (buf, exp, sizeof (buf)) != 0)
|
|
{
|
|
printf ("%s: check failed: ", __FUNCTION__);
|
|
print_buffer (buf, sizeof (buf));
|
|
printf ("!= ");
|
|
print_buffer (exp, sizeof (exp));
|
|
printf ("\n");
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* This test check for initial position and feek value for fmemopen objects
|
|
opened with append mode. */
|
|
static int
|
|
do_test_read_append (void)
|
|
{
|
|
char buf[32] = "testing buffer";
|
|
size_t buflen = strlen (buf);
|
|
long fpos;
|
|
|
|
/* POSIX defines for 'a+' the initial position is the first null byte. */
|
|
FILE *fp = fmemopen (buf, sizeof (buf), "a+");
|
|
|
|
fpos = ftell (fp);
|
|
if (fpos != buflen)
|
|
{
|
|
printf ("%s: ftell|SEEK_SET (fp) %li != strlen (%s) %zu\n",
|
|
__FUNCTION__, fpos, buf, buflen);
|
|
fclose (fp);
|
|
return 1;
|
|
}
|
|
|
|
fseek (fp, 0, SEEK_END);
|
|
|
|
if (fpos != buflen)
|
|
{
|
|
printf ("%s: ftell|SEEK_END (fp) %li != strlen (%s) %zu\n",
|
|
__FUNCTION__, fpos, buf, buflen);
|
|
fclose (fp);
|
|
return 1;
|
|
}
|
|
fclose (fp);
|
|
|
|
/* Check if attempting to read past the current size, defined as strlen (buf)
|
|
yield an EOF. */
|
|
fp = fmemopen (buf, sizeof (buf), "a+");
|
|
if (getc(fp) != EOF)
|
|
{
|
|
printf ("%s: getc(fp) != EOF\n", __FUNCTION__);
|
|
fclose (fp);
|
|
return -1;
|
|
}
|
|
|
|
fclose (fp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* This test check for fseek (SEEK_END) using negative offsets (BZ#14292). The
|
|
starting position of descriptor is different base on the opening mode. */
|
|
static int
|
|
do_test_read_seek_neg (const char *mode, const char *expected)
|
|
{
|
|
char buf[] = "abcdefghijklmnopqrstuvxz0123456789";
|
|
char tmp[10];
|
|
size_t tmps = sizeof (tmps);
|
|
long offset = -11;
|
|
|
|
FILE *fp = fmemopen (buf, sizeof (buf), mode);
|
|
fseek (fp, offset, SEEK_END);
|
|
fread (tmp, tmps, 1, fp);
|
|
|
|
if (memcmp (tmp, expected, tmps) != 0)
|
|
{
|
|
printf ("%s: fmemopen(%s) - fseek (fp, %li, SEEK_END):\n",
|
|
__FUNCTION__, mode, offset);
|
|
printf (" returned: ");
|
|
print_buffer (tmp, tmps);
|
|
printf ("\n");
|
|
printf (" expected: ");
|
|
print_buffer (expected, tmps);
|
|
printf ("\n");
|
|
return 1;
|
|
}
|
|
|
|
fclose (fp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
do_test_read_seek_negative (void)
|
|
{
|
|
int ret = 0;
|
|
|
|
/* 'r' and 'w' modes defines the initial position at the buffer start and
|
|
seek with SEEK_END shall seek relative to its size give in fmemopen
|
|
call. The expected tmp result is 0 to 9 *without* the ending null */
|
|
ret += do_test_read_seek_neg ("r", "0123456789");
|
|
/* 'a+' mode sets the initial position at the first null byte in buffer and
|
|
SEEK_END shall seek relative to its size as well. The expected result is
|
|
z012345678, since SEEK_END plus a+ start at '\0', not size. */
|
|
ret += do_test_read_seek_neg ("a+", "z012345678");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
do_test_write_append_2 (const char *str)
|
|
{
|
|
char buf[10];
|
|
size_t strn = strlen (str);
|
|
strcpy (buf, str);
|
|
|
|
FILE *fp = fmemopen (buf, sizeof (buf), "a+");
|
|
size_t r = ftell (fp);
|
|
size_t e = strlen (buf);
|
|
if (r != e)
|
|
{
|
|
printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e);
|
|
return 1;
|
|
}
|
|
|
|
if (fseek (fp, 0, SEEK_SET) == -1)
|
|
{
|
|
printf ("%s: fseek returned -1\n", __FUNCTION__);
|
|
return 1;
|
|
}
|
|
|
|
int gr;
|
|
for (int i=0; i<strn; ++i)
|
|
{
|
|
if ((gr = getc (fp)) != str[i])
|
|
{
|
|
printf ("%s: getc failed returned %d, expected %d\n", __FUNCTION__,
|
|
gr, str[i]);
|
|
return 1;
|
|
}
|
|
}
|
|
if ((gr = getc (fp)) != EOF)
|
|
{
|
|
printf ("%s: getc failed returned %d, expected EOF\n", __FUNCTION__,
|
|
gr);
|
|
return 1;
|
|
}
|
|
|
|
if (fseek (fp, e+1, SEEK_SET) == -1)
|
|
{
|
|
printf ("%s: fseek returned -1\n", __FUNCTION__);
|
|
return 1;
|
|
}
|
|
|
|
if ((r = ftell (fp)) != e+1)
|
|
{
|
|
printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+1);
|
|
return 1;
|
|
}
|
|
|
|
if ((gr = getc (fp)) != EOF)
|
|
{
|
|
printf ("%s: getc failed returned %i\n", __FUNCTION__, gr);
|
|
return 1;
|
|
}
|
|
|
|
/* Check if internal position is not changed with a getc returning EOF. */
|
|
if ((r = ftell (fp)) != e+1)
|
|
{
|
|
printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+1);
|
|
return 1;
|
|
}
|
|
|
|
if (fseek (fp, 0, SEEK_CUR) == -1)
|
|
{
|
|
printf ("%s: fseek returned -1\n", __FUNCTION__);
|
|
return 1;
|
|
}
|
|
|
|
/* This should be overwritten by fprintf + fflush. */
|
|
buf[e+2] = 'X';
|
|
|
|
if ((r = fprintf (fp, "%d", 101)) != 3)
|
|
{
|
|
printf ("%s: fprintf returned %zu, expected %d\n", __FUNCTION__, r, 3);
|
|
return 1;
|
|
}
|
|
|
|
fflush (fp);
|
|
|
|
/* Check if internal position is changed by 3 (strlen of '101'). */
|
|
if ((r = ftell (fp)) != e+3)
|
|
{
|
|
printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+3);
|
|
return 1;
|
|
}
|
|
|
|
char exp[20];
|
|
sprintf (exp, "%s%d", str, 101);
|
|
if (memcmp (buf, exp, strlen (exp)) != 0)
|
|
{
|
|
printf ("%s: check failed:", __FUNCTION__);
|
|
printf ("\nexpected: ");
|
|
print_buffer (buf, sizeof (buf));
|
|
printf ("\nbuffer: ");
|
|
print_buffer (exp, sizeof (exp));
|
|
printf ("\n");
|
|
return 1;
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
do_test (void)
|
|
{
|
|
int ret = 0;
|
|
|
|
ret += do_test_write_append ("a");
|
|
ret += do_test_write_append_without_null ("a");
|
|
ret += do_test_write_append ("a+");
|
|
ret += do_test_write_append_without_null ("a+");
|
|
|
|
ret += do_test_read_append ();
|
|
|
|
ret += do_test_read_seek_negative ();
|
|
|
|
/* First test plus addend will fit in the define buffer of size 10. */
|
|
ret += do_test_write_append_2 ("test");
|
|
/* The second test will also fit, but not the final '\0'. */
|
|
ret += do_test_write_append_2 ("testing");
|
|
|
|
return ret;
|
|
}
|
|
|
|
#define TEST_FUNCTION do_test ()
|
|
#include "../test-skeleton.c"
|