OpenE2K
/
glibc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[BZ #12724] libio: revert partial POSIX 2008 fclose support 

In BZ #12724, partial support for POSIX 2008 fclose behavior was added.
Since it isn't entirely conforming to the spec, some applications are
known to be breaking in this intermediate state.  So revert the partial
support until we can get things fully implemented.

This reverts commit fcabc0f8b1.

Signed-off-by: Mike Frysinger <vapier@gentoo.org>
This commit is contained in:
Mike Frysinger 2012-12-01 13:00:08 -05:00
parent f638872ab4
commit eb6cbd249f
4 changed files with 11 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
ChangeLog
View File

@ -1,3 +1,10 @@
2012-12-01 Mike Frysinger <vapier@gentoo.org>
* libio/fileops.c (_IO_new_file_close_it): Do not always flush
when currently writing and seek to current position when not.
* libio/Makefile (tests): Remove bug-fclose1.
* libio/bug-fclose1.c: Delete.
2012-12-01 Joseph Myers <joseph@codesourcery.com>
* manual/arith.texi (feenableexcept): Fix typo.

2
libio/Makefile
View File

@ -59,7 +59,7 @@ tests = tst_swprintf tst_wprintf tst_swscanf tst_wscanf tst_getwc tst_putwc \
tst-memstream1 tst-memstream2 \
tst-wmemstream1 tst-wmemstream2 \
bug-memstream1 bug-wmemstream1 \
tst-setvbuf1 tst-popen1 tst-fgetwc bug-wsetpos bug-fclose1 tst-fseek \
tst-setvbuf1 tst-popen1 tst-fgetwc bug-wsetpos tst-fseek \
tst-fwrite-error
ifeq (yes,$(build-shared))
# Add test-fopenloc only if shared library is enabled since it depends on

132
libio/bug-fclose1.c
View File

@ -1,132 +0,0 @@
// BZ #12724
static void do_prepare (void);
#define PREPARE(argc, argv) do_prepare ()
static int do_test (void);
#define TEST_FUNCTION do_test()
#include "../test-skeleton.c"
static int fd;
static void
do_prepare (void)
{
fd = create_temp_file ("bug-fclose1.", NULL);
if (fd == -1)
{
printf ("cannot create temporary file: %m\n");
exit (1);
}
}
static int
do_test (void)
{
static const char pattern[] = "hello world";
/* Prepare a seekable file. */
if (write (fd, pattern, sizeof pattern) != sizeof pattern)
{
printf ("cannot write pattern: %m\n");
return 1;
}
if (lseek (fd, 1, SEEK_SET) != 1)
{
printf ("cannot seek after write: %m\n");
return 1;
}
/* Create an output stream visiting the file; when it is closed, all
other file descriptors visiting the file must see the new file
position. */
int fd2 = dup (fd);
if (fd2 < 0)
{
printf ("cannot duplicate descriptor for writing: %m\n");
return 1;
}
FILE *f = fdopen (fd2, "w");
if (f == NULL)
{
printf ("first fdopen failed: %m\n");
return 1;
}
if (fputc (pattern[1], f) != pattern[1])
{
printf ("fputc failed: %m\n");
return 1;
}
if (fclose (f) != 0)
{
printf ("first fclose failed: %m\n");
return 1;
}
errno = 0;
if (lseek (fd2, 0, SEEK_CUR) != -1)
{
printf ("lseek after fclose after write did not fail\n");
return 1;
}
if (errno != EBADF)
{
printf ("lseek after fclose after write did not fail with EBADF: %m\n");
return 1;
}
off_t o = lseek (fd, 0, SEEK_CUR);
if (o != 2)
{
printf ("\
lseek on original descriptor after first fclose returned %ld, expected 2\n",
(long int) o);
return 1;
}
/* Likewise for an input stream. */
fd2 = dup (fd);
if (fd2 < 0)
{
printf ("cannot duplicate descriptor for reading: %m\n");
return 1;
}
f = fdopen (fd2, "r");
if (f == NULL)
{
printf ("second fdopen failed: %m\n");
return 1;
}
char c = fgetc (f);
if (c != pattern[2])
{
printf ("getc returned %c, expected %c\n", c, pattern[2]);
return 1;
}
if (fclose (f) != 0)
{
printf ("second fclose failed: %m\n");
return 1;
}
errno = 0;
if (lseek (fd2, 0, SEEK_CUR) != -1)
{
printf ("lseek after fclose after read did not fail\n");
return 1;
}
if (errno != EBADF)
{
printf ("lseek after fclose after read did not fail with EBADF: %m\n");
return 1;
}
o = lseek (fd, 0, SEEK_CUR);
if (o != 3)
{
printf ("\
lseek on original descriptor after second fclose returned %ld, expected 3\n",
(long int) o);
return 1;
}
return 0;
}

14
libio/fileops.c
View File

@ -155,21 +155,13 @@ int
_IO_new_file_close_it (fp)
_IO_FILE *fp;
{
int write_status;
if (!_IO_file_is_open (fp))
return EOF;
int write_status;
if (_IO_in_put_mode (fp))
if ((fp->_flags & _IO_NO_WRITES) == 0
&& (fp->_flags & _IO_CURRENTLY_PUTTING) != 0)
write_status = _IO_do_flush (fp);
else if (fp->_offset != _IO_pos_BAD && fp->_IO_read_base != NULL
&& !_IO_in_backup (fp))
{
off64_t o = _IO_SEEKOFF (fp, 0, _IO_seek_cur, 0);
if (o == WEOF)
write_status = EOF;
else
write_status = _IO_SYSSEEK (fp, o, SEEK_SET) < 0 ? EOF : 0;
}
else
write_status = 0;