text: /* Test24: opendir, readdir, rewinddir, closedir       Author: Jan-Mark Wams */
  
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <sys/wait.h>
  #include <string.h>
  #include <stdlib.h>
  #include <unistd.h>
  #include <limits.h>
  #include <fcntl.h>
  #include <dirent.h>
  #include <errno.h>
  #include <time.h>
  #include <stdio.h>
  
  _PROTOTYPE(void main, (int argc, char *argv[]));
  _PROTOTYPE(void chk_dir, (DIR * dirpntr));
  _PROTOTYPE(void test24a, (void));
  _PROTOTYPE(void test24b, (void));
  _PROTOTYPE(void test24c, (void));
  _PROTOTYPE(void makelongnames, (void));
  _PROTOTYPE(void e, (int number));
  _PROTOTYPE(void quit, (void));
  
  #define OVERFLOW_DIR_NR	(OPEN_MAX + 1)
  #define MAX_ERROR	4
  #define ITERATIONS 5
  
  #define DIRENT0	((struct dirent *) NULL)
  #define System(cmd)	if (system(cmd) != 0) printf("``%s'' failed\n", cmd)
  #define Chdir(dir)	if (chdir(dir) != 0) printf("Can't goto %s\n", dir)
  
  int errct = 0;
  int subtest = 1;
  int superuser;
  
  char MaxName[NAME_MAX + 1];	/* Name of maximum length */
  char MaxPath[PATH_MAX];		/* Same for path */
  char ToLongName[NAME_MAX + 2];	/* Name of maximum +1 length */
  char ToLongPath[PATH_MAX + 1];	/* Same for path, both too long */
  
  void main(argc, argv)
  int argc;
  char *argv[];
  {
    int i, m = 0xFFFF;
  
    sync();
    if (argc == 2) m = atoi(argv[1]);
    printf("Test 24 ");
    fflush(stdout);
    System("rm -rf DIR_24; mkdir DIR_24");
    Chdir("DIR_24");
    makelongnames();
    superuser = (geteuid() == 0);
  
    for (i = 0; i < ITERATIONS; i++) {
  	if (m & 0001) test24a();
  	if (m & 0002) test24b();
  	if (m & 0004) test24c();
    }
    quit();
  }
  
  void test24a()
  {				/* Test normal operations. */
    int fd3, fd4, fd5;
    DIR *dirp;
    int j, ret, fd, flags;
    struct stat st1, st2;
    int stat_loc;
    time_t time1;
  
    subtest = 1;
  
    System("rm -rf ../DIR_24/*");
  
    if ((fd = dup(0)) != 3) e(1);	/* dup stdin */
    close(fd);			/* free the fd again */
    dirp = opendir("/");		/* open "/" */
    if (dirp == ((DIR *) NULL)) e(2);	/* has to succseed */
    if ((fd = dup(0)) <= 2) e(3);	/* dup stdin */
    if (fd > 3) {			/* if opendir() uses fd 3 */
  	flags = fcntl(3, F_GETFD);	/* get fd fags of 3 */
  	if (!(flags & FD_CLOEXEC)) e(4);	/* it should be closed on */
    }				/* exec..() calls */
    close(fd);			/* free the fd again */
    ret = closedir(dirp);		/* close, we don't need it */
    if (ret == -1) e(5);		/* closedir () unsucces full */
    if (ret != 0) e(6);		/* should be 0 or -1 */
    if ((fd = dup(0)) != 3) e(7);	/* see if next fd is same */
    close(fd);			/* free the fd again */
  
    System("rm -rf foo; mkdir foo");
    Chdir("foo");
    System("touch f1 f2 f3 f4 f5");	/* make f1 .. f5 */
    System("rm f[24]");		/* creat `holes' in entrys */
    Chdir("..");
  
    if ((dirp = opendir("foo")) == ((DIR *) NULL)) e(8);	/* open foo */
    chk_dir(dirp);		/* test if foo's ok */
    for (j = 0; j < 10; j++) {
  	errno = j * 47 % 7;	/* there should */
  	if (readdir(dirp) != DIRENT0) e(9);	/* be nomore dir */
  	if (errno != j * 47 % 7) e(10);	/* entrys */
    }
    rewinddir(dirp);		/* rewind foo */
    chk_dir(dirp);		/* test foosok */
    for (j = 0; j < 10; j++) {
  	errno = j * 23 % 7;	/* there should */
  	if (readdir(dirp) != DIRENT0) e(11);	/* be nomore dir */
  	if (errno != j * 23 % 7) e(12);	/* entrys */
    }
    if ((fd4 = creat("foo/f4", 0666)) <= 2) e(13);	/* Open a file. */
    System("rm foo/f4");		/* Kill entry. */
    rewinddir(dirp);		/* Rewind foo. */
    if ((fd3 = open("foo/f3", O_WRONLY)) <= 2) e(14);	/* Open more files. */
    if ((fd5 = open("foo/f5", O_WRONLY)) <= 2) e(15);
    if (write(fd3, "Hello", 6) != 6) e(16);
    if (write(fd4, "Hello", 6) != 6) e(17);	/* write some data */
    if (close(fd5) != 0) e(18);
    chk_dir(dirp);
    for (j = 0; j < 10; j++) {
  	errno = j * 101 % 7;	/* there should */
  	if (readdir(dirp) != DIRENT0) e(19);	/* be nomore dir */
  	if (errno != j * 101 % 7) e(20);	/* entrys */
    }
    if (close(fd4) != 0) e(21);	/* shouldn't matter */
    if (close(fd3) != 0) e(22);	/* when we do this */
    if (closedir(dirp) != 0) e(23);	/* close foo again */
  
    Chdir("foo");
    if ((dirp = opendir(".//")) == ((DIR *) NULL)) e(24);	/* open foo again */
    Chdir("..");
    chk_dir(dirp);		/* foosok? */
    for (j = 0; j < 10; j++) {
  	errno = (j * 101) % 7;	/* there should */
  	if (readdir(dirp) != DIRENT0) e(25);	/* be nomore dir */
  	if (errno != (j * 101) % 7) e(26);	/* entrys */
    }
  
    if (closedir(dirp) != 0) e(27);	/* It should be closable */
  
    stat("foo", &st1);		/* get stat */
    time(&time1);
    while (time1 >= time((time_t *)0))
  	;
    if ((dirp = opendir("foo")) == ((DIR *) NULL)) e(28);	/* open, */
    if (readdir(dirp) == DIRENT0) e(29);	/* read and */
    stat("foo", &st2);		/* get new stat */
    if (st1.st_atime > st2.st_atime) e(30);	/* st_atime check */
  
    switch (fork()) {
        case -1:	printf("Can't fork\n");	break;
        case 0:
  	rewinddir(dirp);	/* rewind childs dirp */
  	if (readdir(dirp) == DIRENT0) e(31);	/* read should be ok */
  	if (closedir(dirp) != 0) e(32);	/* close child'd foo */
  	exit(0);		/* 0 stops here */
        default:
  	if (wait(&stat_loc) == -1) e(33);	/* PARENT wait()'s */
  	break;
    }
    if (closedir(dirp) != 0) e(34);	/* close parent's foo */
  }
  
  void test24b()
  {
  /* See what happens with too many dir's open.  Check if file size seems ok, 
   * and independency.
   */
  
    int i, j;			/* i = highest open dir count */
    DIR *dirp[OVERFLOW_DIR_NR], *dp;
    struct dirent *dep, *dep1, *dep2;
    char name[NAME_MAX + 2];	/* buffer for file name, and count */
    int dot = 0, dotdot = 0;
  
    subtest = 2;
  
    System("rm -rf ../DIR_24/*");
  
    for (i = 0; i < OVERFLOW_DIR_NR; i++) {
  	dirp[i] = opendir("/");
  	if (dirp[i] == ((DIR *) NULL)) {
  		if (errno != EMFILE) e(1);
  		break;
  	}
    }
    if (i <= 4) e(2);		/* sounds resanable */
    if (i >= OVERFLOW_DIR_NR) e(3);	/* might be to small */
    for (j = 0; j < i; j++) {
  	if (closedir(dirp[(j + 5) % i]) != 0) e(4);	/* neat! */
    }
  
    /* Now check if number of bytes in d_name can go up till NAME_MAX */
    System("rm -rf foo; mkdir foo");
    Chdir("foo");
    name[0] = 0;
    for (i = 0; i <= NAME_MAX; i++) {
  	if (strcat(name, "X") != name) e(5);
  	close(creat(name, 0666));	/* fails once on */
    }				/* XX..XX, 1 too long */
    Chdir("..");
    /* Now change i-th X to Y in name buffer record file of length i. */
    if ((dp = opendir("foo")) == ((DIR *) NULL)) e(6);
    while ((dep = readdir(dp)) != DIRENT0) {
  	if (strcmp("..", dep->d_name) == 0)
  		dotdot++;
  	else if (strcmp(".", dep->d_name) == 0)
  		dot++;
  	else
  		name[strlen(dep->d_name)] += 1;	/* 'X' + 1 == 'Y' */
    }
    if (closedir(dp) != 0) e(7);
    for (i = 1; i <= NAME_MAX; i++) {	/* Check if every length */
  	if (name[i] != 'Y') e(8);	/* has been seen once. */
    }
  
    /* Check upper and lower bound. */
    if (name[0] != 'X') e(9);
    if (name[NAME_MAX + 1] != '\0') e(10);
  
    /* Now check if two simultaniouse open dirs do the same */
    if ((dirp[1] = opendir("foo")) == ((DIR *) NULL)) e(11);
    if ((dirp[2] = opendir("foo")) == ((DIR *) NULL)) e(12);
    if ((dep1 = readdir(dirp[1])) == DIRENT0) e(13);
    if ((dep2 = readdir(dirp[2])) == DIRENT0) e(14);
    if (dep1->d_name == dep2->d_name) e(15);	/* 1 & 2 Should be */
    strcpy(name, dep2->d_name);	/* differand buffers */
    if (strcmp(dep1->d_name, name) != 0) e(16);	/* But hold the same */
    if ((dep1 = readdir(dirp[1])) == DIRENT0) e(17);
    if ((dep1 = readdir(dirp[1])) == DIRENT0) e(18);	/* lose some entries */
    if ((dep1 = readdir(dirp[1])) == DIRENT0) e(19);	/* Using dirp 1 has */
    if (dep1->d_name == dep2->d_name) e(20);	/* no effect on 2 */
    if (strcmp(dep2->d_name, name) != 0) e(21);
    rewinddir(dirp[1]);		/* Rewinding dirp 1 */
    if ((dep2 = readdir(dirp[2])) == DIRENT0) e(22);	/* can't effect 2 */
    if (strcmp(dep2->d_name, name) == 0) e(23);	/* Must be next */
    if (closedir(dirp[1]) != 0) e(24);	/* Closing dirp 1 */
    if ((dep2 = readdir(dirp[2])) == DIRENT0) e(25);	/* can't effect 2 */
    if (strcmp(dep2->d_name, name) == 0) e(26);	/* Must be next */
    if (closedir(dirp[2]) != 0) e(27);
  }
  
  void test24c()
  {
  /* Test whether wrong things go wrong right. */
  
    DIR *dirp;
  
    subtest = 3;
  
    System("rm -rf ../DIR_24/*");
  
    if (opendir("foo/bar/nono") != ((DIR *) NULL)) e(1);	/* nonexistent */
    if (errno != ENOENT) e(2);
    System("mkdir foo; chmod 677 foo");	/* foo inaccesable */
    if (opendir("foo/bar/nono") != ((DIR *) NULL)) e(3);
    if (superuser) {
  	if (errno != ENOENT) e(4);	/* su has access */
  	System("chmod 377 foo");
  	if ((dirp = opendir("foo")) == ((DIR *) NULL)) e(5);
  	if (closedir(dirp) != 0) e(6);
    }
    if (!superuser) {
  	if (errno != EACCES) e(7);	/* we don't ;-) */
  	System("chmod 377 foo");
  	if (opendir("foo") != ((DIR *) NULL)) e(8);
    }
    System("chmod 777 foo");
  
    if (mkdir(MaxName, 0777) != 0) e(9);	/* make longdir */
    if ((dirp = opendir(MaxName)) == ((DIR *) NULL)) e(10);	/* open it */
    if (closedir(dirp) != 0) e(11);	/* close it */
    if (rmdir(MaxName) != 0) e(12);	/* then remove it */
    if ((dirp = opendir(MaxPath)) == ((DIR *) NULL)) e(13);	/* open '.'  */
    if (closedir(dirp) != 0) e(14);	/* close it */
  #if 0 /* XXX - anything could happen with the bad pointer */
    if (closedir(dirp) != -1) e(15);	/* close it again */
    if (closedir(dirp) != -1) e(16);	/* and again */
  #endif /* 0 */
    if (opendir(ToLongName) != ((DIR *) NULL)) e(17);	/* is too long */
  #ifdef _POSIX_NO_TRUNC
  # if _POSIX_NO_TRUNC - 0 != -1
    if (errno != ENAMETOOLONG) e(18);
  # else
    if (errno != ENOENT) e(19);
  # endif
  #else
  # include "error, this case requires dynamic checks and is not handled"
  #endif
    if (opendir(ToLongPath) != ((DIR *) NULL)) e(20);	/* path is too long */
    if (errno != ENAMETOOLONG) e(21);
    System("touch foo/abc");	/* make a file */
    if (opendir("foo/abc") != ((DIR *) NULL)) e(22);	/* not a dir */
    if (errno != ENOTDIR) e(23);
  }
  
  void chk_dir(dirp)		/* dir should contain             */
  DIR *dirp;			/* (`f1', `f3', `f5', `.', `..')  */
  {				/* no more, no less               */
    int f1 = 0, f2 = 0, f3 = 0, f4 = 0, f5 = 0,	/* counters for all */
     other = 0, dot = 0, dotdot = 0;	/* possible entrys */
    int i;
    struct dirent *dep;
    char *fname;
    int oldsubtest = subtest;
  
    subtest = 4;
  
    for (i = 0; i < 5; i++) {	/* 3 files and `.' and `..' == 5 entrys */
  	dep = readdir(dirp);
  	if (dep == DIRENT0) {	/* not einough */
  		if (dep == DIRENT0) e(1);
  		break;
  	}
  	fname = dep->d_name;
  	if (strcmp(fname, ".") == 0)
  		dot++;
  	else if (strcmp(fname, "..") == 0)
  		dotdot++;
  	else if (strcmp(fname, "f1") == 0)
  		f1++;
  	else if (strcmp(fname, "f2") == 0)
  		f2++;
  	else if (strcmp(fname, "f3") == 0)
  		f3++;
  	else if (strcmp(fname, "f4") == 0)
  		f4++;
  	else if (strcmp(fname, "f5") == 0)
  		f5++;
  	else
  		other++;
    }				/* do next dir entry */
  
    if (dot != 1) e(2);		/* Check the entrys */
    if (dotdot != 1) e(3);
    if (f1 != 1) e(4);
    if (f3 != 1) e(5);
    if (f5 != 1) e(6);
    if (f2 != 0) e(7);
    if (f4 != 0) e(8);
    if (other != 0) e(9);
  
    subtest = oldsubtest;
  }
  
  void makelongnames()
  {
    register int i;
  
    memset(MaxName, 'a', NAME_MAX);
    MaxName[NAME_MAX] = '\0';
    for (i = 0; i < PATH_MAX - 1; i++) {	/* idem path */
  	MaxPath[i++] = '.';
  	MaxPath[i] = '/';
    }
    MaxPath[PATH_MAX - 1] = '\0';
  
    strcpy(ToLongName, MaxName);	/* copy them Max to ToLong */
    strcpy(ToLongPath, MaxPath);
  
    ToLongName[NAME_MAX] = 'a';
    ToLongName[NAME_MAX + 1] = '\0';	/* extend ToLongName by one too many */
    ToLongPath[PATH_MAX - 1] = '/';
    ToLongPath[PATH_MAX] = '\0';	/* inc ToLongPath by one */
  }
  
  void e(n)
  int n;
  {
    int err_num = errno;		/* Save in case printf clobbers it. */
  
    printf("Subtest %d,  error %d  errno=%d: ", subtest, n, errno);
    errno = err_num;
    perror("");
    if (errct++ > MAX_ERROR) {
  	printf("Too many errors; test aborted\n");
  	chdir("..");
  	system("rm -rf DIR*");
  	exit(1);
    }
    errno = 0;
  }
  
  void quit()
  {
    Chdir("..");
    System("rm -rf DIR_24");
  
    if (errct == 0) {
  	printf("ok\n");
  	exit(0);
    } else {
  	printf("%d errors\n", errct);
  	exit(1);
    }
  }
  