void attachprocess(void) { char buf[100]; Dir *sym, *mem; int fd; if (!adrflg) { dprint("used pid$a\n"); return; } sym = dirfstat(fsym); sprint(buf, "/proc/%lu/mem", adrval); corfil = buf; setcor(); sprint(buf, "/proc/%lu/text", adrval); fd = open(buf, OREAD); mem = nil; if (sym==nil || fd < 0 || (mem=dirfstat(fd))==nil || sym->qid.path != mem->qid.path) dprint("warning: text images may be inconsistent\n"); free(sym); free(mem); if (fd >= 0) close(fd); }
void checkqid(int f1, int pid) { int fd; Dir *d1, *d2; char buf[128]; if(kernel || rdebug) return; d1 = dirfstat(f1); if(d1 == nil) fatal("checkqid: (qid not checked) dirfstat: %r"); sprint(buf, "/proc/%d/text", pid); fd = open(buf, OREAD); if(fd < 0 || (d2 = dirfstat(fd)) == nil){ fatal("checkqid: (qid not checked) dirstat %s: %r", buf); return; /* not reached */ } close(fd); if(d1->qid.path != d2->qid.path || d1->qid.vers != d2->qid.vers || d1->qid.type != d2->qid.type){ print("path %llux %llux vers %lud %lud type %d %d\n", d1->qid.path, d2->qid.path, d1->qid.vers, d2->qid.vers, d1->qid.type, d2->qid.type); print("warning: image does not match text for pid %d\n", pid); } free(d1); free(d2); }
char* readfile(char *dir, char *name, int *np) { char *file, *data; int fd, len; Dir *d; if(np != nil) *np = 0; file = estrstrdup(dir, name); fd = open(file, OREAD); if(fd < 0) return nil; d = dirfstat(fd); free(file); len = 0; if(d != nil) len = d->length; free(d); data = emalloc(len+1); read(fd, data, len); close(fd); if(np != nil) *np = len; return data; }
void ls(char *file) { Dir *d; int fd, i, nd; fd = open(file, OREAD); if(fd < 0) return; /* * read box to find all messages * each one has a directory, and is in numerical order */ d = dirfstat(fd); if(d == nil){ close(fd); return; } if(!(d->mode & DMDIR)){ fprint(2, "file %s\n", file); free(d); close(fd); return; } free(d); while((nd = dirread(fd, &d)) > 0){ for(i = 0; i < nd; i++){ fprint(2, "%s/%s %c\n", file, d[i].name, "-d"[(d[i].mode & DMDIR) == DMDIR]); } free(d); } close(fd); }
/* * Copy the file referenced by fd to the temp file */ void armove(Biobuf *b, Arfile *ap, Armember *bp) { char *cp; Dir *d; if ((d = dirfstat(Bfildes(b))) == nil) { fprint(2, "ar: cannot stat %s: %r\n", file); return; } trim(file, bp->hdr.name, sizeof(bp->hdr.name)); for (cp = strchr(bp->hdr.name, 0); /* blank pad on right */ cp < bp->hdr.name+sizeof(bp->hdr.name); cp++) *cp = ' '; sprint(bp->hdr.date, "%-12ld", d->mtime); sprint(bp->hdr.uid, "%-6d", 0); sprint(bp->hdr.gid, "%-6d", 0); sprint(bp->hdr.mode, "%-8lo", d->mode); sprint(bp->hdr.size, "%-10lld", (vlong)d->length); strncpy(bp->hdr.fmag, ARFMAG, 2); bp->size = d->length; bp->date = d->mtime; arread(b, bp, bp->size); if (d->length&0x01) d->length++; if (ap) { arinsert(ap, bp); ap->size += d->length+SAR_HDR; } free(d); }
/* * copies while holding the mail lock, * then tries to copy permissions and group ownership */ static int copyData(int ffd, int tfd, MbLock *ml) { Dir *fd, td; char buf[BufSize]; int n; for(;;){ n = read(ffd, buf, BufSize); if(n <= 0){ if(n < 0) return 0; break; } if(write(tfd, buf, n) != n) return 0; mbLockRefresh(ml); } fd = dirfstat(ffd); if(fd != nil){ nulldir(&td); td.mode = fd->mode; if(dirfwstat(tfd, &td) >= 0){ nulldir(&td); td.gid = fd->gid; dirfwstat(tfd, &td); } } return 1; }
Font* openfont(Display *d, char *name) { Font *fnt; int fd, i, n; char *buf; Dir *dir; fd = open(name, OREAD); if(fd < 0) return 0; dir = dirfstat(fd); if(dir == nil){ Err0: close(fd); return 0; } n = dir->length; free(dir); buf = malloc(n+1); if(buf == 0) goto Err0; buf[n] = 0; i = read(fd, buf, n); close(fd); if(i != n){ free(buf); return 0; } fnt = buildfont(d, buf, name); free(buf); return fnt; }
void fscreate(Chan *c, char *name, int mode, ulong perm) { Dir *d; Cname *n; if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0) error(Efilename); n = addelem(newcname(FS(c)->name->s), name); osenter(); FS(c)->fd = create(n->s, mode, perm); osleave(); if(FS(c)->fd < 0) { cnameclose(n); fserr(FS(c)); } d = dirfstat(FS(c)->fd); if(d == nil) { cnameclose(n); close(FS(c)->fd); FS(c)->fd = -1; fserr(FS(c)); } c->qid = d->qid; free(d); cnameclose(FS(c)->name); FS(c)->name = n; c->mode = openmode(mode); c->offset = 0; FS(c)->offset = 0; c->flag |= COPEN; }
/* * return true if any part of the database has changed */ int ndbchanged(struct ndb *db) { /* TODO: implement me (no one calls this yet) */ assert(0); return 0; #if 0 struct ndb *ndb; struct dir *d; /* FIX ME */ for(ndb = db; ndb != NULL; ndb = ndb->next){ d = dirfstat(Bfildes(&ndb->b)); if(d == NULL) continue; if(ndb->qid.path != d->qid.path || ndb->qid.vers != d->qid.vers){ free(d); return 1; } free(d); } return 0; #endif }
/* * dump any cached information, forget the hash tables, and reopen a single file */ int ndbreopen(struct ndb *db) { int fd; struct dir *d; /* forget what we know about the open files */ if(db->isopen){ _ndbcacheflush(db); hffree(db); fclose(db->b); db->mtime = 0; db->isopen = 0; } /* try the open again */ db->b = fopen(db->file, "r"); if(! db->b) return -1; #if 0 d = dirfstat(fd); if(d == NULL){ close(fd); return -1; } db->qid = d->qid; db->mtime = d->mtime; db->length = d->length; free(d); #endif db->isopen = 1; return 0; }
void main(int argc, char *argv[]) { Dir *d; char *p, *file; int fd, len; ARGBEGIN{ case 'p': usepass = 1; break; case 'v': verb = 1; break; case 'a': convaes = 1; break; default: usage(); } ARGEND if(argc != 1) usage(); file = argv[0]; /* get original key */ if(usepass) { print("enter password file is encoded with\n"); getpass(&okey, nil, 0, 1); } else { getauthkey(&okey); } if(!verb) { print("enter password to reencode with\n"); getpass(&nkey, nil, 0, 1); } fd = open(file, ORDWR); if(fd < 0) error("can't open %s: %r\n", file); d = dirfstat(fd); if(d == nil) error("can't stat %s: %r\n", file); len = d->length; p = malloc(len); if(p == nil) error("out of memory"); if(read(fd, p, len) != len) error("can't read key file: %r\n"); len = convert(&p, len); if(pwrite(fd, p, len, 0) != len) error("can't write key file: %r\n"); close(fd); exits(nil); }
void print_item(char *file) { char name[4096], *p, *ep; Dir *dbuf; int f, c; int bol, bop; sprint(name, "%s/%s", NEWS, file); f = open(name, OREAD); if(f < 0) { fprint(2, "news: "); perror(name); return; } strcpy(name, "..."); dbuf = dirfstat(f); if(dbuf == nil) return; Bprint(&bout, "\n%s (%s) %s\n", file, dbuf->muid[0]? dbuf->muid : dbuf->uid, asctime(localtime(dbuf->mtime))); free(dbuf); bol = 1; /* beginning of line ...\n */ bop = 1; /* beginning of page ...\n\n */ for(;;) { c = read(f, name, sizeof(name)); if(c <= 0) break; p = name; ep = p+c; while(p < ep) { c = *p++; if(c == '\n') { if(!bop) { Bputc(&bout, c); if(bol) bop = 1; bol = 1; } continue; } if(bol) { Bputc(&bout, '\t'); bol = 0; bop = 0; } Bputc(&bout, c); } } if(!bol) Bputc(&bout, '\n'); close(f); }
void main(int argc, char *argv[]) { Dir *d; char *p, *np, *file, key[DESKEYLEN]; int fd, len; ARGBEGIN{ case 'v': verb = 1; break; case 'p': usepass = 1; break; default: usage(); }ARGEND if(argc != 1) usage(); file = argv[0]; /* get original key */ if(usepass){ print("enter password file is encoded with\n"); getpass(authkey, nil, 0, 1); } else getauthkey(authkey); print("enter password to reencode with\n"); getpass(key, nil, 0, 1); fd = open(file, ORDWR); if(fd < 0) error("can't open %s: %r\n", file); d = dirfstat(fd); if(d == nil) error("can't stat %s: %r\n", file); len = d->length; p = malloc(len); if(!p) error("out of memory"); np = malloc((len/OKEYDBLEN)*KEYDBLEN + KEYDBOFF); if(!np) error("out of memory"); if(read(fd, p, len) != len) error("can't read key file: %r\n"); len = convert(p, np, key, len); if(verb) exits(0); if(pwrite(fd, np, len, 0) != len) error("can't write key file: %r\n"); close(fd); exits(0); }
void hintprint(HConnect *hc, Hio *hout, char *uri, int thresh, int havej) { int i, j, pr, prefix, fd, siz, havei, newhint = 0, n; char *query, *sf, etag[32], *wurl; Dir *dir; Hint *h, *haveh; query = hstrdup(hc, uri); urlcanon(query); j = urllookup(hashstr(query)); if(j < 0) return; query = strrchr(uri,'/'); if(!query) return; /* can't happen */ prefix = query-uri+1; /* = strlen(dirname)+1 */ h = hints[j]; for(i=0; i<nhint[j]; i++){ if(havej > 0 && havej < URLmax){ /* exclude hints client has */ haveh = hints[havej]; for(havei=0; havei<nhint[havej]; havei++) if( haveh[havei].url == h[i].url) goto continuei; } sf = urlname[h[i].url]; pr = h[i].prob; if(pr<thresh) break; n = strlen(webroot) + strlen(sf) + 1; wurl = halloc(hc, n); strcpy(wurl, webroot); strcat(wurl, sf); fd = open(wurl, OREAD); if(fd<0) continue; dir = dirfstat(fd); if(dir == nil){ close(fd); continue; } close(fd); snprint(etag, sizeof(etag), "\"%lluxv%lx\"", dir->qid.path, dir->qid.vers); siz = (int)( log((double)dir->length) * RECIPLOG2 + 0.9999); free(dir); if(strncmp(uri,sf,prefix)==0 && strchr(sf+prefix,'/')==0 && sf[prefix]!=0) sf = sf+prefix; hprint(hout, "Fresh: %d,%s,%d,%s\r\n", pr, etag, siz, sf); newhint++; continuei: ; } if(newhint) hprint(hout, "Fresh: have/%d\r\n", j); }
void mminit(char *file, int mode) { Dir *d; uintptr va; void *p, *np; int hashsize; /* make it a power of two -- see why later */ ventifd = open(file, mode); if (ventifd < 0) sysfatal("Can't open %s: %r\n", file); d = dirfstat(ventifd); if (! d) sysfatal("Can't stat %s: %r", file); /* allocate: size for the file, 1/32 that size for the map, and * start it at the 1 GB boundary, please. */ /* get top of heap */ p = segbrk(0, 0); va = (uintptr)p; /* no non-nix systems we just usr sbrk and only have little pages */ hashsize = d->length/32; maxmap = hashsize / sizeof(*maps); hashb = log2(maxmap); if (va == (uintptr)-1) { p = sbrk(0); va = (uintptr)p; maps = (void *)va; va += hashsize; mmventidatabase = mmventidata = (void *)va; va += d->length; va = ROUNDUP((va), 4096); if (brk((void *)va) < 0) sysfatal("brk to %#p failed\n", (void *)va); } else { va = ROUNDUP((va), 1ULL*GiB); maps = (void *)va; va += hashsize; mmventidatabase = mmventidata = (void *)va; va += d->length; va = ROUNDUP((va), 1ULL*GiB); segbrk(0, (void *)va); } fprint(2, "mmventidatabase is %#p\n", mmventidatabase); fprint(2, "File size %lld, hashsize %d, maps %#p, data %#p\n", d->length, hashsize, maps, mmventidata); /* morecore */ np=(void*)va; segbrk(p, np); reload(); }
static u64int fdsize(int fd) { Dir *dir; u64int size; dir = dirfstat(fd); if(dir == nil) vtFatal("could not stat file: %r"); size = dir->length; free(dir); return size; }
Ident getident(int fd) { Dir *d; Ident i; d = dirfstat(fd); if(d == nil) return (Ident){-1, -1, (Qid){0, 0, 0}}; i = (Ident){d->type, d->dev, d->qid}; free(d); return i; }
static int fromwebdir(HConnect *c) { char buf[4096], *p, *ext, *type; int i, fd, n, defaulted; Dir *d; if(webroot == nil || strstr(c->req.uri, "..")) return hnotfound(c); snprint(buf, sizeof buf-20, "%s/%s", webroot, c->req.uri+1); defaulted = 0; reopen: if((fd = open(buf, OREAD)) < 0) return hnotfound(c); d = dirfstat(fd); if(d == nil){ close(fd); return hnotfound(c); } if(d->mode&DMDIR){ if(!defaulted){ defaulted = 1; strcat(buf, "/index.html"); free(d); close(fd); goto reopen; } free(d); return hnotfound(c); } free(d); p = buf+strlen(buf); type = "application/octet-stream"; for(i=0; exttab[i].ext; i++){ ext = exttab[i].ext; if(p-strlen(ext) >= buf && strcmp(p-strlen(ext), ext) == 0){ type = exttab[i].type; break; } } if(hsettype(c, type) < 0){ close(fd); return 0; } while((n = read(fd, buf, sizeof buf)) > 0) if(hwrite(&c->hout, buf, n) < 0) break; close(fd); hflush(&c->hout); return 0; }
int Bage(Biobuf *b) { Dir *dir; int32_t mtime; dir = dirfstat(Bfildes(b)); if(dir != nil) mtime = dir->mtime; else mtime = 0; free(dir); return time(nil) - mtime; }
void openfiles(void) { Dir *d; int i; for(i = 0; i < 20; i++){ d = dirfstat(i); if(d != nil){ fprint(2, "fd[%d]='%s' type=%c dev=%d user='******'%s'\n", i, d->name, d->type, d->dev, d->uid, d->gid); free(d); } } }
static Srv* srvAlloc(char* service, int mode, int fd) { Dir *dir; Srv *srv; int srvfd; char *mntpnt; vtLock(sbox.lock); for(srv = sbox.head; srv != nil; srv = srv->next){ if(strcmp(srv->service, service) != 0) continue; /* * If the service exists, but is stale, * free it up and let the name be reused. */ if((dir = dirfstat(srv->srvfd)) != nil){ free(dir); vtSetError("srv: already serving '%s'", service); vtUnlock(sbox.lock); return nil; } srvFree(srv); break; } if((srvfd = srvFd(service, mode, fd, &mntpnt)) < 0){ vtUnlock(sbox.lock); return nil; } close(fd); srv = vtMemAllocZ(sizeof(Srv)); srv->srvfd = srvfd; srv->service = vtStrDup(service); srv->mntpnt = mntpnt; if(sbox.tail != nil){ srv->prev = sbox.tail; sbox.tail->next = srv; } else{ sbox.head = srv; srv->prev = nil; } sbox.tail = srv; vtUnlock(sbox.lock); return srv; }
void main(int argc, char *argv[]) { char *lockfile; int fd, ppid, ssize; struct Dir *statbuf; if (argc != 4) { fprint(2, "usage: LOCK lockfile hostname ppid\n"); exits("lock failed on usage"); } lockfile = argv[1]; if ((fd=create(lockfile, ORDWR, DMEXCL|0666)) < 0) { exits("lock failed on create"); } ppid = atoi(argv[3]); ssize = sprint(lockstring, "%s %s\n", argv[2], argv[3]); if (write(fd, lockstring, ssize) != ssize) { fprint(2, "LOCK:write(): %r\n"); exits("lock failed on write to lockfile"); } switch(fork()) { default: exits(""); case 0: break; case -1: fprint(2, "LOCK:fork(): %r\n"); exits("lock failed on fork"); } for(;;) { statbuf = dirfstat(fd); if(statbuf == nil) break; if (statbuf->length == 0){ free(statbuf); break; } free(statbuf); if (write(fd, "", 0) < 0) break; sleep(3000); } close(fd); postnote(PNGROUP, ppid, "kill"); exits(""); }
int updateQid(int fd, Qid *q) { Dir *dir; Qid dq; dir = dirfstat(fd); if(dir == nil) sysfatal("can't dirfstat"); dq = dir->qid; free(dir); if(q->path == dq.path && q->vers == dq.vers && q->type == dq.type) return 0; *q = dq; return 1; }
static int gunzip(int ofd, char *ofile, Biobuf *bin) { Dir *d; GZHead h; int err; h.file = nil; gzok = 0; for(;;){ if(Bgetc(bin) < 0) return 1; Bungetc(bin); if(setjmp(zjmp)) return 0; header(bin, &h); gzok = 0; wlen = 0; crc = 0; if(!table && verbose) fprint(2, "extracting %s to %s\n", h.file, ofile); err = inflate((void*)ofd, crcwrite, bin, (int(*)(void*))Bgetc); if(err != FlateOk) error("inflate failed: %s", flateerr(err)); trailer(bin, wlen); if(table){ if(verbose) print("%-32s %10ld %s", h.file, wlen, ctime(h.mtime)); else print("%s\n", h.file); }else if(settimes && h.mtime && (d=dirfstat(ofd)) != nil){ d->mtime = h.mtime; dirfwstat(ofd, d); free(d); } free(h.file); h.file = nil; gzok = Boffset(bin); } }
static String* Brdstring(Biobuf *b) { int32_t len; String *s; Dir *d; d = dirfstat(Bfildes(b)); if (d == nil) /* shouldn't happen, we just opened it */ len = 0; else len = d->length; free(d); s = s_newalloc(len); s_read(b, s, len); return s; }
void sayhi(void) { Dir *dp; reply("220-%s ESMTP\r\n", dom); sleep(3000); dp = dirfstat(0); if (dp && dp->length > 0) { syslog(0, "smtpd", "Hung up on impatient spammer %s", nci->rsys); if(Dflag) sleep(delaysecs()*1000); reply("554 5.7.0 Spammer!\r\n"); exits("spammer didn't wait for greeting to finish"); } free(dp); reply("220 \r\n"); }
static Disk* openfile(Disk *disk) { Dir *d; if((d = dirfstat(disk->fd)) == nil){ free(disk); return nil; } disk->secsize = 512; disk->size = d->length; disk->secs = disk->size / disk->secsize; disk->offset = 0; free(d); findgeometry(disk); return mkwidth(disk); }
/* * return true if any part of the database has changed */ int ndbchanged(Ndb *db) { Ndb *ndb; Dir *d; for(ndb = db; ndb != nil; ndb = ndb->next){ d = dirfstat(Bfildes(&ndb->b)); if(d == nil) continue; if(ndb->qid.path != d->qid.path || ndb->qid.vers != d->qid.vers){ free(d); return 1; } free(d); } return 0; }
Obj* openobj(char *name) { Dir *d; Obj *obj; obj = emalloc(sizeof *obj); obj->name = name; obj->version = version++; if((obj->fd = open(name, ORDWR)) < 0) sysfatal("open %s: %r", name); if((d = dirfstat(obj->fd)) == nil) sysfatal("dirfstat: %r"); obj->bp = emalloc(d->length); if(readn(obj->fd, obj->bp, d->length) != d->length) sysfatal("read %s: %r", name); obj->ep = obj->bp+d->length; return obj; }
/* * dump any cached information, forget the hash tables, and reopen a single file */ int ndbreopen(struct ndb *db) { int fd; struct dir *d; /* forget what we know about the open files */ if(db->isopen){ _ndbcacheflush(db); hffree(db); fclose(db->b); db->mtime = 0; db->isopen = 0; } /* try the open again */ db->b = fopen(db->file, "r"); if(! db->b) { return -1; } #if 0 d = dirfstat(fd); if(d == NULL){ close(fd); return -1; } db->qid.path = d->qid.path; db->mtime = d->mtime; db->length = d->length; free(d); #else struct stat s; /* we opened it, this WILL work */ stat(db->file, &s); db->qid.path = s.st_ino; db->mtime = s.st_mtime + 1; db->length = s.st_size; #endif db->isopen = 1; return 0; }