Return to wls.c CVS log

Up to [Research Unix] / researchv10no / cmd / worm

Annotation of researchv10no/cmd/worm/wls.c, revision 1.1

1.1     ! root        1: #include       <libc.h>
        !             2: #include       "worm.h"
        !             3: #include       "sym.h"
        !             4: #include       <sys/types.h>
        !             5: #include       <sys/stat.h>
        !             6: #include       <pwd.h>
        !             7: #include       <grp.h>
        !             8: 
        !             9: int lflag = 0;
        !            10: int bflag = 0;
        !            11: 
        !            12: main(argc, argv)
        !            13:        char **argv;
        !            14: {
        !            15:        Superblock s;
        !            16:        register Inode *i;
        !            17:        char *e;
        !            18:        char *dev = "/dev/worm0";
        !            19:        int c;
        !            20:        extern char *optarg;
        !            21:        extern int optind;
        !            22:        void pr();
        !            23: 
        !            24:        while((c = getopt(argc, argv, "lbf:")) != -1)
        !            25:                switch(c)
        !            26:                {
        !            27:                case 'f':       dev = optarg; break;
        !            28:                case 'l':       lflag = 1; break;
        !            29:                case 'b':       bflag = 1; break;
        !            30:                case '?':       usage();
        !            31:                }
        !            32:        dev = mapdev(dev);
        !            33:        if((s.fd = open(dev, 0)) < 0){
        !            34:                perror(dev);
        !            35:                exit(1);
        !            36:        }
        !            37:        if(e = openinode(&s, DO_INODE|SPIN_DOWN)){
        !            38:                fprint(2, "%s: %s\n", dev, e);
        !            39:                exit(1);
        !            40:        }
        !            41:        c = 0;
        !            42:        if(optind < argc)
        !            43:                while(optind < argc){
        !            44:                        if(i = inodeof(argv[optind]))
        !            45:                                pr(i);
        !            46:                        else {
        !            47:                                Fprint(2, "%s not found\n", argv[optind]);
        !            48:                                c = 1;
        !            49:                        }
        !            50:                        optind++;
        !            51:                }
        !            52:        else
        !            53:                inodetraverse(pr);
        !            54:        exit(c);
        !            55: }
        !            56: 
        !            57: char *
        !            58: suid(n)
        !            59: {
        !            60:        static char buf[24];
        !            61:        struct passwd *p;
        !            62:        char *s;
        !            63: 
        !            64:        sprint(buf, "#%d", n);
        !            65:        if(s = (char *)symlook(buf, S_UID, (void *)0))
        !            66:                strcpy(buf, s);
        !            67:        else {
        !            68:                s = strdup(buf);
        !            69:                if(p = getpwuid(n))
        !            70:                        strcpy(buf, p->pw_name);
        !            71:                (void)symlook(s, S_UID, (void *)strdup(buf));
        !            72:        }
        !            73:        return(buf);
        !            74: }
        !            75: 
        !            76: char *
        !            77: sgid(n)
        !            78: {
        !            79:        static char buf[24];
        !            80:        struct group *g;
        !            81:        char *s;
        !            82: 
        !            83:        sprint(buf, "#%d", n);
        !            84:        if(s = (char *)symlook(buf, S_GID, (void *)0))
        !            85:                strcpy(buf, s);
        !            86:        else {
        !            87:                s = strdup(buf);
        !            88:                if(g = getgrgid(n))
        !            89:                        strcpy(buf, g->gr_name);
        !            90:                (void)symlook(s, S_GID, (void *)strdup(buf));
        !            91:        }
        !            92:        return(buf);
        !            93: }
        !            94: 
        !            95: mode(n, sx)
        !            96: {
        !            97:        Fputc(1, (n&4)? 'r':'-');
        !            98:        Fputc(1, (n&2)? 'w':'-');
        !            99:        Fputc(1, (n&1)? sx:'-');
        !           100: }
        !           101: 
        !           102: void
        !           103: pr(i)
        !           104:        register Inode *i;
        !           105: {
        !           106:        char *s;
        !           107: 
        !           108:        if(lflag){
        !           109:                Fputc(1, ((i->mode&S_IFMT) == S_IFDIR)? 'd':'-');
        !           110:                mode(i->mode>>6, ((i->mode&S_IFMT) == S_ISUID)? 's':'x');
        !           111:                mode(i->mode>>3, ((i->mode&S_IFMT) == S_ISGID)? 's':'x');
        !           112:                mode(i->mode, 'x');
        !           113:                Fputc(1, ((i->mode&S_IFMT) == S_IFLNK)? 'L':' ');
        !           114:                s = ctime(&i->ctime);
        !           115:                s += 4;
        !           116:                s[12] = 0;
        !           117:                Fprint(1, "%2d%8s%7s %6ld %s %s\n", 1, suid(i->uid), sgid(i->gid),
        !           118:                        i->nbytes, s, i->name.n);
        !           119:                return;
        !           120:        }
        !           121:        if(bflag)
        !           122:                Fprint(1, "%s\t%ld\n", i->name.n, i->block);
        !           123:        else
        !           124:                Fprint(1, "%s\n", i->name.n);
        !           125: }
        !           126: 
        !           127: usage()
        !           128: {
        !           129:        fprint(2, "Usage: worm ls [-fdevice] [-l] [-b] [files ...]\n");
        !           130:        exit(2);
        !           131: }

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