![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to neta.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / fs|
Return to neta.c CVS log | Up to [Research Unix] / researchv10no / sys / fs |
1.1 root 1: #include "sys/param.h"
2: #include "sys/systm.h"
3: #include "sys/inode.h"
4: #include "sys/dir.h"
5: #include "sys/user.h"
6: #include "sys/proc.h"
7: #include "sys/stat.h"
8: #include "sys/neta.h"
9: #include "sys/buf.h"
10: #include "sys/stream.h"
11: #include "sys/conf.h"
12:
13: /*
14: * obsolete network filesystem protocol
15: *
16: * i_fsflags is used in various places instead of the
17: * obsolete i_key
18: * this is a cheat
19: * it is allowed only because neta will soon vanish
20: */
21:
22: struct senda nilx;
23: static long natrannum;
24: #define ND 100
25: struct {
26: char len, s, n;
27: struct senda x[ND];
28: struct rcva y[ND];
29: } netabuf = {ND};
30: #define addx(z) netabuf.x[netabuf.n] = *z; netabuf.s = 1;
31: #define addy(z) netabuf.y[netabuf.n++] = *z; if(netabuf.n >= ND) netabuf.n = 0; netabuf.s = 0;
32:
33: int naput(), naupdat(), naread(), nawrite(), natrunc(), nastat();
34: int nanami(), namount();
35: struct fstypsw nafs =
36: fsinit(naput, naupdat, naread, nawrite, natrunc, nastat,
37: nanami, namount, nodev, nullopen, nodev);
38:
39: namount(sip, ip, flag, mnt, fstyp)
40: struct inode *ip, *sip;
41: {
42: if (!suser())
43: return;
44: if (mnt)
45: nadomount(sip, ip, flag, fstyp);
46: else
47: naunmount(ip, fstyp);
48: }
49:
50: nadomount(cip, dip, flag, fstyp)
51: register struct inode *cip, *dip;
52: {
53: struct inode pi;
54: register struct inode *rip;
55:
56: if(cip->i_sptr == NULL) {
57: u.u_error = ENXIO;
58: return;
59: }
60: if((dip->i_mode & IFMT) != IFDIR) {
61: u.u_error = ENOTDIR;
62: return;
63: }
64: /*
65: * take care, because of the stupid user-generated device
66: */
67: if (dip->i_fstyp == fstyp && dip->i_dev == flag) {
68: u.u_error = EBUSY;
69: return;
70: }
71: pi.i_dev = flag;
72: pi.i_fstyp = fstyp;
73: if ((rip = iget(&pi, flag, ROOTINO)) == NULL)
74: return;
75: if (rip->i_count > 1) {
76: iput(rip);
77: u.u_error = EBUSY;
78: return;
79: }
80: /*
81: * fake the root, rather than sending NAGET now,
82: * to avoid a deadlock when a server mounts itself
83: * the next stat will correct it
84: */
85: rip->i_mode = IFDIR|0555;
86: rip->i_un.i_tag = (flag<<16)|ROOTINO;
87: rip->i_un.i_cip = cip;
88: rip->i_nlink = 2;
89: rip->i_size = 32;
90: rip->i_uid = rip->i_gid = -1;
91: dip->i_mroot = rip;
92: rip->i_mpoint = dip;
93: prele(rip);
94: dip->i_count++;
95: cip->i_count++;
96: cip->i_un.i_fsflags = 0;
97: }
98:
99: naunmount(mip, fstyp)
100: register struct inode *mip;
101: {
102: register struct inode *rip;
103:
104: rip = mip->i_mroot;
105: plock(rip);
106: xumount(rip); /* shared text from remote root */
107: if (rip->i_count > 1 || ifsbusy(rip)) {
108: u.u_error = EBUSY;
109: prele(rip);
110: return;
111: }
112: plock(mip);
113: mip->i_mroot = NULL;
114: iput(mip);
115: if ((mip = rip->i_un.i_cip) == NULL)
116: panic("naunmount");
117: iput(rip);
118: iput(mip);
119: }
120:
121: naput(ip)
122: struct inode *ip;
123: { struct senda x;
124: struct rcva y;
125:
126: if (ip->i_un.i_cip == NULL)
127: return; /* obscure gmount safety */
128: if(ip->i_flag & ICHG)
129: naupdat(ip, &time, &time, 0);
130: x = nilx;
131: x.trannum = natrannum++;
132: x.cmd = NPUT;
133: x.uid = u.u_uid;
134: x.tag = ip->i_un.i_tag;
135: x.dev = ip->i_dev;
136: x.ino = ip->i_number;
137: send(ip->i_un.i_cip, &x, &y);
138: if(y.errno)
139: u.u_error = y.errno;
140: }
141:
142: /*
143: * special case:
144: * the root is faked up locally
145: * really just to avoid a silly deadlock in the face server
146: */
147: nafillin(fip, ip)
148: struct inode *fip;
149: register struct inode *ip;
150: { struct senda x;
151: struct rcva y;
152:
153: ip->i_un.i_cip = NULL; /* in case we have to put it */
154: if (fip->i_un.i_cip == NULL) {
155: u.u_error = ENXIO;
156: iput(ip);
157: return (-1);
158: }
159: x = nilx;
160: x.trannum = natrannum++;
161: x.cmd = NGET;
162: x.uid = u.u_uid;
163: x.dev = ip->i_dev;
164: x.ino = ip->i_number;
165: send(fip->i_un.i_cip, &x, &y);
166: if(y.errno == 0) {
167: ip->i_mode = y.mode;
168: ip->i_un.i_tag = y.tag;
169: ip->i_un.i_cip = fip->i_un.i_cip;
170: ip->i_nlink = y.nlink;
171: ip->i_size = y.size;
172: ip->i_uid = y.uid;
173: ip->i_gid = y.gid;
174: return (0);
175: }
176: iput(ip);
177: u.u_error = y.errno;
178: return(-1);
179: }
180:
181: /* this is used by CREAT */
182: naupdat(ip, ta, tm, waitfor)
183: struct inode *ip;
184: time_t *ta, *tm;
185: { struct senda x;
186: struct rcva y;
187:
188: if (ip->i_un.i_cip == NULL)
189: return; /* obscure gmount safety */
190: x = nilx;
191: x.trannum = natrannum++;
192: x.cmd = NUPDAT;
193: x.uid = u.u_uid;
194: x.gid = u.u_gid;
195: x.newuid = ip->i_uid;
196: x.newgid = ip->i_gid;
197: x.mode = ip->i_mode;
198: x.tag = ip->i_un.i_tag;
199: x.dev = ip->i_dev;
200: x.ino = ip->i_number;
201: if(ip->i_flag & IACC)
202: x.ta = *ta;
203: else
204: x.ta = 0;
205: if(ip->i_flag & ICHG)
206: x.tm = *tm;
207: else
208: x.tm = 0;
209: send(ip->i_un.i_cip, &x, &y);
210: if(y.errno) {
211: u.u_error = y.errno;
212: return;
213: }
214: ip->i_mode = y.mode;
215: ip->i_nlink = y.nlink;
216: ip->i_size = y.size;
217: ip->i_uid = y.uid;
218: ip->i_gid = y.gid;
219: ip->i_flag &= ~(IUPD|IACC|ICHG);
220: }
221:
222: naread(ip)
223: struct inode *ip;
224: { struct senda x;
225: struct rcva y;
226: struct buf *bp;
227: int n;
228:
229: bp = geteblk();
230: clrbuf(bp); /* could use user's buffer */
231: x = nilx;
232: x.trannum = natrannum++;
233: x.cmd = NREAD;
234: x.uid = u.u_uid;
235: x.tag = ip->i_un.i_tag;
236: x.dev = ip->i_dev;
237: x.ino = ip->i_number;
238: x.buf = bp->b_un.b_addr;
239: do {
240: n = u.u_count;
241: if(n > BUFSIZE)
242: n = BUFSIZE;
243: x.count = n;
244: x.offset = Ltol(u.u_offset);
245: send(ip->i_un.i_cip, &x, &y);
246: if((n = y.count) > 0) {
247: if(u.u_segflg != SEGSYS) {
248: if(copyout(bp->b_un.b_addr, u.u_base, n)) {
249: u.u_error = EFAULT;
250: break;
251: }
252: }
253: else
254: bcopy(bp->b_un.b_addr, u.u_base, n);
255: u.u_base += n;
256: u.u_offset = Lladd(u.u_offset, n);
257: u.u_count -= n;
258: }
259: if(y.errno)
260: u.u_error = y.errno;
261: } while(u.u_error == 0 && u.u_count != 0 && n > 0);
262: brelse(bp);
263: }
264: nawrite(ip)
265: struct inode *ip;
266: { struct senda x;
267: struct rcva y;
268: struct buf *bp;
269: int n;
270:
271: bp = geteblk();
272: x = nilx;
273: x.trannum = natrannum++;
274: x.cmd = NWRT;
275: x.uid = u.u_uid;
276: x.tag = ip->i_un.i_tag;
277: x.dev = ip->i_dev;
278: x.ino = ip->i_number;
279: x.buf = bp->b_un.b_addr;
280: do {
281: n = u.u_count;
282: if(n > BUFSIZE) /* should be bufsiz, but ... */
283: n = BUFSIZE;
284: if(u.u_segflg != SEGSYS) {
285: if(copyin(u.u_base, bp->b_un.b_addr, n)) {
286: u.u_error = EFAULT;
287: break;
288: }
289: }
290: else
291: bcopy(u.u_base, bp->b_un.b_addr, n);
292: x.count = n;
293: x.offset = Ltol(u.u_offset);
294: send(ip->i_un.i_cip, &x, &y);
295: if(y.errno) {
296: u.u_error = y.errno;
297: break;
298: }
299: ip->i_flag |= IUPD|ICHG;
300: u.u_count -= n;
301: u.u_offset = Lladd(u.u_offset, n);
302: u.u_base += n;
303: } while(u.u_error == 0 && u.u_count != 0);
304: brelse(bp);
305: }
306:
307: natrunc(ip)
308: struct inode *ip;
309: { struct senda x;
310: struct rcva y;
311:
312: x = nilx;
313: x.trannum = natrannum++;
314: x.cmd = NTRUNC;
315: x.uid = u.u_uid;
316: x.tag = ip->i_un.i_tag;
317: x.dev = ip->i_dev;
318: x.ino = ip->i_number;
319: send(ip->i_un.i_cip, &x, &y);
320: if(y.errno)
321: u.u_error = y.errno;
322: }
323:
324: nastat(ip, ub)
325: struct inode *ip;
326: struct stat *ub;
327: { struct senda x;
328: struct rcva y;
329: struct stat ds;
330:
331: x = nilx;
332: x.trannum = natrannum++;
333: x.cmd = NSTAT;
334: x.uid = u.u_uid;
335: x.tag = ip->i_un.i_tag;
336: x.dev = ip->i_dev;
337: x.ino = ip->i_number;
338: x.ta = time;
339: send(ip->i_un.i_cip, &x, &y);
340: if(y.errno) {
341: u.u_error = y.errno;
342: return;
343: }
344: ds.st_dev = ip->i_dev;
345: ds.st_ino = ip->i_number;
346: ip->i_mode = ds.st_mode = y.mode;
347: ip->i_nlink = ds.st_nlink = y.nlink;
348: ip->i_uid = ds.st_uid = y.uid;
349: ip->i_gid = ds.st_gid = y.gid;
350: ds.st_size = ip->i_size = y.size;
351: ds.st_atime = y.tm[0];
352: ds.st_mtime = y.tm[1];
353: ds.st_ctime = y.tm[2];
354: if(copyout((caddr_t)&ds, (caddr_t)ub, sizeof(ds)) < 0)
355: u.u_error = EFAULT;
356: }
357:
358: /* a lot like fsnami */
359: nanami(p, flagp, follow)
360: struct nx *p;
361: struct argnamei *flagp;
362: { register struct inode *dp, *dip;
363: register char *cp;
364: int i, fstyp;
365: dev_t d;
366: struct direct dent;
367: struct senda x;
368: struct rcva y;
369:
370: cp = p->cp;
371: dp = p->dp;
372: x = nilx;
373: x.cmd = NNAMI;
374: x.uid = u.u_uid;
375: x.gid = u.u_gid;
376:
377: /*
378: * dp must be a directory and
379: * must have X permission.
380: * cp is a path name relative to that directory.
381: */
382:
383: dirloop:
384: if((dp->i_mode&IFMT) != IFDIR)
385: u.u_error = ENOTDIR;
386: (void) access(dp, IEXEC);
387: for (i=0; *cp!='\0' && *cp!='/'; i++) {
388: if (i >= DIRSIZ) {
389: u.u_error = ENOENT;
390: break;
391: }
392: dent.d_name[i] = *cp++;
393: }
394: if(u.u_error)
395: goto outnull;
396: while (i < DIRSIZ)
397: dent.d_name[i++] = '\0';
398: if (dent.d_name[0] == '\0') { /* null name, e.g. "/" or "" */
399: if (flagp->flag != NI_SEARCH) {
400: u.u_error = ENOENT;
401: goto outnull;
402: }
403: goto out;
404: }
405: u.u_segflg = SEGSYS;
406:
407: /* send off the request, get back ino, dev, flagp stuff */
408: x.trannum = natrannum++;
409: x.tag = dp->i_un.i_tag;
410: x.dev = dp->i_dev;
411: x.ino = dp->i_number;
412: x.count = DIRSIZ;
413: x.buf = dent.d_name;
414: while(*cp == '/')
415: cp++;
416: if(*cp=='\0') {
417: switch(flagp->flag) {
418: case NI_SEARCH:
419: x.flags = NSEARCH;
420: break;
421: case NI_DEL:
422: x.flags = NDEL;
423: break;
424: case NI_LINK:
425: x.flags = NLINK;
426: x.dev = flagp->un.il->i_dev;
427: x.ino = flagp->un.il->i_number;
428: break;
429: case NI_CREAT:
430: case NI_NXCREAT:
431: x.flags = NCREAT;
432: x.mode = flagp->un.mode;
433: break;
434: case NI_MKDIR:
435: x.flags = NMKDIR;
436: x.mode = flagp->un.mode;
437: break;
438: case NI_RMDIR:
439: x.flags = NRMDIR;
440: break;
441: default:
442: u.u_error = ENXIO;
443: goto outnull;
444: }
445: }
446: send(dp->i_un.i_cip, &x, &y);
447: if(y.errno) {
448: u.u_error = y.errno;
449: goto outnull;
450: }
451: if(y.flags == NOMATCH)
452: goto nomatch;
453: dent.d_ino = y.ino;
454: if (y.ino == 0) {
455: printf("y.ino 0 in nanami\n");
456: u.u_error = ENOENT;
457: goto outnull;
458: }
459: d = y.dev;
460:
461: if(*cp == 0 && (flagp->flag==NI_DEL || flagp->flag==NI_RMDIR)) {
462: /* delete the entry, server did all but xrele */
463: dip = iget(dp, d, dent.d_ino);
464: if (dip == NULL)
465: goto outnull;
466: if (dip->i_count == 1) {
467: dip->i_un.i_cip = NULL;
468: iput(dip);
469: goto outnull;
470: }
471: if(dip->i_flag&ITEXT)
472: xrele(dip); /* free busy text */
473: dip->i_nlink--;
474: dip->i_flag |= ICHG;
475: iput(dip);
476: goto outnull;
477: }
478: /*
479: * Special handling for ".."
480: */
481: fstyp = dp->i_fstyp;
482:
483: if(y.flags == NROOT) { /* popped out of net fs */
484: if (dp == u.u_rdir)
485: dent.d_ino = dp->i_number;
486: else if (dp != rootdir && dent.d_ino==ROOTINO
487: && dp->i_number == ROOTINO) {
488: if ((dip = dp->i_mpoint) == NULL)
489: panic("namei: mpoint");
490: iput(dp);
491: dp = dip;
492: plock(dp);
493: dp->i_count++;
494: /* was there always .. there? */
495: if(*cp && cp < p->nbuf + 3)
496: panic("nanami");
497: if(!*cp && cp < p->nbuf + 2)
498: panic("nanami2");
499: if(*cp)
500: *--cp = '/';
501: *--cp = '.';
502: *--cp = '.';
503: if(fstyp != dp->i_fstyp)
504: goto more;
505: goto dirloop;
506: }
507: }
508: dip = dp;
509: prele(dip);
510: dp = iget(dip, d, dent.d_ino);
511: if(dp == NULL) {
512: iput(dip);
513: goto out;
514: }
515: if (dp->i_count == 1 && nafillin(dip, dp) < 0) {
516: iput(dip);
517: dp = NULL;
518: goto out;
519: }
520: if(fstyp != dp->i_fstyp) {
521: iput(dip);
522: goto more;
523: }
524: /*
525: * Check for symbolic link
526: */
527: if ((dp->i_mode&IFMT)==IFLNK && (follow || *cp)) {
528: char *ocp;
529:
530: ocp = cp;
531: while (*cp++)
532: ;
533: if (dp->i_size + (cp-ocp) >= p->nlen-1
534: || ++p->nlink>8) {
535: u.u_error = ELOOP;
536: iput(dip);
537: goto outnull;
538: }
539: bcopy(ocp, p->nbuf+dp->i_size + 1, cp-ocp);
540: *(p->nbuf + dp->i_size) = '/';
541: u.u_base = p->nbuf;
542: u.u_count = dp->i_size;
543: u.u_offset = ltoL(0);
544: readi(dp);
545: if(u.u_error) {
546: iput(dip);
547: goto outnull;
548: }
549: cp = p->nbuf;
550: iput(dp);
551: if (*cp == '/') {
552: iput(dip);
553: while (*cp == '/')
554: cp++;
555: if ((dp = u.u_rdir) == NULL)
556: dp = rootdir;
557: plock(dp);
558: dp->i_count++;
559: } else {
560: dp = dip;
561: plock(dp);
562: }
563: if(fstyp != dp->i_fstyp)
564: goto more;
565: goto dirloop;
566: }
567: iput(dip);
568: if(*cp)
569: goto dirloop;
570: if(flagp->flag == NI_SEARCH && flagp->un.buf)
571: bcopy((caddr_t)dent.d_name, flagp->un.buf, flagp->len);
572: goto out;
573:
574: nomatch:
575: /*
576: * Search failed.
577: */
578: switch(flagp->flag) { /* probably creating a new file */
579: case NI_LINK: /* make a link */
580: case NI_MKDIR: /* make directory */
581: goto outnull;
582: case NI_CREAT: /* create a new file */
583: case NI_NXCREAT:
584: if(y.errno == EACCES || y.ino == 0) {
585: u.u_error = EACCES;
586: goto outnull;
587: }
588: dip = iget(dp, y.dev, y.ino);
589: if(dip == NULL)
590: goto outnull;
591: if (dip->i_count == 1 && nafillin(dp, dip) < 0)
592: goto outnull;
593: iput(dp);
594: dp = dip;
595: flagp->un.mode = ~flagp->un.mode;
596: goto out;
597:
598: default:
599: u.u_error = ENOENT;
600: goto outnull;
601: }
602:
603: out:
604: p->dp = dp;
605: return (0);
606:
607: outnull:
608: iput(dp);
609: p->dp = NULL;
610: return (0);
611:
612: more:
613: p->cp = cp;
614: p->dp = dp;
615: return (1);
616: }
617:
618: struct {
619: int tran;
620: short proc, dev;
621: } ntx[32]; /* more debuggery */
622: send(cip, x, y)
623: struct inode *cip;
624: struct senda *x;
625: struct rcva *y;
626: { int n, tn, ix;
627: x->version = NETVERSION;
628: /* until demux works, use key as a lock */
629: while(cip->i_un.i_fsflags)
630: sleep((caddr_t)cip, PZERO);
631: cip->i_un.i_fsflags = 1;
632: tn = x->trannum;
633: netabuf.s = 2;
634: for(ix = 0; ntx[ix].tran && ix < 32; ix++) {
635: ntx[ix].tran = tn;
636: ntx[ix].proc = u.u_procp->p_pid;
637: ntx[ix].dev = x->dev;
638: }
639: n = istwrite(cip, (char *)x, sizeof(*x));
640: netabuf.s = 3;
641: if(n == -1) {
642: y->errno = EIO;
643: goto bad;
644: }
645: netabuf.s = 4;
646: if(x->count > 0 && x->buf && x->cmd != NREAD) {
647: n = istwrite(cip, x->buf, x->count);
648: if(n == -1)
649: goto bad;
650: }
651: readagain:
652: netabuf.s = 5;
653: n = istread(cip, (char *)y, sizeof(*y), 0);
654: netabuf.s = 6;
655: if(n != sizeof(*y))
656: goto bad;
657: if(y->errno == 0 && x->cmd == NREAD) {
658: n = istread(cip, x->buf, y->count, 0);
659: if(n != y->count) {
660: printf("neta: read %d expected %d\n", n, y->count);
661: /* shut it down */
662: istwrite(cip, (char *)x, 0);
663: goto bad;
664: }
665: }
666: if(y->errno == 0) {
667: if(y->trannum != tn) {
668: if(y->trannum < tn) /* distant past */
669: goto readagain;
670: printf("neta: sent %d got %d\n", tn, y->trannum);
671: goto bad;
672: }
673: addx(x);
674: addy(y);
675: if(ix < 32)
676: ntx[ix].tran = 0;
677: cip->i_un.i_fsflags = 0;
678: wakeup((caddr_t)cip);
679: return;
680: }
681: bad:
682: cip->i_un.i_fsflags = 0;
683: if(ix < 32)
684: ntx[ix].tran = 0;
685: for(ix = 0; ix < 32; ix++)
686: if(ntx[ix].tran)
687: printf("tran %d proc %d 0x%x\n", ntx[ix].tran, ntx[ix].proc, ntx[ix].dev);
688: wakeup((caddr_t)cip);
689: addx(x);
690: addy(y);
691: if(y->errno)
692: return;
693: y->errno = EIO;
694: }
695: static struct D { struct D *a; char *b;} VER = {&VER,"\n85/6/9:neta.c\n"};
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.