Return to getwd.c CVS log

Up to [CSRG BSD Unix] / 42BSD / lib / libc / gen

Annotation of 42BSD/lib/libc/gen/getwd.c, revision 1.1

1.1     ! root        1: /*     @(#)getwd.c     4.8     (Berkeley)      3/2/83  */
        !             2: 
        !             3: /*
        !             4:  * getwd() returns the pathname of the current working directory. On error
        !             5:  * an error message is copied to pathname and null pointer is returned.
        !             6:  */
        !             7: #include <sys/param.h>
        !             8: #include <sys/stat.h>
        !             9: #include <sys/dir.h>
        !            10: 
        !            11: #define CURDIR         "."
        !            12: #define GETWDERR(s)    strcpy(pathname, (s));
        !            13: #define PARENTDIR      ".."
        !            14: #define PATHSEP                "/"
        !            15: #define ROOTDIR                "/"
        !            16: 
        !            17: char *strcpy();
        !            18: static int pathsize;                   /* pathname length */
        !            19: 
        !            20: char *
        !            21: getwd(pathname)
        !            22:        char *pathname;
        !            23: {
        !            24:        char pathbuf[MAXPATHLEN];               /* temporary pathname buffer */
        !            25:        char *pnptr = &pathbuf[(sizeof pathbuf)-1]; /* pathname pointer */
        !            26:        char *prepend();                /* prepend dirname to pathname */
        !            27:        dev_t rdev;                     /* root device number */
        !            28:        DIR *dirp;                      /* directory stream */
        !            29:        ino_t rino;                     /* root inode number */
        !            30:        struct direct *dir;             /* directory entry struct */
        !            31:        struct stat d ,dd;              /* file status struct */
        !            32: 
        !            33:        pathsize = 0;
        !            34:        *pnptr = '\0';
        !            35:        stat(ROOTDIR, &d);
        !            36:        rdev = d.st_dev;
        !            37:        rino = d.st_ino;
        !            38:        for (;;) {
        !            39:                stat(CURDIR, &d);
        !            40:                if (d.st_ino == rino && d.st_dev == rdev)
        !            41:                        break;          /* reached root directory */
        !            42:                if ((dirp = opendir(PARENTDIR)) == NULL) {
        !            43:                        GETWDERR("getwd: can't open ..");
        !            44:                        goto fail;
        !            45:                }
        !            46:                if (chdir(PARENTDIR) < 0) {
        !            47:                        GETWDERR("getwd: can't chdir to ..");
        !            48:                        goto fail;
        !            49:                }
        !            50:                fstat(dirp->dd_fd, &dd);
        !            51:                if (d.st_dev == dd.st_dev) {
        !            52:                        if (d.st_ino == dd.st_ino) {
        !            53:                                /* reached root directory */
        !            54:                                closedir(dirp);
        !            55:                                break;
        !            56:                        }
        !            57:                        do {
        !            58:                                if ((dir = readdir(dirp)) == NULL) {
        !            59:                                        closedir(dirp);
        !            60:                                        GETWDERR("getwd: read error in ..");
        !            61:                                        goto fail;
        !            62:                                }
        !            63:                        } while (dir->d_ino != d.st_ino);
        !            64:                } else
        !            65:                        do {
        !            66:                                if((dir = readdir(dirp)) == NULL) {
        !            67:                                        closedir(dirp);
        !            68:                                        GETWDERR("getwd: read error in ..");
        !            69:                                        goto fail;
        !            70:                                }
        !            71:                                stat(dir->d_name, &dd);
        !            72:                        } while(dd.st_ino != d.st_ino || dd.st_dev != d.st_dev);
        !            73:                closedir(dirp);
        !            74:                pnptr = prepend(PATHSEP, prepend(dir->d_name, pnptr));
        !            75:        }
        !            76:        if (*pnptr == '\0')             /* current dir == root dir */
        !            77:                strcpy(pathname, ROOTDIR);
        !            78:        else {
        !            79:                strcpy(pathname, pnptr);
        !            80:                if (chdir(pnptr) < 0) {
        !            81:                        GETWDERR("getwd: can't change back to .");
        !            82:                        return (NULL);
        !            83:                }
        !            84:        }
        !            85:        return (pathname);
        !            86: 
        !            87: fail:
        !            88:        chdir(prepend(CURDIR, pnptr));
        !            89:        return (NULL);
        !            90: }
        !            91: 
        !            92: /*
        !            93:  * prepend() tacks a directory name onto the front of a pathname.
        !            94:  */
        !            95: static char *
        !            96: prepend(dirname, pathname)
        !            97:        register char *dirname;
        !            98:        register char *pathname;
        !            99: {
        !           100:        register int i;                 /* directory name size counter */
        !           101: 
        !           102:        for (i = 0; *dirname != '\0'; i++, dirname++)
        !           103:                continue;
        !           104:        if ((pathsize += i) < MAXPATHLEN)
        !           105:                while (i-- > 0)
        !           106:                        *--pathname = *--dirname;
        !           107:        return (pathname);
        !           108: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.