Return to getfs.c CVS log

Up to [Research Unix] / researchv9 / cmd / ps

Annotation of researchv9/cmd/ps/getfs.c, revision 1.1.1.1

1.1       root        1: #include "ps.h"
                      2: 
                      3: #define NNAMES 16
                      4: 
                      5: char *fspts[3];
                      6: 
                      7: struct direct *fsbeg, *fsend, *fsprev;
                      8: 
                      9: #ifdef TEST
                     10: main(argc, argv)
                     11: char **argv;
                     12: {
                     13:        register struct direct *fs; int dev; char *getfs();
                     14:        getfstab();
                     15:        if (argc <= 1)
                     16:                for (fs=fsbeg; fs < fsend; fs++)
                     17:                        printf("%3d,%3d %.14s\n",
                     18:                                major(fs->d_ino), minor(fs->d_ino), fs->d_name);
                     19:        else while ((argc -= 2) > 0) {
                     20:                dev = atoi(*++argv);
                     21:                dev = makedev(dev, atoi(*++argv));
                     22:                printf("%3d,%3d %.14s\n", major(dev), minor(dev), getfs(dev));
                     23:        }
                     24:        exit(0);
                     25: }
                     26: #endif
                     27: 
                     28: char *
                     29: getfs(dev)
                     30: register dev;
                     31: {
                     32:        register struct direct *fs;
                     33: 
                     34:        if ((fs = fsprev) && fs->d_ino == dev)
                     35:                return fs->d_name;
                     36:        for (fs=fsbeg; fs < fsend; fs++)
                     37:                if (fs->d_ino == dev ||
                     38:                    (major(fs->d_ino) == major(dev) && minor(fs->d_ino) == 255)) {
                     39:                        fsprev = fs;
                     40:                        return fs->d_name;
                     41:                }
                     42:        return 0;
                     43: }
                     44: 
                     45: getfstab()
                     46: {
                     47:        char *buffer, *bufpt, *nlpt, *strchr(), *strrchr(), *sindex();
                     48:        struct stat fd_st;
                     49:        register struct direct *fs = 0;
                     50:        register char *p; int fd;
                     51: 
                     52:        if (fsbeg)
                     53:                return 0;
                     54: 
                     55:        if ((fd = open("/etc/fstab", 0)) < 0)
                     56:                return 1;
                     57: 
                     58:        if (fstat(fd, &fd_st) || (buffer = malloc((int)fd_st.st_size+1)) == 0)
                     59:                return close(fd), 1;
                     60: 
                     61:        if (!Read(fd, buffer, (int)fd_st.st_size))
                     62:                return free(buffer), close(fd), 1;
                     63:        buffer[fd_st.st_size] = 0;
                     64: 
                     65:        for (bufpt=buffer; nlpt=strchr(bufpt, '\n'); bufpt=nlpt) {
                     66:                *nlpt++ = 0;
                     67:                if ((p = strchr(bufpt, ':')) == 0)
                     68:                        continue;
                     69:                *p = 0;
                     70:                if (stat(bufpt, &fd_st))
                     71:                        continue;
                     72:                if ((fs = Nalloc(struct direct, fspts, NNAMES)) == 0)
                     73:                        break;
                     74:                if (p = strrchr(bufpt, '/'))
                     75:                        ++p;
                     76:                else
                     77:                        p = bufpt;
                     78:                strncpy(fs->d_name, p, DIRSIZ);
                     79:                fs->d_ino = fd_st.st_rdev;
                     80:        }
                     81:        free(buffer), close(fd);
                     82: 
                     83:        if ((fd = open("/usr/net/friends", 0)) < 0)
                     84:                return 1;
                     85: 
                     86:        if (fstat(fd, &fd_st) || (buffer = malloc((int)fd_st.st_size+1)) == 0)
                     87:                return close(fd), 1;
                     88: 
                     89:        if (!Read(fd, buffer, (int)fd_st.st_size))
                     90:                return free(buffer), close(fd), 1;
                     91:        buffer[fd_st.st_size] = 0;
                     92: 
                     93:        for (bufpt=buffer; nlpt=strchr(bufpt, '\n'); bufpt=nlpt) {
                     94:                *nlpt++ = 0;
                     95:                if ((bufpt = sindex(bufpt, " \t")) == 0)
                     96:                        continue;
                     97:                if ((bufpt = strrchr(bufpt, '/')) == 0)
                     98:                        continue;
                     99:                if ((p = sindex(++bufpt, " \t")) == 0)
                    100:                        continue;
                    101:                *p = 0;
                    102:                if ((fs = Nalloc(struct direct, fspts, NNAMES)) == 0)
                    103:                        break;
                    104:                strncpy(fs->d_name, bufpt, DIRSIZ);
                    105:                fs->d_ino = makedev(atoi(++p), 255);
                    106:        }
                    107:        free(buffer), close(fd);
                    108: 
                    109:        if (stat(bufpt = "/proc", &fd_st) == 0 &&
                    110:           (fs = Nalloc(struct direct, fspts, NNAMES))) {
                    111:                strncpy(fs->d_name, bufpt+1, DIRSIZ);
                    112:                fs->d_ino = fd_st.st_dev;
                    113:        }
                    114:        if (fs) {
                    115:                fsbeg = (struct direct *)fspts[0];
                    116:                fsend = (struct direct *)fspts[1];
                    117:        }
                    118:        return 0;
                    119: }
                    120: 
                    121: char *
                    122: sindex(s, c)
                    123: register char *s, *c;
                    124: {
                    125:        register char *p = 0, *q;
                    126:        while (*c) {
                    127:                if ((q = strchr(s, *c++)) == 0)
                    128:                        continue;
                    129:                if (p == 0 || q < p)
                    130:                        p = q;
                    131:        }
                    132:        return p;
                    133: }

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