/* Comment on usage and program: ark!/mnt/rene/prac/os/unix/comment.changes */

/* "const.h", created by Rene Montsma and Menno Wilcke */

#include <sys/types.h> /* type defs */

#include <sys/stat.h> /* struct stat */

#include <sys/wait.h>

#include <errno.h> /* the error-numbers */

#include <fcntl.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <utime.h>

#include <stdio.h>

#define NOCRASH 1 /* test11(), 2nd pipe */

#define PDPNOHANG 1 /* test03(), write_standards() */

#define MAXERR 2

#define USER_ID 12

#define GROUP_ID 1

#define FF 3 /* first free filedes. */

#define USER 1 /* uid */

#define GROUP 0 /* gid */

#define ARSIZE 256 /* array size */

#define PIPESIZE 3584 /* max number of bytes to be written on pipe */

#define MAXOPEN 17 /* maximum number of extra open files */

#define MAXLINK 0177 /* maximum number of links per file */

#define LINKCOUNT 5

#define MASK 0777 /* selects lower nine bits */

#define END_FILE 0 /* returned by read-call at eof */

#define OK 0

#define FAIL -1

#define R 0 /* read (open-call) */

#define W 1 /* write (open-call) */

#define RW 2 /* read & write (open-call) */

#define RWX 7 /* read & write & execute (mode) */

#define NIL ""

#define UMASK "umask"

#define CREAT "creat"

#define WRITE "write"

#define READ "read"

#define OPEN "open"

#define CLOSE "close"

#define LSEEK "lseek"

#define ACCESS "access"

#define CHDIR "chdir"

#define CHMOD "chmod"

#define LINK "link"

#define UNLINK "unlink"

#define PIPE "pipe"

#define STAT "stat"

#define FSTAT "fstat"

#define DUP "dup"

#define UTIME "utime"

int errct;

char *file[];

char *fnames[];

char *dir[];

/* "decl.c", created by Rene Montsma and Menno Wilcke */

/* Used in open_alot, close_alot */

char *file[20] = {"f0", "f1", "f2", "f3", "f4", "f5", "f6",

"f7", "f8", "f9", "f10", "f11", "f12", "f13",

"f14", "f15", "f16", "f17", "f18", "f19"}, *fnames[8] = {"---", "--x", "-w-", "-wx", "r--",

"r-x", "rw-", "rwx"}, *dir[8] = {"d---", "d--x", "d-w-", "d-wx", "dr--", "dr-x",

"drw-", "drwx"};

/* Needed for easy creating and deleting of directories */

/* "test.c", created by Rene Montsma and Menno Wilcke */

_PROTOTYPE(int main, (int argc, char *argv []));

_PROTOTYPE(void test, (int mask));

_PROTOTYPE(void test01, (void));

_PROTOTYPE(void test02, (void));

_PROTOTYPE(void test08, (void));

_PROTOTYPE(void test09, (void));

_PROTOTYPE(void test10, (void));

_PROTOTYPE(int link_alot, (char *bigboss));

_PROTOTYPE(int unlink_alot, (int number));

_PROTOTYPE(void get_new, (char name []));

_PROTOTYPE(void test11, (void));

_PROTOTYPE(void comp_stats, (struct stat *stbf1, struct stat *stbf2));

_PROTOTYPE(void comp_inodes, (int m, int m1));

_PROTOTYPE(void e, (char *string));

_PROTOTYPE(void nlcr, (void));

_PROTOTYPE(void str, (char *s));

_PROTOTYPE(void err, (int number, char *scall, char *name));

_PROTOTYPE(void make_and_fill_dirs, (void));

_PROTOTYPE(void put_file_in_dir, (char *dirname, int mode));

_PROTOTYPE(void init_array, (char *a));

_PROTOTYPE(void clear_array, (char *b));

_PROTOTYPE(int comp_array, (char *a, char *b, int range));

_PROTOTYPE(void try_close, (int filedes, char *name));

_PROTOTYPE(void try_unlink, (char *fname));

_PROTOTYPE(void Remove, (int fdes, char *fname));

_PROTOTYPE(int get_mode, (char *name));

_PROTOTYPE(void check, (char *scall, int number));

_PROTOTYPE(void put, (int nr));

_PROTOTYPE(int open_alot, (void));

