| /* 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-2018 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 <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <errno.h> |
| #include <unistd.h> |
| #include <fcntl.h> |
| #include <locale.h> |
| #include <wchar.h> |
| |
| 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; |
| } |
