int permf(VacFile *vf, char *user, int p) { VacDir dir; uint32_t perm; if(vacfilegetdir(vf, &dir)) return 0; perm = dir.mode & 0777; if(noperm) goto Good; if((p*Pother) & perm) goto Good; if(strcmp(user, dir.gid)==0 && ((p*Pgroup) & perm)) goto Good; if(strcmp(user, dir.uid)==0 && ((p*Powner) & perm)) goto Good; vdcleanup(&dir); return 0; Good: vdcleanup(&dir); return 1; }
char * rstat(Fid *f) { VacDir dir; static uint8_t statbuf[1024]; VacFile *parent; if(!f->busy) return vtstrdup(Enotexist); parent = vacfilegetparent(f->file); vacfilegetdir(f->file, &dir); thdr.stat = statbuf; thdr.nstat = vacstat(parent, &dir, thdr.stat, sizeof statbuf); vdcleanup(&dir); vacfiledecref(parent); return 0; }
int vacmerge(VacFile *fp, char *name) { VacFs *mfs; VacDir vd; VacDirEnum *de; VacFile *mp; uint64_t maxqid, offset; if(strlen(name) < 4 || strcmp(name+strlen(name)-4, ".vac") != 0) return -1; if((mfs = vacfsopen(z, name, VtOREAD, 100)) == nil) return -1; if(verbose) fprint(2, "merging %s\n", name); mp = vacfsgetroot(mfs); de = vdeopen(mp); if(de){ offset = 0; if(vacfsgetmaxqid(mfs, &maxqid) >= 0){ _vacfsnextqid(fs, &offset); vacfsjumpqid(fs, maxqid+1); } while(vderead(de, &vd) > 0){ if(vd.qid > maxqid){ warn("vacmerge %s: maxqid=%lld but %s has %lld", name, maxqid, vd.elem, vd.qid); vacfsjumpqid(fs, vd.qid - maxqid); maxqid = vd.qid; } vacmergefile(fp, mp, &vd, name, offset, maxqid); vdcleanup(&vd); } vdeclose(de); } vacfiledecref(mp); vacfsclose(mfs); return 0; }
int vacdirread(Fid *f, char *p, int32_t off, int32_t cnt) { int i, n, nb; VacDir vd; /* * special case of rewinding a directory * otherwise ignore the offset */ if(off == 0 && f->vde){ vdeclose(f->vde); f->vde = nil; } if(f->vde == nil){ f->vde = vdeopen(f->file); if(f->vde == nil) return -1; } for(nb = 0; nb < cnt; nb += n) { i = vderead(f->vde, &vd); if(i < 0) return -1; if(i == 0) break; n = vacstat(f->file, &vd, (uint8_t*)p, cnt-nb); if(n <= BIT16SZ) { vdeunread(f->vde); break; } vdcleanup(&vd); p += n; } return nb; }
/* * Archive the file named name, which has stat info d, * into the vac directory fp (p = parent). * * If we're doing a vac -d against another archive, the * equivalent directory to fp in that archive is diffp. */ void vac(VacFile *fp, VacFile *diffp, char *name, Dir *d) { char *elem, *s; static char buf[65536]; int fd, i, n, bsize; int64_t off; Dir *dk; // kids VacDir vd, vddiff; VacFile *f, *fdiff; VtEntry e; if(!includefile(name)){ warn("excluding %s%s", name, (d->mode&DMDIR) ? "/" : ""); return; } if(d->mode&DMDIR) stats.ndir++; else stats.nfile++; if(merge && vacmerge(fp, name) >= 0) return; if(verbose) fprint(2, "%s%s\n", name, (d->mode&DMDIR) ? "/" : ""); if((fd = open(name, OREAD)) < 0){ warn("open %s: %r", name); return; } elem = strrchr(name, '/'); if(elem) elem++; else elem = name; plan9tovacdir(&vd, d); if((f = vacfilecreate(fp, elem, vd.mode)) == nil){ warn("vacfilecreate %s: %r", name); return; } if(diffp) fdiff = vacfilewalk(diffp, elem); else fdiff = nil; if(vacfilesetdir(f, &vd) < 0) warn("vacfilesetdir %s: %r", name); if(d->mode&DMDIR){ while((n = dirread(fd, &dk)) > 0){ for(i=0; i<n; i++){ s = vtmalloc(strlen(name)+1+strlen(dk[i].name)+1); strcpy(s, name); strcat(s, "/"); strcat(s, dk[i].name); vac(f, fdiff, s, &dk[i]); free(s); } free(dk); } }else{ off = 0; bsize = fs->bsize; if(fdiff){ /* * Copy fdiff's contents into f by moving the score. * We'll diff and update below. */ if(vacfilegetentries(fdiff, &e, nil) >= 0) if(vacfilesetentries(f, &e, nil) >= 0){ bsize = e.dsize; /* * Or if -q is set, and the metadata looks the same, * don't even bother reading the file. */ if(qdiff && vacfilegetdir(fdiff, &vddiff) >= 0){ if(vddiff.mtime == vd.mtime) if(vddiff.size == vd.size) if(!vddiff.plan9 || (/* vddiff.p9path == vd.p9path && */ vddiff.p9version == vd.p9version)){ stats.skipfiles++; stats.nfile--; vdcleanup(&vddiff); goto Out; } /* * Skip over presumably-unchanged prefix * of an append-only file. */ if(vd.mode&ModeAppend) if(vddiff.size < vd.size) if(vddiff.plan9 && vd.plan9) if(vddiff.p9path == vd.p9path){ off = vd.size/bsize*bsize; if(seek(fd, off, 0) >= 0) stats.skipdata += off; else{ seek(fd, 0, 0); // paranoia off = 0; } } vdcleanup(&vddiff); // XXX different verbose chatty prints for kaminsky? } } } if(qdiff && verbose) fprint(2, "+%s\n", name); while((n = readn(fd, buf, bsize)) > 0){ if(fdiff && sha1matches(f, off/bsize, (uint8_t*)buf, n)){ off += n; stats.skipdata += n; continue; } if(vacfilewrite(f, buf, n, off) < 0){ warn("venti write %s: %r", name); goto Out; } stats.data += n; off += n; } /* * Since we started with fdiff's contents, * set the size in case fdiff was bigger. */ if(fdiff && vacfilesetsize(f, off) < 0) warn("vtfilesetsize %s: %r", name); } Out: vacfileflush(f, 1); vacfiledecref(f); if(fdiff) vacfiledecref(fdiff); close(fd); }
VacFile* recentarchive(VacFs *fs, char *path) { VacFile *fp, *f; VacDirEnum *de; VacDir vd; char buf[10]; int year, mmdd, nn, n, n1; char *p; fp = vacfsgetroot(fs); de = vdeopen(fp); year = 0; if(de){ for(; vderead(de, &vd) > 0; vdcleanup(&vd)){ if(strlen(vd.elem) != 4) continue; if((n = strtol(vd.elem, &p, 10)) < 1900 || *p != 0) continue; if(year < n) year = n; } } vdeclose(de); if(year == 0){ vacfiledecref(fp); return nil; } snprint(buf, sizeof buf, "%04d", year); if((f = vacfilewalk(fp, buf)) == nil){ fprint(2, "warning: dirread %s but cannot walk", buf); vacfiledecref(fp); return nil; } fp = f; de = vdeopen(fp); mmdd = 0; nn = 0; if(de){ for(; vderead(de, &vd) > 0; vdcleanup(&vd)){ if(strlen(vd.elem) < 4) continue; if((n = strtol(vd.elem, &p, 10)) < 100 || n > 1231 || p != vd.elem+4) continue; if(*p == '.'){ if(p[1] == '0' || (n1 = strtol(p+1, &p, 10)) == 0 || *p != 0) continue; }else{ if(*p != 0) continue; n1 = 0; } if(n < mmdd || (n == mmdd && n1 < nn)) continue; mmdd = n; nn = n1; } } vdeclose(de); if(mmdd == 0){ vacfiledecref(fp); return nil; } if(nn == 0) snprint(buf, sizeof buf, "%04d", mmdd); else snprint(buf, sizeof buf, "%04d.%d", mmdd, nn); if((f = vacfilewalk(fp, buf)) == nil){ fprint(2, "warning: dirread %s but cannot walk", buf); vacfiledecref(fp); return nil; } vacfiledecref(fp); sprint(path, "%04d/%s", year, buf); return f; }
void unvac(VacFile *f, char *name, VacDir *vdir) { static char buf[65536]; int fd, n, m, bsize; ulong mode, mode9; char *newname; char *what; vlong off; Dir d, *dp; VacDirEnum *vde; VacDir newvdir; VacFile *newf; if(vdir) mode = vdir->mode; else mode = vacfilegetmode(f); if(vdir){ if(table){ if(chatty){ mode9 = vdir->mode&0777; if(mode&ModeDir) mode9 |= DMDIR; if(mode&ModeAppend) mode9 |= DMAPPEND; if(mode&ModeExclusive) mode9 |= DMEXCL; print("%M %-10s %-10s %11lld %t %s\n", mode9, vdir->uid, vdir->gid, vdir->size, vdir->mtime, name); }else print("%s%s\n", name, (mode&ModeDir) ? "/" : ""); } else if(chatty) fprint(2, "%s%s\n", name, (mode&ModeDir) ? "/" : ""); } if(mode&(ModeDevice|ModeLink|ModeNamedPipe|ModeExclusive)){ if(table) return; if(mode&ModeDevice) what = "device"; else if(mode&ModeLink) what = "link"; else if(mode&ModeNamedPipe) what = "named pipe"; else if(mode&ModeExclusive) what = "lock"; else what = "unknown type of file"; fprint(2, "warning: ignoring %s %s\n", what, name); return; } if(mode&ModeDir){ if((vde = vdeopen(f)) == nil){ fprint(2, "vdeopen %s: %r", name); errors++; return; } if(!table && !tostdout && vdir){ // create directory if((dp = dirstat(name)) == nil){ if((fd = create(name, OREAD, DMDIR|(mode&0777))) < 0){ fprint(2, "mkdir %s: %r\n", name); vdeclose(vde); } close(fd); }else{ if(!(dp->mode&DMDIR)){ fprint(2, "%s already exists and is not a directory\n", name); errors++; free(dp); vdeclose(vde); return; } free(dp); } } while(vderead(vde, &newvdir) > 0){ if(name == nil) newname = newvdir.elem; else newname = smprint("%s/%s", name, newvdir.elem); if(wantfile(newname)){ if((newf = vacfilewalk(f, newvdir.elem)) == nil){ fprint(2, "walk %s: %r\n", name); errors++; }else if(newf == f){ fprint(2, "walk loop: %s\n", newname); vacfiledecref(newf); }else{ unvac(newf, newname, &newvdir); vacfiledecref(newf); } } if(newname != newvdir.elem) free(newname); vdcleanup(&newvdir); } vdeclose(vde); }else{ if(!table){ off = 0; if(tostdout) fd = dup(1, -1); else if(diff && (fd = open(name, ORDWR)) >= 0){ bsize = vacfiledsize(f); while((n = readn(fd, buf, bsize)) > 0){ if(sha1matches(f, off/bsize, (uchar*)buf, n)){ off += n; stats.skipdata += n; continue; } seek(fd, off, 0); if((m = vacfileread(f, buf, n, off)) < 0) break; if(writen(fd, buf, m) != m){ fprint(2, "write %s: %r\n", name); goto Err; } off += m; stats.data += m; if(m < n){ nulldir(&d); d.length = off; if(dirfwstat(fd, &d) < 0){ fprint(2, "dirfwstat %s: %r\n", name); goto Err; } break; } } } else if((fd = create(name, OWRITE, mode&0777)) < 0){ fprint(2, "create %s: %r\n", name); errors++; return; } while((n = vacfileread(f, buf, sizeof buf, off)) > 0){ if(writen(fd, buf, n) != n){ fprint(2, "write %s: %r\n", name); Err: errors++; close(fd); remove(name); return; } off += n; stats.data += n; } close(fd); } } if(vdir && settimes && !tostdout){ nulldir(&d); d.mtime = vdir->mtime; if(dirwstat(name, &d) < 0) fprint(2, "warning: setting mtime on %s: %r", name); } }