_PROTOTYPE(int close_alot, (int number));

_PROTOTYPE(void clean_up_the_mess, (void));

_PROTOTYPE(void chmod_8_dirs, (int sw));

_PROTOTYPE(void quit, (void));

/*****************************************************************************

* TEST *

****************************************************************************/

int main(argc, argv)

int argc;

char *argv[];

{

int n, mask;

sync();

if (geteuid() == 0 || getuid() == 0) {

printf("Test 17 cannot run as root; test aborted\n");

exit(1);

}

system("rm -rf DIR_18; mkdir DIR_18");

chdir("DIR_18");

mask = (argc == 2 ? atoi(argv[1]) : 0xFFFF);

if (fork()) {

printf("Test 17 ");

fflush(stdout);

wait(&n);

clean_up_the_mess();

quit();

} else {

test(mask);

exit(0);

}

return(-1); /* impossible */

}

void test(mask)

int mask;

{

umask(0); /* not honest, but i always forget */

if (mask & 00001) test01();

if (mask & 00002) make_and_fill_dirs();

if (mask & 00004) test02();

if (mask & 00010) test08();

if (mask & 00020) test09();

if (mask & 00040) test10();

if (mask & 00100) test11();

umask(022);

} /* test */

/* "t1.c" created by Rene Montsma and Menno Wilcke */

/*****************************************************************************

* test UMASK *

****************************************************************************/

void test01()

{

int oldvalue, newvalue, tempvalue;

int nr;

if ((oldvalue = umask(0777)) != 0) err(0, UMASK, NIL);

/* Special test: only the lower 9 bits (protection bits) may part- *

* icipate. ~0777 means: 111 000 000 000. Giving this to umask must*

* not change any value. */

if ((newvalue = umask(~0777)) != 0777) err(1, UMASK, "illegal");

if (oldvalue == newvalue) err(11, UMASK, "not change mask");

if ((tempvalue = umask(0)) != 0) err(2, UMASK, "values");

/* Now test all possible modes of umask on a file */

for (newvalue = MASK; newvalue >= 0; newvalue -= 0111) {

tempvalue = umask(newvalue);

if (tempvalue != oldvalue) {

err(1, UMASK, "illegal");

break; /* no use trying more */

} else if ((nr = creat("file01", 0777)) < 0)

err(5, CREAT, "'file01'");

else {

try_close(nr, "'file01'");

if (get_mode("file01") != (MASK & ~newvalue))

err(7, UMASK, "mode computed");

try_unlink("file01");

}

oldvalue = newvalue;

}

/* The loop has terminated with umask(0) */

if ((tempvalue = umask(0)) != 0)

err(7, UMASK, "umask may influence rest of tests!");

} /* test01 */

/*****************************************************************************

* test CREAT *

****************************************************************************/

void test02()

