![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to u9fs.cold 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.cold 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: if(rf->fd->offset != rhdr.offset){
532: seekdir(rf->fd->dir, 0);
533: for(n=0; n<rhdr.offset; ){
534: de = readdir(rf->fd->dir);
535: if(de == 0)
536: break;
537: if(de->d_ino==0 || de->d_name[0]==0)
538: continue;
539: if(strcmp(de->d_name, ".")==0 || strcmp(de->d_name, "..")==0)
540: continue;
541: n += DIRLEN;
542: }
543: }
544: for(n=0; n<rhdr.count; ){
545: de = readdir(rf->fd->dir);
546: if(de == 0)
547: break;
548: if(de->d_ino==0 || de->d_name[0]==0)
549: continue;
550: if(strcmp(de->d_name, ".")==0 || strcmp(de->d_name, "..")==0)
551: continue;
552: strncpy(d.name, de->d_name, NAMELEN-1);
553: d.name[NAMELEN-1] = 0;
554: path = erealloc(0, strlen(f->path)+1+strlen(de->d_name)+1);
555: sprintf(path, "%s/%s", f->path, de->d_name);
556: memset(&stbuf, 0, sizeof stbuf);
557: if(stat(path, &stbuf) < 0){
558: fprintf(stderr, "dir: bad path %s\n", path);
559: /* but continue... probably a bad symlink */
560: }
561: free(path);
562: strncpy(d.uid, id2name(uid, stbuf.st_uid), NAMELEN);
563: strncpy(d.gid, id2name(gid, stbuf.st_gid), NAMELEN);
564: d.qid.path = qid(&stbuf);
565: d.qid.vers = vers(&stbuf);
566: d.mode = (d.qid.path&CHDIR)|(stbuf.st_mode&0777);
567: d.atime = stbuf.st_atime;
568: d.mtime = stbuf.st_mtime;
569: d.len.l.hlength = 0;
570: d.len.l.length = stbuf.st_size;
571: convD2M(&d, rdata+n);
572: n += DIRLEN;
573: }
574: }else{
575: errno = 0;
576: if(rf->fd->offset != rhdr.offset){
577: rf->fd->offset = rhdr.offset;
578: if(lseek(rf->fd->fd, rhdr.offset, 0) < 0)
579: errjmp(sys_errlist[errno]);
580: }
581: n = read(rf->fd->fd, rdata, rhdr.count);
582: if(n < 0)
583: errjmp(sys_errlist[errno]);
584: }
585: rf->fd->offset += n;
586: thdr.count = n;
587: thdr.data = rdata;
588: }
589:
590: void
591: rwrite(void)
592: {
593: Rfile *rf;
594: int n;
595:
596: rf = rfilefid();
597: if(rf->fd == 0)
598: errjmp(Enotopen);
599: if(rhdr.count > sizeof rdata)
600: errjmp(Etoolarge);
601: errno = 0;
602: if(rf->fd->offset != rhdr.offset){
603: rf->fd->offset = rhdr.offset;
604: if(lseek(rf->fd->fd, rhdr.offset, 0) < 0)
605: errjmp(sys_errlist[errno]);
606: }
607: n = write(rf->fd->fd, rhdr.data, rhdr.count);
608: if(n < 0)
609: errjmp(sys_errlist[errno]);
610: rf->fd->offset += n;
611: thdr.count = n;
612: }
613:
614: void
615: rstat(void)
616: {
617: Rfile *rf;
618: File *f;
619: Dir d;
620:
621: rf = rfilefid();
622: f = rf->file;
623: errjmp(dostat(f, 0));
624: strncpy(d.name, f->name, NAMELEN);
625: strncpy(d.uid, id2name(uid, f->stbuf.st_uid), NAMELEN);
626: strncpy(d.gid, id2name(gid, f->stbuf.st_gid), NAMELEN);
627: d.qid = f->qid;
628: d.mode = (f->qid.path&CHDIR)|(f->stbuf.st_mode&0777);
629: d.atime = f->stbuf.st_atime;
630: d.mtime = f->stbuf.st_mtime;
631: d.len.l.hlength = 0;
632: d.len.l.length = f->stbuf.st_size;
633: convD2M(&d, thdr.stat);
634: }
635:
636: void
637: rwstat(void)
638: {
639: Rfile *rf;
640: File *f;
641: Dir d;
642: Pass *p;
643: char *path, *dir, name[NAMELEN];
644:
645: rf = rfilefid();
646: f = rf->file;
647: errjmp(dostat(f, 0));
648: convM2D(rhdr.stat, &d);
649: errno = 0;
650: if(rf->uid != f->stbuf.st_uid)
651: errjmp(Eowner);
652: if(strcmp(d.name, f->name) != 0){
653: parentwrperm(rf);
654: dir = bldpath(f->path, "..", name);
655: path = erealloc(0, strlen(dir)+1+strlen(d.name)+1);
656: sprintf(path, "%s/%s", dir, d.name);
657: if(link(f->path, path) < 0){
658: free(path);
659: errjmp(sys_errlist[errno]);
660: }
661: if(unlink(f->path) < 0){
662: free(path);
663: errjmp(sys_errlist[errno]);
664: }
665: free(f->path);
666: free(f->name);
667: f->path = path;
668: f->name = estrdup(d.name);
669: }
670: if((d.mode&0777) != (f->stbuf.st_mode&0777)){
671: if(chmod(f->path, d.mode&0777) < 0)
672: errjmp(sys_errlist[errno]);
673: f->stbuf.st_mode &= ~0777;
674: f->stbuf.st_mode |= d.mode&0777;
675: }
676: p = name2pass(gid, d.gid);
677: if(p == 0)
678: errjmp(Eunknown);
679: if(p->id != f->stbuf.st_gid){
680: if(chown(f->path, f->stbuf.st_uid, p->id) < 0)
681: errjmp(sys_errlist[errno]);
682: f->stbuf.st_gid = p->id;
683: }
684: }
685:
686: void
687: rclunk(int rm)
688: {
689: int ret;
690: char *err;
691: Rfile *rf;
692: File *f;
693: Fd *fd;
694:
695: err = 0;
696: rf = rfilefid();
697: f = rf->file;
698: if(rm){
699: parentwrperm(rf);
700: if(f->qid.path & CHDIR)
701: ret = rmdir(f->path);
702: else
703: ret = unlink(f->path);
704: if(ret)
705: err = sys_errlist[errno];
706: }else if(rf->rclose){ /* ignore errors */
707: if(f->qid.path & CHDIR)
708: rmdir(f->path);
709: else
710: unlink(f->path);
711: }
712:
713: rf->busy = 0;
714: if(--f->ref == 0){
715: free(f->path);
716: free(f->name);
717: free(f);
718: }
719: fd = rf->fd;
720: if(fd){
721: if(fd->ref <= 0)
722: error("clunk fd count");
723: if(--fd->ref == 0){
724: if(fd->fd)
725: close(fd->fd);
726: if(fd->dir)
727: closedir(fd->dir);
728: free(fd);
729: }
730: rf->fd = 0;
731: }
732: if(err)
733: errjmp(err);
734: }
735:
736: char*
737: bldpath(char *a, char *elem, char *name)
738: {
739: char *path, *p;
740:
741: if(strcmp(elem, "..") == 0){
742: if(strcmp(a, "/") == 0){
743: path = estrdup(a);
744: strcpy(name, a);
745: }else{
746: p = strrchr(a, '/');
747: if(p == 0){
748: fprintf(stderr, "path: '%s'\n", path);
749: error("malformed path 1");
750: }
751: if(p == a) /* reduced to "/" */
752: p++;
753: path = erealloc(0, (p-a)+1);
754: memmove(path, a, (p-a));
755: path[(p-a)] = 0;
756: if(strcmp(path, "/") == 0)
757: p = path;
758: else{
759: p = strrchr(path, '/');
760: if(p == 0){
761: fprintf(stderr, "path: '%s'\n", path);
762: error("malformed path 2");
763: }
764: p++;
765: }
766: strcpy(name, p);
767: }
768: }else{
769: if(strcmp(a, "/") == 0)
770: a = "";
771: path = erealloc(0, strlen(a)+1+strlen(elem)+1);
772: sprintf(path, "%s/%s", a, elem);
773: strcpy(name, elem);
774: }
775: if(strlen(name) >= NAMELEN)
776: error("bldpath: name too long");
777: return path;
778: }
779:
780: char*
781: dostat(File *f, char *elem)
782: {
783: char *path;
784: struct stat stbuf;
785: char name[NAMELEN];
786:
787: if(elem)
788: path = bldpath(f->path, elem, name);
789: else
790: path = f->path;
791: errno = 0;
792: if(stat(path, &stbuf) < 0)
793: return sys_errlist[errno];
794: if(elem){
795: free(f->path);
796: f->path = path;
797: f->name = estrdup(name);
798: }
799: f->qid.path = qid(&stbuf);
800: f->qid.vers = vers(&stbuf);
801: f->stbuf = stbuf;
802: return 0;
803: }
804:
805: int
806: omode(int m)
807: {
808: switch(m){
809: case 0: /* OREAD */
810: case 3: /* OEXEC */
811: return 0;
812: case 1: /* OWRITE */
813: return 1;
814: case 2: /* ORDWR */
815: return 2;
816: }
817: errjmp(Emode);
818: return 0;
819: }
820:
821: void
822: sendmsg(char *err)
823: {
824: int n;
825:
826: if(err){
827: thdr.type = Rerror;
828: strncpy(thdr.ename, err, ERRLEN);
829: }
830: DBG(fprintf(stderr, "<< %s\n", mfmt(&thdr)));
831: n = convS2M(&thdr, tdata);
832: if(n == 0)
833: error("bad sendmsg format");
834: if(write(1, tdata, n) != n)
835: error("write error");
836: }
837:
838:
839: int
840: okfid(int fid)
841: {
842: enum{ Delta=10 };
843:
844: if(fid < 0){
845: fprintf(stderr, "u9fs: negative fid %d\n", fid);
846: return 0;
847: }
848: if(fid >= nrfilealloc){
849: fid += Delta;
850: rfile = erealloc(rfile, fid*sizeof(Rfile));
851: memset(rfile+nrfilealloc, 0, (fid-nrfilealloc)*sizeof(Rfile));
852: nrfilealloc = fid;
853: }
854: return 1;
855: }
856:
857: Rfile*
858: rfilefid(void)
859: {
860: Rfile *rf;
861:
862: if(!okfid(rhdr.fid))
863: errjmp(Ebadfid);
864: rf = &rfile[rhdr.fid];
865: if(rf->busy == 0)
866: errjmp(Ebadfid);
867: if(rf->file->ref <= 0)
868: error("ref count");
869: return rf;
870: }
871:
872: void
873: perm(Rfile *rf, int mask, struct stat *st)
874: {
875: if(st == 0)
876: st = &rf->file->stbuf;
877: /* plan 9 access semantics; simpler and more sensible */
878: if(rf->uid == st->st_uid)
879: if((st->st_mode>>6) & mask)
880: return;
881: if(rf->gid == st->st_gid)
882: if((st->st_mode>>3) & mask)
883: return;
884: if((st->st_mode>>0) & mask)
885: return;
886: errjmp(Eperm);
887: }
888:
889: void
890: parentwrperm(Rfile *rf)
891: {
892: Rfile trf;
893: struct stat st;
894: char *dirp, dir[512];
895:
896: dirp = bldpath(rf->file->path, "..", dir);
897: if(strlen(dirp) < sizeof dir){ /* ugly: avoid leaving dirp allocated */
898: strcpy(dir, dirp);
899: free(dirp);
900: dirp = dir;
901: }
902: if(stat(dirp, &st) < 0)
903: errjmp(Eperm);
904: trf.uid = rf->uid;
905: trf.gid = rf->gid;
906: perm(&trf, 2, &st);
907: }
908:
909: File*
910: newfile(void)
911: {
912: File *f;
913:
914: f = erealloc(0, sizeof(File));
915: memset(f, 0, sizeof(File));
916: f->ref = 1;
917: return f;
918: }
919:
920: /*
921: * qids: directory bit, seven bits of device, 24 bits of inode
922: */
923: Ulong
924: vers(struct stat *st)
925: {
926: return st->st_mtime;
927: }
928:
929: Ulong
930: qid(struct stat *st)
931: {
932: static int nqdev;
933: static Uchar *qdev;
934: Ulong q;
935: int dev;
936:
937: if(qdev == 0){
938: qdev = erealloc(0, 65536U);
939: memset(qdev, 0, 65536U);
940: }
941: q = 0;
942: if((st->st_mode&S_IFMT) == S_IFDIR)
943: q = CHDIR;
944: dev = st->st_dev & 0xFFFFUL;
945: if(qdev[dev] == 0){
946: if(++nqdev >= 128)
947: error("too many devices");
948: qdev[dev] = nqdev;
949: }
950: q |= qdev[dev]<<24;
951: q |= st->st_ino & 0x00FFFFFFUL;
952: return q;
953: }
954:
955: Pass*
956: name2pass(Pass **pw, char *name)
957: {
958: int i;
959: Pass *p;
960:
961: for(i=0; i<256; i++)
962: for(p = pw[i]; p; p = p->next)
963: if(strcmp(name, p->name) == 0)
964: return p;
965: return 0;
966: }
967:
968: char*
969: id2name(Pass **pw, int id)
970: {
971: int i;
972: Pass *p;
973: char *s;
974: static char buf[8];
975:
976: s = 0;
977: /* use last on list == first in file */
978: i = (id&0xFF) ^ ((id>>8)&0xFF);
979: for(p = pw[i]; p; p = p->next)
980: if(p->id == id)
981: s = p->name;
982: if(s)
983: return s;
984: sprintf(buf, "%d", id);
985: return buf;
986: }
987:
988: void
989: freepass(Pass **pass)
990: {
991: int i;
992: Pass *p, *np;
993:
994: for(i=0; i<256; i++){
995: for(p = pass[i]; p; p = np){
996: np = p->next;
997: free(p);
998: }
999: pass[i] = 0;
1000: }
1001: }
1002:
1003: void
1004: getpwdf(void)
1005: {
1006: static mtime;
1007: struct stat stbuf;
1008: struct passwd *pw;
1009: int i;
1010: Pass *p;
1011:
1012: if(stat("/etc/passwd", &stbuf) < 0)
1013: error("can't read /etc/passwd");
1014: if(stbuf.st_mtime <= mtime)
1015: return;
1016: freepass(uid);
1017: while(pw = getpwent()){
1018: i = pw->pw_uid;
1019: i = (i&0xFF) ^ ((i>>8)&0xFF);
1020: p = erealloc(0, sizeof(Pass));
1021: p->next = uid[i];
1022: uid[i] = p;
1023: p->id = pw->pw_uid;
1024: p->gid = pw->pw_gid;
1025: p->name = estrdup(pw->pw_name);
1026: }
1027: setpwent();
1028: endpwent();
1029: }
1030:
1031: void
1032: getgrpf(void)
1033: {
1034: static mtime;
1035: struct stat stbuf;
1036: struct group *pw;
1037: int i;
1038: Pass *p;
1039:
1040: if(stat("/etc/group", &stbuf) < 0)
1041: error("can't read /etc/group");
1042: if(stbuf.st_mtime <= mtime)
1043: return;
1044: freepass(gid);
1045: while(pw = getgrent()){
1046: i = pw->gr_gid;
1047: i = (i&0xFF) ^ ((i>>8)&0xFF);
1048: p = erealloc(0, sizeof(Pass));
1049: p->next = gid[i];
1050: gid[i] = p;
1051: p->id = pw->gr_gid;
1052: p->gid = 0;
1053: p->name = estrdup(pw->gr_name);
1054: }
1055: setgrent();
1056: endgrent();
1057: }
1058:
1059: void
1060: error(char *s)
1061: {
1062: fprintf(stderr, "u9fs: %s\n", s);
1063: perror("unix error");
1064: exit(1);
1065: }
1066:
1067: void
1068: errjmp(char *s)
1069: {
1070: if(s == 0)
1071: return;
1072: sendmsg(s);
1073: longjmp(loopjmp, 1);
1074: }
1075:
1076: void*
1077: erealloc(void *p, unsigned n)
1078: {
1079: if(p == 0)
1080: p = malloc(n);
1081: else
1082: p = realloc(p, n);
1083: if(p == 0)
1084: error("realloc fail");
1085: return p;
1086: }
1087:
1088: char*
1089: estrdup(char *p)
1090: {
1091: p = strdup(p);
1092: if(p == 0)
1093: error("strdup fail");
1094: return p;
1095: }
1096:
1097: #ifdef SOCKETS
1098: void
1099: remotehostname(void)
1100: {
1101: struct sockaddr_in sock;
1102: struct hostent *hp;
1103: int len;
1104: int on = 1;
1105:
1106: len = sizeof sock;
1107: if(getpeername(0, &sock, &len) < 0)
1108: error("getpeername");
1109: hp = gethostbyaddr((char *)&sock.sin_addr, sizeof (struct in_addr),
1110: sock.sin_family);
1111: if(hp == 0)
1112: error("gethostbyaddr");
1113: strcpy(bsdhost, hp->h_name);
1114: fprintf(stderr, "bsdhost %s on %d\n", bsdhost, getpid());
1115:
1116: setsockopt(0, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));
1117: }
1118: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.