Return to du.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/du.c, revision 1.1.1.1

1.1       root        1: #include "stdio.h"
                      2: #include "sys/param.h"
                      3: #include "sys/stat.h"
                      4: #include "ndir.h"
                      5: #include "ftw.h"
                      6: 
                      7: enum Params {Maxpathlen=1024, Nlinks=600};
                      8: char flags[128];       /* -a, -s */
                      9: char buf[Maxpathlen];
                     10: unsigned long totlen, dirlen[Maxpathlen];
                     11: struct {
                     12:        int ino, dev;
                     13: } ml[Nlinks];
                     14: int nlink, follow, level;
                     15: extern int errno;
                     16: 
                     17: main(argc, argv)
                     18: char **argv;
                     19: {      extern char *optarg;
                     20:        extern int optind;
                     21:        int c;
                     22: 
                     23:        while((c = getopt(argc, argv, "as")) != -1)
                     24:        switch(c) {
                     25:                default:
                     26:                        fprintf(stderr, "usage: %s [-a] [-s] [files]\n", argv[0]);
                     27:                        exit(1);
                     28:                case 'a': case 's':
                     29:                        flags[c]++;
                     30:                        break;
                     31:        }
                     32:        if(optind >= argc) {
                     33:                doit(".");
                     34:                        if(flags['s'])
                     35:                                printf("%d\t%s\n", totlen, argv[optind]);
                     36:        }
                     37:        else
                     38:                for(; optind < argc; optind++) {
                     39:                        follow = 1;
                     40:                        doit(argv[optind]);
                     41:                        if(flags['s'])
                     42:                                printf("%d\t%s\n", totlen, argv[optind]);
                     43:                        totlen = 0;
                     44:                }
                     45:        exit(0);
                     46: }
                     47: 
                     48: fn(name, stb, code, s)
                     49: char *name;
                     50: struct stat *stb;
                     51: struct FTW *s;
                     52: {      int n;
                     53:        if(follow) {
                     54:                follow = 0;
                     55:                if(code == FTW_SL) {
                     56:                        s->quit = FTW_FOLLOW;
                     57:                        return(0);
                     58:                }
                     59:        }
                     60:        switch(code) {
                     61:        case FTW_D:
                     62:                dirlen[++level] = 0;
                     63:        case FTW_SL:
                     64:        case FTW_F:     /* stupid size semantics (BSIZE not networked) */
                     65: common:
                     66:                if(seenit(stb))
                     67:                        return(0);
                     68:                n = ((stb->st_size + BSIZE(stb->st_dev)-1) >> BSHIFT(stb->st_dev))
                     69:                        * (BSIZE(stb->st_dev)/1024);
                     70:                totlen += n;
                     71:                dirlen[level] += n;
                     72:                if(flags['a'])
                     73:                        printf("%d\t%s%s\n", n, name, code==FTW_D? "/": "");
                     74:                break;
                     75:        case FTW_DP:
                     76:                if(!flags['s']) {
                     77:                        printf("%d\t%s\n", dirlen[level], name);
                     78:                        fflush(stdout); /* bogus new stdio */
                     79:                }
                     80:                dirlen[level-1] += dirlen[level];
                     81:                level--;
                     82:                break;
                     83:        case FTW_DNR:
                     84:                perror(name);
                     85:                goto common;
                     86:        case FTW_NS:
                     87:        case FTW_NSL:
                     88:                perror(name);
                     89:        }
                     90:        return(0);
                     91: }
                     92: 
                     93: doit(s)
                     94: char *s;
                     95: {
                     96:        level = 0;
                     97:        ftw(s, fn, 100);
                     98: }
                     99: 
                    100: seenit(s)
                    101: struct stat *s;
                    102: {      int i;
                    103:        if(s->st_nlink == 1 || (s->st_mode & S_IFMT) != S_IFREG)
                    104:                return(0);
                    105:        for(i = 0; i < nlink; i++)
                    106:                if(ml[i].ino == s->st_ino && ml[i].dev == s->st_dev)
                    107:                        return(1);
                    108:        if(i < Nlinks) {
                    109:                ml[i].ino = s->st_ino;
                    110:                ml[i].dev = s->st_dev;
                    111:                nlink++;
                    112:        }
                    113:        return(0);
                    114: }

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