![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to u9fs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / u9fs|
Return to u9fs.c CVS log | Up to [Research Unix] / researchv10no / cmd / u9fs |
1.1 root 1: #include "u.h"
2: #include <sys/types.h>
3: #include <sys/stat.h>
4: #include "libc.h"
5: #include "9p.h"
6: #include "stdio.h"
7: #include "setjmp.h"
8: #include "pwd.h"
9: #include "grp.h"
10:
11: #define DBG(f)
12:
13: struct group *getgrent(void);
14: struct passwd *getpwent(void);
15:
16: #ifdef SYSV
17: # include <dirent.h>
18: # define DTYPE struct dirent
19: # define SOCKETS
20: #endif
21: #ifdef V10
22: # include <ndir.h>
23: # define DTYPE struct direct
24: #endif
25: #ifdef BSD
26: # include <sys/dir.h>
27: # define DTYPE struct direct
28: # define SOCKETS
29: #endif
30: #ifdef SOCKETS
31: # define sendmsg __sendmsg
32: # include <sys/socket.h>
33: # include <netinet/in.h>
34: # include <netdb.h>
35: # undef sendmsg
36: char bsdhost[256];
37: void remotehostname(void);
38: #endif
39:
40: typedef struct File File;
41: typedef struct Rfile Rfile;
42: typedef struct Fd Fd;
43: typedef struct Pass Pass;
44:
45: struct Fd{
46: int ref;
47: Ulong offset;
48: int fd;
49: DIR *dir;
50: };
51:
52: struct Rfile{
53: int busy;
54: int uid;
55: int gid;
56: int rclose;
57: File *file;
58: Fd *fd;
59: };
60:
61: struct File{
62: int ref;
63: char *path;
64: char *name;
65: Qid qid;
66: struct stat stbuf;
67: };
68:
69: struct Pass{
70: int id;
71: int gid;
72: char *name;
73: Pass *next;
74: };
75:
76: char data[2][MAXMSG+MAXFDATA];
77: char tdata[MAXMSG+MAXFDATA];
78: char rdata[MAXFDATA];
79: Fcall rhdr;
80: Fcall thdr;
81: Rfile *rfile;
82: File *file0;
83: int nrfilealloc;
84: jmp_buf loopjmp;
85: Pass* uid[256];
86: Pass* gid[256];
87: int devallowed;
88: int connected;
89:
90: void io(void);
91: void error(char*);
92: char *mfmt(Fcall*);
93: void sendmsg(char*);
94: int okfid(int);
95: Rfile* rfilefid(void);
96: File* newfile(void);
97: void* erealloc(void*, unsigned);
98: char* estrdup(char*);
99: char* dostat(File*, char*);
100: char* bldpath(char*, char*, char*);
101: Ulong qid(struct stat*);
102: Ulong vers(struct stat*);
103: void errjmp(char*);
104: int omode(int);
105: char* id2name(Pass**, int);
106: Pass* name2pass(Pass**, char*);
107: void getpwdf(void);
108: void getgrpf(void);
109: void perm(Rfile*, int, struct stat*);
110: void parentwrperm(Rfile*);
111:
112: void rsession(void);
113: void rattach(void);
114: void rflush(void);
115: void rclone(void);
116: void rwalk(void);
117: void ropen(void);
118: void rcreate(void);
119: void rread(void);
120: void rwrite(void);
121: void rclunk(int);
122: void rstat(void);
123: void rwstat(void);
124: void rclwalk(void);
125:
126: char Eauth[] = "authentication failed";
127: char Eperm[] = "permission denied";
128: char Ebadfid[] = "fid unknown or out of range";
129: char Efidactive[] = "fid already in use";
130: char Eopen[] = "file is open";
131: char Emode[] = "invalid open mode";
132: char Especial[] = "no access to special file";
133: char Especial0[] = "already attached without access to special files";
134: char Especial1[] = "already attached with access to special files";
135: char Enotopen[] = "file is not open";
136: char Etoolarge[] = "i/o count too large";
137: char Ebaddir[] = "i/o error on directory";
138: char Eunknown[] = "unknown user or group";
139: char Euid[] = "can't set uid";
140: char Egid[] = "can't set gid";
141: char Eowner[] = "not owner";
142:
143: int
144: main(int argc, char *argv[])
145: {
146: freopen(LOG, "a", stderr);
147: setbuf(stderr, (void*)0);
148: DBG(fprintf(stderr, "u9fs\nkill %d\n", getpid()));
149: if(argc > 1)
150: if(chroot(argv[1]) == -1)
151: error("chroot failed");
152:
153: # ifdef SOCKETS
154: remotehostname();
155: # endif
156:
157: io();
158: return 0;
159: }
160:
161: void
162: io(void)
163: {
164: int m;
165: static int toggle, ndata;
166: char *datap;
167:
168: /*
169: * TCP does not preserve record boundaries; this dance works around
170: * the problem.
171: */
172: setjmp(loopjmp);
173:
174: /*
175: * Invariant: data[toggle] has ndata bytes already
176: */
177: loop:
178: datap = data[toggle];
179: toggle ^= 1;
180: for(;;){
181: if(ndata){
182: m = convM2S(datap, &rhdr, ndata);
183: /* m is number of bytes more than a full message */
184: if(m >= 0){
185: memmove(data[toggle], datap+(ndata-m), m);
186: ndata = m;
187: break;
188: }
189: }
190: m = read(0, datap+ndata, (MAXMSG+MAXFDATA)-ndata);
191: if(m <= 0)
192: error("read");
193: ndata += m;
194: }
195:
196: thdr.type = rhdr.type+1;
197: thdr.tag = rhdr.tag;
198: thdr.fid = rhdr.fid;
199: DBG(fprintf(stderr, ">> %s\n", mfmt(&rhdr)));
200: switch(rhdr.type){
201: case Tnop:
202: case Tflush: /* this is a synchronous fs; easy */
203: break;
204: case Tsession:
205: rsession();
206: break;
207: case Tattach:
208: rattach();
209: break;
210: case Tclone:
211: rclone();
212: break;
213: case Twalk:
214: rwalk();
215: break;
216: case Tstat:
217: rstat();
218: break;
219: case Twstat:
220: rwstat();
221: break;
222: case Topen:
223: ropen();
224: break;
225: case Tcreate:
226: rcreate();
227: break;
228: case Tread:
229: rread();
230: break;
231: case Twrite:
232: rwrite();
233: break;
234: case Tclunk:
235: rclunk(0);
236: break;
237: case Tremove:
238: rclunk(1);
239: break;
240: default:
241: fprintf(stderr, "unknown message %s\n", mfmt(&rhdr));
242: error("bad message");
243: }
244: sendmsg(0);
245: goto loop;
246: }
247:
248: void
249: rsession(void)
250: {
251: memset(thdr.authid, 0, sizeof(thdr.authid));
252: memset(thdr.authdom, 0, sizeof(thdr.authdom));
253: memset(thdr.chal, 0, sizeof(thdr.chal));
254: }
255:
256: void
257: rattach(void)
258: {
259: Rfile *rf;
260: char *err;
261: Pass *p;
262:
263: err = 0;
264: if(file0 == 0){
265: file0 = newfile();
266: file0->ref++; /* one extra to hold it up */
267: file0->path = estrdup("/");
268: file0->name = estrdup("/");
269: errjmp(dostat(file0, 0));
270: }
271: if(!okfid(rhdr.fid))
272: errjmp(Ebadfid);
273: if(strncmp(rhdr.aname, "device", 6) == 0){
274: if(connected && !devallowed)
275: errjmp(Especial0);
276: devallowed = 1;
277: }else{
278: if(connected && devallowed)
279: errjmp(Especial1);
280: }
281: getpwdf();
282: getgrpf();
283: rf = &rfile[rhdr.fid];
284: if(rf->busy)
285: errjmp(Efidactive);
286: rf->busy = 1;
287: rf->rclose = 0;
288: rf->file = file0;
289: file0->ref++;
290: p = name2pass(uid, rhdr.uname);
291: if(p == 0)
292: errjmp(Eunknown);
293: if(p->id == 0)
294: errjmp(Eperm);
295: # ifdef SOCKETS
296: if(ruserok(bsdhost, 0, rhdr.uname, rhdr.uname) < 0)
297: errjmp(Eperm);
298: # endif
299: rf->uid = p->id;
300: rf->gid = p->gid;
301: thdr.qid = file0->qid;
302: connected = 1;
303: }
304:
305: void
306: rclone(void)
307: {
308: Rfile *rf, *nrf;
309: File *f;
310:
311: rfilefid();
312: if(!okfid(rhdr.newfid))
313: errjmp(Ebadfid);
314: rf = &rfile[rhdr.fid];
315: nrf = &rfile[rhdr.newfid];
316: f = rf->file;
317: if(nrf->busy)
318: errjmp(Efidactive);
319: nrf->busy = 1;
320: nrf->file = f;
321: f->ref++;
322: nrf->fd = rf->fd;
323: nrf->uid = rf->uid;
324: nrf->gid = rf->gid;
325: nrf->rclose = rf->rclose;
326: if(nrf->fd){
327: if(nrf->fd->ref == 0)
328: error("clone fd count");
329: nrf->fd->ref++;
330: }
331: }
332:
333: void
334: rwalk(void)
335: {
336: char *err;
337: Rfile *rf;
338: File *of, *f;
339:
340: rf = rfilefid();
341: if(rf->fd)
342: errjmp(Eopen);
343: of = rf->file;
344: perm(rf, 1, 0);
345: f = newfile();
346: f->path = estrdup(of->path);
347: err = dostat(f, rhdr.name);
348: if(err){
349: f->ref = 0;
350: free(f->path);
351: errjmp(err);
352: }
353: if(of->ref <= 0)
354: error("walk ref count");
355: if(--of->ref == 0){
356: free(of->path);
357: free(of->name);
358: free(of);
359: }
360: rf->file = f;
361: thdr.qid = f->qid;
362: }
363:
364: void
365: ropen(void)
366: {
367: Rfile *rf;
368: File *f;
369: int fd;
370: DIR *dir;
371: int m, trunc;
372:
373: rf = rfilefid();
374: f = rf->file;
375: if(rf->fd)
376: error("open already open");
377: if(!devallowed && (f->stbuf.st_mode & S_IFCHR))
378: errjmp(Especial);
379: m = rhdr.mode & (16|3);
380: trunc = m & 16; /* OTRUNC */
381: switch(m){
382: case 0:
383: perm(rf, 4, 0);
384: break;
385: case 1:
386: case 1|16:
387: perm(rf, 2, 0);
388: break;
389: case 2:
390: case 0|16:
391: case 2|16:
392: perm(rf, 4, 0);
393: perm(rf, 2, 0);
394: break;
395: case 3:
396: perm(rf, 1, 0);
397: break;
398: default:
399: errjmp(Emode);
400: }
401:
402: m = omode(m & 3);
403: errno = 0;
404: if(f->qid.path & CHDIR){
405: if(rhdr.mode != 0) /* OREAD */
406: errjmp(Eperm);
407: dir = opendir(f->path);
408: if(dir == 0)
409: errjmp(sys_errlist[errno]);
410: fd = 0;
411: }else{
412: if(trunc){
413: fd = creat(f->path, 0666);
414: if(fd >= 0)
415: if(m != 1){
416: close(fd);
417: fd = open(f->path, m);
418: }
419: }else
420: fd = open(f->path, m);
421: if(fd < 0)
422: errjmp(sys_errlist[errno]);
423: dir = 0;
424: }
425: rf->rclose = rhdr.mode & 64; /* ORCLOSE */
426: rf->fd = erealloc(0, sizeof(Fd));
427: rf->fd->ref = 1;
428: rf->fd->fd = fd;
429: rf->fd->dir = dir;
430: rf->fd->offset = 0;
431: thdr.qid = f->qid;
432: }
433:
434: void
435: rcreate(void)
436: {
437: Rfile *rf;
438: File *f, *of;
439: char *path, *err;
440: int fd;
441: int m;
442: char name[NAMELEN];
443:
444: rf = rfilefid();
445: if(rf->fd)
446: errjmp(Eopen);
447: perm(rf, 2, 0);
448: path = bldpath(rf->file->path, rhdr.name, name);
449: m = omode(rhdr.mode&3);
450: errno = 0;
451: if(rhdr.perm & CHDIR){
452: if(m){
453: free(path);
454: errjmp(Eperm);
455: }
456: fd = mkdir(path, 0777);
457: if(fd < 0){
458: free(path);
459: errjmp(sys_errlist[errno]);
460: }
461: fd = open(path, 0);
462: free(path);
463: if(fd >= 0){
464: fchmod(fd, rhdr.perm&0777);
465: fchown(fd, rf->uid, rf->gid);
466: }
467: }else{
468: fd = creat(path, 0666);
469: if(fd >= 0){
470: if(m != 1){
471: close(fd);
472: fd = open(path, m);
473: }
474: fchmod(fd, rhdr.perm&0777);
475: fchown(fd, rf->uid, rf->gid);
476: }
477: free(path);
478: if(fd < 0)
479: errjmp(sys_errlist[errno]);
480: }
481: f = newfile();
482: of = rf->file;
483: f->path = estrdup(of->path);
484: err = dostat(f, rhdr.name);
485: if(err){
486: free(f->path);
487: free(f->name);
488: free(f);
489: errjmp(err);
490: }
491: if(!devallowed && (f->stbuf.st_mode & S_IFCHR)){
492: free(f->path);
493: free(f->name);
494: free(f);
495: errjmp(Especial);
496: }
497: if(--of->ref == 0){
498: free(of->path);
499: free(of->name);
500: free(of);
501: }
502: rf->file = f;
503: rf->rclose = rhdr.mode & 64; /* ORCLOSE */
504: rf->fd = erealloc(0, sizeof(Fd));
505: rf->fd->ref = 1;
506: rf->fd->fd = fd;
507: rf->fd->dir = 0;
508: rf->fd->offset = 0;
509: thdr.qid = f->qid;
510: }
511:
512: void
513: rread(void)
514: {
515: Rfile *rf;
516: File *f;
517: long n;
518: DTYPE *de;
519: Dir d;
520: struct stat stbuf;
521: char *path;
522:
523: rf = rfilefid();
524: if(rf->fd == 0)
525: errjmp(Enotopen);
526: if(rhdr.count > sizeof rdata)
527: errjmp(Etoolarge);
528: f = rf->file;
529: if(rf->fd->dir){
530: errno = 0;
531: rhdr.count = (rhdr.count/DIRLEN)*DIRLEN;
532: if(rf->fd->offset != rhdr.offset){
533: seekdir(rf->fd->dir, 0);
534: for(n=0; n<rhdr.offset; ){
535: de = readdir(rf->fd->dir);
536: if(de == 0)
537: break;
538: if(de->d_ino==0 || de->d_name[0]==0)
539: continue;
540: if(strcmp(de->d_name, ".")==0 || strcmp(de->d_name, "..")==0)
541: continue;
542: n += DIRLEN;
543: }
544: }
545: for(n=0; n<rhdr.count; ){
546: de = readdir(rf->fd->dir);
547: if(de == 0)
548: break;
549: if(de->d_ino==0 || de->d_name[0]==0)
550: continue;
551: if(strcmp(de->d_name, ".")==0 || strcmp(de->d_name, "..")==0)
552: continue;
553: strncpy(d.name, de->d_name, NAMELEN-1);
554: d.name[NAMELEN-1] = 0;
555: path = erealloc(0, strlen(f->path)+1+strlen(de->d_name)+1);
556: sprintf(path, "%s/%s", f->path, de->d_name);
557: memset(&stbuf, 0, sizeof stbuf);
558: if(stat(path, &stbuf) < 0){
559: fprintf(stderr, "dir: bad path %s\n", path);
560: /* but continue... probably a bad symlink */
561: }
562: free(path);
563: strncpy(d.uid, id2name(uid, stbuf.st_uid), NAMELEN);
564: strncpy(d.gid, id2name(gid, stbuf.st_gid), NAMELEN);
565: d.qid.path = qid(&stbuf);
566: d.qid.vers = vers(&stbuf);
567: d.mode = (d.qid.path&CHDIR)|(stbuf.st_mode&0777);
568: d.atime = stbuf.st_atime;
569: d.mtime = stbuf.st_mtime;
570: d.len.l.hlength = 0;
571: d.len.l.length = stbuf.st_size;
572: convD2M(&d, rdata+n);
573: n += DIRLEN;
574: }
575: }else{
576: errno = 0;
577: if(rf->fd->offset != rhdr.offset){
578: rf->fd->offset = rhdr.offset;
579: if(lseek(rf->fd->fd, rhdr.offset, 0) < 0)
580: errjmp(sys_errlist[errno]);
581: }
582: n = read(rf->fd->fd, rdata, rhdr.count);
583: if(n < 0)
584: errjmp(sys_errlist[errno]);
585: }
586: rf->fd->offset += n;
587: thdr.count = n;
588: thdr.data = rdata;
589: }
590:
591: void
592: rwrite(void)
593: {
594: Rfile *rf;
595: int n;
596:
597: rf = rfilefid();
598: if(rf->fd == 0)
599: errjmp(Enotopen);
600: if(rhdr.count > sizeof rdata)
601: errjmp(Etoolarge);
602: errno = 0;
603: if(rf->fd->offset != rhdr.offset){
604: rf->fd->offset = rhdr.offset;
605: if(lseek(rf->fd->fd, rhdr.offset, 0) < 0)
606: errjmp(sys_errlist[errno]);
607: }
608: n = write(rf->fd->fd, rhdr.data, rhdr.count);
609: if(n < 0)
610: errjmp(sys_errlist[errno]);
611: rf->fd->offset += n;
612: thdr.count = n;
613: }
614:
615: void
616: rstat(void)
617: {
618: Rfile *rf;
619: File *f;
620: Dir d;
621:
622: rf = rfilefid();
623: f = rf->file;
624: errjmp(dostat(f, 0));
625: strncpy(d.name, f->name, NAMELEN);
626: strncpy(d.uid, id2name(uid, f->stbuf.st_uid), NAMELEN);
627: strncpy(d.gid, id2name(gid, f->stbuf.st_gid), NAMELEN);
628: d.qid = f->qid;
629: d.mode = (f->qid.path&CHDIR)|(f->stbuf.st_mode&0777);
630: d.atime = f->stbuf.st_atime;
631: d.mtime = f->stbuf.st_mtime;
632: d.len.l.hlength = 0;
633: d.len.l.length = f->stbuf.st_size;
634: convD2M(&d, thdr.stat);
635: }
636:
637: void
638: rwstat(void)
639: {
640: Rfile *rf;
641: File *f;
642: Dir d;
643: Pass *p;
644: char *path, *dir, name[NAMELEN];
645:
646: rf = rfilefid();
647: f = rf->file;
648: errjmp(dostat(f, 0));
649: convM2D(rhdr.stat, &d);
650: errno = 0;
651: if(rf->uid != f->stbuf.st_uid)
652: errjmp(Eowner);
653: if(strcmp(d.name, f->name) != 0){
654: parentwrperm(rf);
655: dir = bldpath(f->path, "..", name);
656: path = erealloc(0, strlen(dir)+1+strlen(d.name)+1);
657: sprintf(path, "%s/%s", dir, d.name);
658: if(link(f->path, path) < 0){
659: free(path);
660: errjmp(sys_errlist[errno]);
661: }
662: if(unlink(f->path) < 0){
663: free(path);
664: errjmp(sys_errlist[errno]);
665: }
666: free(f->path);
667: free(f->name);
668: f->path = path;
669: f->name = estrdup(d.name);
670: }
671: if((d.mode&0777) != (f->stbuf.st_mode&0777)){
672: if(chmod(f->path, d.mode&0777) < 0)
673: errjmp(sys_errlist[errno]);
674: f->stbuf.st_mode &= ~0777;
675: f->stbuf.st_mode |= d.mode&0777;
676: }
677: p = name2pass(gid, d.gid);
678: if(p == 0)
679: errjmp(Eunknown);
680: if(p->id != f->stbuf.st_gid){
681: if(chown(f->path, f->stbuf.st_uid, p->id) < 0)
682: errjmp(sys_errlist[errno]);
683: f->stbuf.st_gid = p->id;
684: }
685: }
686:
687: void
688: rclunk(int rm)
689: {
690: int ret;
691: char *err;
692: Rfile *rf;
693: File *f;
694: Fd *fd;
695:
696: err = 0;
697: rf = rfilefid();
698: f = rf->file;
699: if(rm){
700: parentwrperm(rf);
701: if(f->qid.path & CHDIR)
702: ret = rmdir(f->path);
703: else
704: ret = unlink(f->path);
705: if(ret)
706: err = sys_errlist[errno];
707: }else if(rf->rclose){ /* ignore errors */
708: if(f->qid.path & CHDIR)
709: rmdir(f->path);
710: else
711: unlink(f->path);
712: }
713:
714: rf->busy = 0;
715: if(--f->ref == 0){
716: free(f->path);
717: free(f->name);
718: free(f);
719: }
720: fd = rf->fd;
721: if(fd){
722: if(fd->ref <= 0)
723: error("clunk fd count");
724: if(--fd->ref == 0){
725: if(fd->fd)
726: close(fd->fd);
727: if(fd->dir)
728: closedir(fd->dir);
729: free(fd);
730: }
731: rf->fd = 0;
732: }
733: if(err)
734: errjmp(err);
735: }
736:
737: char*
738: bldpath(char *a, char *elem, char *name)
739: {
740: char *path, *p;
741:
742: if(strcmp(elem, "..") == 0){
743: if(strcmp(a, "/") == 0){
744: path = estrdup(a);
745: strcpy(name, a);
746: }else{
747: p = strrchr(a, '/');
748: if(p == 0){
749: fprintf(stderr, "path: '%s'\n", path);
750: error("malformed path 1");
751: }
752: if(p == a) /* reduced to "/" */
753: p++;
754: path = erealloc(0, (p-a)+1);
755: memmove(path, a, (p-a));
756: path[(p-a)] = 0;
757: if(strcmp(path, "/") == 0)
758: p = path;
759: else{
760: p = strrchr(path, '/');
761: if(p == 0){
762: fprintf(stderr, "path: '%s'\n", path);
763: error("malformed path 2");
764: }
765: p++;
766: }
767: strcpy(name, p);
768: }
769: }else{
770: if(strcmp(a, "/") == 0)
771: a = "";
772: path = erealloc(0, strlen(a)+1+strlen(elem)+1);
773: sprintf(path, "%s/%s", a, elem);
774: strcpy(name, elem);
775: }
776: if(strlen(name) >= NAMELEN)
777: error("bldpath: name too long");
778: return path;
779: }
780:
781: char*
782: dostat(File *f, char *elem)
783: {
784: char *path;
785: struct stat stbuf;
786: char name[NAMELEN];
787:
788: if(elem)
789: path = bldpath(f->path, elem, name);
790: else
791: path = f->path;
792: errno = 0;
793: if(stat(path, &stbuf) < 0)
794: return sys_errlist[errno];
795: if(elem){
796: free(f->path);
797: f->path = path;
798: f->name = estrdup(name);
799: }
800: f->qid.path = qid(&stbuf);
801: f->qid.vers = vers(&stbuf);
802: f->stbuf = stbuf;
803: return 0;
804: }
805:
806: int
807: omode(int m)
808: {
809: switch(m){
810: case 0: /* OREAD */
811: case 3: /* OEXEC */
812: return 0;
813: case 1: /* OWRITE */
814: return 1;
815: case 2: /* ORDWR */
816: return 2;
817: }
818: errjmp(Emode);
819: return 0;
820: }
821:
822: void
823: sendmsg(char *err)
824: {
825: int n;
826:
827: if(err){
828: thdr.type = Rerror;
829: strncpy(thdr.ename, err, ERRLEN);
830: }
831: DBG(fprintf(stderr, "<< %s\n", mfmt(&thdr)));
832: n = convS2M(&thdr, tdata);
833: if(n == 0)
834: error("bad sendmsg format");
835: if(write(1, tdata, n) != n)
836: error("write error");
837: }
838:
839:
840: int
841: okfid(int fid)
842: {
843: enum{ Delta=10 };
844:
845: if(fid < 0){
846: fprintf(stderr, "u9fs: negative fid %d\n", fid);
847: return 0;
848: }
849: if(fid >= nrfilealloc){
850: fid += Delta;
851: rfile = erealloc(rfile, fid*sizeof(Rfile));
852: memset(rfile+nrfilealloc, 0, (fid-nrfilealloc)*sizeof(Rfile));
853: nrfilealloc = fid;
854: }
855: return 1;
856: }
857:
858: Rfile*
859: rfilefid(void)
860: {
861: Rfile *rf;
862:
863: if(!okfid(rhdr.fid))
864: errjmp(Ebadfid);
865: rf = &rfile[rhdr.fid];
866: if(rf->busy == 0)
867: errjmp(Ebadfid);
868: if(rf->file->ref <= 0)
869: error("ref count");
870: return rf;
871: }
872:
873: void
874: perm(Rfile *rf, int mask, struct stat *st)
875: {
876: if(st == 0)
877: st = &rf->file->stbuf;
878: /* plan 9 access semantics; simpler and more sensible */
879: if(rf->uid == st->st_uid)
880: if((st->st_mode>>6) & mask)
881: return;
882: if(rf->gid == st->st_gid)
883: if((st->st_mode>>3) & mask)
884: return;
885: if((st->st_mode>>0) & mask)
886: return;
887: errjmp(Eperm);
888: }
889:
890: void
891: parentwrperm(Rfile *rf)
892: {
893: Rfile trf;
894: struct stat st;
895: char *dirp, dir[512];
896:
897: dirp = bldpath(rf->file->path, "..", dir);
898: if(strlen(dirp) < sizeof dir){ /* ugly: avoid leaving dirp allocated */
899: strcpy(dir, dirp);
900: free(dirp);
901: dirp = dir;
902: }
903: if(stat(dirp, &st) < 0)
904: errjmp(Eperm);
905: trf.uid = rf->uid;
906: trf.gid = rf->gid;
907: perm(&trf, 2, &st);
908: }
909:
910: File*
911: newfile(void)
912: {
913: File *f;
914:
915: f = erealloc(0, sizeof(File));
916: memset(f, 0, sizeof(File));
917: f->ref = 1;
918: return f;
919: }
920:
921: /*
922: * qids: directory bit, seven bits of device, 24 bits of inode
923: */
924: Ulong
925: vers(struct stat *st)
926: {
927: return st->st_mtime;
928: }
929:
930: Ulong
931: qid(struct stat *st)
932: {
933: static int nqdev;
934: static Uchar *qdev;
935: Ulong q;
936: int dev;
937:
938: if(qdev == 0){
939: qdev = erealloc(0, 65536U);
940: memset(qdev, 0, 65536U);
941: }
942: q = 0;
943: if((st->st_mode&S_IFMT) == S_IFDIR)
944: q = CHDIR;
945: dev = st->st_dev & 0xFFFFUL;
946: if(qdev[dev] == 0){
947: if(++nqdev >= 128)
948: error("too many devices");
949: qdev[dev] = nqdev;
950: }
951: q |= qdev[dev]<<24;
952: q |= st->st_ino & 0x00FFFFFFUL;
953: return q;
954: }
955:
956: Pass*
957: name2pass(Pass **pw, char *name)
958: {
959: int i;
960: Pass *p;
961:
962: for(i=0; i<256; i++)
963: for(p = pw[i]; p; p = p->next)
964: if(strcmp(name, p->name) == 0)
965: return p;
966: return 0;
967: }
968:
969: char*
970: id2name(Pass **pw, int id)
971: {
972: int i;
973: Pass *p;
974: char *s;
975: static char buf[8];
976:
977: s = 0;
978: /* use last on list == first in file */
979: i = (id&0xFF) ^ ((id>>8)&0xFF);
980: for(p = pw[i]; p; p = p->next)
981: if(p->id == id)
982: s = p->name;
983: if(s)
984: return s;
985: sprintf(buf, "%d", id);
986: return buf;
987: }
988:
989: void
990: freepass(Pass **pass)
991: {
992: int i;
993: Pass *p, *np;
994:
995: for(i=0; i<256; i++){
996: for(p = pass[i]; p; p = np){
997: np = p->next;
998: free(p);
999: }
1000: pass[i] = 0;
1001: }
1002: }
1003:
1004: void
1005: getpwdf(void)
1006: {
1007: static mtime;
1008: struct stat stbuf;
1009: struct passwd *pw;
1010: int i;
1011: Pass *p;
1012:
1013: if(stat("/etc/passwd", &stbuf) < 0)
1014: error("can't read /etc/passwd");
1015: if(stbuf.st_mtime <= mtime)
1016: return;
1017: freepass(uid);
1018: while(pw = getpwent()){
1019: i = pw->pw_uid;
1020: i = (i&0xFF) ^ ((i>>8)&0xFF);
1021: p = erealloc(0, sizeof(Pass));
1022: p->next = uid[i];
1023: uid[i] = p;
1024: p->id = pw->pw_uid;
1025: p->gid = pw->pw_gid;
1026: p->name = estrdup(pw->pw_name);
1027: }
1028: setpwent();
1029: endpwent();
1030: }
1031:
1032: void
1033: getgrpf(void)
1034: {
1035: static mtime;
1036: struct stat stbuf;
1037: struct group *pw;
1038: int i;
1039: Pass *p;
1040:
1041: if(stat("/etc/group", &stbuf) < 0)
1042: error("can't read /etc/group");
1043: if(stbuf.st_mtime <= mtime)
1044: return;
1045: freepass(gid);
1046: while(pw = getgrent()){
1047: i = pw->gr_gid;
1048: i = (i&0xFF) ^ ((i>>8)&0xFF);
1049: p = erealloc(0, sizeof(Pass));
1050: p->next = gid[i];
1051: gid[i] = p;
1052: p->id = pw->gr_gid;
1053: p->gid = 0;
1054: p->name = estrdup(pw->gr_name);
1055: }
1056: setgrent();
1057: endgrent();
1058: }
1059:
1060: void
1061: error(char *s)
1062: {
1063: fprintf(stderr, "u9fs: %s\n", s);
1064: perror("unix error");
1065: exit(1);
1066: }
1067:
1068: void
1069: errjmp(char *s)
1070: {
1071: if(s == 0)
1072: return;
1073: sendmsg(s);
1074: longjmp(loopjmp, 1);
1075: }
1076:
1077: void*
1078: erealloc(void *p, unsigned n)
1079: {
1080: if(p == 0)
1081: p = malloc(n);
1082: else
1083: p = realloc(p, n);
1084: if(p == 0)
1085: error("realloc fail");
1086: return p;
1087: }
1088:
1089: char*
1090: estrdup(char *p)
1091: {
1092: p = strdup(p);
1093: if(p == 0)
1094: error("strdup fail");
1095: return p;
1096: }
1097:
1098: #ifdef SOCKETS
1099: void
1100: remotehostname(void)
1101: {
1102: struct sockaddr_in sock;
1103: struct hostent *hp;
1104: int len;
1105: int on = 1;
1106:
1107: len = sizeof sock;
1108: if(getpeername(0, &sock, &len) < 0)
1109: error("getpeername");
1110: hp = gethostbyaddr((char *)&sock.sin_addr, sizeof (struct in_addr),
1111: sock.sin_family);
1112: if(hp == 0)
1113: error("gethostbyaddr");
1114: strcpy(bsdhost, hp->h_name);
1115: fprintf(stderr, "bsdhost %s on %d\n", bsdhost, getpid());
1116:
1117: setsockopt(0, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));
1118: }
1119: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.