tests/fflush.c

   1 #include <errno.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <unistd.h>
   5 #include <darwintest.h>
   6 #include <darwintest_utils.h>
   7
   8 static char tmpfile_template[] = "/tmp/libc_test_fflushXXXXX";
   9 #define BUFSZ 128
  10 static char wrbuf[BUFSZ] = "";
  11 static const size_t filesz = BUFSZ * 120;
  12
  13 static void
  14 cleanup_tmp_file(void)
  15 {
  16         (void)unlink(tmpfile_template);
  17 }
  18
  19 static const char *
  20 assert_empty_tmp_file(void)
  21 {
  22         T_SETUPBEGIN;
  23
  24         int tmpfd = mkstemp(tmpfile_template);
  25         T_ASSERT_POSIX_SUCCESS(tmpfd, "created tmp file at %s", tmpfile_template);
  26         T_ATEND(cleanup_tmp_file);
  27         close(tmpfd);
  28
  29         T_SETUPEND;
  30
  31         return tmpfile_template;
  32 }
  33
  34 static const char *
  35 assert_full_tmp_file(void)
  36 {
  37         T_SETUPBEGIN;
  38
  39         int tmpfd = mkstemp(tmpfile_template);
  40         T_ASSERT_POSIX_SUCCESS(tmpfd, "created tmp file at %s", tmpfile_template);
  41         T_ATEND(cleanup_tmp_file);
  42
  43         /*
  44          * Write a pattern of bytes into the file -- the lowercase alphabet,
  45          * separated by newlines.
  46          */
  47         for (size_t i = 0; i < BUFSZ; i++) {
  48                 wrbuf[i] = 'a' + (i % 27);
  49                 if (i % 27 == 26) {
  50                         wrbuf[i] = '\n';
  51                 }
  52         }
  53         for (size_t i = 0; i < filesz; i++) {
  54                 ssize_t byteswr = 0;
  55                 do {
  56                         byteswr = write(tmpfd, wrbuf, BUFSZ);
  57                 } while (byteswr == -1 && errno == EAGAIN);
  58
  59                 T_QUIET; T_ASSERT_POSIX_SUCCESS(byteswr, "wrote %d bytes to tmp file",
  60                                 BUFSZ);
  61                 T_QUIET; T_ASSERT_EQ(byteswr, (ssize_t)BUFSZ,
  62                                 "wrote correct amount of bytes to tmp file");
  63         }
  64
  65         close(tmpfd);
  66
  67         T_SETUPEND;
  68
  69         return tmpfile_template;
  70 }
  71
  72 /*
  73  * Ensure that fflush on an input stream conforms to the SUSv3 definition, which
  74  * requires synchronizing the FILE position with the underlying file descriptor.
  75  */
  76 T_DECL(fflush_input, "fflush on a read-only FILE resets fd offset")
  77 {
  78         const char *tmpfile = assert_full_tmp_file();
  79
  80         T_SETUPBEGIN;
  81
  82         FILE *tmpf = fopen(tmpfile, "r");
  83         T_QUIET; T_WITH_ERRNO;
  84         T_ASSERT_NOTNULL(tmpf, "opened tmp file for reading");
  85
  86         /*
  87          * Move some way into the file.
  88          */
  89         char buf[100] = "";
  90         size_t nread = fread(buf, sizeof(buf), 1, tmpf);
  91         T_ASSERT_EQ(nread, (size_t)1, "read correct number of items from FILE");
  92         char last_read_char = buf[sizeof(buf) - 1];
  93
  94         off_t curoff = lseek(fileno(tmpf), 0, SEEK_CUR);
  95         T_ASSERT_GT(curoff, (off_t)0, "file offset should be non-zero");
  96
  97         T_SETUPEND;
  98
  99         /*
 100          * fflush(3) to reset the fd back to the FILE offset.
 101          */
 102         int ret = fflush(tmpf);
 103         T_ASSERT_POSIX_SUCCESS(ret, "fflush on read-only FILE");
 104
 105         off_t flushoff = lseek(fileno(tmpf), 0, SEEK_CUR);
 106         T_ASSERT_EQ(flushoff, (off_t)sizeof(buf),
 107                         "offset of file should be bytes read on FILE after fflush");
 108
 109         /*
 110          * Make sure the FILE is reading the right thing -- the next character
 111          * should be one letter after the last byte read, from the last call to
 112          * fread(3).
 113          */
 114         char c = '\0';
 115         nread = fread(&c, sizeof(c), 1, tmpf);
 116         T_QUIET;
 117         T_ASSERT_EQ(nread, (size_t)1, "read correct number of items from FILE");
 118
 119         /*
 120          * The pattern in the file is the alphabet -- and this doesn't land on
 121          * a newline.
 122          */
 123         T_QUIET;
 124         T_ASSERT_NE((flushoff) % 27, (off_t)0,
 125                         "previous offset shouldn't land on newline");
 126         T_QUIET;
 127         T_ASSERT_NE((flushoff + 1) % 27, (off_t)0,
 128                         "current offset shouldn't land on newline");
 129
 130         T_ASSERT_EQ(c, last_read_char + 1, "read correct byte after fflush");
 131
 132         ret = fflush(tmpf);
 133         T_QUIET; T_ASSERT_POSIX_SUCCESS(ret, "fflush on read-only FILE");
 134
 135         flushoff = lseek(fileno(tmpf), 0, SEEK_CUR);
 136         T_ASSERT_EQ(flushoff, (off_t)(sizeof(buf) + sizeof(c)),
 137                         "offset of file should be incremented after subsequent read");
 138
 139         /*
 140          * Use ungetc(3) to induce the optimized ungetc behavior in the FILE.
 141          */
 142         int ugret = ungetc(c, tmpf);
 143         T_QUIET; T_ASSERT_NE(ugret, EOF, "ungetc after fflush");
 144         T_QUIET; T_ASSERT_EQ((char)ugret, c, "ungetc un-got the correct char");
 145
 146         ret = fflush(tmpf);
 147         T_ASSERT_POSIX_SUCCESS(ret, "fflush after ungetc");
 148         flushoff = lseek(fileno(tmpf), 0, SEEK_CUR);
 149         T_ASSERT_EQ(flushoff, (off_t)sizeof(buf),
 150                         "offset of file should be correct after ungetc and fflush");
 151
 152         nread = fread(&c, sizeof(c), 1, tmpf);
 153         T_QUIET;
 154         T_ASSERT_EQ(nread, (size_t)1, "read correct number of items from FILE");
 155         T_ASSERT_EQ(c, last_read_char + 1,
 156                         "read correct byte after ungetc and fflush");
 157 }
 158
 159 /*
 160  * Try to trick fclose into not reporting an ENOSPC error from the underlying
 161  * descriptor in update mode.  Previous versions of Libc only flushed the FILE
 162  * if it was write-only.
 163  */
 164
 165 #if TARGET_OS_OSX
 166 /*
 167  * Only macOS contains a version of hdiutil that can create disk images.
 168  */
 169
 170 #define DMGFILE "/tmp/test_fclose_enospc.dmg"
 171 #define VOLNAME "test_fclose_enospc"
 172 static const char *small_file = "/Volumes/" VOLNAME "/test.txt";
 173
 174 static void
 175 cleanup_dmg(void)
 176 {
 177         char *hdiutil_detach_argv[] = {
 178                 "/usr/bin/hdiutil", "detach", "/Volumes/" VOLNAME, NULL,
 179         };
 180         pid_t hdiutil_detach = -1;
 181         int ret = dt_launch_tool(&hdiutil_detach, hdiutil_detach_argv, false, NULL,
 182                         NULL);
 183         if (ret != -1) {
 184                 int status = 0;
 185                 (void)waitpid(hdiutil_detach, &status, 0);
 186         }
 187         (void)unlink(DMGFILE);
 188 }
 189
 190 T_DECL(fclose_enospc, "ensure ENOSPC is preserved on fclose")
 191 {
 192         T_SETUPBEGIN;
 193
 194         /*
 195          * Ensure a disk is available that will fill up and start returning ENOSPC.
 196          *
 197          * system(3) would be easier...
 198          */
 199         char *hdiutil_argv[] = {
 200                 "/usr/bin/hdiutil", "create", "-size", "10m", "-type", "UDIF",
 201                 "-volname", VOLNAME, "-nospotlight", "-fs", "HFS+", DMGFILE, "-attach",
 202                 NULL,
 203         };
 204         pid_t hdiutil_create = -1;
 205         int ret = dt_launch_tool(&hdiutil_create, hdiutil_argv, false, NULL, NULL);
 206         T_ASSERT_POSIX_SUCCESS(ret, "created and attached 10MB DMG");
 207         T_ATEND(cleanup_dmg);
 208         int status = 0;
 209         pid_t waited = waitpid(hdiutil_create, &status, 0);
 210         T_QUIET; T_ASSERT_EQ(waited, hdiutil_create,
 211                         "should have waited for the process that was launched");
 212         T_QUIET;
 213         T_ASSERT_TRUE(WIFEXITED(status), "hdiutil should have exited");
 214         T_QUIET;
 215         T_ASSERT_EQ(WEXITSTATUS(status), 0,
 216                         "hdiutil should have exited successfully");
 217
 218         /*
 219          * Open for updating, as previously only write-only files would be flushed
 220          * on fclose.
 221          */
 222         FILE *fp = fopen(small_file, "a+");
 223         T_WITH_ERRNO;
 224         T_ASSERT_NOTNULL(fp, "opened file at %s for append-updating", small_file);
 225
 226         char *buf = malloc(BUFSIZ);
 227         T_QUIET; T_WITH_ERRNO;
 228         T_ASSERT_NOTNULL(buf, "should allocate BUFSIZ bytes");
 229
 230         for (int i = 0; i < BUFSIZ; i++) {
 231                 buf[i] = (char)(i % 256);
 232         }
 233
 234         /*
 235          * Fill up the disk -- induce ENOSPC.
 236          */
 237         size_t wrsize = BUFSIZ;
 238         for (int i = 0; i < 2; i++) {
 239                 for (;;) {
 240                         errno = 0;
 241                         if (write(fileno(fp), buf, wrsize) < 0) {
 242                                 if (errno == ENOSPC) {
 243                                         break;
 244                                 }
 245                                 T_WITH_ERRNO; T_ASSERT_FAIL("write(2) failed");
 246                         }
 247                 }
 248                 wrsize = 1;
 249         }
 250         T_PASS("filled up the file until ENOSPC");
 251         free(buf);
 252
 253         /*
 254          * Make sure the FILE is at the end, so any writes it does hit ENOSPC.
 255          */
 256         ret = fseek(fp, 0, SEEK_END);
 257         T_ASSERT_POSIX_SUCCESS(ret, "fseek to the end of a complete file");
 258
 259         /*
 260          * Try to push a character into the file; since this is buffered, it should
 261          * succeed.
 262          */
 263         ret = fputc('a', fp);
 264         T_ASSERT_POSIX_SUCCESS(ret,
 265                         "fputc to put an additional character in the FILE");
 266
 267         T_SETUPEND;
 268
 269         /*
 270          * fclose should catch the ENOSPC error when it flushes the file, before it
 271          * closes the underlying descriptor.
 272          */
 273         errno = 0;
 274         ret = fclose(fp);
 275         if (ret != EOF) {
 276                 T_ASSERT_FAIL("fclose should fail when the FILE is full");
 277         }
 278         if (errno != ENOSPC) {
 279                 T_WITH_ERRNO; T_ASSERT_FAIL("fclose should fail with ENOSPC");
 280         }
 281
 282         T_PASS("fclose returned ENOSPC");
 283 }
 284
 285 #endif // TARGET_OS_OSX
 286
 287 /*
 288  * Ensure no errors are returned when flushing a read-only, unseekable input
 289  * stream.
 290  */
 291 T_DECL(fflush_unseekable_input,
 292                 "ensure sanity when an unseekable input stream is flushed")
 293 {
 294         T_SETUPBEGIN;
 295
 296         /*
 297          * Use a pipe for the unseekable streams.
 298          */
 299         int pipes[2];
 300         int ret = pipe(pipes);
 301         T_ASSERT_POSIX_SUCCESS(ret, "create a pipe");
 302         FILE *in = fdopen(pipes[0], "r");
 303         T_QUIET; T_WITH_ERRNO; T_ASSERT_NOTNULL(in,
 304                         "open input stream to read end of pipe");
 305         FILE *out = fdopen(pipes[1], "w");
 306         T_QUIET; T_WITH_ERRNO; T_ASSERT_NOTNULL(out,
 307                         "open output stream to write end of pipe");
 308
 309         /*
 310          * Fill the pipe with some text (but not too much that the write would
 311          * block!).
 312          */
 313         fprintf(out, "this is a test and has some more text");
 314         ret = fflush(out);
 315         T_ASSERT_POSIX_SUCCESS(ret, "flushed the output stream");
 316
 317         /*
 318          * Protect stdio from delving too deep into the pipe.
 319          */
 320         char inbuf[8] = {};
 321         setbuffer(in, inbuf, sizeof(inbuf));
 322
 323         /*
 324          * Just read a teensy bit to get the FILE offset different from the
 325          * descriptor "offset."
 326          */
 327         char rdbuf[2] = {};
 328         size_t nitems = fread(rdbuf, sizeof(rdbuf), 1, in);
 329         T_QUIET; T_ASSERT_GT(nitems, (size_t)0,
 330                         "read from the read end of the pipe");
 331
 332         T_SETUPEND;
 333
 334         ret = fflush(in);
 335         T_ASSERT_POSIX_SUCCESS(ret,
 336                         "should successfully flush unseekable input stream after reading");
 337 }
 338
 339 /*
 340  * Ensure that reading to the end of a file and then calling ftell() still
 341  * causes EOF.
 342  */
 343 T_DECL(ftell_feof,
 344                 "ensure ftell does not reset feof when actually at end of file") {
 345         T_SETUPBEGIN;
 346         FILE *fp = fopen("/System/Library/CoreServices/SystemVersion.plist", "rb");
 347         T_WITH_ERRNO;
 348         T_ASSERT_NOTNULL(fp, "opened SystemVersion.plist");
 349         struct stat sb;
 350         T_ASSERT_POSIX_SUCCESS(fstat(fileno(fp), &sb), "fstat SystemVersion.plist");
 351         void *buf = malloc((size_t)(sb.st_size * 2));
 352         T_ASSERT_NOTNULL(buf, "allocating buffer for size of SystemVersion.plist");
 353         T_SETUPEND;
 354
 355         T_ASSERT_POSIX_SUCCESS(fseek(fp, 0, SEEK_SET), "seek to beginning");
 356         // fread can return short *or* zero, according to manpage
 357         fread(buf, (size_t)(sb.st_size * 2), 1, fp);
 358         T_ASSERT_EQ(ftell(fp), (long)sb.st_size, "ftell() == file size");
 359         T_ASSERT_TRUE(feof(fp), "feof() reports end-of-file");
 360         free(buf);
 361 }
 362
 363 T_DECL(putc_flush, "ensure putc flushes to file on close") {
 364         const char *fname = assert_empty_tmp_file();
 365         FILE *fp = fopen(fname, "w");
 366         T_WITH_ERRNO;
 367         T_ASSERT_NOTNULL(fp, "opened temporary file read/write");
 368         T_WITH_ERRNO;
 369         T_ASSERT_EQ(fwrite("testing", 1, 7, fp), 7UL, "write temp contents");
 370         (void)fclose(fp);
 371
 372         fp = fopen(fname, "r+");
 373         T_WITH_ERRNO;
 374         T_ASSERT_NOTNULL(fp, "opened temporary file read/write");
 375
 376         T_ASSERT_POSIX_SUCCESS(fseek(fp, -1, SEEK_END), "seek to end - 1");
 377         T_ASSERT_EQ(fgetc(fp), 'g', "fgetc should read 'g'");
 378         T_ASSERT_EQ(fgetc(fp), EOF, "fgetc should read EOF");
 379         T_ASSERT_EQ(ftell(fp), 7L, "ftell should report position 7");
 380
 381         int ret = fputc('!', fp);
 382         T_ASSERT_POSIX_SUCCESS(ret,
 383                         "fputc to put an additional character in the FILE");
 384         T_ASSERT_EQ(ftell(fp), 8L, "ftell should report position 8");
 385
 386         T_QUIET;
 387         T_ASSERT_POSIX_SUCCESS(fclose(fp), "close temp file");
 388
 389         fp = fopen(fname, "r");
 390         T_WITH_ERRNO;
 391         T_ASSERT_NOTNULL(fp, "opened temporary file read/write");
 392
 393         char buf[9];
 394         T_WITH_ERRNO;
 395         T_ASSERT_NOTNULL(fgets(buf, sizeof(buf), fp), "read file data");
 396         T_ASSERT_EQ_STR(buf, "testing!", "read all the new data");
 397
 398         (void)fclose(fp);
 399 }
 400
 401 T_DECL(putc_writedrop, "ensure writes are flushed with a pending read buffer") {
 402         const char *fname = assert_empty_tmp_file();
 403         FILE *fp = fopen(fname, "w");
 404         T_WITH_ERRNO;
 405         T_ASSERT_NOTNULL(fp, "opened temporary file read/write");
 406         T_WITH_ERRNO;
 407         T_ASSERT_EQ(fwrite("testing", 1, 7, fp), 7UL, "write temp contents");
 408         (void)fclose(fp);
 409
 410         fp = fopen(fname, "r+");
 411         T_WITH_ERRNO;
 412         T_ASSERT_NOTNULL(fp, "opened temporary file read/write");
 413
 414         T_ASSERT_POSIX_SUCCESS(fseek(fp, -1, SEEK_END), "seek to end - 1");
 415
 416         int ret = fputc('!', fp);
 417         T_ASSERT_POSIX_SUCCESS(ret,
 418                         "fputc to put an additional character in the FILE");
 419         // flush the write buffer by reading a byte from the stream to put the
 420         // FILE* into read mode
 421         T_ASSERT_EQ(fgetc(fp), EOF, "fgetc should read EOF");
 422
 423         T_QUIET;
 424         T_ASSERT_POSIX_SUCCESS(fclose(fp), "close temp file");
 425
 426         fp = fopen(fname, "r");
 427         T_WITH_ERRNO;
 428         T_ASSERT_NOTNULL(fp, "opened temporary file read/write");
 429
 430         char buf[9];
 431         T_WITH_ERRNO;
 432         T_ASSERT_NOTNULL(fgets(buf, sizeof(buf), fp), "read file data");
 433         T_ASSERT_EQ_STR(buf, "testin!", "read all the new data");
 434
 435         (void)fclose(fp);
 436 }