![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to f11.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / netfs / serv|
Return to f11.c CVS log | Up to [Research Unix] / researchv10no / netfs / serv |
1.1 root 1: /*
2: * file service routines for FILES-11 ODS-1
3: * in its modern instance, with subdirectories
4: */
5:
6: #include <rf.h>
7: #include "files11.h"
8: #include "f11.h"
9:
10: #define NULL 0
11: #define HUGE 0x7fffffff
12:
13: int diskfd;
14: struct homeblock home;
15: Fsfile indexf;
16: unsigned short dirtyp;
17:
18: static htorf();
19: static char *itoa();
20: static int binchk();
21: char *r50toa();
22: char *malloc();
23:
24: /*
25: * permission hacks
26: */
27: #define UXOTHER 1
28: static Idmap gmap[] = { "other", UXOTHER, 0 };
29:
30: /*
31: * init:
32: * install the root
33: *
34: * argv[1] == the file containing our filesystem
35: */
36: Rfile *
37: fsinit(argc, argv)
38: int argc;
39: char **argv;
40: {
41: register Rfile *f;
42: register long firsthdr;
43: char *p;
44:
45: p = "dir";
46: dirtyp = ator50(&p);
47: if (argc <= 1)
48: rfpanic("no files-11 filesystem specified\n");
49: if ((diskfd = open(argv[1], 0)) < 0) /* readonly for now */
50: rfpanic("%s: cannot open\n", argv[1]);
51: if (lseek(diskfd, (long)HOMEBLK * BLKSIZ, 0) < 0)
52: rfpanic("can't seek for home block\n");
53: if (read(diskfd, (char *)&home, sizeof(home)) != sizeof(home))
54: rfpanic("can't read homeblock\n");
55: if ((f = (Rfile *)malloc(sizeof(Rfile))) == NULL
56: || (f->fs = malloc(sizeof(Fsfile))) == NULL)
57: rfpanic("no mem for root\n");
58: firsthdr = plong(home.H_iblb)+home.H_ibsz;
59: lseek(diskfd, (firsthdr + fidtob(FINDEX)) * BLKSIZ, 0);
60: if (read(diskfd, (char *)&indexf.h, sizeof(indexf.h)) != sizeof(indexf.h))
61: rfpanic("can't read index header\n");
62: indexf.lbase = HUGE;
63: if (gethdr(FROOT, &fsp(f)->h) == 0)
64: rfpanic("can't read root header\n");
65: htorf(f, &fsp(f)->h);
66: fsp(f)->parent = FROOT;
67: fsp(f)->lbase = HUGE;
68: fsp(f)->flags = FBIN;
69: fsp(f)->tboff = fsp(f)->tbno = fsp(f)->tuoff = 0;
70: rfgidmap = gmap;
71: return (f);
72: }
73:
74: /*
75: * access a file
76: */
77: Rfile *
78: fswalk(df, name)
79: Rfile *df;
80: char *name;
81: {
82: register Rfile *f;
83: unsigned short fid;
84: int binary;
85:
86: binary = binchk(name);
87: if (strcmp(name, ".") == 0)
88: return (df);
89: else if (strcmp(name, "..") == 0) {
90: if (df->ino == FROOT) {
91: fserrno = 0; /* magic: popped out */
92: return (NULL);
93: }
94: fid = fsp(df)->parent;
95: } else if ((fid = f11walk(df, name)) == 0)
96: return (NULL);
97: if ((f = (Rfile *)malloc(sizeof(Rfile))) == NULL) {
98: rflog("no mem\n");
99: fserrno = RFEINVAL;
100: return (NULL);
101: }
102: if ((f->fs = malloc(sizeof(Fsfile))) == NULL) {
103: free((char *)f);
104: rflog("no mem\n");
105: fserrno = RFEINVAL;
106: return (NULL);
107: }
108: fsp(f)->lbase = HUGE;
109: if (gethdr(fid, &fsp(f)->h) == 0) {
110: free((char *)f);
111: fserrno = RFEIO;
112: return (NULL);
113: }
114: if (fsp(f)->h.h_ident.i_fnam.f_typ == dirtyp)
115: fsp(f)->parent = fsp(df)->h.h_fnum;
116: htorf(f, &fsp(f)->h);
117: fsp(f)->tboff = fsp(f)->tbno = fsp(f)->tuoff = 0;
118: if (binary)
119: fsp(f)->flags = FBIN;
120: else if (fsp(f)->h.h_fcs.f_rtyp == RTVAR && fsp(f)->h.h_fcs.f_ratt & RTCR)
121: fsp(f)->flags = 0;
122: else
123: fsp(f)->flags = FBIN;
124: return (f);
125: }
126:
127: /*
128: * see if filename is `binary': trailing % in name
129: * stamp it out if so
130: */
131: static
132: binchk(name)
133: register char *name;
134: {
135: name += strlen(name);
136: if (*--name == '%') {
137: *name = 0;
138: return (1);
139: }
140: return (0);
141: }
142:
143: /*
144: * discard a file reference
145: */
146: int
147: fsdone(f)
148: Rfile *f;
149: {
150:
151: free(f->fs);
152: free((char *)f);
153: return (0);
154: }
155:
156: /*
157: * return file status
158: */
159: fsstat(f)
160: register Rfile *f;
161: {
162:
163: if (gethdr(fsp(f)->h.h_fnum, &fsp(f)->h) == 0) {
164: fserrno = RFEINVAL;
165: return (-1);
166: }
167: htorf(f, &fsp(f)->h);
168: return (0);
169: }
170:
171: /*
172: * read
173: */
174: int
175: fsread(f, off, buf, len)
176: Rfile *f;
177: long off;
178: char *buf;
179: int len;
180: {
181:
182: if (fsp(f)->flags & FBIN)
183: return (binread(f, off, buf, len));
184: else
185: return (textread(f, off, buf, len));
186: }
187:
188: int
189: binread(f, off, buf, len)
190: Rfile *f;
191: long off;
192: char *buf;
193: int len;
194: {
195: char bbuf[BLKSIZ];
196: int boff;
197: long bno;
198: int nread, r;
199: int ncpy;
200:
201: nread = 0;
202: bno = off / BLKSIZ;
203: boff = off % BLKSIZ;
204: /*
205: * contract this loop later
206: */
207: r = 0;
208: while (len > 0) {
209: if ((r = f11rblk(f, bno, bbuf)) <= 0)
210: break;
211: ncpy = BLKSIZ - boff;
212: ncpy = (len > ncpy) ? ncpy : len;
213: memcpy(buf, bbuf+boff, ncpy);
214: len -= ncpy;
215: buf += ncpy;
216: nread += ncpy;
217: boff = 0;
218: bno++;
219: }
220: if (nread || r >= 0)
221: return (nread);
222: fserrno = RFEIO;
223: return (-1);
224: }
225:
226: int
227: textread(f, off, buf, len)
228: Rfile *f;
229: long off;
230: char *buf;
231: int len;
232: {
233: unsigned char bbuf[BLKSIZ];
234: int boff;
235: long bno;
236: int nread, r;
237: int ncpy;
238: int rlen;
239: unsigned char *p;
240:
241: nread = 0;
242: if (off == fsp(f)->tuoff) {
243: bno = fsp(f)->tbno;
244: boff = fsp(f)->tboff;
245: } else if (off == 0) {
246: bno = 0;
247: boff = 0;
248: } else { /* wrong, but so what? */
249: bno = off / BLKSIZ;
250: boff = off % BLKSIZ;
251: }
252: if ((r = f11rblk(f, bno, bbuf)) <= 0)
253: goto out;
254: p = bbuf + boff;
255: while (len > 0) {
256: if (boff & 01) {
257: p++;
258: boff++;
259: }
260: if ((bno * BLKSIZ) + boff >= f->size)
261: break;
262: rlen = p[0] + (p[1]<<8);
263: if (rlen == -1) { /* skip to next block */
264: if ((r = f11rblk(f, ++bno, bbuf)) <= 0)
265: goto out;
266: p = bbuf;
267: boff = 0;
268: continue;
269: }
270: if (rlen + 1 > len) /* +1 for newline */
271: /* set a particular error here? */
272: break;
273: p += 2;
274: for (; rlen > 0; rlen -= ncpy) {
275: ncpy = &bbuf[BLKSIZ] - p;
276: if (ncpy > rlen)
277: ncpy = rlen;
278: memcpy(buf, p, ncpy);
279: p += ncpy;
280: boff = p - bbuf;
281: nread += ncpy;
282: buf += ncpy;
283: len -= ncpy;
284: if (ncpy < rlen) { /* next block */
285: if ((r = f11rblk(f, ++bno, bbuf)) <= 0)
286: goto out;
287: p = bbuf;
288: boff = 0;
289: }
290: }
291: *buf++ = '\n';
292: nread++;
293: len--;
294: if (boff > BLKSIZ - 2) { /* about to need new block */
295: if ((r = f11rblk(f, ++bno, bbuf)) <= 0)
296: goto out;
297: p = bbuf;
298: boff = 0;
299: }
300: }
301: out:
302: if (boff == BLKSIZ) {
303: boff = 0;
304: bno++;
305: }
306: if (nread) {
307: fsp(f)->tuoff = off + nread;
308: fsp(f)->tbno = bno;
309: fsp(f)->tboff = boff;
310: }
311: if (nread || r >= 0)
312: return (nread);
313: fserrno = RFEIO;
314: return (-1);
315: }
316:
317: /*
318: * read directory --
319: * return ascii records: decimal `i-number', tab, filename, NUL
320: * filename is filname.typ.ver
321: * *offp gets new file offset for directory
322: */
323: #define DENTSIZE (6+9+4+6+1) /* max len of a directory record */
324:
325: int
326: fsdirread(f, off, buf, len, offp)
327: Rfile *f;
328: long off;
329: char *buf;
330: int len;
331: long *offp;
332: {
333: char bbuf[BLKSIZ];
334: register char *p;
335: register struct directory *dp;
336: struct directory *dend;
337: char *op;
338: int r;
339: long bno;
340: int boff;
341:
342: bno = off / BLKSIZ;
343: if ((r = f11rblk(f, bno, bbuf)) <= 0) {
344: fserrno = RFEIO;
345: return (r);
346: }
347: boff = off % BLKSIZ;
348: dp = (struct directory *)bbuf + (boff/sizeof(struct directory));
349: dend = (struct directory *)&bbuf[BLKSIZ];
350: p = buf;
351: while (len >= DENTSIZE) {
352: while (dp < dend && dp->d_fid.f_num == 0)
353: dp++;
354: if (dp >= dend) {
355: bno++;
356: dp = (struct directory *)bbuf;
357: if ((r = f11rblk(f, bno, bbuf)) <= 0)
358: break;
359: }
360: op = p;
361: p = itoa(p, dp->d_fid.f_num);
362: *p++ = '\t';
363: p = r50toa(p, dp->d_fname.f_nam[0]);
364: p = r50toa(p, dp->d_fname.f_nam[1]);
365: p = r50toa(p, dp->d_fname.f_nam[2]);
366: while (p[-1] == ' ')
367: --p;
368: *p++ = '.';
369: p = r50toa(p, dp->d_fname.f_typ);
370: while (p[-1] == ' ')
371: --p;
372: *p++ = '.';
373: p = itoa(p, dp->d_fname.f_ver);
374: *p++ = 0;
375: len -= p - op;
376: dp++;
377: }
378: if (p == buf && r < 0) {
379: fserrno = RFEIO;
380: return (-1);
381: }
382: *offp = (bno * BLKSIZ) + (char *)dp - bbuf;
383: return (p - buf);
384: }
385:
386: /*
387: * f11 to rf file attributes
388: * -- temporary permission hack:
389: * turn apparent f11 other to asserted unix other group
390: */
391: #define F11OTHER (-1)
392:
393: static
394: htorf(f, h)
395: register Rfile *f;
396: register struct header *h;
397: {
398: f->ino = h->h_fnum;
399: f->dev = 0;
400: f->mode = htouperm(h->h_fpro);
401: if (h->h_ident.i_fnam.f_typ != dirtyp)
402: f->type = RFTREG;
403: else {
404: f->mode |= (f->mode & 0444)>>2; /* copy `read' into `execute' */
405: f->type = RFTDIR;
406: }
407: f->nlink = 1;
408: f->uid = h->h_fown.u_prog;
409: f->gid = h->h_fown.u_proj;
410: if (f->gid == F11OTHER)
411: f->gid = UXOTHER;
412: f->rdev = 0;
413: f->size = hfilesize(h);
414: f->ta = 0;
415: f->tm = htoutime(h->h_ident.i_rvdt);
416: f->tc = htoutime(h->h_ident.i_crdt); /* wrong, but let it stand */
417: if (f->tm == 0)
418: f->tm = f->tc;
419: }
420:
421: /*
422: * number to string
423: */
424:
425: static char digits[] = "0123456789";
426:
427: static char *
428: itoa(s, n)
429: register char *s;
430: register unsigned int n;
431: {
432: register int d;
433:
434: if ((d = n / 10) == 0)
435: *s++ = digits[n];
436: else {
437: s = itoa(s, d);
438: *s++ = digits[n % 10];
439: }
440: return (s);
441: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.