gdb/testsuite/gdb.base/fileio.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <sys/time.h>
   7 #include <errno.h>
   8 #include <sys/wait.h>
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11 #include <time.h>
  12 /* TESTS :
  13  * - open(const char *pathname, int flags, mode_t mode);
  14 1) Attempt to create file that already exists - EEXIST
  15 2) Attempt to open a directory for writing - EISDIR
  16 3) Pathname does not exist - ENOENT
  17 4) Open for write but no write permission - EACCES
  18
  19 read(int fd, void *buf, size_t count);
  20 1) Read using invalid file descriptor - EBADF
  21
  22 write(int fd, const void *buf, size_t count);
  23 1) Write using invalid file descriptor - EBADF
  24 2) Attempt to write to read-only file - EBADF
  25
  26 lseek(int fildes, off_t offset, int whence);
  27 1) Seeking on an invalid file descriptor - EBADF
  28 2) Invalid "whence" (3rd param) value -  EINVAL
  29
  30 close(int fd);
  31 1) Attempt to close an invalid file descriptor - EBADF
  32
  33 stat(const char *file_name, struct stat *buf);
  34 1) Pathname is a null string -  ENOENT
  35 2) Pathname does not exist - ENOENT
  36
  37 fstat(int filedes, struct stat *buf);
  38 1) Attempt to stat using an invalid file descriptor - EBADF
  39
  40 isatty (int desc);
  41 Not applicable. We will test that it returns 1 when expected and a case
  42 where it should return 0.
  43
  44 rename(const char *oldpath, const char *newpath);
  45 1) newpath is an existing directory, but oldpath is not a directory. - EISDIR
  46 2) newpath is a non-empty directory. - ENOTEMPTY or EEXIST
  47 3) newpath is a subdirectory of old path. - EINVAL
  48 4) oldpath does not exist. - ENOENT
  49
  50 unlink(const char *pathname);
  51 1) pathname does not have write access. - EACCES
  52 2) pathname does not exist. - ENOENT
  53
  54 time(time_t *t);
  55 Not applicable.
  56
  57 system (const char * string);
  58 1) See if shell available - returns 0
  59 2) See if shell available - returns !0
  60 3) Execute simple shell command - returns 0
  61 4) Invalid string/command. -  returns 127.  */
  62
  63 static const char *strerrno (int err);
  64
  65 /* Note that OUTDIR is defined by the test suite.  */
  66 #define FILENAME    "foo.fileio.test"
  67 #define RENAMED     "bar.fileio.test"
  68 #define NONEXISTANT "nofoo.fileio.test"
  69 #define NOWRITE     "nowrt.fileio.test"
  70 #define TESTDIR1     "dir1.fileio.test"
  71 #define TESTDIR2     "dir2.fileio.test"
  72 #define TESTSUBDIR   "dir1.fileio.test/subdir.fileio.test"
  73
  74 #define STRING      "Hello World"
  75
  76 static void stop (void) {}
  77
  78 /* A NULL string.  We pass this to stat below instead of a NULL
  79    literal to avoid -Wnonnull warnings.  */
  80 const char *null_str;
  81
  82 void
  83 test_open (void)
  84 {
  85   int ret;
  86
  87   /* Test opening */
  88   errno = 0;
  89   ret = open (OUTDIR FILENAME, O_CREAT | O_TRUNC | O_RDWR, S_IWUSR | S_IRUSR);
  90   printf ("open 1: ret = %d, errno = %d %s\n", ret, errno,
  91           ret >= 0 ? "OK" : "");
  92
  93   if (ret >= 0)
  94     close (ret);
  95   stop ();
  96   /* Creating an already existing file (created by fileio.exp) */
  97   errno = 0;
  98   ret = open (OUTDIR FILENAME, O_CREAT | O_EXCL | O_WRONLY, S_IWUSR | S_IRUSR);
  99   printf ("open 2: ret = %d, errno = %d %s\n", ret, errno,
 100           strerrno (errno));
 101   if (ret >= 0)
 102     close (ret);
 103   stop ();
 104   /* Open directory (for writing) */
 105   errno = 0;
 106   ret = open (".", O_WRONLY);
 107   printf ("open 3: ret = %d, errno = %d %s\n", ret, errno,
 108           strerrno (errno));
 109   if (ret >= 0)
 110     close (ret);
 111   stop ();
 112   /* Opening nonexistant file */
 113   errno = 0;
 114   ret = open (NONEXISTANT, O_RDONLY);
 115   printf ("open 4: ret = %d, errno = %d %s\n", ret, errno,
 116           strerrno (errno));
 117   if (ret >= 0)
 118     close (ret);
 119   stop ();
 120   /* Open for write but no write permission */
 121   errno = 0;
 122   ret = open (OUTDIR NOWRITE, O_CREAT | O_RDONLY, S_IRUSR);
 123   if (ret >= 0)
 124     {
 125       close (ret);
 126       stop ();
 127       errno = 0;
 128       ret = open (OUTDIR NOWRITE, O_WRONLY);
 129       printf ("open 5: ret = %d, errno = %d %s\n", ret, errno,
 130               strerrno (errno));
 131       if (ret >= 0)
 132         close (ret);
 133     }
 134   else
 135     {
 136       stop ();
 137       printf ("open 5: ret = %d, errno = %d\n", ret, errno);
 138     }
 139   stop ();
 140 }
 141
 142 void
 143 test_write (void)
 144 {
 145   int fd, ret;
 146
 147   /* Test writing */
 148   errno = 0;
 149   fd = open (OUTDIR FILENAME, O_WRONLY);
 150   if (fd >= 0)
 151     {
 152       errno = 0;
 153       ret = write (fd, STRING, strlen (STRING));
 154       printf ("write 1: ret = %d, errno = %d %s\n", ret, errno,
 155               ret == strlen (STRING) ? "OK" : "");
 156       close (fd);
 157     }
 158   else
 159     printf ("write 1: errno = %d\n", errno);
 160   stop ();
 161   /* Write using invalid file descriptor */
 162   errno = 0;
 163   ret = write (999, STRING, strlen (STRING));
 164   printf ("write 2: ret = %d, errno = %d, %s\n", ret, errno,
 165           strerrno (errno));
 166   stop ();
 167   /* Write to a read-only file */
 168   errno = 0;
 169   fd = open (OUTDIR FILENAME, O_RDONLY);
 170   if (fd >= 0)
 171     {
 172       errno = 0;
 173       ret = write (fd, STRING, strlen (STRING));
 174       printf ("write 3: ret = %d, errno = %d %s\n", ret, errno,
 175               strerrno (errno));
 176       close (fd);
 177     }
 178   else
 179     printf ("write 3: errno = %d\n", errno);
 180   stop ();
 181 }
 182
 183 void
 184 test_read (void)
 185 {
 186   int fd, ret;
 187   char buf[16];
 188
 189   /* Test reading */
 190   errno = 0;
 191   fd = open (OUTDIR FILENAME, O_RDONLY);
 192   if (fd >= 0)
 193     {
 194       memset (buf, 0, 16);
 195       errno = 0;
 196       ret = read (fd, buf, 16);
 197       buf[15] = '\0'; /* Don't trust anybody... */
 198       if (ret == strlen (STRING))
 199         printf ("read 1: %s %s\n", buf, !strcmp (buf, STRING) ? "OK" : "");
 200       else
 201         printf ("read 1: ret = %d, errno = %d\n", ret, errno);
 202       close (fd);
 203     }
 204   else
 205     printf ("read 1: errno = %d\n", errno);
 206   stop ();
 207   /* Read using invalid file descriptor */
 208   errno = 0;
 209   ret = read (999, buf, 16);
 210   printf ("read 2: ret = %d, errno = %d %s\n", ret, errno,
 211           strerrno (errno));
 212   stop ();
 213 }
 214
 215 void
 216 test_lseek (void)
 217 {
 218   int fd;
 219   off_t ret = 0;
 220
 221   /* Test seeking */
 222   errno = 0;
 223   fd = open (OUTDIR FILENAME, O_RDONLY);
 224   if (fd >= 0)
 225     {
 226       errno = 0;
 227       ret = lseek (fd, 0, SEEK_CUR);
 228       printf ("lseek 1: ret = %ld, errno = %d, %s\n", (long) ret, errno,
 229               ret == 0 ? "OK" : "");
 230       stop ();
 231       errno = 0;
 232       ret = lseek (fd, 0, SEEK_END);
 233       printf ("lseek 2: ret = %ld, errno = %d, %s\n", (long) ret, errno,
 234               ret == 11 ? "OK" : "");
 235       stop ();
 236       errno = 0;
 237       ret = lseek (fd, 3, SEEK_SET);
 238       printf ("lseek 3: ret = %ld, errno = %d, %s\n", (long) ret, errno,
 239               ret == 3 ? "OK" : "");
 240       close (fd);
 241     }
 242   else
 243     {
 244       printf ("lseek 1: ret = %ld, errno = %d %s\n", (long) ret, errno,
 245               strerrno (errno));
 246       stop ();
 247       printf ("lseek 2: ret = %ld, errno = %d %s\n", (long) ret, errno,
 248               strerrno (errno));
 249       stop ();
 250       printf ("lseek 3: ret = %ld, errno = %d %s\n", (long) ret, errno,
 251               strerrno (errno));
 252     }
 253   /* Seeking on an invalid file descriptor */
 254   stop ();
 255 }
 256
 257 void
 258 test_close (void)
 259 {
 260   int fd, ret;
 261
 262   /* Test close */
 263   errno = 0;
 264   fd = open (OUTDIR FILENAME, O_RDONLY);
 265   if (fd >= 0)
 266     {
 267       errno = 0;
 268       ret = close (fd);
 269       printf ("close 1: ret = %d, errno = %d, %s\n", ret, errno,
 270               ret == 0 ? "OK" : "");
 271     }
 272   else
 273     printf ("close 1: errno = %d\n", errno);
 274   stop ();
 275   /* Close an invalid file descriptor */
 276   errno = 0;
 277   ret = close (999);
 278   printf ("close 2: ret = %d, errno = %d, %s\n", ret, errno,
 279           strerrno (errno));
 280   stop ();
 281 }
 282
 283 void
 284 test_stat (void)
 285 {
 286   int ret;
 287   struct stat st;
 288
 289   /* Test stat */
 290   errno = 0;
 291   ret = stat (OUTDIR FILENAME, &st);
 292   if (!ret)
 293     printf ("stat 1: ret = %d, errno = %d %s\n", ret, errno,
 294             st.st_size == 11 ? "OK" : "");
 295   else
 296     printf ("stat 1: ret = %d, errno = %d\n", ret, errno);
 297   stop ();
 298   /* NULL pathname */
 299   errno = 0;
 300   ret = stat (null_str, &st);
 301   printf ("stat 2: ret = %d, errno = %d %s\n", ret, errno,
 302           strerrno (errno));
 303   stop ();
 304   /* Empty pathname */
 305   errno = 0;
 306   ret = stat ("", &st);
 307   printf ("stat 3: ret = %d, errno = %d %s\n", ret, errno,
 308           strerrno (errno));
 309   stop ();
 310   /* Nonexistant file */
 311   errno = 0;
 312   ret = stat (NONEXISTANT, &st);
 313   printf ("stat 4: ret = %d, errno = %d %s\n", ret, errno,
 314           strerrno (errno));
 315   stop ();
 316 }
 317
 318 void
 319 test_fstat (void)
 320 {
 321   int fd, ret;
 322   struct stat st;
 323
 324   /* Test fstat */
 325   errno = 0;
 326   fd = open (OUTDIR FILENAME, O_RDONLY);
 327   if (fd >= 0)
 328     {
 329       errno = 0;
 330       ret = fstat (fd, &st);
 331       if (!ret)
 332         printf ("fstat 1: ret = %d, errno = %d %s\n", ret, errno,
 333                 st.st_size == 11 ? "OK" : "");
 334       else
 335         printf ("fstat 1: ret = %d, errno = %d\n", ret, errno);
 336       close (fd);
 337     }
 338   else
 339     printf ("fstat 1: errno = %d\n", errno);
 340   stop ();
 341   /* Fstat using invalid file descriptor */
 342   errno = 0;
 343   ret = fstat (999, &st);
 344   printf ("fstat 2: ret = %d, errno = %d %s\n", ret, errno,
 345           strerrno (errno));
 346   stop ();
 347 }
 348
 349 void
 350 test_isatty (void)
 351 {
 352   int fd;
 353
 354   /* Check std I/O */
 355   printf ("isatty 1: stdin %s\n", isatty (0) ? "yes OK" : "no");
 356   stop ();
 357   printf ("isatty 2: stdout %s\n", isatty (1) ? "yes OK" : "no");
 358   stop ();
 359   printf ("isatty 3: stderr %s\n", isatty (2) ? "yes OK" : "no");
 360   stop ();
 361   /* Check invalid fd */
 362   printf ("isatty 4: invalid %s\n", isatty (999) ? "yes" : "no OK");
 363   stop ();
 364   /* Check open file */
 365   fd = open (OUTDIR FILENAME, O_RDONLY);
 366   if (fd >= 0)
 367     {
 368       printf ("isatty 5: file %s\n", isatty (fd) ? "yes" : "no OK");
 369       close (fd);
 370     }
 371   else
 372     printf ("isatty 5: file couldn't open\n");
 373   stop ();
 374 }
 375
 376
 377 char sys[1512];
 378
 379 void
 380 test_system (void)
 381 {
 382   /*
 383    * Requires test framework to switch on "set remote system-call-allowed 1"
 384    */
 385   int ret;
 386
 387   /* Test for shell ('set remote system-call-allowed' is disabled
 388      by default).  */
 389   ret = system (NULL);
 390   printf ("system 1: ret = %d %s\n", ret, ret == 0 ? "OK" : "");
 391   stop ();
 392   /* Test for shell again (the testsuite will have enabled it now).  */
 393   ret = system (NULL);
 394   printf ("system 2: ret = %d %s\n", ret, ret != 0 ? "OK" : "");
 395   stop ();
 396   /* This test prepares the directory for test_rename() */
 397   sprintf (sys, "mkdir -p %s/%s %s/%s", OUTDIR, TESTSUBDIR, OUTDIR, TESTDIR2);
 398   ret = system (sys);
 399   if (ret == 127)
 400     printf ("system 3: ret = %d /bin/sh unavailable???\n", ret);
 401   else
 402     printf ("system 3: ret = %d %s\n", ret, ret == 0 ? "OK" : "");
 403   stop ();
 404   /* Invalid command (just guessing ;-) ) */
 405   ret = system ("wrtzlpfrmpft");
 406   printf ("system 4: ret = %d %s\n", ret,
 407           WEXITSTATUS (ret) == 127 ? "OK" : "");
 408   stop ();
 409 }
 410
 411 void
 412 test_rename (void)
 413 {
 414   int ret;
 415   struct stat st;
 416
 417   /* Test rename */
 418   errno = 0;
 419   ret = rename (OUTDIR FILENAME, OUTDIR RENAMED);
 420   if (!ret)
 421     {
 422       errno = 0;
 423       ret = stat (FILENAME, &st);
 424       if (ret && errno == ENOENT)
 425         {
 426           errno = 0;
 427           ret = stat (OUTDIR RENAMED, &st);
 428           printf ("rename 1: ret = %d, errno = %d %s\n", ret, errno,
 429                   strerrno (errno));
 430           errno = 0;
 431         }
 432       else
 433         printf ("rename 1: ret = %d, errno = %d\n", ret, errno);
 434     }
 435   else
 436     printf ("rename 1: ret = %d, errno = %d\n", ret, errno);
 437   stop ();
 438   /* newpath is existing directory, oldpath is not a directory */
 439   errno = 0;
 440   ret = rename (OUTDIR RENAMED, OUTDIR TESTDIR2);
 441   printf ("rename 2: ret = %d, errno = %d %s\n", ret, errno,
 442           strerrno (errno));
 443   stop ();
 444   /* newpath is a non-empty directory */
 445   errno = 0;
 446   ret = rename (OUTDIR TESTDIR2, OUTDIR TESTDIR1);
 447   printf ("rename 3: ret = %d, errno = %d %s\n", ret, errno,
 448           strerrno (errno));
 449   stop ();
 450   /* newpath is a subdirectory of old path */
 451   errno = 0;
 452   ret = rename (OUTDIR TESTDIR1, OUTDIR TESTSUBDIR);
 453   printf ("rename 4: ret = %d, errno = %d %s\n", ret, errno,
 454           strerrno (errno));
 455   stop ();
 456   /* oldpath does not exist */
 457   errno = 0;
 458   ret = rename (OUTDIR NONEXISTANT, OUTDIR FILENAME);
 459   printf ("rename 5: ret = %d, errno = %d %s\n", ret, errno,
 460           strerrno (errno));
 461   stop ();
 462 }
 463
 464 char name[1256];
 465
 466 void
 467 test_unlink (void)
 468 {
 469   int ret;
 470
 471   /* Test unlink */
 472   errno = 0;
 473   ret = unlink (OUTDIR RENAMED);
 474   printf ("unlink 1: ret = %d, errno = %d %s\n", ret, errno,
 475           strerrno (errno));
 476   stop ();
 477   /* No write access */
 478   sprintf (name, "%s/%s/%s", OUTDIR, TESTDIR2, FILENAME);
 479   errno = 0;
 480   ret = open (name, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR);
 481   if (ret >= 0)
 482     {
 483       sprintf (sys, "chmod -w %s/%s", OUTDIR, TESTDIR2);
 484       ret = system (sys);
 485       if (!ret)
 486         {
 487           errno = 0;
 488           ret = unlink (name);
 489           printf ("unlink 2: ret = %d, errno = %d %s\n", ret, errno,
 490                   strerrno (errno));
 491         }
 492       else
 493         printf ("unlink 2: ret = %d chmod failed, errno= %d\n", ret, errno);
 494     }
 495   else
 496     printf ("unlink 2: ret = %d, errno = %d\n", ret, errno);
 497   stop ();
 498   /* pathname doesn't exist */
 499   errno = 0;
 500   ret = unlink (OUTDIR NONEXISTANT);
 501   printf ("unlink 3: ret = %d, errno = %d %s\n", ret, errno,
 502           strerrno (errno));
 503   stop ();
 504 }
 505
 506 void
 507 test_time (void)
 508 {
 509   time_t ret, t;
 510
 511   errno = 0;
 512   ret = time (&t);
 513   printf ("time 1: ret = %ld, errno = %d, t = %ld %s\n", (long) ret, errno, (long) t, ret == t ? "OK" : "");
 514   stop ();
 515   errno = 0;
 516   ret = time (NULL);
 517   printf ("time 2: ret = %ld, errno = %d, t = %ld %s\n",
 518           (long) ret, errno, (long) t, ret >= t && ret < t + 10 ? "OK" : "");
 519   stop ();
 520 }
 521
 522 static const char *
 523 strerrno (int err)
 524 {
 525   switch (err)
 526     {
 527     case 0: return "OK";
 528 #ifdef EACCES
 529     case EACCES: return "EACCES";
 530 #endif
 531 #ifdef EBADF
 532     case EBADF: return "EBADF";
 533 #endif
 534 #ifdef EEXIST
 535     case EEXIST: return "EEXIST";
 536 #endif
 537 #ifdef EFAULT
 538     case EFAULT: return "EFAULT";
 539 #endif
 540 #ifdef EINVAL
 541     case EINVAL: return "EINVAL";
 542 #endif
 543 #ifdef EISDIR
 544     case EISDIR: return "EISDIR";
 545 #endif
 546 #ifdef ENOENT
 547     case ENOENT: return "ENOENT";
 548 #endif
 549 #ifdef ENOTEMPTY
 550     case ENOTEMPTY: return "ENOTEMPTY";
 551 #endif
 552 #ifdef EBUSY
 553     case EBUSY: return "EBUSY";
 554 #endif
 555     default: return "E??";
 556     }
 557 }
 558
 559 int
 560 main ()
 561 {
 562   /* Don't change the order of the calls.  They partly depend on each other */
 563   test_open ();
 564   test_write ();
 565   test_read ();
 566   test_lseek ();
 567   test_close ();
 568   test_stat ();
 569   test_fstat ();
 570   test_isatty ();
 571   test_system ();
 572   test_rename ();
 573   test_unlink ();
 574   test_time ();
 575   return 0;
 576 }