ref: 20429fb04fd109dbd80932170e41ced8521547fe
dir: /sys/src/cmd/walk.c/
#include <u.h> #include <libc.h> #include <bio.h> #include <String.h> #include <fcall.h> int Cflag = 0; int uflag = 0; String *stfmt; /* should turn these flags into a mask */ int dflag = 1; int fflag = 1; int tflag = 0; int xflag = 0; long maxdepth = ~(1<<31); long mindepth = 0; char *dotpath = "."; Dir *dotdir = nil; Biobuf *bout; int seen(Dir*); void warn(char *fmt, ...) { va_list arg; char buf[1024]; /* arbitrary */ int n; if((n = snprint(buf, sizeof(buf), "%s: ", argv0)) < 0) sysfatal("snprint: %r"); va_start(arg, fmt); vseprint(buf+n, buf+sizeof(buf), fmt, arg); va_end(arg); Bflush(bout); fprint(2, "%s\n", buf); } void dofile(char *path, Dir *f, int pathonly) { char *p; if( (f == dotdir) || (tflag && ! (f->qid.type & QTTMP)) || (xflag && ! (f->mode & DMEXEC)) ) return; for(p = s_to_c(stfmt); *p != '\0'; p++){ switch(*p){ case 'U': Bwrite(bout, f->uid, strlen(f->uid)); break; case 'G': Bwrite(bout, f->gid, strlen(f->gid)); break; case 'M': Bwrite(bout, f->muid, strlen(f->muid)); break; case 'a': Bprint(bout, "%uld", f->atime); break; case 'm': Bprint(bout, "%uld", f->mtime); break; case 'n': Bwrite(bout, f->name, strlen(f->name)); break; case 'p': if(path != dotpath) Bwrite(bout, path, strlen(path)); if(! (f->qid.type & QTDIR) && !pathonly){ if(path != dotpath) Bputc(bout, '/'); Bwrite(bout, f->name, strlen(f->name)); } break; case 'q': Bprint(bout, "%ullx.%uld.%.2uhhx", f->qid.path, f->qid.vers, f->qid.type); break; case 's': Bprint(bout, "%lld", f->length); break; case 'x': Bprint(bout, "%M", f->mode); break; /* These two are slightly different, as they tell us about the fileserver instead of the file */ case 'D': Bprint(bout, "%ud", f->dev); break; case 'T': Bprint(bout, "%C", f->type); break; default: abort(); } if(*(p+1) != '\0') Bputc(bout, ' '); } Bputc(bout, '\n'); if(uflag) Bflush(bout); } void walk(char *path, Dir *cf, long depth) { String *file; Dir *dirs, *f, *fe; int fd; long n; if(cf == nil){ warn("path: %s: %r", path); return; } if(depth >= maxdepth) goto nodescend; if((fd = open(path, OREAD)) < 0){ warn("couldn't open %s: %r", path); return; } while((n = dirread(fd, &dirs)) > 0){ fe = dirs+n; for(f = dirs; f < fe; f++){ if(seen(f)) continue; if(! (f->qid.type & QTDIR)){ if(fflag && depth >= mindepth) dofile(path, f, 0); } else if(strcmp(f->name, ".") == 0 || strcmp(f->name, "..") == 0){ warn(". or .. named file: %s/%s", path, f->name); } else{ if(depth+1 > maxdepth){ dofile(path, f, 0); continue; } else if(path == dotpath){ if((file = s_new()) == nil) sysfatal("s_new: %r"); } else{ if((file = s_copy(path)) == nil) sysfatal("s_copy: %r"); if(s_len(file) != 1 || *s_to_c(file) != '/') s_putc(file, '/'); } s_append(file, f->name); walk(s_to_c(file), f, depth+1); s_free(file); } } free(dirs); } close(fd); if(n < 0) warn("%s: %r", path); nodescend: depth--; if(dflag && depth >= mindepth) dofile(path, cf, 0); } char* slashslash(char *s) { char *p, *q; for(p=q=s; *q; q++){ if(q>s && *q=='/' && *(q-1)=='/') continue; if(p != q) *p = *q; p++; } do{ *p-- = '\0'; } while(p>s && *p=='/'); return s; } long estrtol(char *as, char **aas, int base) { long n; char *p; n = strtol(as, &p, base); if(p == as || *p != '\0') sysfatal("estrtol: bad input '%s'", as); else if(aas != nil) *aas = p; return n; } void elimdepth(char *p){ char *q; if(strlen(p) == 0) sysfatal("empty depth argument"); if(q = strchr(p, ',')){ *q = '\0'; if(p != q) mindepth = estrtol(p, nil, 0); p = q+1; if(*p == '\0') return; } maxdepth = estrtol(p, nil, 0); } void usage(void) { fprint(2, "usage: %s [-udftx] [-n mind,maxd] [-e statfmt] [file ...]\n", argv0); exits("usage"); } /* Last I checked (commit 3dd6a31881535615389c24ab9a139af2798c462c), libString calls sysfatal when things go wrong; in my local copy of libString, failed calls return nil and errstr is set. There are various nil checks in this code when calling libString functions, but since they are a no-op and libString needs a rework, I left them in - BurnZeZ */ void main(int argc, char **argv) { long i; Dir *d; stfmt = nil; ARGBEGIN{ case 'C': Cflag++; break; /* undocumented; do not cleanname() the args */ case 'u': uflag++; break; /* unbuffered output */ case 'd': dflag++; fflag = 0; break; /* only dirs */ case 'f': fflag++; dflag = 0; break; /* only non-dirs */ case 't': tflag++; break; /* only tmp files */ case 'x': xflag++; break; /* only executable permission */ case 'n': elimdepth(EARGF(usage())); break; case 'e': if((stfmt = s_reset(stfmt)) == nil) sysfatal("s_reset: %r"); s_append(stfmt, EARGF(usage())); i = strspn(s_to_c(stfmt), "UGMamnpqsxDT"); if(i != s_len(stfmt)) sysfatal("bad stfmt: %s", s_to_c(stfmt)); break; default: usage(); }ARGEND; fmtinstall('M', dirmodefmt); if((bout = Bfdopen(1, OWRITE)) == nil) sysfatal("Bfdopen: %r"); Blethal(bout, nil); if(stfmt == nil){ if((stfmt = s_new()) == nil) sysfatal("s_new: %r"); s_putc(stfmt, 'p'); s_terminate(stfmt); } if(maxdepth != ~(1<<31)) maxdepth++; if(argc == 0){ dotdir = dirstat("."); walk(dotpath, dotdir, 1); } else for(i=0; i<argc; i++){ if(strncmp(argv[i], "#/", 2) == 0) slashslash(argv[i]+2); else{ if(!Cflag) cleanname(argv[i]); slashslash(argv[i]); } if((d = dirstat(argv[i])) != nil && ! (d->qid.type & QTDIR)){ if(fflag && !seen(d) && mindepth < 1) dofile(argv[i], d, 1); } else walk(argv[i], d, 1); free(d); } Bterm(bout); exits(nil); } /* below pilfered from /sys/src/cmd/du.c * NOTE: I did not check for bugs */ #define NCACHE 256 /* must be power of two */ typedef struct { Dir* cache; int n; int max; } Cache; Cache cache[NCACHE]; int seen(Dir *dir) { Dir *dp; int i; Cache *c; c = &cache[dir->qid.path&(NCACHE-1)]; dp = c->cache; for(i=0; i<c->n; i++, dp++) if(dir->qid.path == dp->qid.path && dir->type == dp->type && dir->dev == dp->dev) return 1; if(c->n == c->max){ if (c->max == 0) c->max = 8; else c->max += c->max/2; c->cache = realloc(c->cache, c->max*sizeof(Dir)); if(c->cache == nil) sysfatal("realloc: %r"); } c->cache[c->n++] = *dir; return 0; }