minix/tests/test17.c

   1 /* Comment on usage and program: ark!/mnt/rene/prac/os/unix/comment.changes */
   2
   3 /* "const.h", created by Rene Montsma and Menno Wilcke */
   4
   5 #include <sys/types.h>          /* type defs */
   6 #include <sys/stat.h>           /* struct stat */
   7 #include <sys/wait.h>
   8 #include <errno.h>              /* the error-numbers */
   9 #include <fcntl.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <utime.h>
  14 #include <stdio.h>
  15 #include <limits.h>
  16 #include <assert.h>
  17
  18 #define NOCRASH 1               /* test11(), 2nd pipe */
  19 #define PDPNOHANG  1            /* test03(), write_standards() */
  20 int max_error = 2;
  21 #include "common.h"
  22
  23
  24 #define USER_ID   12
  25 #define GROUP_ID   1
  26 #define FF        3             /* first free filedes. */
  27 #define USER      1             /* uid */
  28 #define GROUP     0             /* gid */
  29
  30 #define ARSIZE   256            /* array size */
  31 #define PIPESIZE 3584           /* max number of bytes to be written on pipe */
  32 #define MAXOPEN  (OPEN_MAX-3)           /* maximum number of extra open files */
  33 #define MAXLINK 0177            /* maximum number of links per file */
  34 #define LINKCOUNT 5
  35 #define MASK    0777            /* selects lower nine bits */
  36 #define END_FILE     0          /* returned by read-call at eof */
  37
  38 #define OK      0
  39 #define FAIL   -1
  40
  41 #define R       0               /* read (open-call) */
  42 #define W       1               /* write (open-call) */
  43 #define RW      2               /* read & write (open-call) */
  44
  45 #define RWX     7               /* read & write & execute (mode) */
  46
  47 #define NIL     ""
  48 #define UMASK   "umask"
  49 #define CREAT   "creat"
  50 #define WRITE   "write"
  51 #define READ    "read"
  52 #define OPEN    "open"
  53 #define CLOSE   "close"
  54 #define LSEEK   "lseek"
  55 #define ACCESS  "access"
  56 #define CHDIR   "chdir"
  57 #define CHMOD   "chmod"
  58 #define LINK    "link"
  59 #define UNLINK  "unlink"
  60 #define PIPE    "pipe"
  61 #define STAT    "stat"
  62 #define FSTAT   "fstat"
  63 #define DUP     "dup"
  64 #define UTIME   "utime"
  65
  66
  67 /* "decl.c", created by Rene Montsma and Menno Wilcke */
  68
  69 /* Used in open_alot, close_alot */
  70 char *filenames[MAXOPEN];
  71
  72 #define MODES 8
  73 char *mode_fnames[MODES] = {"---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"},
  74 *mode_dir[MODES] = {"d---", "d--x", "d-w-", "d-wx", "dr--", "dr-x", "drw-", "drwx"};
  75
  76  /* Needed for easy creating and deleting of directories */
  77
  78 /* "test.c", created by Rene Montsma and Menno Wilcke */
  79
  80
  81 int main(int argc, char *argv []);
  82 void test(int mask);
  83 void test01(void);
  84 void test02(void);
  85 void test08(void);
  86 void test09(void);
  87 void test10(void);
  88 int link_alot(char *bigboss);
  89 int unlink_alot(int number);
  90 void get_new(char name []);
  91 void test11(void);
  92 void nlcr(void);
  93 void str(char *s);
  94 void test03(void);
  95 void put_file_in_dir(char *dirname, int mode);
  96 void init_array(char *a);
  97 void clear_array(char *b);
  98 int comp_array(char *a, char *b, int range);
  99 void try_close(int filedes, char *name);
 100 void try_unlink(char *fname);
 101 void Remove(int fdes, char *fname);
 102 int get_mode(char *name);
 103 void check(char *scall, int number);
 104 void put(int nr);
 105 int open_alot(void);
 106 int close_alot(int number);
 107 void clean_up_the_mess(void);
 108 void chmod_8_dirs(int sw);
 109 void quit(void);
 110
 111 /*****************************************************************************
 112  *                              TEST                                         *
 113  ****************************************************************************/
 114 int main(argc, argv)
 115 int argc;
 116 char *argv[];
 117 {
 118   int n, mask, i;
 119   pid_t child;
 120
 121   start(17);
 122
 123   /* Create filenames for MAXOPEN files, the *filenames[] array. */
 124   for(i = 0; i < MAXOPEN; i++) {
 125         if(asprintf(&filenames[i], "file%d", i) == -1) {
 126                 fprintf(stderr, "asprintf failed\n");
 127                 quit();
 128         }
 129   }
 130
 131
 132   mask = (argc == 2 ? atoi(argv[1]) : 0xFFFF);
 133   subtest = 0;
 134   child = fork();
 135   if (child == -1) {
 136         e(1);
 137         quit();
 138   } else if (child == 0) {
 139         test(mask);
 140         return(0);
 141   } else {
 142         wait(&n);
 143         clean_up_the_mess();
 144         quit();
 145   }
 146   return(-1);                   /* impossible */
 147 }
 148
 149 void test(mask)
 150 int mask;
 151 {
 152   umask(0);                     /* not honest, but i always forget */
 153
 154   if (mask & 00001) test01();
 155   if (mask & 00002) test03();
 156   if (mask & 00004) test02();
 157   if (mask & 00010) test08();
 158   if (mask & 00020) test09();
 159   if (mask & 00040) test10();
 160   if (mask & 00100) test11();
 161   umask(022);
 162 }                               /* test */
 163
 164 /* "t1.c" created by Rene Montsma and Menno Wilcke */
 165
 166 /*****************************************************************************
 167  *                              test UMASK                                   *
 168  ****************************************************************************/
 169 void test01()
 170 {
 171   int oldvalue, newvalue, tempvalue;
 172   int nr;
 173
 174   subtest = 1;
 175   if ((oldvalue = umask(0777)) != 0) e(1);
 176
 177   /* Special test: only the lower 9 bits (protection bits) may part- *
 178    * icipate. ~0777 means: 111 000 000 000. Giving this to umask must*
 179    * not change any value.                                           */
 180
 181   if ((newvalue = umask(~0777)) != 0777) e(2);
 182   if (oldvalue == newvalue) e(3);
 183
 184   if ((tempvalue = umask(0)) != 0) e(4);
 185
 186   /* Now test all possible modes of umask on a file */
 187   for (newvalue = MASK; newvalue >= 0; newvalue -= 0111) {
 188         tempvalue = umask(newvalue);
 189         if (tempvalue != oldvalue) {
 190                 e(5);
 191                 break;          /* no use trying more */
 192         } else if ((nr = creat("file01", 0777)) < 0)
 193                 e(6);
 194         else {
 195                 try_close(nr, "'file01'");
 196                 if (get_mode("file01") != (MASK & ~newvalue))
 197                         e(7);
 198                 try_unlink("file01");
 199         }
 200         oldvalue = newvalue;
 201   }
 202
 203   /* The loop has terminated with umask(0) */
 204   if ((tempvalue = umask(0)) != 0)
 205         e(8);
 206 }                               /* test01 */
 207
 208 /*****************************************************************************
 209  *                              test CREAT                                   *
 210  ****************************************************************************/
 211 void test02()
 212 {
 213   int n, n1, mode;
 214   char a[ARSIZE], b[ARSIZE];
 215   struct stat stbf1;
 216
 217   subtest = 2;
 218   mode = 0;
 219
 220   for (n = 0; n < MAXOPEN; n++) {
 221         if (creat(filenames[n], mode) != FF + n)
 222                 e(1);
 223         else {
 224                 if (get_mode(filenames[n]) != mode)
 225                         e(2);
 226
 227                 /* Change  mode of file to standard mode, we want to *
 228                  * use a lot (20) of files to be opened later, see   *
 229                  * open_alot(), close_alot().                        */
 230                 if (chmod(filenames[n], 0700) != OK) e(3);
 231         }
 232         mode = (mode + 0100) % 01000;
 233   }
 234
 235   /* Already twenty files opened; opening another has to fail */
 236   if (creat("file02", 0777) != FAIL)
 237         e(4);
 238   else
 239         if (errno != EMFILE) e(5);
 240
 241   /* Close all files: seems blunt, but it isn't because we've  *
 242    * checked all fd's already                                  */
 243   if ((n = close_alot(MAXOPEN)) < MAXOPEN) e(6);
 244
 245   /* Creat 1 file twice; check */
 246   if ((n = creat("file02", 0777)) < 0)
 247         e(7);
 248   else {
 249         init_array(a);
 250         if (write(n, a, ARSIZE) != ARSIZE) e(8);
 251
 252         if ((n1 = creat("file02", 0755)) < 0)   /* receate 'file02' */
 253                 e(9);
 254         else {
 255                 /* Fd should be at the top after recreation */
 256                 if (lseek(n1, 0L, SEEK_END) != 0)
 257                         e(10);
 258                 else {
 259                         /* Try to write on recreated file */
 260                         clear_array(b);
 261
 262                         if (lseek(n1, 0L, SEEK_SET) != 0) e(11);
 263                         if (write(n1, a, ARSIZE) != ARSIZE) e(12);
 264
 265                         /* In order to read we've to close and open again */
 266                         try_close(n1, "'file02'  (2nd creation)");
 267                         if ((n1 = open("file02", RW)) < 0)
 268                                 e(13);
 269
 270                         /* Continue */
 271                         if (lseek(n1, 0L, SEEK_SET) != 0) e(14);
 272                         if (read(n1, b, ARSIZE) != ARSIZE) e(15);
 273
 274                         if (comp_array(a, b, ARSIZE) != OK) e(16);
 275                 }
 276                 if (get_mode("file02") != 0777) e(17);
 277                 try_close(n1, "recreated 'file02'");
 278
 279         }
 280         Remove(n, "file02");
 281   }
 282
 283   /* Give 'creat' wrong input: dir not searchable */
 284   if (creat("drw-/file02", 0777) != FAIL) e(18);
 285   else
 286         if (errno != EACCES) e(19);
 287
 288   /* Dir not writable */
 289   if (creat("dr-x/file02", 0777) != FAIL) e(20);
 290   else
 291         if (errno != EACCES) e(21);
 292
 293   /* File not writable */
 294   if (creat("drwx/r-x", 0777) != FAIL) e(22);
 295   else
 296         if (errno != EACCES) e(23);
 297
 298   /* Try to creat a dir */
 299   if ((n = creat("dir", 040777)) != FAIL) {
 300         if (fstat(n, &stbf1) != OK) e(24);
 301         else if (stbf1.st_mode != (mode_t) 0100777)
 302                                 /* cast because mode is negative :-( */
 303                 e(25);
 304         Remove(n, "dir");
 305   }
 306
 307   /* We don't consider it to be a bug when creat * does not accept
 308    * tricky modes                */
 309
 310   /* File is an existing dir */
 311   if (creat("drwx", 0777) != FAIL) e(26);
 312   else
 313         if (errno != EISDIR) e(27);
 314 }                               /* test02 */
 315
 316 void test08()
 317 {
 318   subtest = 8;
 319
 320   /* Test chdir to searchable dir */
 321   if (chdir("drwx") != OK) e(1);
 322   else if (chdir("..") != OK) e(2);
 323
 324   /* Check the chdir(".") and chdir("..") mechanism */
 325   if (chdir("drwx") != OK) e(3);
 326   else {
 327         if (chdir(".") != OK) e(4);
 328
 329         /* If we still are in 'drwx' , we should be able to access *
 330          * file 'rwx'.                                              */
 331         if (access("rwx", 0) != OK) e(5);
 332
 333         /* Try to return to previous dir ('/' !!) */
 334         if (chdir("././../././d--x/../d--x/././..") != OK) e(6);
 335
 336         /* Check whether we are back in '/' */
 337         if (chdir("d--x") != OK) e(7);
 338   }  /* Return to '..' */
 339   if (chdir("..") != OK) e(8);
 340
 341   if (chdir("././././drwx") != OK) e(9);
 342   else if (chdir("././././..") != OK) e(10);
 343
 344   /* Try giving chdir wrong parameters */
 345   if (chdir("drwx/rwx") != FAIL) e(11);
 346   else
 347         if (errno != ENOTDIR) e(12);
 348
 349   if (chdir("drw-") != FAIL) e(13);
 350   else
 351         if (errno != EACCES) e(14);
 352
 353 }                               /* test08 */
 354
 355 /*****************************************************************************
 356  *                              test CHMOD                                   *
 357  ****************************************************************************/
 358 void test09()
 359 {
 360   int n;
 361
 362   subtest = 9;
 363
 364   /* Prepare file09 */
 365   if ((n = creat("drwx/file09", 0644)) != FF) e(1);
 366
 367   try_close(n, "'file09'");
 368
 369   /* Try to chmod a file, check and restore old values, check */
 370   if (chmod("drwx/file09", 0700) != OK) e(2);
 371   else {
 372         /* Check protection */
 373         if (get_mode("drwx/file09") != 0700) e(3);
 374
 375         /* Test if chmod accepts just filenames too */
 376         if (chdir("drwx") != OK) e(4);
 377         else if (chmod("file09", 0177) != OK) e(5);
 378         else
 379                 /* Check if value has been restored */
 380         if (get_mode("../drwx/file09") != 0177) e(6);
 381   }
 382
 383   /* Try setuid and setgid */
 384   if ((chmod("file09", 04777) != OK) || (get_mode("file09") != 04777))
 385         e(7);
 386   if ((chmod("file09", 02777) != OK) || (get_mode("file09") != 02777))
 387         e(8);
 388
 389   /* Remove testfile */
 390   try_unlink("file09");
 391
 392   if (chdir("..") != OK) e(9);
 393
 394   /* Try to chmod directory */
 395   if (chmod("d---", 0777) != OK) e(10);
 396   else {
 397         if (get_mode("d---") != 0777) e(11);
 398         if (chmod("d---", 0000) != OK) e(12);
 399
 400         /* Check if old value has been restored */
 401         if (get_mode("d---") != 0000) e(13);
 402   }
 403
 404   /* Try to make chmod failures */
 405
 406   /* We still are in dir root */
 407   /* Wrong filename */
 408   if (chmod("non-file", 0777) != FAIL) e(14);
 409   else
 410         if (errno != ENOENT) e(15);
 411
 412 }                               /* test 09 */
 413
 414
 415 /* "t4.c", created by Rene Montsma and Menno Wilcke */
 416
 417 /*****************************************************************************
 418  *                              test LINK/UNLINK                             *
 419  ****************************************************************************/
 420 void test10()
 421 {
 422   int n, n1;
 423   char a[ARSIZE], b[ARSIZE], *f, *lf;
 424
 425   subtest = 10;
 426
 427   f = "anotherfile10";
 428   lf = "linkfile10";
 429
 430   if ((n = creat(f, 0702)) != FF) e(1); /* no other open files */
 431   else {
 432         /* Now link correctly */
 433         if (link(f, lf) != OK) e(2);
 434         else if ((n1 = open(lf, RW)) < 0) e(3);
 435         else {
 436                 init_array(a);
 437                 clear_array(b);
 438
 439                 /* Write on 'file10' means being able to    * read
 440                  * through linked filedescriptor       */
 441                 if (write(n, a, ARSIZE) != ARSIZE) e(4);
 442                 if (read(n1, b, ARSIZE) != ARSIZE) e(5);
 443                 if (comp_array(a, b, ARSIZE) != OK) e(6);
 444
 445                 /* Clean up: unlink and close (twice): */
 446                 Remove(n, f);
 447                 try_close(n1, "'linkfile10'");
 448
 449                 /* Check if "linkfile" exists and the info    * on it
 450                  * is correct ('file' has been deleted) */
 451                 if ((n1 = open(lf, R)) < 0) e(7);
 452                 else {
 453                         /* See if 'linkfile' still contains 0..511 ? */
 454
 455                         clear_array(b);
 456                         if (read(n1, b, ARSIZE) != ARSIZE) e(8);
 457                         if (comp_array(a, b, ARSIZE) != OK) e(9);
 458
 459                         try_close(n1, "'linkfile10' 2nd time");
 460                         try_unlink(lf);
 461                 }
 462         }
 463   }
 464
 465   /* Try if unlink fails with incorrect parameters */
 466   /* File does not exist: */
 467   if (unlink("non-file") != FAIL) e(10);
 468   else
 469         if (errno != ENOENT) e(11);
 470
 471   /* Dir can't be written */
 472   if (unlink("dr-x/rwx") != FAIL) e(12);
 473   else
 474         if (errno != EACCES) e(13);
 475
 476   /* Try to unlink a dir being user */
 477   if (unlink("drwx") != FAIL) e(14);
 478   else
 479         if (errno != EPERM) e(15);
 480
 481   /* Try giving link wrong input */
 482
 483   /* First try if link fails with incorrect parameters * name1 does not
 484    * exist.                             */
 485   if (link("non-file", "linkfile") != FAIL) e(16);
 486   else
 487         if (errno != ENOENT) e(17);
 488
 489   /* Name2 exists already */
 490   if (link("drwx/rwx", "drwx/rw-") != FAIL) e(18);
 491   else
 492         if (errno != EEXIST) e(19);
 493
 494   /* Directory of name2 not writable:  */
 495   if (link("drwx/rwx", "dr-x/linkfile") != FAIL) e(20);
 496   else
 497         if (errno != EACCES) e(21);
 498
 499   /* Try to link a dir, being a user */
 500   if (link("drwx", "linkfile") != FAIL) e(22);
 501   else
 502         if (errno != EPERM) e(23);
 503
 504   /* File has too many links */
 505   if ((n = link_alot("drwx/rwx")) != LINKCOUNT - 1)     /* file already has one
 506                                                          * link */
 507         e(24);
 508   if (unlink_alot(n) != n) e(25);
 509
 510 }                               /* test10 */
 511
 512 int link_alot(bigboss)
 513 char *bigboss;
 514 {
 515   int i;
 516   static char employee[6] = "aaaaa";
 517
 518   /* Every file has already got 1 link, so link 0176 times */
 519   for (i = 1; i < LINKCOUNT; i++) {
 520         if (link(bigboss, employee) != OK)
 521                 break;
 522         else
 523                 get_new(employee);
 524   }
 525
 526   return(i - 1);                /* number of linked files */
 527 }                               /* link_alot */
 528
 529 int unlink_alot(number)
 530 int number;                     /* number of files to be unlinked */
 531 {
 532   int j;
 533   static char employee[6] = "aaaaa";
 534
 535   for (j = 0; j < number; j++) {
 536         if (unlink(employee) != OK)
 537                 break;
 538         else
 539                 get_new(employee);
 540   }
 541
 542   return(j);                    /* return number of unlinked files */
 543 }                               /* unlink_alot */
 544
 545 void get_new(name)
 546 char name[];
 547  /* Every call changes string 'name' to a string alphabetically          *
 548   * higher. Start with "aaaaa", next value: "aaaab" .                    *
 549   * N.B. after "aaaaz" comes "aaabz" and not "aaaba" (not needed).       *
 550   * The last possibility will be "zzzzz".                                *
 551   * Total # possibilities: 26+25*4 = 126 = MAXLINK -1 (exactly needed)   */
 552 {
 553   int i;
 554
 555   for (i = 4; i >= 0; i--)
 556         if (name[i] != 'z') {
 557                 name[i]++;
 558                 break;
 559         }
 560 }                               /* get_new */
 561
 562
 563 /*****************************************************************************
 564  *                              test PIPE                                    *
 565  ****************************************************************************/
 566 void test11()
 567 {
 568   int n, fd[2];
 569   char a[ARSIZE], b[ARSIZE];
 570
 571   subtest = 11;
 572
 573   if (pipe(fd) != OK) e(1);
 574   else {
 575         /* Try reading and writing on a pipe */
 576         init_array(a);
 577         clear_array(b);
 578
 579         if (write(fd[1], a, ARSIZE) != ARSIZE) e(2);
 580         else if (read(fd[0], b, (ARSIZE / 2)) != (ARSIZE / 2)) e(3);
 581         else if (comp_array(a, b, (ARSIZE / 2)) != OK) e(4);
 582         else if (read(fd[0], b, (ARSIZE / 2)) != (ARSIZE / 2)) e(5);
 583         else if (comp_array(&a[ARSIZE / 2], b, (ARSIZE / 2)) != OK) e(6);
 584
 585         /* Try to let the pipe make a mistake */
 586         if (write(fd[0], a, ARSIZE) != FAIL) e(7);
 587         if (read(fd[1], b, ARSIZE) != FAIL) e(8);
 588
 589         try_close(fd[1], "'fd[1]'");
 590
 591         /* Now we shouldn't be able to read, because fd[1] has been closed */
 592         if (read(fd[0], b, ARSIZE) != END_FILE) e(9);
 593
 594         try_close(fd[0], "'fd[0]'");
 595   }
 596   if (pipe(fd) < 0) e(10);
 597   else {
 598         /* Test lseek on a pipe: should fail */
 599         if (write(fd[1], a, ARSIZE) != ARSIZE) e(11);
 600         if (lseek(fd[1], 10L, SEEK_SET) != FAIL) e(12);
 601         else
 602                 if (errno != ESPIPE) e(13);
 603
 604         /* Eat half of the pipe: no writing should be possible */
 605         try_close(fd[0], "'fd[0]'  (2nd time)");
 606
 607         /* This makes UNIX crash: omit it if pdp or VAX */
 608 #ifndef NOCRASH
 609         if (write(fd[1], a, ARSIZE) != FAIL) e(14);
 610         else
 611                 if (errno != EPIPE) e(15);
 612 #endif
 613         try_close(fd[1], "'fd[1]'  (2nd time)");
 614   }
 615
 616   /* BUG :                                                            *
 617    * Here we planned to test if we could write 4K bytes on a pipe.    *
 618    * However, this was not possible to implement, because the whole   *
 619    * Monix system crashed when we tried to write more then 3584 bytes *
 620    * (3.5K) on a pipe. That's why we try to write only 3.5K in the    *
 621    * folowing test.                                                   */
 622   if (pipe(fd) < 0) e(16);
 623   else {
 624         for (n = 0; n < (PIPESIZE / ARSIZE); n++)
 625                 if (write(fd[1], a, ARSIZE) != ARSIZE) e(17);
 626         try_close(fd[1], "'fd[1]' (3rd time)");
 627
 628         for (n = 0; n < (PIPESIZE / ARSIZE); n++)
 629                 if (read(fd[0], b, ARSIZE) != ARSIZE) e(18);
 630         try_close(fd[0], "'fd[0]' (3rd time)");
 631   }
 632
 633   /* Test opening a lot of files */
 634   if ((n = open_alot()) != MAXOPEN) e(19);
 635   if (pipe(fd) != FAIL) e(20);
 636   else
 637         if (errno != EMFILE) e(21);
 638   if (close_alot(n) != n) e(22);
 639 }                               /* test11 */
 640
 641
 642 /* Err, test03, init_array, clear_array, comp_array,
 643    try_close, try_unlink, Remove, get_mode, check, open_alot,
 644    close_alot, clean_up_the_mess.
 645 */
 646
 647
 648 /*****************************************************************************
 649 *                                                                            *
 650 *                          MAKE_AND_FILL_DIRS                                *
 651 *                                                                            *
 652 *****************************************************************************/
 653
 654 void test03()
 655  /* Create 8 dir.'s: "d---", "d--x", "d-w-", "d-wx", "dr--", "dr-x",     *
 656   * "drw-", "drwx".                                     * Then create 8 files
 657   * in "drwx", and some needed files in other dirs.  */
 658 {
 659   int mode, i;
 660   subtest = 3;
 661   for (i = 0; i < MODES; i++) {
 662         mkdir(mode_dir[i], 0700);
 663         chown(mode_dir[i], USER_ID, GROUP_ID);
 664   }
 665   setuid(USER_ID);
 666   setgid(GROUP_ID);
 667
 668   for (mode = 0; mode < 8; mode++) put_file_in_dir("drwx", mode);
 669
 670   put_file_in_dir("d-wx", RWX);
 671   put_file_in_dir("dr-x", RWX);
 672   put_file_in_dir("drw-", RWX);
 673
 674   chmod_8_dirs(8);              /* 8 means; 8 different modes */
 675
 676 }                               /* test03 */
 677
 678 void put_file_in_dir(dirname, mode)
 679 char *dirname;
 680 int mode;
 681  /* Fill directory 'dirname' with file with mode 'mode'.   */
 682 {
 683   int nr;
 684
 685   if (chdir(dirname) != OK) e(1);
 686   else {
 687         /* Creat the file */
 688         assert(mode >= 0 && mode < MODES);
 689         if ((nr = creat(mode_fnames[mode], mode * 0100)) < 0) e(2);
 690         else {
 691                 try_close(nr, mode_fnames[mode]);
 692         }
 693
 694         if (chdir("..") != OK) e(3);
 695   }
 696 }                               /* put_file_in_dir */
 697
 698 /*****************************************************************************
 699 *                                                                            *
 700 *                               MISCELLANEOUS                                *
 701 *                                                                            *
 702 *(all about arrays, 'try_close', 'try_unlink', 'Remove', 'get_mode')*
 703 *                                                                            *
 704 *****************************************************************************/
 705
 706 void init_array(a)
 707 char *a;
 708 {
 709   int i;
 710
 711   i = 0;
 712   while (i++ < ARSIZE) *a++ = 'a' + (i % 26);
 713 }                               /* init_array */
 714
 715 void clear_array(b)
 716 char *b;
 717 {
 718   int i;
 719
 720   i = 0;
 721   while (i++ < ARSIZE) *b++ = '0';
 722
 723 }                               /* clear_array */
 724
 725 int comp_array(a, b, range)
 726 char *a, *b;
 727 int range;
 728 {
 729   assert(range >= 0 && range <= ARSIZE);
 730   while (range-- && (*a++ == *b++));
 731   if (*--a == *--b)
 732         return(OK);
 733   else
 734         return(FAIL);
 735 }                               /* comp_array */
 736
 737 void try_close(filedes, name)
 738 int filedes;
 739 char *name;
 740 {
 741   if (close(filedes) != OK) e(90);
 742 }                               /* try_close */
 743
 744 void try_unlink(fname)
 745 char *fname;
 746 {
 747   if (unlink(fname) != 0) e(91);
 748 }                               /* try_unlink */
 749
 750 void Remove(fdes, fname)
 751 int fdes;
 752 char *fname;
 753 {
 754   try_close(fdes, fname);
 755   try_unlink(fname);
 756 }                               /* Remove */
 757
 758 int get_mode(name)
 759 char *name;
 760 {
 761   struct stat stbf1;
 762
 763   if (stat(name, &stbf1) != OK) {
 764         e(92);
 765         return(stbf1.st_mode);  /* return a mode which will cause *
 766                                  * error in the calling function  *
 767                                  * (file/dir bit)                 */
 768   } else
 769         return(stbf1.st_mode & 07777);  /* take last 4 bits */
 770 }                               /* get_mode */
 771
 772
 773 /*****************************************************************************
 774 *                                                                            *
 775 *                                ALOT-functions                              *
 776 *                                                                            *
 777 *****************************************************************************/
 778
 779 int open_alot()
 780 {
 781   int i;
 782
 783   for (i = 0; i < MAXOPEN; i++)
 784         if (open(filenames[i], R) == FAIL) break;
 785   if (i == 0) e(93);
 786   return(i);
 787 }                               /* open_alot */
 788
 789 int close_alot(number)
 790 int number;
 791 {
 792   int i, count = 0;
 793
 794   if (number > MAXOPEN)
 795         e(94);
 796   else
 797         for (i = FF; i < number + FF; i++)
 798                 if (close(i) != OK) count++;
 799
 800   return(number - count);       /* return number of closed files */
 801 }                               /* close_alot */
 802
 803 /*****************************************************************************
 804 *                                                                            *
 805 *                         CLEAN UP THE MESS                                  *
 806 *                                                                            *
 807 *****************************************************************************/
 808
 809 void clean_up_the_mess()
 810 {
 811   int i;
 812   char dirname[6];
 813
 814   /* First remove 'a lot' files */
 815   for (i = 0; i < MAXOPEN; i++) {
 816         try_unlink(filenames[i]);
 817 }
 818
 819   /* Unlink the files in dir 'drwx' */
 820   if (chdir("drwx") != OK)
 821         e(95);
 822   else {
 823         for (i = 0; i < MODES; i++) {
 824                 try_unlink(mode_fnames[i]);
 825         }
 826         if (chdir("..") != OK) e(96);
 827   }
 828
 829   /* Before unlinking files in some dirs, make them writable */
 830   chmod_8_dirs(RWX);
 831
 832   /* Unlink files in other dirs */
 833   try_unlink("d-wx/rwx");
 834   try_unlink("dr-x/rwx");
 835   try_unlink("drw-/rwx");
 836
 837   /* Unlink dirs */
 838   for (i = 0; i < MODES; i++) {
 839         strcpy(dirname, "d");
 840         strcat(dirname, mode_fnames[i]);
 841
 842         /* 'dirname' contains the directoryname */
 843         rmdir(dirname);
 844   }
 845
 846   /* FINISH */
 847 }                               /* clean_up_the_mess */
 848
 849 void chmod_8_dirs(sw)
 850 int sw;                         /* if switch == 8, give all different
 851                          * mode,else the same mode */
 852 {
 853   int mode;
 854   int i;
 855
 856   if (sw == 8)
 857         mode = 0;
 858   else
 859         mode = sw;
 860
 861   for (i = 0; i < MODES; i++) {
 862         chmod(mode_dir[i], 040000 + mode * 0100);
 863         if (sw == 8) mode++;
 864   }
 865 }
 866