gdb/testsuite/gdb.base/fileio.c

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