summaryrefslogtreecommitdiff
path: root/emu/port/devfs-posix.c
diff options
context:
space:
mode:
Diffstat (limited to 'emu/port/devfs-posix.c')
-rw-r--r--emu/port/devfs-posix.c1058
1 files changed, 1058 insertions, 0 deletions
diff --git a/emu/port/devfs-posix.c b/emu/port/devfs-posix.c
new file mode 100644
index 00000000..512c240c
--- /dev/null
+++ b/emu/port/devfs-posix.c
@@ -0,0 +1,1058 @@
+/*
+ * Unix file system interface
+ */
+#define _LARGEFILE64_SOURCE 1
+#define _FILE_OFFSET_BITS 64
+#include "dat.h"
+#include "fns.h"
+#include "error.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/fcntl.h>
+#include <utime.h>
+#include <dirent.h>
+#include <stdio.h>
+#define __EXTENSIONS__
+#undef getwd
+#include <unistd.h>
+#include <pwd.h>
+#include <grp.h>
+
+typedef struct Fsinfo Fsinfo;
+struct Fsinfo
+{
+ int uid;
+ int gid;
+ int mode; /* Unix mode */
+ DIR* dir; /* open directory */
+ struct dirent* de; /* directory reading */
+ int fd; /* open files */
+ ulong offset; /* offset when reading directory */
+ QLock oq; /* mutex for offset */
+ char* spec;
+ Cname* name; /* Unix's name for file */
+ Qid rootqid; /* Plan 9's qid for Inferno's root */
+};
+
+#define FS(c) ((Fsinfo*)(c)->aux)
+
+enum
+{
+ IDSHIFT = 8,
+ NID = 1 << IDSHIFT,
+ IDMASK = NID - 1,
+ MAXPATH = 1024 /* TO DO: eliminate this */
+};
+
+typedef struct Pass Pass;
+struct Pass
+{
+ int id;
+ int gid;
+ char* name;
+ Pass* next;
+};
+
+char rootdir[MAXROOT] = ROOT;
+
+static Pass* uid[NID];
+static Pass* gid[NID];
+static Pass* member[NID];
+static RWlock idl;
+
+static Qid fsqid(struct stat *);
+static void fspath(Cname*, char*, char*);
+static int fsdirconv(Chan*, char*, struct stat*, uchar*, int, int);
+static Cname* fswalkpath(Cname*, char*, int);
+static char* fslastelem(Cname*);
+static char* id2name(Pass**, int);
+static int ingroup(int id, int gid);
+static void fsperm(Chan*, int);
+static long fsdirread(Chan*, uchar*, int, vlong);
+static int fsomode(int);
+static Pass* name2pass(Pass**, char*);
+static void getpwdf(void);
+static void getgrpf(void);
+static void fsremove(Chan*);
+
+/* Unix libc */
+
+extern struct passwd *getpwent(void);
+extern struct group *getgrent(void);
+
+/*
+ * this crud is to compensate for invalid symbolic links;
+ * all you can do is delete them, and good riddance
+ */
+static int
+xstat(char *f, struct stat *sb)
+{
+ if(stat(f, sb) >= 0)
+ return 0;
+ /* could possibly generate ->name as rob suggested */
+ return lstat(f, sb);
+}
+
+static void
+fsfree(Chan *c)
+{
+ cnameclose(FS(c)->name);
+ free(FS(c));
+}
+
+Chan*
+fsattach(char *spec)
+{
+ Chan *c;
+ struct stat stbuf;
+ static int devno;
+ static Lock l;
+
+ getpwdf();
+ getgrpf();
+
+ if(!emptystr(spec) && strcmp(spec, "*") != 0)
+ error(Ebadspec);
+ if(stat(rootdir, &stbuf) < 0)
+ oserror();
+
+ c = devattach('U', spec);
+ c->qid = fsqid(&stbuf);
+ c->aux = smalloc(sizeof(Fsinfo));
+ FS(c)->dir = nil;
+ FS(c)->de = nil;
+ FS(c)->fd = -1;
+ FS(c)->gid = stbuf.st_gid;
+ FS(c)->uid = stbuf.st_uid;
+ FS(c)->mode = stbuf.st_mode;
+ lock(&l);
+ c->dev = devno++;
+ unlock(&l);
+ if (!emptystr(spec)){
+ FS(c)->spec = "/";
+ FS(c)->name = newcname(FS(c)->spec);
+ }else
+ FS(c)->name = newcname(rootdir);
+ FS(c)->rootqid = c->qid;
+
+ return c;
+}
+
+Walkqid*
+fswalk(Chan *c, Chan *nc, char **name, int nname)
+{
+ int j;
+ volatile int alloc;
+ Walkqid *wq;
+ struct stat stbuf;
+ char *n;
+ Cname *next;
+ Cname *volatile current;
+ Qid rootqid;
+
+ if(nname > 0)
+ isdir(c);
+
+ alloc = 0;
+ current = nil;
+ wq = smalloc(sizeof(Walkqid)+(nname-1)*sizeof(Qid));
+ if(waserror()){
+ if(alloc && wq->clone != nil)
+ cclose(wq->clone);
+ cnameclose(current);
+ free(wq);
+ return nil;
+ }
+ if(nc == nil){
+ nc = devclone(c);
+ nc->type = 0;
+ alloc = 1;
+ }
+ wq->clone = nc;
+ rootqid = FS(c)->rootqid;
+ current = FS(c)->name;
+ if(current != nil)
+ incref(&current->r);
+ for(j = 0; j < nname; j++){
+ if(!(nc->qid.type&QTDIR)){
+ if(j==0)
+ error(Enotdir);
+ break;
+ }
+ n = name[j];
+ if(strcmp(n, ".") != 0 && !(isdotdot(n) && nc->qid.path == rootqid.path)){
+ next = current;
+ incref(&next->r);
+ next = addelem(current, n);
+ //print("** ufs walk '%s' -> %s [%s]\n", current->s, n, next->s);
+ if(xstat(next->s, &stbuf) < 0){
+ cnameclose(next);
+ if(j == 0)
+ error(Enonexist);
+ strcpy(up->env->errstr, Enonexist);
+ break;
+ }
+ nc->qid = fsqid(&stbuf);
+ cnameclose(current);
+ current = next;
+ }
+ wq->qid[wq->nqid++] = nc->qid;
+ }
+ poperror();
+ if(wq->nqid < nname){
+ cnameclose(current);
+ if(alloc)
+ cclose(wq->clone);
+ wq->clone = nil;
+ }else if(wq->clone){
+ nc->aux = smalloc(sizeof(Fsinfo));
+ nc->type = c->type;
+ if (nname) {
+ FS(nc)->gid = stbuf.st_gid;
+ FS(nc)->uid = stbuf.st_uid;
+ FS(nc)->mode = stbuf.st_mode;
+ } else {
+ FS(nc)->gid = FS(c)->gid;
+ FS(nc)->uid = FS(c)->uid;
+ FS(nc)->mode = FS(c)->mode;
+ }
+ FS(nc)->name = current;
+ FS(nc)->spec = FS(c)->spec;
+ FS(nc)->rootqid = rootqid;
+ FS(nc)->fd = -1;
+ FS(nc)->dir = nil;
+ FS(nc)->de = nil;
+ }
+ return wq;
+}
+
+static int
+fsstat(Chan *c, uchar *dp, int n)
+{
+ struct stat stbuf;
+ char *p;
+
+ if(xstat(FS(c)->name->s, &stbuf) < 0)
+ oserror();
+ p = fslastelem(FS(c)->name);
+ if(*p == 0)
+ p = "/";
+ rlock(&idl);
+ n = fsdirconv(c, p, &stbuf, dp, n, 0);
+ runlock(&idl);
+ return n;
+}
+
+static Chan*
+fsopen(Chan *c, int mode)
+{
+ int m, isdir;
+
+ m = mode & (OTRUNC|3);
+ switch(m) {
+ case 0:
+ fsperm(c, 4);
+ break;
+ case 1:
+ case 1|16:
+ fsperm(c, 2);
+ break;
+ case 2:
+ case 0|16:
+ case 2|16:
+ fsperm(c, 4);
+ fsperm(c, 2);
+ break;
+ case 3:
+ fsperm(c, 1);
+ break;
+ default:
+ error(Ebadarg);
+ }
+
+ isdir = c->qid.type & QTDIR;
+
+ if(isdir && mode != OREAD)
+ error(Eperm);
+
+ m = fsomode(m & 3);
+ c->mode = openmode(mode);
+
+ if(isdir) {
+ FS(c)->dir = opendir(FS(c)->name->s);
+ if(FS(c)->dir == 0)
+ oserror();
+ }
+ else {
+ if(mode & OTRUNC)
+ m |= O_TRUNC;
+ FS(c)->fd = open(FS(c)->name->s, m, 0666);
+ if(FS(c)->fd < 0)
+ oserror();
+ }
+
+ c->offset = 0;
+ FS(c)->offset = 0;
+ c->flag |= COPEN;
+ return c;
+}
+
+static void
+fscreate(Chan *c, char *name, int mode, ulong perm)
+{
+ int fd, m, o;
+ struct stat stbuf;
+ Cname *n;
+
+ fsperm(c, 2);
+
+ m = fsomode(mode&3);
+ openmode(mode); /* get the errors out of the way */
+
+ if(strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
+ error(Efilename);
+ n = fswalkpath(FS(c)->name, name, 1);
+ if(waserror()){
+ cnameclose(n);
+ nexterror();
+ }
+ if(perm & DMDIR) {
+ if(m)
+ error(Eperm);
+
+ perm &= ~0777 | (FS(c)->mode & 0777);
+ if(mkdir(n->s, perm) < 0)
+ oserror();
+
+ fd = open(n->s, 0);
+ if(fd < 0)
+ oserror();
+ fchmod(fd, perm);
+ fchown(fd, up->env->uid, FS(c)->gid);
+ if(fstat(fd, &stbuf) <0){
+ close(fd);
+ oserror();
+ }
+ close(fd);
+ FS(c)->dir = opendir(n->s);
+ if(FS(c)->dir == nil)
+ oserror();
+ } else {
+ o = (O_CREAT | O_EXCL) | (mode&3);
+ if(mode & OTRUNC)
+ o |= O_TRUNC;
+ perm &= ~0666 | (FS(c)->mode & 0666);
+ fd = open(n->s, o, perm);
+ if(fd < 0)
+ oserror();
+ fchmod(fd, perm);
+ fchown(fd, up->env->uid, FS(c)->gid);
+ if(fstat(fd, &stbuf) < 0){
+ close(fd);
+ oserror();
+ }
+ FS(c)->fd = fd;
+ }
+ cnameclose(FS(c)->name);
+ FS(c)->name = n;
+ poperror();
+
+ c->qid = fsqid(&stbuf);
+ FS(c)->gid = stbuf.st_gid;
+ FS(c)->uid = stbuf.st_uid;
+ FS(c)->mode = stbuf.st_mode;
+ c->mode = openmode(mode);
+ c->offset = 0;
+ FS(c)->offset = 0;
+ c->flag |= COPEN;
+}
+
+static void
+fsclose(Chan *c)
+{
+ if((c->flag & COPEN) != 0){
+ if(c->qid.type & QTDIR)
+ closedir(FS(c)->dir);
+ else
+ close(FS(c)->fd);
+ }
+ if(c->flag & CRCLOSE) {
+ if(!waserror()) {
+ fsremove(c);
+ poperror();
+ }
+ return;
+ }
+ fsfree(c);
+}
+
+static long
+fsread(Chan *c, void *va, long n, vlong offset)
+{
+ long r;
+
+ if(c->qid.type & QTDIR){
+ qlock(&FS(c)->oq);
+ if(waserror()) {
+ qunlock(&FS(c)->oq);
+ nexterror();
+ }
+ r = fsdirread(c, va, n, offset);
+ poperror();
+ qunlock(&FS(c)->oq);
+ }else{
+ r = pread(FS(c)->fd, va, n, offset);
+ if(r < 0 && (errno == ESPIPE || errno == EPIPE)){
+ r = read(FS(c)->fd, va, n);
+ if(r < 0)
+ oserror();
+ }
+ }
+ return r;
+}
+
+static long
+fswrite(Chan *c, void *va, long n, vlong offset)
+{
+ long r;
+
+ r = pwrite(FS(c)->fd, va, n, offset);
+ if(r < 0 && (errno == ESPIPE || errno == EPIPE)){
+ r = write(FS(c)->fd, va, n);
+ if(r < 0)
+ oserror();
+ }
+ return r;
+}
+
+static void
+fswchk(Cname *c)
+{
+ struct stat stbuf;
+
+ if(stat(c->s, &stbuf) < 0)
+ oserror();
+
+ if(stbuf.st_uid == up->env->uid)
+ stbuf.st_mode >>= 6;
+ else
+ if(stbuf.st_gid == up->env->gid || ingroup(up->env->uid, stbuf.st_gid))
+ stbuf.st_mode >>= 3;
+
+ if(stbuf.st_mode & S_IWOTH)
+ return;
+
+ error(Eperm);
+}
+
+static void
+fsremove(Chan *c)
+{
+ int n;
+ volatile struct { Cname *dir; } dir;
+
+ dir.dir = fswalkpath(FS(c)->name, "..", 1);
+ if(waserror()){
+ if(dir.dir != nil)
+ cnameclose(dir.dir);
+ fsfree(c);
+ nexterror();
+ }
+ fswchk(dir.dir);
+ cnameclose(dir.dir);
+ dir.dir = nil;
+ if(c->qid.type & QTDIR)
+ n = rmdir(FS(c)->name->s);
+ else
+ n = remove(FS(c)->name->s);
+ if(n < 0)
+ oserror();
+ poperror();
+ fsfree(c);
+}
+
+static int
+fswstat(Chan *c, uchar *buf, int nb)
+{
+ Dir *d;
+ Pass *p;
+ volatile struct { Cname *ph; } ph;
+ struct stat stbuf;
+ struct utimbuf utbuf;
+ int tsync;
+
+ if(FS(c)->fd >= 0){
+ if(fstat(FS(c)->fd, &stbuf) < 0)
+ oserror();
+ }else{
+ if(stat(FS(c)->name->s, &stbuf) < 0)
+ oserror();
+ }
+ d = malloc(sizeof(*d)+nb);
+ if(d == nil)
+ error(Enomem);
+ if(waserror()){
+ free(d);
+ nexterror();
+ }
+ tsync = 1;
+ nb = convM2D(buf, nb, d, (char*)&d[1]);
+ if(nb == 0)
+ error(Eshortstat);
+ if(!emptystr(d->name) && strcmp(d->name, fslastelem(FS(c)->name)) != 0) {
+ tsync = 0;
+ validname(d->name, 0);
+ ph.ph = fswalkpath(FS(c)->name, "..", 1);
+ if(waserror()){
+ cnameclose(ph.ph);
+ nexterror();
+ }
+ fswchk(ph.ph);
+ ph.ph = fswalkpath(ph.ph, d->name, 0);
+ if(rename(FS(c)->name->s, ph.ph->s) < 0)
+ oserror();
+ cnameclose(FS(c)->name);
+ poperror();
+ FS(c)->name = ph.ph;
+ }
+
+ if(d->mode != ~0 && (d->mode&0777) != (stbuf.st_mode&0777)) {
+ tsync = 0;
+ if(up->env->uid != stbuf.st_uid)
+ error(Eowner);
+ if(FS(c)->fd >= 0){
+ if(fchmod(FS(c)->fd, d->mode&0777) < 0)
+ oserror();
+ }else{
+ if(chmod(FS(c)->name->s, d->mode&0777) < 0)
+ oserror();
+ }
+ FS(c)->mode &= ~0777;
+ FS(c)->mode |= d->mode&0777;
+ }
+
+ if(d->atime != ~0 && d->atime != stbuf.st_atime
+ || d->mtime != ~0 && d->mtime != stbuf.st_mtime) {
+ tsync = 0;
+ if(up->env->uid != stbuf.st_uid)
+ error(Eowner);
+ if(d->mtime != ~0)
+ utbuf.modtime = d->mtime;
+ else
+ utbuf.modtime = stbuf.st_mtime;
+ if(d->atime != ~0)
+ utbuf.actime = d->atime;
+ else
+ utbuf.actime = stbuf.st_atime;
+ if(utime(FS(c)->name->s, &utbuf) < 0) /* TO DO: futimes isn't portable */
+ oserror();
+ }
+
+ if(*d->gid){
+ tsync = 0;
+ rlock(&idl);
+ if(waserror()){
+ runlock(&idl);
+ nexterror();
+ }
+ p = name2pass(gid, d->gid);
+ if(p == 0)
+ error(Eunknown);
+ if(p->id != stbuf.st_gid) {
+ if(up->env->uid != stbuf.st_uid)
+ error(Eowner);
+ if(FS(c)->fd >= 0){
+ if(fchown(FS(c)->fd, stbuf.st_uid, p->id) < 0)
+ oserror();
+ }else{
+ if(chown(FS(c)->name->s, stbuf.st_uid, p->id) < 0)
+ oserror();
+ }
+ FS(c)->gid = p->id;
+ }
+ poperror();
+ runlock(&idl);
+ }
+
+ if(d->length != ~(uvlong)0){
+ tsync = 0;
+ if(FS(c)->fd >= 0){
+ fsperm(c, 2);
+ if(ftruncate(FS(c)->fd, d->length) < 0)
+ oserror();
+ }else{
+ fswchk(FS(c)->name);
+ if(truncate(FS(c)->name->s, d->length) < 0)
+ oserror();
+ }
+ }
+
+ poperror();
+ free(d);
+ if(tsync && FS(c)->fd >= 0 && fsync(FS(c)->fd) < 0)
+ oserror();
+ return nb;
+}
+
+#define QDEVBITS 4 /* 16 devices should be plenty */
+#define MAXDEV (1<<QDEVBITS)
+#define QDEVSHIFT (64-QDEVBITS)
+#define QINOMASK (((uvlong)1<<QDEVSHIFT)-1)
+#define QPATH(d,i) (((uvlong)(d)<<QDEVSHIFT)|((uvlong)(i)&QINOMASK))
+
+static Qid
+fsqid(struct stat *st)
+{
+ Qid q;
+ ulong dev;
+ int idev;
+ static int nqdev = 0;
+ static ulong qdev[MAXDEV];
+ static Lock l;
+
+ q.type = QTFILE;
+ if(S_ISDIR(st->st_mode))
+ q.type = QTDIR;
+
+ dev = st->st_dev;
+ lock(&l);
+ for(idev = 0; idev < nqdev; idev++)
+ if(qdev[idev] == dev)
+ break;
+ if(idev == nqdev) {
+ if(nqdev == MAXDEV) {
+ unlock(&l);
+ error("too many devices");
+ }
+ qdev[nqdev++] = dev;
+ }
+ unlock(&l);
+
+ if(0) /* we'll just let it be masked off */
+ if((uvlong)st->st_ino & ~QINOMASK)
+ error("inode number too large");
+
+ q.path = QPATH(idev, st->st_ino);
+ q.vers = st->st_mtime;
+
+ return q;
+}
+
+static void
+fspath(Cname *c, char *name, char *path)
+{
+ int n;
+
+ if(c->len+strlen(name) >= MAXPATH)
+ panic("fspath: name too long");
+ memmove(path, c->s, c->len);
+ n = c->len;
+ if(path[n-1] != '/')
+ path[n++] = '/';
+ strcpy(path+n, name);
+ if(isdotdot(name))
+ cleanname(path);
+/*print("->%s\n", path);*/
+}
+
+static Cname *
+fswalkpath(Cname *c, char *name, int dup)
+{
+ if(dup)
+ c = newcname(c->s);
+ c = addelem(c, name);
+ if(isdotdot(name))
+ cleancname(c);
+ return c;
+}
+
+static char *
+fslastelem(Cname *c)
+{
+ char *p;
+
+ p = c->s + c->len;
+ while(p > c->s && p[-1] != '/')
+ p--;
+ return p;
+}
+
+/*
+ * Assuming pass is one of the static arrays protected by idl, caller must
+ * hold idl in writer mode.
+ */
+static void
+freepass(Pass **pass)
+{
+ int i;
+ Pass *p, *np;
+
+ for(i=0; i<NID; i++){
+ for(p = pass[i]; p; p = np){
+ np = p->next;
+ free(p);
+ }
+ pass[i] = 0;
+ }
+}
+
+static void
+getpwdf(void)
+{
+ unsigned i;
+ Pass *p;
+ static int mtime; /* serialized by idl */
+ struct stat stbuf;
+ struct passwd *pw;
+
+ if(stat("/etc/passwd", &stbuf) < 0)
+ panic("can't read /etc/passwd");
+
+ /*
+ * Unlocked peek is okay, since the check is a heuristic (as is
+ * the function).
+ */
+ if(stbuf.st_mtime <= mtime)
+ return;
+
+ wlock(&idl);
+ if(stbuf.st_mtime <= mtime) {
+ /*
+ * If we lost a race on updating the database, we can
+ * avoid some work.
+ */
+ wunlock(&idl);
+ return;
+ }
+ mtime = stbuf.st_mtime;
+ freepass(uid);
+ setpwent();
+ while(pw = getpwent()){
+ i = pw->pw_uid;
+ i = (i&IDMASK) ^ ((i>>IDSHIFT)&IDMASK);
+ p = realloc(0, sizeof(Pass));
+ if(p == 0)
+ panic("getpwdf");
+
+ p->next = uid[i];
+ uid[i] = p;
+ p->id = pw->pw_uid;
+ p->gid = pw->pw_gid;
+ p->name = strdup(pw->pw_name);
+ if(p->name == 0)
+ panic("no memory");
+ }
+
+ wunlock(&idl);
+ endpwent();
+}
+
+static void
+getgrpf(void)
+{
+ static int mtime; /* serialized by idl */
+ struct stat stbuf;
+ struct group *pw;
+ unsigned i;
+ int j;
+ Pass *p, *q;
+
+ if(stat("/etc/group", &stbuf) < 0)
+ panic("can't read /etc/group");
+
+ /*
+ * Unlocked peek is okay, since the check is a heuristic (as is
+ * the function).
+ */
+ if(stbuf.st_mtime <= mtime)
+ return;
+
+ wlock(&idl);
+ if(stbuf.st_mtime <= mtime) {
+ /*
+ * If we lost a race on updating the database, we can
+ * avoid some work.
+ */
+ wunlock(&idl);
+ return;
+ }
+ mtime = stbuf.st_mtime;
+ freepass(gid);
+ freepass(member);
+ /*
+ * Pass one -- group name to gid mapping.
+ */
+ setgrent();
+ while(pw = getgrent()){
+ i = pw->gr_gid;
+ i = (i&IDMASK) ^ ((i>>IDSHIFT)&IDMASK);
+ p = realloc(0, sizeof(Pass));
+ if(p == 0)
+ panic("getpwdf");
+ p->next = gid[i];
+ gid[i] = p;
+ p->id = pw->gr_gid;
+ p->gid = 0;
+ p->name = strdup(pw->gr_name);
+ if(p->name == 0)
+ panic("no memory");
+ }
+ /*
+ * Pass two -- group memberships.
+ */
+ setgrent();
+ while(pw = getgrent()){
+ for (j = 0;; j++) {
+ if (pw->gr_mem[j] == nil)
+ break;
+ q = name2pass(gid, pw->gr_mem[j]);
+ if (q == nil)
+ continue;
+ i = q->id + pw->gr_gid;
+ i = (i&IDMASK) ^ ((i>>IDSHIFT)&IDMASK);
+ p = realloc(0, sizeof(Pass));
+ if(p == 0)
+ panic("getpwdf");
+ p->next = member[i];
+ member[i] = p;
+ p->id = q->id;
+ p->gid = pw->gr_gid;
+ }
+ }
+
+ wunlock(&idl);
+ endgrent();
+}
+
+/* Caller must hold idl. Does not raise an error. */
+static Pass*
+name2pass(Pass **pw, char *name)
+{
+ int i;
+ static Pass *p;
+ static Pass **pwdb;
+
+ if(p && pwdb == pw && strcmp(name, p->name) == 0)
+ return p;
+
+ for(i=0; i<NID; i++)
+ for(p = pw[i]; p; p = p->next)
+ if(strcmp(name, p->name) == 0) {
+ pwdb = pw;
+ return p;
+ }
+
+ return 0;
+}
+
+/* Caller must hold idl. Does not raise an error. */
+static char*
+id2name(Pass **pw, int id)
+{
+ int i;
+ Pass *p;
+ char *s;
+
+ s = nil;
+ /* use last on list == first in file */
+ i = (id&IDMASK) ^ ((id>>IDSHIFT)&IDMASK);
+ for(p = pw[i]; p; p = p->next)
+ if(p->id == id)
+ s = p->name;
+ if(s)
+ return s;
+ return ""; /* TO DO: should be "%d" */
+}
+
+/* Caller must hold idl. Does not raise an error. */
+static int
+ingroup(int id, int gid)
+{
+ int i;
+ Pass *p;
+
+ i = id+gid;
+ i = (id&IDMASK) ^ ((id>>IDSHIFT)&IDMASK);
+ for(p = member[i]; p; p = p->next)
+ if(p->id == id && p->gid == gid)
+ return 1;
+ return 0;
+}
+
+static void
+fsperm(Chan *c, int mask)
+{
+ int m;
+
+ m = FS(c)->mode;
+/*
+ print("fsperm: %o %o uuid %d ugid %d cuid %d cgid %d\n",
+ m, mask, up->env->uid, up->env->gid, FS(c)->uid, FS(c)->gid);
+*/
+ if(FS(c)->uid == up->env->uid)
+ m >>= 6;
+ else
+ if(FS(c)->gid == up->env->gid || ingroup(up->env->uid, FS(c)->gid))
+ m >>= 3;
+
+ m &= mask;
+ if(m == 0)
+ error(Eperm);
+}
+
+static int
+isdots(char *name)
+{
+ return name[0] == '.' && (name[1] == '\0' || name[1] == '.' && name[2] == '\0');
+}
+
+static int
+fsdirconv(Chan *c, char *name, struct stat *s, uchar *va, int nb, int indir)
+{
+ Dir d;
+
+ memset(&d, 0, sizeof(d));
+ d.name = name;
+ d.uid = id2name(uid, s->st_uid);
+ d.gid = id2name(gid, s->st_gid);
+ d.muid = "";
+ d.qid = fsqid(s);
+ d.mode = (d.qid.type<<24)|(s->st_mode&0777);
+ d.atime = s->st_atime;
+ d.mtime = s->st_mtime;
+ d.length = s->st_size;
+ if(d.mode&DMDIR)
+ d.length = 0;
+ d.type = 'U';
+ d.dev = c->dev;
+ if(indir && sizeD2M(&d) > nb)
+ return -1; /* directory reader needs to know it didn't fit */
+ return convD2M(&d, va, nb);
+}
+
+static long
+fsdirread(Chan *c, uchar *va, int count, vlong offset)
+{
+ int i;
+ long n, r;
+ struct stat stbuf;
+ char path[MAXPATH], *ep;
+ struct dirent *de;
+ static char slop[8192];
+
+ i = 0;
+ fspath(FS(c)->name, "", path);
+ ep = path+strlen(path);
+ if(FS(c)->offset != offset) {
+ seekdir(FS(c)->dir, 0);
+ FS(c)->de = nil;
+ for(n=0; n<offset; ) {
+ de = readdir(FS(c)->dir);
+ if(de == 0) {
+ /* EOF, so stash offset and return 0 */
+ FS(c)->offset = n;
+ return 0;
+ }
+ if(de->d_ino==0 || de->d_name[0]==0 || isdots(de->d_name))
+ continue;
+ strecpy(ep, path+sizeof(path), de->d_name);
+ if(xstat(path, &stbuf) < 0) {
+ fprint(2, "dir: bad path %s\n", path);
+ continue;
+ }
+ rlock(&idl);
+ r = fsdirconv(c, de->d_name, &stbuf, slop, sizeof(slop), 1);
+ runlock(&idl);
+ if(r <= 0) {
+ FS(c)->offset = n;
+ return 0;
+ }
+ n += r;
+ }
+ FS(c)->offset = offset;
+ }
+
+ /*
+ * Take idl on behalf of id2name. Stalling attach, which is a
+ * rare operation, until the readdir completes is probably
+ * preferable to adding lock round-trips.
+ */
+ rlock(&idl);
+ while(i < count){
+ de = FS(c)->de;
+ FS(c)->de = nil;
+ if(de == nil)
+ de = readdir(FS(c)->dir);
+ if(de == nil)
+ break;
+
+ if(de->d_ino==0 || de->d_name[0]==0 || isdots(de->d_name))
+ continue;
+
+ strecpy(ep, path+sizeof(path), de->d_name);
+ if(xstat(path, &stbuf) < 0) {
+ fprint(2, "dir: bad path %s\n", path);
+ continue;
+ }
+ r = fsdirconv(c, de->d_name, &stbuf, va+i, count-i, 1);
+ if(r <= 0){
+ FS(c)->de = de;
+ break;
+ }
+ i += r;
+ FS(c)->offset += r;
+ }
+ runlock(&idl);
+ return i;
+}
+
+static int
+fsomode(int m)
+{
+ if(m < 0 || m > 3)
+ error(Ebadarg);
+ return m == 3? 0: m;
+}
+
+void
+setid(char *name, int owner)
+{
+ Pass *p;
+
+ if(owner && !iseve())
+ return;
+ kstrdup(&up->env->user, name);
+
+ rlock(&idl);
+ p = name2pass(uid, name);
+ if(p == nil){
+ runlock(&idl);
+ up->env->uid = -1;
+ up->env->gid = -1;
+ return;
+ }
+
+ up->env->uid = p->id;
+ up->env->gid = p->gid;
+ runlock(&idl);
+}
+
+Dev fsdevtab = {
+ 'U',
+ "fs",
+
+ devinit,
+ fsattach,
+ fswalk,
+ fsstat,
+ fsopen,
+ fscreate,
+ fsclose,
+ fsread,
+ devbread,
+ fswrite,
+ devbwrite,
+ fsremove,
+ fswstat
+};
generated by cgit v1.2.3 (git 2.46.0) at 2025-12-10 13:47:01 +0000