From 5046dbb4a7eba5eccfd258f92f4735c9ffc8d069 Mon Sep 17 00:00:00 2001 From: Zack Weinberg Date: Thu, 8 Jun 2017 15:39:03 -0400 Subject: Prepare for radical source tree reorganization. All top-level files and directories are moved into a temporary storage directory, REORG.TODO, except for files that will certainly still exist in their current form at top level when we're done (COPYING, COPYING.LIB, LICENSES, NEWS, README), all old ChangeLog files (which are moved to the new directory OldChangeLogs, instead), and the generated file INSTALL (which is just deleted; in the new order, there will be no generated files checked into version control). --- REORG.TODO/libio/tst-ftell-active-handler.c | 684 ++++++++++++++++++++++++++++ 1 file changed, 684 insertions(+) create mode 100644 REORG.TODO/libio/tst-ftell-active-handler.c (limited to 'REORG.TODO/libio/tst-ftell-active-handler.c') diff --git a/REORG.TODO/libio/tst-ftell-active-handler.c b/REORG.TODO/libio/tst-ftell-active-handler.c new file mode 100644 index 0000000000..5cc013da11 --- /dev/null +++ b/REORG.TODO/libio/tst-ftell-active-handler.c @@ -0,0 +1,684 @@ +/* Verify that ftell returns the correct value at various points before and + after the handler on which it is called becomes active. + Copyright (C) 2014-2017 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 + . */ + +#include +#include +#include +#include +#include +#include +#include +#include + +static int do_test (void); + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" + +#define get_handles_fdopen(filename, fd, fp, fd_mode, mode) \ +({ \ + int ret = 0; \ + (fd) = open ((filename), (fd_mode), 0); \ + if ((fd) == -1) \ + { \ + printf ("open failed: %m\n"); \ + ret = 1; \ + } \ + else \ + { \ + (fp) = fdopen ((fd), (mode)); \ + if ((fp) == NULL) \ + { \ + printf ("fdopen failed: %m\n"); \ + close (fd); \ + ret = 1; \ + } \ + } \ + ret; \ +}) + +#define get_handles_fopen(filename, fd, fp, mode) \ +({ \ + int ret = 0; \ + (fp) = fopen ((filename), (mode)); \ + if ((fp) == NULL) \ + { \ + printf ("fopen failed: %m\n"); \ + ret = 1; \ + } \ + else \ + { \ + (fd) = fileno (fp); \ + if ((fd) == -1) \ + { \ + printf ("fileno failed: %m\n"); \ + ret = 1; \ + } \ + } \ + ret; \ +}) + +/* data points to either char_data or wide_data, depending on whether we're + testing regular file mode or wide mode respectively. Similarly, + fputs_func points to either fputs or fputws. data_len keeps track of the + length of the current data and file_len maintains the current file + length. */ +static const void *data; +static const char *char_data = "abcdef"; +static const wchar_t *wide_data = L"abcdef"; +static size_t data_len; +static size_t file_len; + +typedef int (*fputs_func_t) (const void *data, FILE *fp); +typedef void *(*fgets_func_t) (void *ws, int n, FILE *fp); +fputs_func_t fputs_func; +fgets_func_t fgets_func; + +/* This test verifies that the offset reported by ftell is correct after the + file is truncated using ftruncate. ftruncate does not change the file + offset on truncation and hence, SEEK_CUR should continue to point to the + old offset and not be changed to the new offset. */ +static int +do_ftruncate_test (const char *filename) +{ + FILE *fp = NULL; + int fd; + int ret = 0; + struct test + { + const char *mode; + int fd_mode; + } test_modes[] = { + {"r+", O_RDWR}, + {"w", O_WRONLY | O_TRUNC}, + {"w+", O_RDWR | O_TRUNC}, + {"a", O_WRONLY}, + {"a+", O_RDWR} + }; + + for (int j = 0; j < 2; j++) + { + for (int i = 0; i < sizeof (test_modes) / sizeof (struct test); i++) + { + int fileret; + printf ("\tftruncate: %s (file, \"%s\"): ", + j == 0 ? "fopen" : "fdopen", + test_modes[i].mode); + + if (j == 0) + fileret = get_handles_fopen (filename, fd, fp, test_modes[i].mode); + else + fileret = get_handles_fdopen (filename, fd, fp, + test_modes[i].fd_mode, + test_modes[i].mode); + + if (fileret != 0) + return fileret; + + /* Write some data. */ + size_t written = fputs_func (data, fp); + + if (written == EOF) + { + printf ("fputs[1] failed to write data\n"); + ret |= 1; + } + + /* Record the offset. */ + long offset = ftell (fp); + + /* Flush data to allow switching active handles. */ + if (fflush (fp)) + { + printf ("Flush failed: %m\n"); + ret |= 1; + } + + /* Now truncate the file. */ + if (ftruncate (fd, 0) != 0) + { + printf ("Failed to truncate file: %m\n"); + ret |= 1; + } + + /* ftruncate does not change the offset, so there is no need to call + anything to be able to switch active handles. */ + long new_offset = ftell (fp); + + /* The offset should remain unchanged since ftruncate does not update + it. */ + if (offset != new_offset) + { + printf ("Incorrect offset. Expected %ld, but got %ld\n", + offset, new_offset); + + ret |= 1; + } + else + printf ("offset = %ld\n", offset); + + fclose (fp); + } + } + + return ret; +} +/* Test that ftell output after a rewind is correct. */ +static int +do_rewind_test (const char *filename) +{ + int ret = 0; + struct test + { + const char *mode; + int fd_mode; + size_t old_off; + size_t new_off; + } test_modes[] = { + {"w", O_WRONLY | O_TRUNC, 0, data_len}, + {"w+", O_RDWR | O_TRUNC, 0, data_len}, + {"r+", O_RDWR, 0, data_len}, + /* The new offsets for 'a' and 'a+' modes have to factor in the + previous writes since they always append to the end of the + file. */ + {"a", O_WRONLY, 0, 3 * data_len}, + {"a+", O_RDWR, 0, 4 * data_len}, + }; + + /* Empty the file before the test so that our offsets are simple to + calculate. */ + FILE *fp = fopen (filename, "w"); + if (fp == NULL) + { + printf ("Failed to open file for emptying\n"); + return 1; + } + fclose (fp); + + for (int j = 0; j < 2; j++) + { + for (int i = 0; i < sizeof (test_modes) / sizeof (struct test); i++) + { + FILE *fp; + int fd; + int fileret; + + printf ("\trewind: %s (file, \"%s\"): ", j == 0 ? "fdopen" : "fopen", + test_modes[i].mode); + + if (j == 0) + fileret = get_handles_fdopen (filename, fd, fp, + test_modes[i].fd_mode, + test_modes[i].mode); + else + fileret = get_handles_fopen (filename, fd, fp, test_modes[i].mode); + + if (fileret != 0) + return fileret; + + /* Write some content to the file, rewind and ensure that the ftell + output after the rewind is 0. POSIX does not specify what the + behavior is when a file is rewound in 'a' mode, so we retain + current behavior, which is to keep the 0 offset. */ + size_t written = fputs_func (data, fp); + + if (written == EOF) + { + printf ("fputs[1] failed to write data\n"); + ret |= 1; + } + + rewind (fp); + long offset = ftell (fp); + + if (offset != test_modes[i].old_off) + { + printf ("Incorrect old offset. Expected %zu, but got %ld, ", + test_modes[i].old_off, offset); + ret |= 1; + } + else + printf ("old offset = %ld, ", offset); + + written = fputs_func (data, fp); + + if (written == EOF) + { + printf ("fputs[1] failed to write data\n"); + ret |= 1; + } + + /* After this write, the offset in append modes should factor in the + implicit lseek to the end of file. */ + offset = ftell (fp); + if (offset != test_modes[i].new_off) + { + printf ("Incorrect new offset. Expected %zu, but got %ld\n", + test_modes[i].new_off, offset); + ret |= 1; + } + else + printf ("new offset = %ld\n", offset); + } + } + return ret; +} + +/* Test that the value of ftell is not cached when the stream handle is not + active. */ +static int +do_ftell_test (const char *filename) +{ + int ret = 0; + struct test + { + const char *mode; + int fd_mode; + size_t old_off; + size_t new_off; + size_t eof_off; + } test_modes[] = { + /* In w, w+ and r+ modes, the file position should be at the + beginning of the file. After the write, the offset should be + updated to data_len. We don't use eof_off in w and a modes since + they don't allow reading. */ + {"w", O_WRONLY | O_TRUNC, 0, data_len, 0}, + {"w+", O_RDWR | O_TRUNC, 0, data_len, 2 * data_len}, + {"r+", O_RDWR, 0, data_len, 3 * data_len}, + /* For the 'a' mode, the initial file position should be the + current end of file. After the write, the offset has data_len + added to the old value. For a+ mode however, the initial file + position is the file position of the underlying file descriptor, + since it is initially assumed to be in read mode. */ + {"a", O_WRONLY, 3 * data_len, 4 * data_len, 5 * data_len}, + {"a+", O_RDWR, 0, 5 * data_len, 6 * data_len}, + }; + for (int j = 0; j < 2; j++) + { + for (int i = 0; i < sizeof (test_modes) / sizeof (struct test); i++) + { + FILE *fp; + int fd; + int fileret; + + printf ("\tftell: %s (file, \"%s\"): ", j == 0 ? "fdopen" : "fopen", + test_modes[i].mode); + + if (j == 0) + fileret = get_handles_fdopen (filename, fd, fp, + test_modes[i].fd_mode, + test_modes[i].mode); + else + fileret = get_handles_fopen (filename, fd, fp, test_modes[i].mode); + + if (fileret != 0) + return fileret; + + long off = ftell (fp); + if (off != test_modes[i].old_off) + { + printf ("Incorrect old offset. Expected %zu but got %ld, ", + test_modes[i].old_off, off); + ret |= 1; + } + else + printf ("old offset = %ld, ", off); + + /* The effect of this write on the offset should be seen in the ftell + call that follows it. */ + int write_ret = write (fd, data, data_len); + if (write_ret != data_len) + { + printf ("write failed (%m)\n"); + ret |= 1; + } + off = ftell (fp); + + if (off != test_modes[i].new_off) + { + printf ("Incorrect new offset. Expected %zu but got %ld", + test_modes[i].new_off, off); + ret |= 1; + } + else + printf ("new offset = %ld", off); + + /* Read to the end, write some data to the fd and check if ftell can + see the new ofset. Do this test only for files that allow + reading. */ + if (test_modes[i].fd_mode != O_WRONLY) + { + wchar_t tmpbuf[data_len]; + + rewind (fp); + + while (fgets_func (tmpbuf, data_len, fp) && !feof (fp)); + + write_ret = write (fd, data, data_len); + if (write_ret != data_len) + { + printf ("write failed (%m)\n"); + ret |= 1; + } + off = ftell (fp); + + if (off != test_modes[i].eof_off) + { + printf (", Incorrect offset after read EOF. " + "Expected %zu but got %ld\n", + test_modes[i].eof_off, off); + ret |= 1; + } + else + printf (", offset after EOF = %ld\n", off); + } + else + putc ('\n', stdout); + + fclose (fp); + } + } + + return ret; +} + +/* This test opens the file for writing, moves the file offset of the + underlying file, writes out data and then checks if ftell trips on it. */ +static int +do_write_test (const char *filename) +{ + FILE *fp = NULL; + int fd; + int ret = 0; + struct test + { + const char *mode; + int fd_mode; + } test_modes[] = { + {"w", O_WRONLY | O_TRUNC}, + {"w+", O_RDWR | O_TRUNC}, + {"r+", O_RDWR} + }; + + for (int j = 0; j < 2; j++) + { + for (int i = 0; i < sizeof (test_modes) / sizeof (struct test); i++) + { + int fileret; + printf ("\twrite: %s (file, \"%s\"): ", j == 0 ? "fopen" : "fdopen", + test_modes[i].mode); + + if (j == 0) + fileret = get_handles_fopen (filename, fd, fp, test_modes[i].mode); + else + fileret = get_handles_fdopen (filename, fd, fp, + test_modes[i].fd_mode, + test_modes[i].mode); + + if (fileret != 0) + return fileret; + + /* Move offset to just before the end of the file. */ + off_t seek_ret = lseek (fd, file_len - 1, SEEK_SET); + if (seek_ret == -1) + { + printf ("lseek failed: %m\n"); + ret |= 1; + } + + /* Write some data. */ + size_t written = fputs_func (data, fp); + + if (written == EOF) + { + printf ("fputs[1] failed to write data\n"); + ret |= 1; + } + + /* Verify that the offset points to the end of the file. The length + of the file would be the original length + the length of data + written to it - the amount by which we moved the offset using + lseek. */ + long offset = ftell (fp); + file_len = file_len - 1 + data_len; + + if (offset != file_len) + { + printf ("Incorrect offset. Expected %zu, but got %ld\n", + file_len, offset); + + ret |= 1; + } + + printf ("offset = %ld\n", offset); + fclose (fp); + } + } + + return ret; +} + +/* This test opens a file in append mode, writes some data, and then verifies + that ftell does not trip over it. */ +static int +do_append_test (const char *filename) +{ + FILE *fp = NULL; + int ret = 0; + int fd; + + struct test + { + const char *mode; + int fd_mode; + } test_modes[] = { + {"a", O_WRONLY}, + {"a+", O_RDWR} + }; + + for (int j = 0; j < 2; j++) + { + for (int i = 0; i < sizeof (test_modes) / sizeof (struct test); i++) + { + int fileret; + + printf ("\tappend: %s (file, \"%s\"): ", j == 0 ? "fopen" : "fdopen", + test_modes[i].mode); + + if (j == 0) + fileret = get_handles_fopen (filename, fd, fp, test_modes[i].mode); + else + fileret = get_handles_fdopen (filename, fd, fp, + test_modes[i].fd_mode, + test_modes[i].mode); + + if (fileret != 0) + return fileret; + + /* Write some data. */ + size_t written = fputs_func (data, fp); + + if (written == EOF) + { + printf ("fputs[1] failed to write all data\n"); + ret |= 1; + } + + /* Verify that the offset points to the end of the file. The file + len is maintained by adding data_len each time to reflect the data + written to it. */ + long offset = ftell (fp); + file_len += data_len; + + if (offset != file_len) + { + printf ("Incorrect offset. Expected %zu, but got %ld\n", + file_len, offset); + + ret |= 1; + } + + printf ("offset = %ld\n", offset); + fclose (fp); + } + } + + /* For fdopen in 'a' mode, the file descriptor should not change if the file + is already open with the O_APPEND flag set. */ + fd = open (filename, O_WRONLY | O_APPEND, 0); + if (fd == -1) + { + printf ("open(O_APPEND) failed: %m\n"); + return 1; + } + + off_t seek_ret = lseek (fd, file_len - 1, SEEK_SET); + if (seek_ret == -1) + { + printf ("lseek[O_APPEND][0] failed: %m\n"); + ret |= 1; + } + + fp = fdopen (fd, "a"); + if (fp == NULL) + { + printf ("fdopen(O_APPEND) failed: %m\n"); + close (fd); + return 1; + } + + off_t new_seek_ret = lseek (fd, 0, SEEK_CUR); + if (seek_ret == -1) + { + printf ("lseek[O_APPEND][1] failed: %m\n"); + ret |= 1; + } + + printf ("\tappend: fdopen (file, \"a\"): O_APPEND: "); + + if (seek_ret != new_seek_ret) + { + printf ("incorrectly modified file offset to %jd, should be %jd", + (intmax_t) new_seek_ret, (intmax_t) seek_ret); + ret |= 1; + } + else + printf ("retained current file offset %jd", (intmax_t) seek_ret); + + new_seek_ret = ftello (fp); + + if (seek_ret != new_seek_ret) + { + printf (", ftello reported incorrect offset %jd, should be %jd\n", + (intmax_t) new_seek_ret, (intmax_t) seek_ret); + ret |= 1; + } + else + printf (", ftello reported correct offset %jd\n", (intmax_t) seek_ret); + + fclose (fp); + + return ret; +} + +static int +do_one_test (const char *filename) +{ + int ret = 0; + + ret |= do_ftell_test (filename); + ret |= do_write_test (filename); + ret |= do_append_test (filename); + ret |= do_rewind_test (filename); + ret |= do_ftruncate_test (filename); + + return ret; +} + +/* Run a set of tests for ftell for regular files and wide mode files. */ +static int +do_test (void) +{ + int ret = 0; + FILE *fp = NULL; + char *filename; + size_t written; + int fd = create_temp_file ("tst-active-handler-tmp.", &filename); + + if (fd == -1) + { + printf ("create_temp_file: %m\n"); + return 1; + } + + fp = fdopen (fd, "w"); + if (fp == NULL) + { + printf ("fdopen[0]: %m\n"); + close (fd); + return 1; + } + + data = char_data; + data_len = strlen (char_data); + file_len = strlen (char_data); + written = fputs (data, fp); + + if (written == EOF) + { + printf ("fputs[1] failed to write data\n"); + ret = 1; + } + + fclose (fp); + if (ret) + return ret; + + /* Tests for regular files. */ + puts ("Regular mode:"); + fputs_func = (fputs_func_t) fputs; + fgets_func = (fgets_func_t) fgets; + data = char_data; + data_len = strlen (char_data); + ret |= do_one_test (filename); + + /* Truncate the file before repeating the tests in wide mode. */ + fp = fopen (filename, "w"); + if (fp == NULL) + { + printf ("fopen failed %m\n"); + return 1; + } + fclose (fp); + + /* Tests for wide files. */ + puts ("Wide mode:"); + if (setlocale (LC_ALL, "en_US.UTF-8") == NULL) + { + printf ("Cannot set en_US.UTF-8 locale.\n"); + return 1; + } + fputs_func = (fputs_func_t) fputws; + fgets_func = (fgets_func_t) fgetws; + data = wide_data; + data_len = wcslen (wide_data); + ret |= do_one_test (filename); + + return ret; +} -- cgit 1.4.1