test24.c

Go to the documentation of this file.

/* 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);
  }
}

---