{

int n, n1, mode;

char a[ARSIZE], b[ARSIZE];

struct stat stbf1;

mode = 0;

/* Create twenty files, check filedes */

for (n = 0; n < MAXOPEN; n++) {

if (creat(file[n], mode) != FF + n)

err(13, CREAT, file[n]);

else {

if (get_mode(file[n]) != mode)

err(7, CREAT, "mode set while creating many files");

/* Change mode of file to standard mode, we want to *

* use a lot (20) of files to be opened later, see *

* open_alot(), close_alot(). */

if (chmod(file[n], 0700) != OK) err(5, CHMOD, file[n]);

}

mode = (mode + 0100) % 01000;

}

/* Already twenty files opened; opening another has to fail */

if (creat("file02", 0777) != FAIL)

err(9, CREAT, "created");

else

check(CREAT, EMFILE);

/* Close all files: seems blunt, but it isn't because we've *

* checked all fd's already */

if ((n = close_alot(MAXOPEN)) < MAXOPEN) err(5, CLOSE, "MAXOPEN files");

/* Creat 1 file twice; check */

if ((n = creat("file02", 0777)) < 0)

err(5, CREAT, "'file02'");

else {

init_array(a);

if (write(n, a, ARSIZE) != ARSIZE) err(1, WRITE, "bad");

if ((n1 = creat("file02", 0755)) < 0) /* receate 'file02' */

err(5, CREAT, "'file02' (2nd time)");

else {

/* Fd should be at the top after recreation */

if (lseek(n1, 0L, SEEK_END) != 0)

err(11, CREAT, "not truncate file by recreation");

else {

/* Try to write on recreated file */

clear_array(b);

if (lseek(n1, 0L, SEEK_SET) != 0)

err(5, LSEEK, "to top of 2nd fd 'file02'");

if (write(n1, a, ARSIZE) != ARSIZE)

err(1, WRITE, "(2) bad");

/* In order to read we've to close and open again */

try_close(n1, "'file02' (2nd creation)");

if ((n1 = open("file02", RW)) < 0)

err(5, OPEN, "'file02' (2nd recreation)");

/* Continue */

if (lseek(n1, 0L, SEEK_SET) != 0)

err(5, LSEEK, "to top 'file02'(2nd fd) (2)");

if (read(n1, b, ARSIZE) != ARSIZE)

err(1, READ, "wrong");

if (comp_array(a, b, ARSIZE) != OK) err(11, CREAT,

"not really truncate file by recreation");

}

if (get_mode("file02") != 0777)

err(11, CREAT, "not maintain mode by recreation");

try_close(n1, "recreated 'file02'");

}

Remove(n, "file02");

}

/* Give 'creat' wrong input: dir not searchable */

if (creat("drw-/file02", 0777) != FAIL)

err(4, CREAT, "'drw-'");

else

check(CREAT, EACCES);

/* Dir not writable */

if (creat("dr-x/file02", 0777) != FAIL)

err(12, CREAT, "'dr-x/file02'");

else

check(CREAT, EACCES);

/* File not writable */

if (creat("drwx/r-x", 0777) != FAIL)

err(11, CREAT, "recreate non-writable file");

else

check(CREAT, EACCES);

/* Try to creat a dir */

if ((n = creat("dir", 040777)) != FAIL) {

if (fstat(n, &stbf1) != OK)

err(5, FSTAT, "'dir'");

else if (stbf1.st_mode != (mode_t) 0100777)

/* cast because mode is negative :-( */

err(11, CREAT, "'creat' a new directory");

Remove(n, "dir");

}

/* We don't consider it to be a bug when creat * does not accept

* tricky modes */

/* File is an existing dir */

if (creat("drwx", 0777) != FAIL)

err(11, CREAT, "create an existing dir!");

else

check(CREAT, EISDIR);

} /* test02 */

void test08()

{

/* Test chdir to searchable dir */

if (chdir("drwx") != OK)

err(5, CHDIR, "to accessible dir");

else if (chdir("..") != OK)

err(11, CHDIR, "not return to '..'");

/* Check the chdir(".") and chdir("..") mechanism */

if (chdir("drwx") != OK)

err(5, CHDIR, "to 'drwx'");

else {

if (chdir(".") != OK) err(5, CHDIR, "to working dir (.)");

/* If we still are in 'drwx' , we should be able to access *

* file 'rwx'. */

if (access("rwx", 0) != OK) err(5, CHDIR, "rightly to '.'");

/* Try to return to previous dir ('/' !!) */

if (chdir("././../././d--x/../d--x/././..") != OK)

err(5, CHDIR, "to motherdir (..)");

/* Check whether we are back in '/' */

if (chdir("d--x") != OK) err(5, CHDIR, "rightly to a '..'");

}

/* Return to '..' */

if (chdir("..") != OK) err(5, CHDIR, "to '..'");

if (chdir("././././drwx") != OK)

err(11, CHDIR, "not follow a path");

else if (chdir("././././..") != OK)

err(11, CHDIR, "not return to path");

/* Try giving chdir wrong parameters */

if (chdir("drwx/rwx") != FAIL)

err(11, CHDIR, "chdir to a file");

else

check(CHDIR, ENOTDIR);

if (chdir("drw-") != FAIL)

err(4, CHDIR, "'/drw-'");

else

check(CHDIR, EACCES);

/* To be sure: return to root */

/* If (chdir("/") != OK) err(5, CHDIR, "to '/' (2nd time)"); */

} /* test08 */

/* New page */

/*****************************************************************************

* test CHMOD *

****************************************************************************/

void test09()

