dirseek.c

/*
 * Copyright (c) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009
 *      The President and Fellows of Harvard College.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE UNIVERSITY OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * dirseek.c
 *
 *      Tests seeking on directories (both legally and illegally).
 *
 *      Makes a test subdirectory in the current directory.
 *
 *      Intended for the file system assignment. Should run (on SFS)
 *      when that assignment is complete.
 *
 *      Note: checks a few things that are not _strictly_ guaranteed
 *      by the official semantics of getdirentry() but that are more
 *      or less necessary in a sane implementation, like that the
 *      current seek position returned after seeking is the same
 *      position that was requested. If you believe your
 *      implementation is legal and the the test is rejecting it
 *      gratuitously, please contact the course staff.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <err.h>

#define TESTDIR "seektestdir"

static struct {
        const char *name;
        int make_it;
        off_t pos;
} testfiles[] = {
        { ".",          0, -1 },
        { "..",         0, -1 },
        { "ridcully",   1, -1 },
        { "weatherwax", 1, -1 },
        { "ogg",        1, -1 },
        { "vorbis",     1, -1 },
        { "verence",    1, -1 },
        { "magrat",     1, -1 },
        { "agnes",      1, -1 },
        { "rincewind",  1, -1 },
        { "angua",      1, -1 },
        { "cherry",     1, -1 },
        { "dorfl",      1, -1 },
        { "nobby",      1, -1 },
        { "carrot",     1, -1 },
        { "vimes",      1, -1 },
        { "detritus",   1, -1 },
        { "twoflower",  1, -1 },
        { "teatime",    1, -1 },
        { "qu",         1, -1 },
        { NULL, 0, 0 }
};

/************************************************************/
/* Test code                                                */
/************************************************************/

static int dirfd;

static
int
findentry(const char *name)
{
        int i;

        for (i=0; testfiles[i].name; i++) {
                if (!strcmp(testfiles[i].name, name)) {
                        return i;
                }
        }
        return -1;
}

static
void
openit(void)
{
        dirfd = open(".", O_RDONLY);
        if (dirfd < 0) {
                err(1, ".: open");
        }
}

static
void
closeit(void)
{
        if (close(dirfd)<0) {
                err(1, ".: close");
        }
        dirfd = -1;
}

static
void
readit(void)
{
        char buf[4096];
        off_t pos;
        int len;
        int n, i, ix;

        for (i=0; testfiles[i].name; i++) {
                testfiles[i].pos = -1;
        }

        pos = lseek(dirfd, 0, SEEK_CUR);
        if (pos < 0) {
                err(1, ".: lseek(0, SEEK_CUR)");
        }
        n = 0;

        while ((len = getdirentry(dirfd, buf, sizeof(buf)-1)) > 0) {

                if ((unsigned)len >= sizeof(buf)-1) {
                        errx(1, ".: entry %d: getdirentry returned "
                             "invalid length %d", n, len);
                }
                buf[len] = 0;
                ix = findentry(buf);
                if (ix < 0) {
                        errx(1, ".: entry %d: getdirentry returned "
                             "unexpected name %s", n, buf);
                }

                if (testfiles[ix].pos >= 0) {
                        errx(1, ".: entry %d: getdirentry returned "
                             "%s a second time", n, buf);
                }

                testfiles[ix].pos = pos;
                
                pos = lseek(dirfd, 0, SEEK_CUR);
                if (pos < 0) {
                        err(1, ".: lseek(0, SEEK_CUR)");
                }
                n++;
        }
        if (len<0) {
                err(1, ".: entry %d: getdirentry", n);
        }

        for (i=0; testfiles[i].name; i++) {
                if (testfiles[i].pos < 0) {
                        errx(1, ".: getdirentry failed to return %s",
                             testfiles[i].name);
                }
        }
        if (i!=n) {
                /*
                 * If all of the other checks have passed, this should not
                 * be able to fail. But... just in case I forgot something
                 * or there's a bug...
                 */

                errx(1, ".: getdirentry returned %d names, not %d (huh...?)",
                     n, i);
        }
}
        
