Return to curdir.c CVS log

Up to [Research Unix] / researchv10no / dk / cmd / pupu

Annotation of researchv10no/dk/cmd/pupu/curdir.c, revision 1.1.1.1

1.1       root        1: static char Sccsid[]="@(#)curdir.c     3.4";
                      2: 
                      3: # define       IROOT   2
                      4: # include      "sys/types.h"
                      5: # include      "macros.h"
                      6: 
                      7: #include <stdio.h>
                      8: #include "sys/param.h"
                      9: #include <mtab.h>
                     10: #include "sys/dir.h"
                     11: #include "sys/filsys.h"
                     12: /*
                     13:        current directory.
                     14:        Places the full pathname of the current directory in `str'.
                     15:        Handles file systems not mounted on a root directory
                     16:        via /etc/mtab (see mtab(V)).
                     17:        NOTE: PWB systems don't use mtab(V), but they don't mount
                     18:        file systems anywhere but on a root directory (so far, at least).
                     19: 
                     20:        returns 0 on success
                     21:        < 0 on failure.
                     22: 
                     23:        Current directory on return:
                     24:                success: same as on entry
                     25:                failure: UNKNOWN!
                     26: */
                     27: static char *curdirp;
                     28: 
                     29: static char    *flg[] = {
                     30:        "read/write",
                     31:        "read only"
                     32:        };
                     33: 
                     34: static struct mtab mtab[NMOUNT], *mp;
                     35: static struct filsys super;
                     36: 
                     37: 
                     38: curdir(str)
                     39: char *str;
                     40: {
                     41:        register int n;
                     42: 
                     43:        curdirp = str;
                     44:        n = findir(0);
                     45:        return(n+chdir(str));
                     46: }
                     47: 
                     48: 
                     49: # define ADDSLASH      if (flag) *curdirp++ = '/';
                     50: # define QUIT          { close(fd); return(-1); }
                     51: 
                     52: findir(flag)
                     53: {
                     54:        register int fd,inum;
                     55:        register char *tp;
                     56:        char *slashp,tmp[100];
                     57:        int dev, r;
                     58:        struct direct entry;
                     59:        struct stat s;
                     60: 
                     61:        if (stat(".",&s)<0) return(-1);
                     62:        if ((inum = s.st_ino) == IROOT) {
                     63:                dev = s.st_dev;
                     64:                if ((fd = open("/",0))<0) return(-1);
                     65:                if (fstat(fd,&s)<0)
                     66:                        QUIT;
                     67:                if (dev == s.st_dev) {
                     68:                        *curdirp++ = '/';
                     69:                        *curdirp = 0;
                     70:                        close(fd);
                     71:                        return(0);
                     72:                }
                     73:                slashp = entry.d_name;
                     74:                slashp--;
                     75:                while (read(fd,&entry,sizeof(entry)) == sizeof(entry)) {
                     76:                        if (entry.d_ino == 0) continue;
                     77:                        *slashp = '/';
                     78:                        if (stat(slashp,&s)<0) continue;
                     79:                        if (s.st_dev != dev) continue;
                     80:                        if ((s.st_mode&S_IFMT) != S_IFDIR) continue;
                     81:                        for (tp = slashp; *curdirp = (*tp++); curdirp++);
                     82:                        ADDSLASH;
                     83:                        *curdirp = 0;
                     84:                        close(fd);
                     85:                        return(0);
                     86:                }
                     87:                close(fd);
                     88: 
                     89:                fd = open("/etc/mtab",0);
                     90:                if(fd < 0) {
                     91:                        fprintf(stderr, "curdir: cannot open /etc/mtab!\n");
                     92:                        return(-1);
                     93:                }
                     94:                read(fd, mtab, sizeof mtab);
                     95:                for(mp = mtab; mp < &mtab[NMOUNT]; mp++) {
                     96:                        if(mp->m_dname[0]) {
                     97:                                sprintf(tmp,"/dev/%s",mp->m_dname);
                     98:                                if ( stat(tmp,&s) < 0 )
                     99:                                        QUIT;
                    100:                                if ( s.st_rdev != dev ) continue;
                    101:                                for ( tp = mp->m_path; *curdirp = (*tp++); curdirp++ );
                    102:                                ADDSLASH;
                    103:                                close(fd);
                    104:        /*  test print
                    105:                                printf("%.10s on /dev/%s %s on %s",
                    106:                                mp->m_path, mp->m_dname);
                    107:        end test print */
                    108:                                return(0);
                    109:                        }
                    110:                }
                    111:        
                    112:                QUIT;
                    113:        }
                    114:        if ((fd = open("..",0))<0) return(-1);
                    115:        for (entry.d_ino = 0; entry.d_ino != inum; )
                    116:                if (read(fd,&entry,sizeof(entry)) != sizeof(entry))
                    117:                        QUIT;
                    118:        close(fd);
                    119:        if (chdir("..")<0) return(-1);
                    120:        if (findir(-1)<0) r = -1;
                    121:        else r = 0;
                    122:        for (tp = entry.d_name; *curdirp = (*tp++); curdirp++);
                    123:        ADDSLASH;
                    124:        *curdirp = 0;
                    125:        return(r);
                    126: }

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