{

int n;

/* Prepare file09 */

if ((n = creat("drwx/file09", 0644)) != FF) err(5, CREAT, "'drwx/file09'");

try_close(n, "'file09'");

/* Try to chmod a file, check and restore old values, check */

if (chmod("drwx/file09", 0700) != OK)

err(5, CHMOD, "'drwx/file09'"); /* set rwx */

else {

/* Check protection */

if (get_mode("drwx/file09") != 0700) err(7, CHMOD, "mode");

/* Test if chmod accepts just filenames too */

if (chdir("drwx") != OK)

err(5, CHDIR, "to '/drwx'");

else if (chmod("file09", 0177) != OK) /* restore oldies */

err(5, CHMOD, "'h1'");

else

/* Check if value has been restored */

if (get_mode("../drwx/file09") != 0177)

err(7, CHMOD, "restored mode");

}

/* Try setuid and setgid */

if ((chmod("file09", 04777) != OK) || (get_mode("file09") != 04777))

err(11, CHMOD, "not set uid-bit");

if ((chmod("file09", 02777) != OK) || (get_mode("file09") != 02777))

err(11, CHMOD, "not set gid-bit");

/* Remove testfile */

try_unlink("file09");

if (chdir("..") != OK) err(5, CHDIR, "to '..'");

/* Try to chmod directory */

if (chmod("d---", 0777) != OK)

err(5, CHMOD, "dir 'd---'");

else {

if (get_mode("d---") != 0777) err(7, CHMOD, "protection value");

if (chmod("d---", 0000) != OK) err(5, CHMOD, "dir 'a' 2nd time");

/* Check if old value has been restored */

if (get_mode("d---") != 0000)

err(7, CHMOD, "restored protection value");

}

/* Try to make chmod failures */

/* We still are in dir root */

/* Wrong filename */

if (chmod("non-file", 0777) != FAIL)

err(3, CHMOD, NIL);

else

check(CHMOD, ENOENT);

} /* test 09 */

/* New page */

/* "t4.c", created by Rene Montsma and Menno Wilcke */

/*****************************************************************************

* test LINK/UNLINK *

****************************************************************************/

void test10()

{

int n, n1;

char a[ARSIZE], b[ARSIZE], *f, *lf;

f = "file10";

lf = "linkfile10";

if ((n = creat(f, 0702)) != FF) /* no other open files */

err(13, CREAT, f);

else {

/* Now link correctly */

if (link(f, lf) != OK)

err(5, LINK, lf);

else if ((n1 = open(lf, RW)) < 0)

err(5, OPEN, "'linkfile10'");

else {

init_array(a);

clear_array(b);

/* Write on 'file10' means being able to * read

* through linked filedescriptor */

if (write(n, a, ARSIZE) != ARSIZE) err(1, WRITE, "bad");

if (read(n1, b, ARSIZE) != ARSIZE) err(1, READ, "bad");

if (comp_array(a, b, ARSIZE) != OK) err(8, "r/w", NIL);

/* Clean up: unlink and close (twice): */

Remove(n, f);

try_close(n1, "'linkfile10'");

/* Check if "linkfile" exists and the info * on it

* is correct ('file' has been deleted) */

if ((n1 = open(lf, R)) < 0)

err(5, OPEN, "'linkfile10'");

else {

/* See if 'linkfile' still contains 0..511 ? */

clear_array(b);

if (read(n1, b, ARSIZE) != ARSIZE)

err(1, READ, "bad");

if (comp_array(a, b, ARSIZE) != OK)

err(8, "r/w", NIL);

try_close(n1, "'linkfile10' 2nd time");

try_unlink(lf);

}

}

}

/* Try if unlink fails with incorrect parameters */

/* File does not exist: */

if (unlink("non-file") != FAIL)

err(2, UNLINK, "name");

else

check(UNLINK, ENOENT);

/* Dir can't be written */

if (unlink("dr-x/rwx") != FAIL)

err(11, UNLINK, "could unlink in non-writable dir.");

else

check(UNLINK, EACCES);

/* Try to unlink a dir being user */

if (unlink("drwx") != FAIL)

err(11, UNLINK, "unlink dir's as user");

else

check(UNLINK, EPERM);

/* Try giving link wrong input */

/* First try if link fails with incorrect parameters * name1 does not

* exist. */

if (link("non-file", "linkfile") != FAIL)

err(2, LINK, "1st name");

else

check(LINK, ENOENT);

/* Name2 exists already */

if (link("drwx/rwx", "drwx/rw-") != FAIL)

err(2, LINK, "2nd name");

else

check(LINK, EEXIST);

/* Directory of name2 not writable: */

if (link("drwx/rwx", "dr-x/linkfile") != FAIL)

err(11, LINK, "link non-writable file");

else

check(LINK, EACCES);

/* Try to link a dir, being a user */

if (link("drwx", "linkfile") != FAIL)

err(11, LINK, "link a dir without superuser!");

else

check(LINK, EPERM);

/* File has too many links */

if ((n = link_alot("drwx/rwx")) != LINKCOUNT - 1) /* file already has one

* link */

err(5, LINK, "many files");

if (unlink_alot(n) != n) err(5, UNLINK, "all linked files");

} /* test10 */