static
void
firstread(void)
{
        off_t pos;

        pos = lseek(dirfd, 0, SEEK_CUR);
        if (pos < 0) {
                err(1, ".: lseek(0, SEEK_CUR)");
        }
        if (pos != 0) {
                errx(1, ".: File position after open not 0");
        }

        printf("Scanning directory...\n");

        readit();
}

static
void
doreadat0(void)
{
        off_t pos;

        printf("Rewinding directory and reading it again...\n");

        pos = lseek(dirfd, 0, SEEK_SET);
        if (pos < 0) {
                err(1, ".: lseek(0, SEEK_SET)");
        }
        if (pos != 0) {
                errx(1, ".: lseek(0, SEEK_SET) returned %ld", (long) pos);
        }

        readit();
}

static
void
readone(const char *shouldbe)
{
        char buf[4096];
        int len;

        len = getdirentry(dirfd, buf, sizeof(buf)-1);
        if (len < 0) {
                err(1, ".: getdirentry");
        }
        if ((unsigned)len >= sizeof(buf)-1) {
                errx(1, ".: getdirentry returned invalid length %d", len);
        }
        buf[len] = 0;

        if (strcmp(buf, shouldbe)) {
                errx(1, ".: getdirentry returned %s (expected %s)",
                     buf, shouldbe);
        }
}

static
void
doreadone(int which)
{
        off_t pos;
        pos = lseek(dirfd, testfiles[which].pos, SEEK_SET);
        if (pos<0) {
                err(1, ".: lseek(%ld, SEEK_SET)", (long) testfiles[which].pos);
        }
        if (pos != testfiles[which].pos) {
                errx(1, ".: lseek(%ld, SEEK_SET) returned %ld",
                     (long) testfiles[which].pos, (long) pos);
        }

        readone(testfiles[which].name);
}

static
void
readallonebyone(void)
{
        int i;

        printf("Trying to read each entry again...\n");
        for (i=0; testfiles[i].name; i++) {
                doreadone(i);
        }
}

static
void
readallrandomly(void)
{
        int n, i, x;

        printf("Trying to read a bunch of entries randomly...\n");

        for (i=0; testfiles[i].name; i++);
        n = i;

        srandom(39584);
        for (i=0; i<512; i++) {
                x = (int)(random()%n);
                doreadone(x);
        }
}

static
void
readateof(void)
{
        char buf[4096];
        int len;

        len = getdirentry(dirfd, buf, sizeof(buf)-1);
        if (len < 0) {
                err(1, ".: at EOF: getdirentry");
        }
        if (len==0) {
                return;
        }
        if ((unsigned)len >= sizeof(buf)-1) {
                errx(1, ".: at EOF: getdirentry returned "
                     "invalid length %d", len);
        }
        buf[len] = 0;
        errx(1, ".: at EOF: got unexpected name %s", buf);
}

static
void
doreadateof(void)
{
        off_t pos;
        int i;

        printf("Trying to read after going to EOF...\n");

        pos = lseek(dirfd, 0, SEEK_END);
        if (pos<0) {
                err(1, ".: lseek(0, SEEK_END)");
        }

        for (i=0; testfiles[i].name; i++) {
                if (pos <= testfiles[i].pos) {
                        errx(1, ".: EOF position %ld below position %ld of %s",
                             pos, testfiles[i].pos, testfiles[i].name);
                }
        }

        readateof();
}

static
void
inval_read(void)
{
        char buf[4096];
        int len;

        len = getdirentry(dirfd, buf, sizeof(buf)-1);

        /* Any result is ok, as long as the system doesn't crash */
        (void)len;
}

