Return to getwd.c CVS log

Up to [Research Unix] / researchv9 / libc / gen

Annotation of researchv9/libc/gen/getwd.c, revision 1.1

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

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