int link_alot(bigboss)

char *bigboss;

{

int i;

static char employee[6] = "aaaaa";

/* Every file has already got 1 link, so link 0176 times */

for (i = 1; i < LINKCOUNT; i++) {

if (link(bigboss, employee) != OK)

break;

else

get_new(employee);

}

return(i - 1); /* number of linked files */

} /* link_alot */

int unlink_alot(number)

int number; /* number of files to be unlinked */

{

int j;

static char employee[6] = "aaaaa";

for (j = 0; j < number; j++) {

if (unlink(employee) != OK)

break;

else

get_new(employee);

}

return(j); /* return number of unlinked files */

} /* unlink_alot */

void get_new(name)

char name[];

/* Every call changes string 'name' to a string alphabetically *

* higher. Start with "aaaaa", next value: "aaaab" . *

* N.B. after "aaaaz" comes "aaabz" and not "aaaba" (not needed). *

* The last possibility will be "zzzzz". *

* Total # possibilities: 26+25*4 = 126 = MAXLINK -1 (exactly needed) */

{

int i;

for (i = 4; i >= 0; i--)

if (name[i] != 'z') {

name[i]++;

break;

}

} /* get_new */

/* New page */

/*****************************************************************************

* test PIPE *

****************************************************************************/

void test11()

{

int n, fd[2];

char a[ARSIZE], b[ARSIZE];

if (pipe(fd) != OK)

err(13, PIPE, NIL);

else {

/* Try reading and writing on a pipe */

init_array(a);

clear_array(b);

if (write(fd[1], a, ARSIZE) != ARSIZE)

err(5, WRITE, "on pipe");

else if (read(fd[0], b, (ARSIZE / 2)) != (ARSIZE / 2))

err(5, READ, "on pipe (2nd time)");

else if (comp_array(a, b, (ARSIZE / 2)) != OK)

err(7, PIPE, "values read/written");

else if (read(fd[0], b, (ARSIZE / 2)) != (ARSIZE / 2))

err(5, READ, "on pipe 2");

else if (comp_array(&a[ARSIZE / 2], b, (ARSIZE / 2)) != OK)

err(7, PIPE, "pipe created");

/* Try to let the pipe make a mistake */

if (write(fd[0], a, ARSIZE) != FAIL)

err(11, WRITE, "write on fd[0]");

if (read(fd[1], b, ARSIZE) != FAIL) err(11, READ, "read on fd[1]");

try_close(fd[1], "'fd[1]'");

/* Now we shouldn't be able to read, because fd[1] has been closed */

if (read(fd[0], b, ARSIZE) != END_FILE) err(2, PIPE, "'fd[1]'");

try_close(fd[0], "'fd[0]'");

}

if (pipe(fd) < 0)

err(5, PIPE, "2nd time");

else {

/* Test lseek on a pipe: should fail */

if (write(fd[1], a, ARSIZE) != ARSIZE)

err(5, WRITE, "on pipe (2nd time)");

if (lseek(fd[1], 10L, SEEK_SET) != FAIL)

err(11, LSEEK, "lseek on a pipe");

else

check(PIPE, ESPIPE);

/* Eat half of the pipe: no writing should be possible */

try_close(fd[0], "'fd[0]' (2nd time)");

/* This makes UNIX crash: omit it if pdp or VAX */

#ifndef NOCRASH

if (write(fd[1], a, ARSIZE) != FAIL)

err(11, WRITE, "write on wrong pipe");

else

check(PIPE, EPIPE);

#endif

try_close(fd[1], "'fd[1]' (2nd time)");

}

/* BUG : *

* Here we planned to test if we could write 4K bytes on a pipe. *

* However, this was not possible to implement, because the whole *

* Monix system crashed when we tried to write more then 3584 bytes *

* (3.5K) on a pipe. That's why we try to write only 3.5K in the *

* folowing test. */

if (pipe(fd) < 0)

err(5, PIPE, "3rd time");

else {

for (n = 0; n < (PIPESIZE / ARSIZE); n++)

if (write(fd[1], a, ARSIZE) != ARSIZE)

err(5, WRITE, "on pipe (3rd time) 4K");

try_close(fd[1], "'fd[1]' (3rd time)");

for (n = 0; n < (PIPESIZE / ARSIZE); n++)

if (read(fd[0], b, ARSIZE) != ARSIZE)

err(5, READ, "from pipe (3rd time) 4K");

try_close(fd[0], "'fd[0]' (3rd time)");

}

/* Test opening a lot of files */

if ((n = open_alot()) != MAXOPEN) err(5, OPEN, "MAXOPEN files");

if (pipe(fd) != FAIL)

err(9, PIPE, "open");

else

check(PIPE, EMFILE);

if (close_alot(n) != n) err(5, CLOSE, "all opened files");

} /* test11 */