static
void
dobadreads(void)
{
        off_t pos, pos2, eof;
        int valid, i, k=0;

        printf("Trying some possibly invalid reads...\n");

        eof = lseek(dirfd, 0, SEEK_END);
        if (eof < 0) {
                err(1, ".: lseek(0, SEEK_END)");
        }

        for (pos=0; pos < eof; pos++) {
                valid = 0;
                for (i=0; testfiles[i].name; i++) {
                        if (pos==testfiles[i].pos) {
                                valid = 1;
                        }
                }
                if (valid) {
                        /* don't try offsets that are known to be valid */
                        continue;
                }

                pos2 = lseek(dirfd, pos, SEEK_SET);
                if (pos2 < 0) {
                        /* this is ok */
                }
                else {
                        inval_read();
                        k++;
                }
        }

        if (k>0) {
                printf("Survived %d invalid reads...\n", k);
        }
        else {
                printf("Couldn't find any invalid offsets to try...\n");
        }

        printf("Trying to read beyond EOF...\n");
        pos2 = lseek(dirfd, eof + 1000, SEEK_SET);
        if (pos2 < 0) {
                /* this is ok */
        }
        else {
                inval_read();
        }
}

static
void
dotest(void)
{
        printf("Opening directory...\n");
        openit();

        printf("Running tests...\n");

        /* read the whole directory */
        firstread();

        /* make sure eof behaves right */
        readateof();

        /* read all the filenames again by seeking */
        readallonebyone();

        /* try reading at eof */
        doreadateof();

        /* read a bunch of the filenames over and over again */
        readallrandomly();

        /* rewind and read the whole thing again, to make sure that works */
        doreadat0();

        /* do invalid reads */
        dobadreads();

        /* rewind again to make sure the invalid attempts didn't break it */
        doreadat0();

        printf("Closing directory...\n");
        closeit();
}

/************************************************************/
/* Setup code                                               */
/************************************************************/

static
void
mkfile(const char *name)
{
        int fd, i, r;
        static const char message[] = "The turtle moves!\n";
        char buf[32*sizeof(message)+1];

        buf[0]=0;
        for (i=0; i<32; i++) {
                strcat(buf, message);
        }

        /* Use O_EXCL, because we know the file shouldn't already be there */
        fd = open(name, O_WRONLY|O_CREAT|O_EXCL, 0664);
        if (fd<0) {
                err(1, "%s: create", name);
        }

        r = write(fd, buf, strlen(buf));
        if (r<0) {
                err(1, "%s: write", name);
        }
        if ((unsigned)r != strlen(buf)) {
                errx(1, "%s: short write (%d bytes)", name, r);
        }

        if (close(fd)<0) {
                err(1, "%s: close", name);
        }
}

static
void
setup(void)
{
        int i;

        printf("Making directory %s...\n", TESTDIR);

        /* Create a directory */
        if (mkdir(TESTDIR, 0775)<0) {
                err(1, "%s: mkdir", TESTDIR);
        }

        /* Switch to it */
        if (chdir(TESTDIR)<0) {
                err(1, "%s: chdir", TESTDIR);
        }

        printf("Making some files...\n");

        /* Populate it */
        for (i=0; testfiles[i].name; i++) {
                if (testfiles[i].make_it) {
                        mkfile(testfiles[i].name);
                }
                testfiles[i].pos = -1;
        }
}

static
void
cleanup(void)
{
        int i;

        printf("Cleaning up...\n");

        /* Remove the files */
        for (i=0; testfiles[i].name; i++) {
                if (testfiles[i].make_it) {
                        if (remove(testfiles[i].name)<0) {
                                err(1, "%s: remove", testfiles[i].name);
                        }
                }
        }

        /* Leave the dir */
        if (chdir("..")<0) {
                err(1, "..: chdir");
        }

        /* Remove the dir */
        if (rmdir(TESTDIR)<0) {
                err(1, "%s: rmdir", TESTDIR);
        }
}


int
main()
{
        setup();

        /* Do the whole thing twice */
        dotest();
        dotest();

        cleanup();
        return 0;
}