![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to funcs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / netfs / libnetb|
Return to funcs.c CVS log | Up to [Research Unix] / researchv10no / netfs / libnetb |
1.1 root 1: #include "netb.h"
2: #include "nberrno.h"
3: #include "rf.h"
4: #include "tag.h"
5:
6: #define NULL 0
7: extern char *strchr();
8: extern int defaultuid, defaultgid;
9: extern int cuid, cgid;
10:
11: #define ARB 4096
12:
13: /*
14: * netb-to-local service translation
15: */
16:
17: static long timeoff;
18: static timecheck();
19: static Rfile *root; /* should this be a global? */
20: static int nberrno;
21:
22: /*
23: * magic knowledge: fserrno and nberrno codes are the same
24: */
25: #define fstonberr(e) (e)
26:
27: /*
28: * compatibility with old clients
29: * that don't generate NBROOTTAG
30: */
31: static Tag oldrtag;
32: static int oldrdev;
33: #define OLDRINO 2L
34: static int oldclient; /* it used oldrtag */
35: static int sawroot;
36:
37: static Rfile *getfile();
38: static putmode();
39:
40: /*
41: * make a tag from a file
42: * the root is an exception; it has NBROOTTAG, always
43: * 0x80000000 is a temporary protection against confusion with oldrtag
44: */
45: #define maketag(f) (0x80000000|((f)->dev<<16)|((f)->ino&0xffff))
46:
47: /*
48: * file modes
49: * not specified in netb.h,
50: * but they are the same as V7 Unix
51: */
52:
53: #define NB_IFMT 0170000 /* file type */
54: #define NB_IFDIR 0040000 /* directory */
55: #define NB_IFREG 0100000 /* regular file */
56: #define NB_PERM 07777 /* permissions */
57:
58: #define fstonbmode(m) (m) /* other modes (assumed) same as rf */
59: #define nbtofsmode(m) ((m)&07777) /* modes that may be set */
60:
61: long time();
62:
63: /*
64: * init things;
65: * called before the connection is fully open
66: * mainly, set up the root
67: */
68:
69: int
70: _rfinit(argc, argv)
71: int argc;
72: char **argv;
73: {
74:
75: if ((root = fsinit(argc, argv)) == NULL) {
76: rflog("init failed\n");
77: return (0);
78: }
79: if (_rfnewtag((Tag)NBROOTTAG, root) != root) {
80: rflog("can't install root\n");
81: return (0);
82: }
83: return (1);
84: }
85:
86: /*
87: * namei
88: *
89: * hand the pathname to fswalk, a piece at a time
90: * on reaching the end, do the operation implied by SNB_FLAGS
91: * fswalk might return an Rfile that is already in our table;
92: * keep the older one.
93: * -- be careful when calling fsdone on intermediate directories
94: * in the path; they might be in use in some other way, and
95: * fsdone will wreak havoc.
96: * dirintab is there so _rfdone needn't be called every time,
97: * especially for directories we know are already in the table
98: */
99:
100: _rfnamei(fd, sp, len)
101: int fd;
102: unsigned char *sp;
103: int len;
104: {
105: unsigned char rbuf[RNMSIZE];
106: register unsigned char *pp;
107: register Rfile *f, *df;
108: Rfile *lnf;
109: int dirintab;
110: register char *cp, *ep;
111: Tag t;
112: int cruid, crgid, crmode;
113: long tm;
114:
115: nberrno = 0;
116: tonetchar(rbuf, RNB_FLAGS, 0);
117: pp = sp;
118: if (len < SNMSIZE)
119: rfpanic("namei: len %d\n", len);
120: pp[len] = 0; /* guarantee null at end of name */
121: cp = (char *)pp + SNMSIZE;
122: while (*cp == '/')
123: cp++;
124: dirintab = 1;
125: if ((df = getfile(&pp[SNB_TAG])) == NULL) {
126: nberrno = NBEINVAL;
127: goto out;
128: }
129: while ((ep = strchr(cp, '/')) != NULL) {
130: *ep++ = 0;
131: while (*ep == '/')
132: ep++;
133: if (df->type != RFTDIR) {
134: nberrno = NBENOENT;
135: goto out;
136: }
137: if (_rfpdsearch(df, rfuid, rfgid) == NULL) {
138: nberrno = NBEACCES;
139: goto out;
140: }
141: if ((f = fswalk(df, cp)) == NULL)
142: goto eout;
143: if (f != df && dirintab == 0)
144: fsdone(df);
145: if (f->ino == root->ino && f->dev == root->dev) {
146: if (f != root)
147: fsdone(f);
148: df = root;
149: dirintab = 1;
150: } else if ((df = _rftagtof(maketag(f))) != NULL) {
151: fsdone(f);
152: dirintab = 1;
153: } else {
154: df = f;
155: dirintab = 0;
156: }
157: cp = ep;
158: }
159: /*
160: * cp is now last component
161: *
162: * the tests that follow are wrong if the root isn't a directory
163: * think about implications
164: */
165: if (df->type != RFTDIR) {
166: nberrno = NBENOENT;
167: goto out;
168: }
169: if (_rfpdsearch(df, rfuid, rfgid) == 0) {
170: nberrno = NBEACCES;
171: goto out;
172: }
173: switch (frnetchar(pp, SNB_FLAGS)) {
174: case NI_SEARCH:
175: if (cp[0] == 0) { /* empty filename */
176: f = df;
177: fsstat(f); /* get fresh info */
178: break;
179: }
180: if ((f = fswalk(df, cp)) == NULL)
181: goto eout;
182: break;
183:
184: case NI_NXCREAT:
185: case NI_CREAT:
186: cruid = rfuid;
187: if (cruid == RFNOID && defaultuid != RFNOID)
188: cruid = defaultuid;
189: crgid = rfgid;
190: if (crgid == RFNOID && defaultgid != RFNOID)
191: crgid = defaultgid;
192: crmode = frnetshort(pp, SNM_MODE);
193: if ((f = fswalk(df, cp)) == NULL) { /* doesn't exist */
194: if (cruid == RFNOID || crgid == RFNOID /* don't create ownerless files */
195: || _rfpdwrite(df, cruid, crgid) == 0) {
196: nberrno = NBEACCES;
197: goto out;
198: }
199: } else if (frnetchar(pp, SNB_FLAGS) == NI_NXCREAT) {
200: _rfdone(f);
201: nberrno = NBEEXIST; /* NXCREAT means it shouldn't exist */
202: goto out;
203: } else {
204: if (_rfpwrite(f, cruid, crgid) == 0) {
205: _rfdone(f);
206: nberrno = NBEACCES;
207: goto out;
208: }
209: cruid = f->uid;
210: crgid = f->gid;
211: crmode = f->mode;
212: _rfdone(f); /* we'll re-create anyway */
213: }
214: if ((f = fscreate(df, cp, crmode, cruid, crgid)) == NULL)
215: goto eout;
216: break;
217:
218: case NI_LINK:
219: if ((lnf = getfile(&pp[SNM_INO])) == NULL) {
220: nberrno = NBEINVAL;
221: goto out;
222: }
223: #if NOTDEF
224: if (lnf->type == RFTDIR && _rfpsuper(lnf, rfuid, rfgid) == 0) {
225: #else
226: if (lnf->type == RFTDIR) {
227: #endif
228: nberrno = NBEISDIR;
229: goto out;
230: }
231: if (_rfpdwrite(df, rfuid, rfgid) == 0) {
232: nberrno = NBEACCES;
233: goto out;
234: }
235: if (fslink(df, cp, lnf) < 0)
236: goto eout;
237: goto out;
238:
239: case NI_MKDIR:
240: cruid = rfuid;
241: if (cruid == RFNOID && defaultuid != RFNOID)
242: cruid = defaultuid;
243: crgid = rfgid;
244: if (crgid == RFNOID && defaultgid != RFNOID)
245: crgid = defaultgid;
246: if (cruid == RFNOID || crgid == RFNOID
247: || _rfpdwrite(df, cruid, crgid) == 0) {
248: nberrno = NBEACCES;
249: goto out;
250: }
251: if (fsmkdir(df, cp, frnetshort(pp, SNM_MODE), cruid, crgid) < 0)
252: goto eout;
253: goto out;
254:
255: case NI_RMDIR:
256: if (_rfpdwrite(df, rfuid, rfgid) == 0) {
257: nberrno = NBEACCES;
258: goto out;
259: }
260: if (fsrmdir(df, cp) < 0)
261: goto eout;
262: goto out;
263:
264: case NI_DEL:
265: if (_rfpdwrite(df, rfuid, rfgid) == 0) {
266: nberrno = NBEACCES;
267: goto out;
268: }
269: if ((f = fswalk(df, cp)) == NULL)
270: goto eout;
271: #if NOTDEF
272: if (f->type == RFTDIR && _rfpsuper(f, rfuid, rfgid) == 0) {
273: #else
274: if (f->type == RFTDIR) {
275: #endif
276: _rfdone(f);
277: nberrno = NBEISDIR;
278: goto out;
279: }
280: _rfdone(f);
281: if (fsdelete(df, cp) < 0)
282: goto eout;
283: goto out;
284:
285: default:
286: nberrno = NBEINVAL;
287: goto out;
288: }
289: /*
290: * returning a newly-opened file
291: */
292: if (f->dev == root->dev && f->ino == root->ino)
293: t = NBROOTTAG;
294: else
295: t = maketag(f);
296: if ((lnf = _rfnewtag(t, f)) == NULL) {
297: fsdone(f);
298: nberrno = NBEINVAL;
299: goto out;
300: } else if (lnf != f) { /* already had that file */
301: fsdone(f);
302: f = lnf;
303: }
304: if (f == df)
305: dirintab = 1; /* we just made sure of that */
306: pp = rbuf;
307: tonetlong(pp, RNM_TAG, t);
308: tonetlong(pp, RNM_INO, f->ino);
309: tonetshort(pp, RNM_DEV, f->dev);
310: putmode(pp, RNM_MODE, f);
311: tonetshort(pp, RNM_NLINK, f->nlink);
312: /*
313: * the default ownership here might be wrong...check it.
314: */
315: if (defaultuid != RFNOID && rfuid == RFNOID && f->uid == defaultuid)
316: len = cuid; /* tell him he owns it */
317: else
318: len = _rfcuid(f->uid);
319: tonetshort(pp, RNM_UID, len);
320: len = _rfcgid(f->gid); /* stub - this gid processing may be wrong */
321: if (len == RFNOID)
322: len = cgid;
323: tonetshort(pp, RNM_GID, len);
324: tonetshort(pp, RNM_RDEV, f->rdev);
325: #if 0x100000000 == 0 /* 32-bit machine */
326: tonetlong(pp, RNM_SIZE, f->size);
327: #else /* probably the Cray */
328: if ((tm = f->size) > 0x7fffffff)
329: tm = 0x7fffffff;
330: tonetlong(pp, RNM_SIZE, tm);
331: #endif
332: tm = f->ta + timeoff;
333: tonetlong(pp, RNM_ATIME, tm);
334: tm = f->tm + timeoff;
335: tonetlong(pp, RNM_MTIME, tm);
336: tm = f->tc + timeoff;
337: tonetlong(pp, RNM_CTIME, tm);
338: if (oldclient) {
339: len = (f->dev & 0xff) | (oldrdev & 0xff00);
340: tonetshort(pp, RNM_DEV, len);
341: if (f == root) {
342: tonetlong(pp, RNM_TAG, oldrtag);
343: tonetshort(pp, RNM_DEV, oldrdev);
344: tonetlong(pp, RNM_INO, OLDRINO);
345: }
346: }
347: goto out;
348:
349: /*
350: * failed to find a file
351: * if nberrno == 0, popped out of root
352: */
353: eout:
354: if (fserrno)
355: nberrno = fstonberr(fserrno);
356: else {
357: nberrno = 0;
358: tonetchar(rbuf, RNB_FLAGS, NBROOT);
359: while (*cp && *cp != '/')
360: cp++;
361: len = cp - (char *)(sp + SNMSIZE);
362: if (rfdebug)
363: rflog("popped out; used %d\n", len);
364: tonetlong(rbuf, RNM_USED, len);
365: }
366: /*
367: * done
368: */
369: out:
370: if (dirintab == 0)
371: _rfdone(df);
372: tonetshort(rbuf, RNB_ERRNO, nberrno);
373: _rfresp(fd, sp, rbuf, RNMSIZE);
374: }
375:
376: /*
377: * discard f if it is not in the tag table
378: * used by rfnamei to discard files fetched halfway,
379: * e.g. directories in the middle of a path
380: */
381:
382: _rfdone(f)
383: register Rfile *f;
384: {
385:
386: if (f == root)
387: return;
388: if (_rftagtof(maketag(f)) == f)
389: return;
390: fsdone(f);
391: }
392:
393: /*
394: * put
395: */
396:
397: _rfput(fd, sp, len)
398: int fd;
399: register unsigned char *sp;
400: int len;
401: {
402: unsigned char rbuf[RNBSIZE];
403: Tag t;
404: Rfile *f;
405:
406: t = frnetlong(sp, SNB_TAG);
407: if ((f = getfile(&sp[SNB_TAG])) == NULL)
408: nberrno = NBEINVAL;
409: else {
410: _rfdeltag(t);
411: nberrno = 0;
412: fsdone(f);
413: }
414: tonetshort(rbuf, RNB_ERRNO, nberrno);
415: _rfresp(fd, sp, rbuf, RNBSIZE);
416: }
417:
418: /*
419: * stat
420: */
421:
422: _rfstat(fd, sp, len)
423: int fd;
424: unsigned char *sp;
425: int len;
426: {
427: int i;
428: unsigned char rbuf[RSTSIZE];
429: register unsigned char *rp;
430: register Rfile *f;
431: long tm;
432:
433: if (len < SSTSIZE)
434: rfpanic("stat: len %d\n", len);
435: rp = rbuf;
436: if ((f = getfile(&sp[SNB_TAG])) == NULL)
437: nberrno = NBEINVAL;
438: else if (fsstat(f) < 0)
439: nberrno = fstonberr(fserrno);
440: else {
441: nberrno = 0;
442: /* should have hysteresis here */
443: timecheck(frnetlong(sp, SST_TIME));
444: tonetlong(rp, RST_INO, f->ino);
445: tonetshort(rp, RST_DEV, f->dev);
446: putmode(rp, RST_MODE, f);
447: tonetshort(rp, RST_NLINK, f->nlink);
448: if (defaultuid != RFNOID && rfuid == RFNOID && f->uid == defaultuid)
449: i = cuid; /* let the client think he owns it */
450: else
451: i = _rfcuid(f->uid);
452: /*rflog("stat: f->uid=%d defaultuid=%d cuid=%d rfcuid=%d returning %d\n",
453: f->uid, defaultuid, cuid, _rfcuid(f->uid), i);*/
454: tonetshort(rp, RST_UID, i);
455: i = _rfcgid(f->gid); /* stub - default gid processing? */
456: tonetshort(rp, RST_GID, i);
457: #if 0x100000000 == 0 /* 32-bit machine */
458: tonetlong(rp, RST_SIZE, f->size);
459: #else /* probably the Cray */
460: if ((tm = f->size) > 0x7fffffff)
461: tm = 0x7fffffff;
462: tonetlong(rp, RST_SIZE, f->size);
463: #endif
464: tm = f->ta + timeoff;
465: tonetlong(rp, RST_ATIME, tm);
466: tm = f->tm + timeoff;
467: tonetlong(rp, RST_MTIME, tm);
468: tm = f->tc + timeoff;
469: tonetlong(rp, RST_CTIME, tm);
470: }
471: tonetshort(rp, RNB_ERRNO, nberrno);
472: _rfresp(fd, sp, rp, RSTSIZE);
473: }
474:
475: /*
476: * update:
477: * write attributes
478: */
479:
480: _rfupdate(fd, sp, len)
481: int fd;
482: register unsigned char *sp;
483: int len;
484: {
485: unsigned char rbuf[RNBSIZE];
486: static Rfile na;
487: Rfile *f;
488:
489: if (len < SUPSIZE)
490: rfpanic("update: len %d\n", len);
491: if ((f = getfile(&sp[SNB_TAG])) == NULL)
492: nberrno = NBEINVAL;
493: else {
494: na.mode = nbtofsmode(frnetshort(sp, SUP_MODE));
495: na.ta = frnetlong(sp, SUP_ATIME);
496: na.tm = frnetlong(sp, SUP_MTIME);
497: if (na.ta == 0) /* current time: local system did it */
498: na.ta = f->ta;
499: else
500: na.ta -= timeoff;
501: if (na.tm == 0)
502: na.tm = f->tm;
503: else
504: na.tm -= timeoff;
505: na.uid = f->uid; /* netb doesn't supply */
506: na.gid = f->gid;
507: na.size = f->size; /* not set here */
508: if ((na.mode & NB_PERM) != (fstonbmode(f->mode) & NB_PERM)
509: && _rfpowner(f, rfuid, rfgid) == 0)
510: nberrno = NBEPERM;
511: else if (fsupdate(f, &na) < 0)
512: nberrno = fstonberr(fserrno);
513: else
514: nberrno = 0;
515: }
516: tonetshort(rbuf, RNB_ERRNO, nberrno);
517: _rfresp(fd, sp, rbuf, RNBSIZE);
518: }
519:
520: /*
521: * read
522: */
523: _rfread(fd, sp, mlen)
524: int fd;
525: register unsigned char *sp;
526: int mlen;
527: {
528: unsigned char rbuf[RNBSIZE+ARB]; /* should be negotiated size */
529: Rfile *f;
530: int len;
531:
532: if (mlen < SRDSIZE)
533: rfpanic("read: len %d\n", mlen);
534: len = frnetlong(sp, SRD_LEN);
535: tonetchar(rbuf, RNB_FLAGS, 0);
536: if (len <= 0 || (f = getfile(&sp[SNB_TAG])) == NULL) {
537: nberrno = NBEINVAL;
538: len = 0;
539: } else if (_rfpread(f, rfuid, rfgid) == 0) {
540: nberrno = NBEACCES;
541: len = 0;
542: } else {
543: if (len > ARB)
544: len = ARB;
545: len = fsread(f, frnetlong(sp, SRD_OFFSET),
546: (char *)rbuf + RNBSIZE, len);
547: if (len < 0) {
548: nberrno = fstonberr(fserrno);
549: len = 0;
550: } else {
551: nberrno = 0;
552: if (len == 0)
553: tonetchar(rbuf, RNB_FLAGS, NBEND);
554: }
555: }
556: tonetshort(rbuf, RNB_ERRNO, nberrno);
557: len += RNBSIZE;
558: _rfresp(fd, sp, rbuf, len);
559: }
560:
561: /*
562: * read directory
563: */
564: _rfdir(fd, sp, mlen)
565: int fd;
566: register unsigned char *sp;
567: int mlen;
568: {
569: unsigned char rbuf[RDISIZE+ARB];
570: Rfile *f;
571: int len;
572: long noff;
573:
574: if (mlen < SRDSIZE)
575: rfpanic("readdir: len %d\n", mlen);
576: len = frnetlong(sp, SRD_LEN);
577: if (len <= 0 || (f = getfile(&sp[SNB_TAG])) == NULL) {
578: nberrno = NBEINVAL;
579: len = 0;
580: } else if (f->type != RFTDIR) {
581: nberrno = NBENOTDIR;
582: len = 0;
583: } else if (_rfpdread(f, rfuid, rfgid) == 0) {
584: nberrno = NBEACCES;
585: len = 0;
586: } else {
587: if (len > ARB)
588: len = ARB;
589: len = fsdirread(f, frnetlong(sp, SRD_OFFSET),
590: (char *)rbuf + RDISIZE, len, &noff);
591: if (len < 0) {
592: nberrno = fstonberr(fserrno);
593: len = 0;
594: } else {
595: nberrno = 0;
596: noff -= frnetlong(sp, SRD_OFFSET);
597: tonetlong(rbuf, RDI_USED, noff);
598: }
599: }
600: tonetshort(rbuf, RNB_ERRNO, nberrno);
601: len += RDISIZE;
602: _rfresp(fd, sp, rbuf, len);
603: }
604:
605: /*
606: * write
607: * --permissions botch:
608: * if we just check for write permission,
609: * f = creat(name, 0) will leave a file descriptor we can't write
610: * hence the owner check
611: * if the client wants to protect the user better,
612: * it can do its own checks;
613: * here we are concerned with the server
614: */
615: _rfwrite(fd, sp, mlen)
616: int fd;
617: register unsigned char *sp;
618: int mlen;
619: {
620: unsigned char rbuf[RNBSIZE];
621: Rfile *f;
622: int n;
623: long off;
624:
625: n = frnetlong(sp, SWR_LEN);
626: if (mlen != SWRSIZE + n)
627: rfpanic("write: size skew %d\n", mlen);
628: off = frnetlong(sp, SWR_OFFSET);
629: nberrno = 0;
630: if ((f = getfile(&sp[SNB_TAG])) == NULL)
631: nberrno = NBEINVAL;
632: else if (_rfpwrite(f, rfuid, rfgid) == 0
633: && _rfpowner(f, rfuid, rfgid) == 0)
634: nberrno = NBEACCES;
635: else if ((n = fswrite(f, off, (char *)sp + SWRSIZE, n)) < 0)
636: nberrno = fstonberr(fserrno);
637: tonetlong(rbuf, RNB_FSIZE, f->size);
638: tonetshort(rbuf, RNB_ERRNO, nberrno);
639: _rfresp(fd, sp, rbuf, RNBSIZE);
640: }
641:
642: /*
643: * truncate file
644: */
645: _rftrunc(fd, sp, len)
646: int fd;
647: register unsigned char *sp;
648: int len;
649: {
650: unsigned char rbuf[RNBSIZE];
651: register Rfile *f;
652: Rfile newf;
653:
654: nberrno = 0;
655: if ((f = getfile(&sp[SNB_TAG])) == NULL)
656: nberrno = NBEINVAL;
657: else if (_rfpwrite(f, rfuid, rfgid) == 0
658: && _rfpowner(f, rfuid, rfgid) == 0) /* wrong? */
659: nberrno = NBEACCES;
660: else {
661: newf = *f;
662: newf.size = 0;
663: if (fsupdate(f, &newf) < 0)
664: nberrno = fstonberr(fserrno);
665: }
666: tonetlong(rbuf, RNB_ERRNO, nberrno);
667: _rfresp(fd, sp, rbuf, RNBSIZE);
668: }
669:
670: /*
671: * turn SNB_TAG (or some other tag)
672: * into an Rfile
673: */
674:
675: static Rfile *
676: getfile(pp)
677: register unsigned char *pp;
678: {
679: Tag t;
680: Rfile *f;
681:
682: t = frnetlong(pp, 0);
683: if (t == NBROOTTAG || (oldclient && t == oldrtag)) {
684: sawroot = 1;
685: return (root); /* easy */
686: }
687: if ((f = _rftagtof(t)) != NULL)
688: return (f);
689: if (sawroot == 0 && (t & 0xffff) == OLDRINO) { /* old-style root tag? */
690: oldrtag = t;
691: oldrdev = t >> 16;
692: oldclient = 1;
693: rflog("old client; root tag %lx\n", t);
694: sawroot = 1;
695: return (root);
696: }
697: nberrno = NBEINVAL; /* shouldn't happen */
698: rflog("bad tag %lx\n", t);
699: return (NULL);
700: }
701:
702: static
703: putmode(pp, off, f)
704: register unsigned char *pp;
705: int off;
706: register Rfile *f;
707: {
708: int mode;
709:
710: mode = fstonbmode(f->mode);
711: if (f->type == RFTDIR) {
712: mode &= 07777;
713: mode |= NB_IFDIR;
714: } else if ((mode & NB_IFMT) == 0)
715: mode |= NB_IFREG;
716: /* else pass mode through unchanged for now */
717: tonetshort(pp, off, mode);
718: }
719:
720: /*
721: * correct offset twixt client time and ours
722: * only so often, or if difference is large;
723: * e.g. hosts synchronize from a common clock,
724: * but at different times
725: */
726:
727: static
728: timecheck(cltime)
729: long cltime;
730: {
731: static int stall;
732: static long lastck;
733: long ourtime;
734: int diff;
735:
736: if (stall-- != 0) /* only every few stats */
737: return;
738: stall = 3;
739: ourtime = time((long *)0);
740: diff = cltime - ourtime;
741: if (diff == timeoff) {
742: lastck = ourtime;
743: return; /* no change */
744: }
745: if (diff - timeoff < 2 && diff - timeoff > -2 /* modest change */
746: && ourtime - lastck < 90*60) /* and last change was recent */
747: return;
748: lastck = ourtime;
749: rflog("time: client %ld server %ld old diff %d new %d\n",
750: cltime, ourtime, timeoff, diff);
751: timeoff = diff;
752: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.