/* New page */

void comp_stats(stbf1, stbf2)

struct stat *stbf1, *stbf2;

{

if (stbf1->st_dev != stbf2->st_dev) err(7, "st/fst", "'dev'");

if (stbf1->st_ino != stbf2->st_ino) err(7, "st/fst", "'ino'");

if (stbf1->st_mode != stbf2->st_mode) err(7, "st/fst", "'mode'");

if (stbf1->st_nlink != stbf2->st_nlink) err(7, "st/fst", "'nlink'");

if (stbf1->st_uid != stbf2->st_uid) err(7, "st/fst", "'uid'");

if (stbf1->st_gid != stbf2->st_gid) err(7, "st/fst", "'gid'");

if (stbf1->st_rdev != stbf2->st_rdev) err(7, "st/fst", "'rdev'");

if (stbf1->st_size != stbf2->st_size) err(7, "st/fst", "'size'");

if (stbf1->st_atime != stbf2->st_atime) err(7, "st/fst", "'atime'");

if (stbf1->st_mtime != stbf2->st_mtime) err(7, "st/fst", "'mtime'");

} /* comp_stats */

/* New page */

/* "t5.c", created by Rene Montsma and Menno Wilcke */

void comp_inodes(m, m1)

int m, m1; /* twee filedes's */

{

struct stat stbf1, stbf2;

if (fstat(m, &stbf1) == OK)

if (fstat(m1, &stbf2) == OK) {

if (stbf1.st_ino != stbf2.st_ino)

err(7, DUP, "inode number");

} else

err(100, "comp_inodes", "cannot 'fstat' (m1)");

else

err(100, "comp_inodes", "cannot 'fstat' (m)");

} /* comp_inodes */

/* "support.c", created by Rene Montsma and Menno Wilcke */

/* Err, make_and_fill_dirs, init_array, clear_array, comp_array,

try_close, try_unlink, Remove, get_mode, check, open_alot,

close_alot, clean_up_the_mess.

*/

/***********************************************************************

* EXTENDED FIONS *

**********************************************************************/

/* First extended functions (i.e. not oldfashioned monixcalls.

e(), nlcr(), octal.*/

void e(string)

char *string;

{

printf("Error: %s ", string);

}

void nlcr()

{

printf("\n");

}

void str(s)

char *s;

{

printf(s);

}

/*****************************************************************************

* *

* ERR(or) messages *

* *

*****************************************************************************/

void err(number, scall, name)

/* Give nice error messages */

char *scall, *name;

int number;

