![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to file.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / netb / src|
Return to file.c CVS log | Up to [Research Unix] / researchv9 / netb / src |
1.1 root 1: /* when the client reads directories, some work may be required */
2: #include "share.h"
3:
4: file tfile;
5: int roottag;
6: unsigned char *slash;
7:
8: openit()
9: { int n;
10: if(!openfile()) {
11: if(client.namiflags != NBROOT)
12: client.errno = ENOENT;
13: return;
14: }
15: n = gimmefile();
16: if(n < 0)
17: return;
18: files[n].fd = tfile.fd;
19: files[n].flags = tfile.flags;
20: if(stat(nmbuf, &files[n].stb) < 0) {
21: client.errno = errno; /* must have been set? */
22: close(tfile.fd);
23: return; /* files[n].tag is 0 still */
24: }
25: checkdev(files[n].stb.st_dev);
26: files[n].tag = maketag(&files[n].stb);
27: if(setname(n))
28: return;
29: checkdupl(n);
30: retnami(n);
31: }
32:
33: creatit()
34: { int n, fd;
35: if((n = openfile()) && client.flags == NI_NXCREAT) {
36: client.errno = EEXIST;
37: close(tfile.fd);
38: return;
39: }
40: if(n) { /* exists, creat it */
41: if(writeperm())
42: return;
43: n = creat(nmbuf, (int)client.mode);
44: if(n >= 0)
45: close(n);
46: else {
47: client.errno = errno;
48: return;
49: }
50: n = gimmefile();
51: if(n < 0)
52: return;
53: files[n].fd = tfile.fd;
54: files[n].flags = tfile.flags;
55: if(stat(nmbuf, &files[n].stb) < 0) {
56: client.errno = errno;
57: close(tfile.fd);
58: return;
59: }
60: checkdev(files[n].stb.st_dev);
61: files[n].tag = maketag(&files[n].stb);
62: if(setname(n))
63: return;
64: checkdupl(n); /* here it is important too to get the new one */
65: retnami(n);
66: return;
67: }
68: /* doesn't exist, creat it */
69: if(client.namiflags == NBROOT)
70: return; /* can't creat the root (is errno set?) */
71: n = gimmefile();
72: if(n < 0)
73: return;
74: if(dirwriteperm())
75: return;
76: if((client.mode & S_IFMT)) { /* no symbolic links or mknods */
77: error("client: client.mode 0%o\n", client.mode);
78: client.errno = EXDEV;
79: return;
80: }
81: if((fd = creat(nmbuf, client.mode)) < 0) {
82: client.errno = errno;
83: return;
84: }
85: if(chown(nmbuf, clientuid(), clientgid()) < 0)
86: return;
87: files[n].fd = open(nmbuf, 2);
88: if(files[n].fd < 0) {
89: files[n].fd = open(nmbuf, 0);
90: if(files[n].fd < 0) {
91: client.errno = errno;
92: unlink(nmbuf);
93: close(fd);
94: return;
95: }
96: files[n].flags = 1;
97: }
98: close(fd); /* fd was write-only */
99: if(stat(nmbuf, &files[n].stb) < 0) { /* it was there a second ago */
100: client.errno = errno;
101: unlink(nmbuf);
102: close(files[n].fd);
103: return;
104: }
105: checkdev(files[n].stb.st_dev);
106: files[n].tag = maketag(&files[n].stb);
107: if(setname(n))
108: return;
109: retnami(n);
110: }
111:
112: linkit()
113: { int i, n;
114: if(dirwriteperm())
115: return;
116: if(openfile()) {
117: client.errno = EEXIST;
118: close(tfile.fd);
119: return;
120: }
121: for(i = 0; i < FILES; i++)
122: if(files[i].tag == client.ino)
123: break;
124: if(i >= FILES) { /* can't happen */
125: error("can't happen: linkit %s, no tag %x\n", nmbuf, client.ino);
126: client.errno = EXDEV; /* not really */
127: return;
128: }
129: debug("linking %s to %s\n", files[i].name, nmbuf);
130: n = link(files[i].name, nmbuf);
131: if(n < 0) {
132: debug("link errno %d\n", errno);
133: client.errno = errno;
134: }
135: }
136:
137: mkdirit()
138: { int n;
139: if(openfile()) {
140: client.errno = EEXIST;
141: close(tfile.fd); /* how does entry get tossed? */
142: return;
143: }
144: if(client.namiflags == NBROOT)
145: return;
146: if(dirwriteperm())
147: return;
148: if(mkdir(nmbuf, client.mode) < 0) {
149: client.errno = errno;
150: return;
151: }
152: if(chown(nmbuf, clientuid(), clientgid()) < 0)
153: return;
154: }
155:
156: rmdirit()
157: {
158: if(!openfile()) {
159: client.errno = EEXIST;
160: return;
161: }
162: close(tfile.fd);
163: if(dirwriteperm())
164: return;
165: if(rmdir(nmbuf) < 0)
166: client.errno = errno;
167: else
168: client.errno = 0;
169: }
170:
171: delit()
172: {
173: if(!openfile()) {
174: client.errno = ENOENT;
175: close(tfile.fd);
176: return;
177: }
178: if(client.namiflags == NBROOT)
179: return;
180: close(tfile.fd);
181: if(dirwriteperm())
182: return;
183: if((tfile.stb.st_mode & S_IFMT) != S_IFREG) {
184: client.errno = EISDIR;
185: return;
186: }
187: if(unlink(nmbuf) < 0)
188: client.errno = errno;
189: else
190: client.errno = 0;
191: }
192:
193: openfile()
194: { unsigned char *p;
195: static struct stat statb;
196: int i;
197: slash = 0;
198: for(p = nmbuf; *p; ) {
199: for(; *p == '/'; p++)
200: slash = p;
201: if(*p == 0)
202: break;
203: *--p = 0;
204: i = stat(nmbuf, &statb);
205: if(i < 0) {
206: debug("openfile: stat %s (%d)\n", nmbuf, errno);
207: client.errno = errno;
208: return(0);
209: }
210: if(searchperm())
211: return(0);
212: *p++ = '/';
213: checkdev(statb.st_dev);
214: if(maketag(&statb) == roottag && p[0] == '.' && p[1] == '.'
215: && (p[2] == 0 || p[2] == '/')) {
216: client.namiflags = NBROOT;
217: client.used = 2 + (p - nmbuf) - nmoffset;
218: debug("openfile: root used %d offset %d\n", client.used,
219: nmoffset);
220: return(0);
221: }
222: while(*p && *p != '/')
223: p++;
224: }
225: i = stat(nmbuf, &statb);
226: if(i < 0)
227: return(0);
228: tfile.fd = -1;
229: tfile.flags = 0;
230: tfile.stb = statb;
231: tfile.fd = open(nmbuf, 2);
232: if(tfile.fd < 0) {
233: tfile.fd = open(nmbuf, 0);
234: if(tfile.fd < 0)
235: return(0);
236: tfile.flags = 1;
237: }
238: return(1);
239: }
240:
241: retnami(n)
242: { file *t = files + n;
243: client.tag = t->tag;
244: client.ino = t->stb.st_ino;
245: client.dev = hostdev(t->stb.st_dev);
246: debug("retnami dev 0x%x ino %d tag 0x%x %s\n", client.dev, client.ino,
247: client.tag, t->name);
248: client.mode = t->stb.st_mode;
249: client.used = 0; /* ? */
250: client.nlink = t->stb.st_nlink;
251: client.uid = hostuid(t->stb.st_uid);
252: client.gid = hostgid(t->stb.st_gid);
253: client.size = t->stb.st_size; /* watch it! */
254: if(cray && client.size >= 0x80000000)
255: client.size = 0x7fffffff;
256: /* fortunately all known hosts agree on time */
257: client.ta = t->stb.st_atime - dtime;
258: client.tc = t->stb.st_ctime - dtime;
259: client.tm = t->stb.st_mtime - dtime;
260: }
261:
262: gimmefile()
263: { int i;
264: for(i = 0; i < FILES; i++)
265: if(files[i].tag == 0)
266: break;
267: if(i >= FILES) {
268: error("out of file structs %d\n", i);
269: client.errno = ENFILE;
270: return(-1);
271: }
272: files[i].flags = 0;
273: files[i].pos = 0;
274: return(i);
275: }
276:
277: /* is this really an error to recover from? */
278: setname(n)
279: { unsigned char *p;
280: p = (unsigned char *)malloc(strlen(nmbuf) + 1);
281: if(p == NULL) {
282: error("out of space on %s\n", nmbuf);
283: client.errno = ENOSPC;
284: return(-1);
285: }
286: strcpy(p, nmbuf);
287: files[n].name = p;
288: return(0);
289: }
290:
291: checkdupl(n)
292: { int i;
293: unsigned char *x;
294: /* if it duplicates someone we've got, toss the old one, but use its tag */
295: for(i = 0; i < FILES; i++) {
296: if(i == n)
297: continue;
298: if(files[i].tag != files[n].tag)
299: continue;
300: debug("ok: creat found dup %s\n", nmbuf);
301: if(strlen(files[i].name) < strlen(files[n].name)) {
302: x = files[n].name;
303: files[n].name = files[i].name;
304: free(x);
305: }
306: else
307: free(files[i].name);
308: close(files[i].fd);
309: files[i].tag = 0;
310: }
311: /* update device translation if necessary */
312: checkdev(files[n].stb.st_dev);
313: }
314:
315: dev *devs;
316: int devlen, ndev;
317: checkdev(n)
318: { int i;
319: for(i = 0; i < ndev; i++)
320: if(devs[i].hdev == n)
321: return;
322: if(ndev >= devlen) {
323: if(!devlen)
324: devs = (dev *) malloc((devlen = 10) * sizeof(dev));
325: else {
326: devlen *= 2;
327: devs = (dev *) realloc((char *)devs, devlen * sizeof(dev));
328: error("reallocated devs to %d entries\n", devlen);
329: }
330: if(!devs)
331: fatal("alloc of %d devs failed!\n", devlen);
332: }
333: if(ndev >= 256)
334: fatal("%d devs? (too many)\n", ndev);
335: devs[ndev].hdev = n;
336: devs[ndev].cdev = hisdev | ndev;
337: debug("devs[%d] %x->%x\n", ndev, n, hisdev | ndev);
338: ndev++;
339: }
340:
341: addroot()
342: { int n;
343: n = gimmefile();
344: files[n].name = (unsigned char *)"/";
345: files[n].fd = open("/", 2);
346: if(files[n].fd < 0) {
347: files[n].fd = open("/", 0);
348: if(files[n].fd < 0)
349: fatal("can't open root, errno %d\n", errno);
350: files[n].flags = 1;
351: }
352: if(stat("/", &files[n].stb) < 0)
353: fatal("stat root errno %d\n", errno);
354: checkdev(files[n].stb.st_dev);
355: files[n].tag = maketag(&files[n].stb);
356: roottag = files[n].tag;
357: debug("root %d, tag 0x%x\n", n, files[n].tag);
358: if(files[n].stb.st_ino != ROOTINO) /* which ROOTINO is this? */
359: error("client and host probably don't agree on rootino %d\n",
360: files[n].stb.st_ino);
361: }
362:
363: maketag(s)
364: struct stat *s;
365: { int tag;
366: tag = (hostdev(s->st_dev) << 16) | s->st_ino;
367: debug("maketag (%x,%x)->%x\n", s->st_dev, s->st_ino, tag);
368: return(tag);
369: }
370:
371: #if cray == 1
372: #include "signal.h"
373: int crapsig;
374: char sysbuf[256];
375: mkdir(s)
376: char *s;
377: { int pid, ret = 0;
378: if(!crapsig++)
379: signal(SIGCLD, SIG_IGN);
380: sprintf(sysbuf, "mkdir %s", s);
381: if(strlen(sysbuf) >= sizeof(sysbuf))
382: fatal("sysbuf overflow %s\n", sysbuf);
383: if((pid = fork()) == 0) {
384: setuid(clientuid());
385: setgid(clientgid());
386: exit(system(sysbuf));
387: }
388: wait(&ret);
389: if(!ret)
390: return(0);
391: errno = EPERM; /* who knows? */
392: return(-1);
393: }
394: rmdir(s)
395: char *s;
396: {
397: if(!crapsig++)
398: signal(SIGCLD, SIG_IGN);
399: sprintf(sysbuf, "rmdir %s", s);
400: if(strlen(sysbuf) >= sizeof(sysbuf))
401: fatal("sysbuf overflow in rmdir %s\n", sysbuf);
402: if(system(sysbuf) == 0)
403: return(0);
404: errno = EPERM; /* ? */
405: return(-1);
406: }
407: fchmod()
408: {
409: fatal("!!!fchmod called\n");
410: }
411: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.