![[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] / researchv10no / cmd / face|
Return to file.c CVS log | Up to [Research Unix] / researchv10no / cmd / face |
1.1 root 1: /*
2: * routines for creating and looking up internal files
3: *
4: * the internal file structure is a tree of Files.
5: * terminal nodes are regular files;
6: * their contents is in a real file outside.
7: * other nodes are directories;
8: * they exist only in our memory.
9: *
10: * directories are sorted lists;
11: * files are looked up by binary search.
12: */
13:
14: #include "faces.h"
15: #include "faceproto.h" /* for FROOT */
16: #include <stdio.h>
17: #include <sys/types.h>
18: #include <sys/stat.h>
19: #include "dirent.h" /* non-portable portable routines */
20:
21: static File *root;
22: static int nextino;
23:
24: #define DIRINIT 10
25: #define DIRCHUNK 100
26:
27: /*
28: * built-in directories
29: * every outside data file must be in one of these
30: */
31:
32: struct builtin {
33: char *ourname;
34: char *extname;
35: File *file;
36: time_t mtime;
37: } builtins[] = {
38: {"48x48x1", "/usr/jerq/icon/face48"},
39: {"48x48x2", "/usr/jerq/icon/48x48x2"},
40: {"512x512x8", "/t0/face/512x512x8"},
41: 0
42: };
43:
44: static time_t ptime, mtime;
45:
46: extern char *strchr();
47: extern File *falloc();
48:
49: /*
50: * remake the face tree
51: */
52:
53: maketree(pfile, mfile)
54: char *pfile, *mfile;
55: {
56: File *df, *f;
57: FILE *fp;
58: char *dir, *pers, *ref;
59: register struct builtin *bp;
60:
61: (void)newdata(pfile, mfile); /* store times */
62: if (root == NULL) {
63: nextino = FROOT;
64: root = newfile();
65: } else {
66: nextino = FROOT + 1;
67: freetree(root);
68: }
69: initdir(root, root);
70: for (bp = builtins; bp->ourname; bp++) {
71: f = newfile();
72: initdir(f, root);
73: filldir(f, bp->extname);
74: enterfile(root, bp->ourname, f);
75: bp->file = f;
76: }
77: if ((fp = fopen(pfile, "r")) == NULL)
78: log("%s: cannot open; no people\n", pfile);
79: else {
80: while (pcrack(fp, pfile, &dir, &pers, &ref)) {
81: if ((df = lookent(root, dir)) == NULL) {
82: df = newfile();
83: initdir(df, root);
84: enterfile(root, dir, df);
85: }
86: f = newfile(); /* make dir/pers */
87: if (enterfile(df, pers, f)) {
88: log("%s: %s/%s=%s: dup for %s/%s\n",
89: pfile, dir, pers, ref, dir, pers);
90: ffree(f);
91: continue;
92: }
93: initdir(f, df);
94: for (bp = builtins; bp->ourname; bp++)
95: if ((df = lookent(bp->file, ref)) != NULL)
96: enterfile(f, bp->ourname, df);
97: }
98: fclose(fp);
99: }
100: if ((fp = fopen(mfile, "r")) == NULL)
101: log("%s: cannot open; no machines\n", mfile);
102: else {
103: while (pcrack(fp, mfile, &dir, (char **)NULL, &ref)) {
104: if ((df = lookent(root, ref)) == NULL) {
105: log("%s: %s=%s: %s not found\n",
106: mfile, dir, ref, ref);
107: continue;
108: }
109: if ((f = enterfile(root, dir, df)) != NULL) {
110: if (f == df) {
111: log("%s: %s=%s: already true\n",
112: mfile, dir, ref);
113: continue;
114: }
115: uniondir(df, f, mfile, dir, ref);
116: }
117: }
118: fclose(fp);
119: }
120: }
121:
122: /*
123: * parse a line in people file or machine file
124: * fairly hackish
125: * people file: dir/person=realfile
126: * machine file: machdir=dir
127: * return 1 if a valid entry found,
128: * 0 if end of file
129: */
130:
131: pcrack(fp, fname, dirp, persp, refp)
132: FILE *fp;
133: char *fname;
134: char **dirp, **persp, **refp;
135: {
136: static char buf[100];
137: register char *p;
138:
139: again:
140: buf[sizeof(buf)-1] = 0;
141: if (fgets(buf, sizeof(buf), fp) == NULL)
142: return (0); /* EOF */
143: if (buf[sizeof(buf)-1]) {
144: buf[sizeof(buf)-1] = 0;
145: log("%s: line too long: %s ...\n", fname, buf);
146: return (0); /* too hard to recover for now */
147: }
148: if (buf[0] == '#' || buf[0] == '\n')
149: goto again; /* skip comments, empties */
150: p = buf;
151: *dirp = p;
152: if (persp) {
153: if ((p = strchr(p, '/')) == NULL) {
154: log("%s: missing /: %s", fname, buf);
155: goto again;
156: }
157: *p++ = 0;
158: *persp = p;
159: }
160: if ((p = strchr(p, '=')) == NULL) {
161: if (persp)
162: (*persp)[-1] = '/'; /* hack */
163: log("%s: missing =: %s", fname, buf);
164: goto again;
165: }
166: *p++ = 0;
167: *refp = p;
168: if ((p = strchr(p, '\n')) != NULL) /* fgets should promise this */
169: *p = 0;
170: return (1);
171: }
172:
173: /*
174: * see if the outside data has changed,
175: * and we should rebuild the tree
176: */
177:
178: newdata(pfile, mfile)
179: char *pfile, *mfile;
180: {
181: struct stat st;
182: int new;
183: register struct builtin *bp;
184:
185: new = 0;
186: for (bp = builtins; bp->ourname; bp++) {
187: if (stat(bp->extname, &st) < 0)
188: continue;
189: if (bp->mtime == 0)
190: bp->mtime = st.st_mtime;
191: if (bp->mtime < st.st_mtime) {
192: bp->mtime = st.st_mtime;
193: new = 1;
194: }
195: }
196: if (stat(pfile, &st) >= 0) {
197: if (ptime == 0)
198: ptime = st.st_mtime;
199: if (ptime < st.st_mtime) {
200: ptime = st.st_mtime;
201: new = 1;
202: }
203: }
204: if (stat(mfile, &st) >= 0) {
205: if (mtime == 0)
206: mtime = st.st_mtime;
207: if (mtime < st.st_mtime) {
208: mtime = st.st_mtime;
209: new = 1;
210: }
211: }
212: return (new);
213: }
214:
215: /*
216: * free a sub-tree
217: */
218: freetree(f)
219: register File *f;
220: {
221: register int i;
222: register File *nf;
223:
224: if (!isdir(f))
225: return;
226: for (i = 0; i < f->nfiles; i++) {
227: nf = f->dir[i].file;
228: if (nf == f /* probably "." */
229: || strcmp(f->dir[i].name, "..") == 0) {
230: nf->nlinks--;
231: continue;
232: }
233: if (isdir(nf))
234: freetree(nf);
235: if (--nf->nlinks > 0)
236: continue;
237: if (nf->data)
238: free(nf->data);
239: if (nf->dir)
240: free((char *)nf->dir);
241: ffree(nf);
242: }
243: if (f->data)
244: free(f->data);
245: f->data = NULL;
246: f->nfiles = 0; /* (but still allocated) */
247: }
248:
249: /*
250: * make a new file
251: */
252:
253: File *
254: newfile()
255: {
256: register File *f;
257:
258: f = falloc();
259: f->nlinks = 0; /* no entries yet */
260: f->ino = nextino++;
261: f->data = NULL;
262: f->dir = NULL;
263: return (f);
264: }
265:
266: /*
267: * init a directory:
268: * set up . and ..
269: */
270:
271: initdir(f, parent)
272: register File *f;
273: File *parent;
274: {
275: extern long time();
276:
277: if (f->dir == NULL) {
278: f->dir = (Dirent *)emalloc(DIRINIT*sizeof(Dirent));
279: f->nalloc = DIRINIT;
280: } else if (f->nalloc < 2)
281: panic("init badly formed dir\n");
282: if (f->data) {
283: free(f->data);
284: f->data = NULL;
285: }
286: f->nfiles = 2;
287: strcpy(f->dir[0].name, ".");
288: f->dir[0].file = f;
289: f->nlinks++;
290: strcpy(f->dir[1].name, "..");
291: f->dir[1].file = parent;
292: parent->nlinks++;
293: f->tc = time((long *)0);
294: f->ta = f->tc;
295: f->tm = f->tc;
296: }
297:
298: /*
299: * look up an entry in a directory
300: */
301:
302: File *
303: lookent(f, name)
304: File *f;
305: register char *name;
306: {
307: register Dirent *d;
308: register int i, cmp, u, l;
309:
310: if (!isdir(f))
311: return (NULL);
312: d = f->dir;
313: u = f->nfiles; /* first entry known to be too big */
314: l = 0; /* first entry known to be big enough */
315: while (u > l) {
316: i = (u + l)/2;
317: if ((cmp = name[0] - d[i].name[0]) == 0
318: && (cmp = strcmp(name, d[i].name)) == 0)
319: return (d[i].file);
320: else if (cmp < 0)
321: u = i;
322: else
323: l = i + 1;
324: }
325: return (NULL);
326: }
327:
328: /*
329: * enter newf in f with the given name
330: * if it is a new entry, return NULL
331: * if f already had name, return the old one, leave it in place
332: */
333:
334: File *
335: enterfile(f, name, newf)
336: File *f;
337: register char *name;
338: File *newf;
339: {
340: register Dirent *d;
341: register int i, cmp, u, l;
342:
343: if (!isdir(f))
344: panic("enter non-dir\n");
345: if (f->nalloc <= f->nfiles) { /* need more room */
346: f->nalloc += DIRCHUNK;
347: f->dir = (Dirent *)erealloc((char *)f->dir, f->nalloc*sizeof(Dirent));
348: }
349: d = f->dir;
350: u = f->nfiles; /* first entry known to be too big */
351: l = 0; /* first entry known to be big enough */
352: while (u > l) {
353: i = (u + l)/2;
354: if ((cmp = name[0] - d[i].name[0]) == 0
355: && (cmp = strcmp(name, d[i].name)) == 0)
356: return (d[i].file); /* unexpected */
357: else if (cmp < 0)
358: u = i;
359: else
360: l = i + 1;
361: }
362: /*
363: * not found; d[u] is too big
364: * insert before d[u]
365: */
366: for (i = f->nfiles; i > u; i--)
367: d[i] = d[i-1];
368: strncpy(d[i].name, name, DIRNSIZE);
369: d[i].file = newf;
370: f->nfiles++;
371: newf->nlinks++;
372: if (f->data) { /* invalid now */
373: free(f->data);
374: f->data = NULL;
375: }
376: return (NULL);
377: }
378:
379: /*
380: * look up a full pathname
381: */
382:
383: File *
384: lookfile(path)
385: register char *path;
386: {
387: File *f;
388: register char *sl;
389:
390: f = root;
391: for (;;) {
392: while (*path == '/')
393: path++;
394: if (*path == 0)
395: return (f);
396: if ((sl = strchr(path, '/')) != NULL)
397: *sl = 0; /* cheap hack */
398: f = lookent(f, path);
399: if (sl)
400: *sl = '/'; /* cheap hack returns */
401: if (f == NULL)
402: return (NULL);
403: if (sl == NULL)
404: return (f); /* no more slashes, so we're done */
405: path = sl + 1;
406: }
407: }
408:
409: /*
410: * link each entry from f to uf,
411: * fussing about duplicates
412: * --the string arguments are just for the log message
413: */
414:
415: uniondir(f, uf, mfile, dir, ref)
416: File *f, *uf;
417: char *mfile, *dir, *ref;
418: {
419: register int i;
420: register Dirent *dp;
421: register File *ef;
422:
423: dp = f->dir;
424: for (i = 0; i < f->nfiles; dp++, i++) {
425: if (dp->name[0] == '.'
426: && (strcmp(dp->name, ".") == 0 || strcmp(dp->name, "..") == 0))
427: continue;
428: if ((ef = enterfile(uf, dp->name, dp->file)) != NULL
429: && ef != dp->file) /* same file already there */
430: log("%s: %s=%s: file %s duplicate\n",
431: mfile, dir, ref, dp->name);
432: }
433: }
434:
435: /*
436: * copy directory entries from the outside
437: * to one of ours
438: * save many calls to enterfile, and many searches
439: * for files that don't exist, by building the directory
440: * here and sorting it
441: */
442:
443: static int
444: dircmp(a, b)
445: char *a, *b;
446: {
447: return (strncmp(((Dirent *)a)->name, ((Dirent *)b)->name, DIRNSIZE));
448: }
449:
450: filldir(f, realdir)
451: register File *f;
452: char *realdir;
453: {
454: DIR *fp;
455: register struct dirent *dp;
456: register Dirent *idp;
457: File *nf;
458: int rdlen;
459:
460: if ((fp = opendir(realdir)) == NULL) {
461: log("%s: can't opendir\n", realdir);
462: return;
463: }
464: rdlen = strlen(realdir);
465: idp = &f->dir[f->nfiles];
466: while ((dp = readdir(fp)) != NULL) {
467: if (dp->d_name[0] == '.'
468: && (strcmp(dp->d_name, ".") == 0 || strcmp(dp->d_name, "..") == 0))
469: continue;
470: nf = newfile();
471: if (f->nalloc <= f->nfiles) {
472: f->nalloc += DIRCHUNK;
473: f->dir = (Dirent *)erealloc((char *)f->dir, f->nalloc*sizeof(Dirent));
474: idp = &f->dir[f->nfiles]; /* realloc may move it */
475: }
476: strncpy(idp->name, dp->d_name, DIRNSIZE);
477: idp->file = nf;
478: idp++;
479: f->nfiles++;
480: nf->nlinks++;
481: nf->data = emalloc(rdlen+1+strlen(dp->d_name)+1);
482: strcpy(nf->data, realdir);
483: nf->data[rdlen] = '/';
484: strcpy(nf->data+rdlen+1, dp->d_name);
485: }
486: closedir(fp);
487: qsort((char *)f->dir, f->nfiles, sizeof(Dirent), dircmp);
488: }
489:
490: /*
491: * set up directory data to be sent to client
492: */
493: dirdata(f)
494: register File *f;
495: {
496: register int i;
497: register unsigned char *p;
498:
499: if (!isdir(f))
500: panic("dirdata not dir\n");
501: f->size = f->nfiles * FDLEN;
502: f->data = emalloc((int)f->size);
503: p = (unsigned char *)f->data;
504: for (i = 0; i < f->nfiles; i++) {
505: tofshort(p, FD_INO, f->dir[i].file->ino);
506: strncpy(p + FD_NAME, f->dir[i].name, FDLEN - FD_NAME);
507: p += FDLEN;
508: }
509: }
510:
511: /*
512: * manage storage for Files;
513: * cheap hack for speed, to cut malloc calls
514: * keep a free list of Files, linked on f->data
515: */
516:
517: static File *fflist;
518: #define FILECHUNK 100
519:
520: File *
521: falloc()
522: {
523: register File *f;
524: register int i;
525:
526: if ((f = fflist) != NULL) {
527: fflist = (File *)f->data;
528: return (f);
529: }
530: f = (File *)emalloc(FILECHUNK*sizeof(File));
531: for (i = 0; i < FILECHUNK-1; f++, i++) {
532: f->data = (char *)fflist;
533: fflist = f;
534: }
535: return (f);
536: }
537:
538: ffree(f)
539: File *f;
540: {
541: f->data = (char *)fflist;
542: fflist = f;
543: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.