{

errct++;

if (errct > MAXERR) {

printf("Too many errors; test aborted\n");

quit();

}

e("");

str("\t");

switch (number) {

case 0:

str(scall);

str(": illegal initial value.");

break;

case 1:

str(scall);

str(": ");

str(name);

str(" value returned.");

break;

case 2:

str(scall);

str(": accepting illegal ");

str(name);

str(".");

break;

case 3:

str(scall);

str(": accepting non-existing file.");

break;

case 4:

str(scall);

str(": could search non-searchable dir (");

str(name);

str(").");

break;

case 5:

str(scall);

str(": cannot ");

str(scall);

str(" ");

str(name);

str(".");

break;

case 7:

str(scall);

str(": incorrect ");

str(name);

str(".");

break;

case 8:

str(scall);

str(": wrong values.");

break;

case 9:

str(scall);

str(": accepting too many ");

str(name);

str(" files.");

break;

case 10:

str(scall);

str(": even a superuser can't do anything!");

break;

case 11:

str(scall);

str(": could ");

str(name);

str(".");

break;

case 12:

str(scall);

str(": could write in non-writable dir (");

str(name);

str(").");

break;

case 13:

str(scall);

str(": wrong filedes returned (");

str(name);

str(").");

break;

case 100:

str(scall); /* very common */

str(": ");

str(name);

str(".");

break;

default: str("errornumber does not exist!\n");

}

nlcr();

} /* err */

/*****************************************************************************

* *

* MAKE_AND_FILL_DIRS *

* *

*****************************************************************************/

void make_and_fill_dirs()

/* Create 8 dir.'s: "d---", "d--x", "d-w-", "d-wx", "dr--", "dr-x", *

* "drw-", "drwx". * Then create 8 files

* in "drwx", and some needed files in other dirs. */

{

int mode, i;

for (i = 0; i < 8; i++) {

mkdir(dir[i], 0700);

chown(dir[i], USER_ID, GROUP_ID);

}

setuid(USER_ID);

setgid(GROUP_ID);

for (mode = 0; mode < 8; mode++) put_file_in_dir("drwx", mode);

put_file_in_dir("d-wx", RWX);

put_file_in_dir("dr-x", RWX);

put_file_in_dir("drw-", RWX);

chmod_8_dirs(8); /* 8 means; 8 different modes */

} /* make_and_fill_dirs */

void put_file_in_dir(dirname, mode)

char *dirname;

int mode;

/* Fill directory 'dirname' with file with mode 'mode'. */

{

int nr;

if (chdir(dirname) != OK)

err(5, CHDIR, "to dirname (put_f_in_dir)");

else {

/* Creat the file */

if ((nr = creat(fnames[mode], mode * 0100)) < 0)

err(13, CREAT, fnames[mode]);

else

try_close(nr, fnames[mode]);

if (chdir("..") != OK)

err(5, CHDIR, "to previous dir (put_f_in_dir)");

}

} /* put_file_in_dir */

/*****************************************************************************

* *

* MISCELLANEOUS *

* *

*(all about arrays, 'try_close', 'try_unlink', 'Remove', 'get_mode')*

* *

*****************************************************************************/

void init_array(a)

char *a;

{

int i;

i = 0;

while (i++ < ARSIZE) *a++ = 'a' + (i % 26);

} /* init_array */

void clear_array(b)

char *b;

{

int i;

i = 0;

while (i++ < ARSIZE) *b++ = '0';

} /* clear_array */

int comp_array(a, b, range)

char *a, *b;

int range;

{

if ((range < 0) || (range > ARSIZE)) {

err(100, "comp_array", "illegal range");

return(FAIL);

} else {

while (range-- && (*a++ == *b++));

if (*--a == *--b)

return(OK);

else

return(FAIL);

}

} /* comp_array */

void try_close(filedes, name)

int filedes;

char *name;

{

if (close(filedes) != OK) err(5, CLOSE, name);

} /* try_close */

void try_unlink(fname)

char *fname;

{

if (unlink(fname) != 0) err(5, UNLINK, fname);

} /* try_unlink */

void Remove(fdes, fname)

int fdes;

char *fname;

{

try_close(fdes, fname);

try_unlink(fname);

} /* Remove */

int get_mode(name)

char *name;

{

struct stat stbf1;

if (stat(name, &stbf1) != OK) {

err(5, STAT, name);

return(stbf1.st_mode); /* return a mode which will cause *

* error in the calling function *

* (file/dir bit) */

} else

return(stbf1.st_mode & 07777); /* take last 4 bits */

} /* get_mode */

/*****************************************************************************

* *

* CHECK *

* *

*****************************************************************************/

void check(scall, number)

int number;

char *scall;

{

if (errno != number) {