![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to exrecover.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / ex|
Return to exrecover.c CVS log | Up to [Research Unix] / researchv10dc / cmd / ex |
1.1 root 1: /* Copyright (c) 1981 Regents of the University of California */
2: static char *sccsid = "@(#)exrecover.c 7.4 10/16/81";
3: #include <stdio.h> /* mjm: BUFSIZ: stdio = 512, VMUNIX = 1024 */
4: #undef BUFSIZ /* mjm: BUFSIZ different */
5: #undef EOF /* mjm: EOF and NULL effectively the same */
6: #undef NULL
7:
8: #include "ex.h"
9: #include "ex_temp.h"
10: #include "ex_tty.h"
11: #include "local/uparm.h"
12: #include "sys/dir.h"
13:
14: char xstr[1]; /* make loader happy */
15: short tfile = -1; /* ditto */
16:
17: /*
18: *
19: * This program searches through the specified directory and then
20: * the directory usrpath(preserve) looking for an instance of the specified
21: * file from a crashed editor or a crashed system.
22: * If this file is found, it is unscrambled and written to
23: * the standard output.
24: *
25: * If this program terminates without a "broken pipe" diagnostic
26: * (i.e. the editor doesn't die right away) then the buffer we are
27: * writing from is removed when we finish. This is potentially a mistake
28: * as there is not enough handshaking to guarantee that the file has actually
29: * been recovered, but should suffice for most cases.
30: */
31:
32: /*
33: * For lint's sake...
34: */
35: #ifndef lint
36: #define ignorl(a) a
37: #endif
38:
39: /*
40: * This directory definition also appears (obviously) in expreserve.c.
41: * Change both if you change either.
42: */
43: char mydir[] = usrpath(preserve);
44:
45: /*
46: * Limit on the number of printed entries
47: * when an, e.g. ``ex -r'' command is given.
48: */
49: #define NENTRY 50
50:
51: char *ctime();
52: char nb[BUFSIZ];
53: int vercnt; /* Count number of versions of file found */
54:
55: main(argc, argv)
56: int argc;
57: char *argv[];
58: {
59: register char *cp;
60: register int b, i;
61:
62: /*
63: * Initialize as though the editor had just started.
64: */
65: fendcore = (line *) sbrk(0);
66: dot = zero = dol = fendcore;
67: one = zero + 1;
68: endcore = fendcore - 2;
69: iblock = oblock = -1;
70:
71: /*
72: * If given only a -r argument, then list the saved files.
73: */
74: if (argc == 2 && eq(argv[1], "-r")) {
75: listfiles(mydir);
76: exit(0);
77: }
78: if (argc != 3)
79: error(" Wrong number of arguments to exrecover", 0);
80:
81: CP(file, argv[2]);
82:
83: /*
84: * Search for this file.
85: */
86: findtmp(argv[1]);
87:
88: /*
89: * Got (one of the versions of) it, write it back to the editor.
90: */
91: cp = ctime(&H.Time);
92: cp[19] = 0;
93: fprintf(stderr, " [Dated: %s", cp);
94: fprintf(stderr, vercnt > 1 ? ", newest of %d saved]" : "]", vercnt);
95: H.Flines++;
96:
97: /*
98: * Allocate space for the line pointers from the temp file.
99: */
100: if ((int) sbrk((int) (H.Flines * sizeof (line))) == -1)
101: /*
102: * Good grief.
103: */
104: error(" Not enough core for lines", 0);
105: #ifdef DEBUG
106: fprintf(stderr, "%d lines\n", H.Flines);
107: #endif
108:
109: /*
110: * Now go get the blocks of seek pointers which are scattered
111: * throughout the temp file, reconstructing the incore
112: * line pointers at point of crash.
113: */
114: b = 0;
115: while (H.Flines > 0) {
116: ignorl(lseek(tfile, (long) blocks[b] * BUFSIZ, 0));
117: i = H.Flines < BUFSIZ / sizeof (line) ?
118: H.Flines * sizeof (line) : BUFSIZ;
119: if (read(tfile, (char *) dot, i) != i) {
120: perror(nb);
121: exit(1);
122: }
123: dot += i / sizeof (line);
124: H.Flines -= i / sizeof (line);
125: b++;
126: }
127: dot--; dol = dot;
128:
129: /*
130: * Sigh... due to sandbagging some lines may really not be there.
131: * Find and discard such. This shouldn't happen much.
132: */
133: scrapbad();
134:
135: /*
136: * Now if there were any lines in the recovered file
137: * write them to the standard output.
138: */
139: if (dol > zero) {
140: addr1 = one; addr2 = dol; io = 1;
141: putfile(0);
142: }
143:
144: /*
145: * Trash the saved buffer.
146: * Hopefully the system won't crash before the editor
147: * syncs the new recovered buffer; i.e. for an instant here
148: * you may lose if the system crashes because this file
149: * is gone, but the editor hasn't completed reading the recovered
150: * file from the pipe from us to it.
151: *
152: * This doesn't work if we are coming from an non-absolute path
153: * name since we may have chdir'ed but what the hay, noone really
154: * ever edits with temporaries in "." anyways.
155: */
156: if (nb[0] == '/')
157: ignore(unlink(nb));
158:
159: /*
160: * Adieu.
161: */
162: exit(0);
163: }
164:
165: /*
166: * Print an error message (notably not in error
167: * message file). If terminal is in RAW mode, then
168: * we should be writing output for "vi", so don't print
169: * a newline which would screw up the screen.
170: */
171: /*VARARGS2*/
172: error(str, inf)
173: char *str;
174: int inf;
175: {
176:
177: fprintf(stderr, str, inf);
178: #ifndef USG3TTY
179: ioctl(2, TIOCGETP, &tty);
180: if ((tty.sg_flags & RAW) == 0)
181: #else
182: ioctl(2, TCGETA, &tty);
183: if (tty.c_lflag & ICANON)
184: #endif
185: fprintf(stderr, "\n");
186: exit(1);
187: }
188:
189: /*
190: * Here we save the information about files, when
191: * you ask us what files we have saved for you.
192: * We buffer file name, number of lines, and the time
193: * at which the file was saved.
194: */
195: struct svfile {
196: char sf_name[FNSIZE + 1];
197: int sf_lines;
198: char sf_entry[DIRSIZ + 1];
199: time_t sf_time;
200: };
201:
202: listfiles(dirname)
203: char *dirname;
204: {
205: register FILE *dir;
206: struct direct dirent;
207: int ecount, qucmp();
208: register int f;
209: char *cp;
210: struct svfile *fp, svbuf[NENTRY];
211:
212: /*
213: * Open usrpath(preserve), and go there to make things quick.
214: */
215: dir = fopen(dirname, "r");
216: if (dir == NULL) {
217: perror(dirname);
218: return;
219: }
220: if (chdir(dirname) < 0) {
221: perror(dirname);
222: return;
223: }
224:
225: /*
226: * Look at the candidate files in usrpath(preserve).
227: */
228: fp = &svbuf[0];
229: ecount = 0;
230: while (fread((char *) &dirent, sizeof dirent, 1, dir) == 1) {
231: if (dirent.d_ino == 0)
232: continue;
233: if (dirent.d_name[0] != 'E')
234: continue;
235: #ifdef DEBUG
236: fprintf(stderr, "considering %s\n", dirent.d_name);
237: #endif
238: /*
239: * Name begins with E; open it and
240: * make sure the uid in the header is our uid.
241: * If not, then don't bother with this file, it can't
242: * be ours.
243: */
244: f = open(dirent.d_name, 0);
245: if (f < 0) {
246: #ifdef DEBUG
247: fprintf(stderr, "open failed\n");
248: #endif
249: continue;
250: }
251: if (read(f, (char *) &H, sizeof H) != sizeof H) {
252: #ifdef DEBUG
253: fprintf(stderr, "culdnt read hedr\n");
254: #endif
255: ignore(close(f));
256: continue;
257: }
258: ignore(close(f));
259: if (getuid() != H.Uid) {
260: #ifdef DEBUG
261: fprintf(stderr, "uid wrong\n");
262: #endif
263: continue;
264: }
265:
266: /*
267: * Saved the day!
268: */
269: enter(fp++, dirent.d_name, ecount);
270: ecount++;
271: #ifdef DEBUG
272: fprintf(stderr, "entered file %s\n", dirent.d_name);
273: #endif
274: }
275: ignore(fclose(dir));
276:
277: /*
278: * If any files were saved, then sort them and print
279: * them out.
280: */
281: if (ecount == 0) {
282: fprintf(stderr, "No files saved.\n");
283: return;
284: }
285: qsort(&svbuf[0], ecount, sizeof svbuf[0], qucmp);
286: for (fp = &svbuf[0]; fp < &svbuf[ecount]; fp++) {
287: cp = ctime(&fp->sf_time);
288: cp[10] = 0;
289: fprintf(stderr, "On %s at ", cp);
290: cp[16] = 0;
291: fprintf(stderr, &cp[11]);
292: fprintf(stderr, " saved %d lines of file \"%s\"\n",
293: fp->sf_lines, fp->sf_name);
294: }
295: }
296:
297: /*
298: * Enter a new file into the saved file information.
299: */
300: enter(fp, fname, count)
301: struct svfile *fp;
302: char *fname;
303: {
304: register char *cp, *cp2;
305: register struct svfile *f, *fl;
306: time_t curtime, itol();
307:
308: f = 0;
309: if (count >= NENTRY) {
310: /*
311: * My god, a huge number of saved files.
312: * Would you work on a system that crashed this
313: * often? Hope not. So lets trash the oldest
314: * as the most useless.
315: *
316: * (I wonder if this code has ever run?)
317: */
318: fl = fp - count + NENTRY - 1;
319: curtime = fl->sf_time;
320: for (f = fl; --f > fp-count; )
321: if (f->sf_time < curtime)
322: curtime = f->sf_time;
323: for (f = fl; --f > fp-count; )
324: if (f->sf_time == curtime)
325: break;
326: fp = f;
327: }
328:
329: /*
330: * Gotcha.
331: */
332: fp->sf_time = H.Time;
333: fp->sf_lines = H.Flines;
334: for (cp2 = fp->sf_name, cp = savedfile; *cp;)
335: *cp2++ = *cp++;
336: for (cp2 = fp->sf_entry, cp = fname; *cp && cp-fname < 14;)
337: *cp2++ = *cp++;
338: *cp2++ = 0;
339: }
340:
341: /*
342: * Do the qsort compare to sort the entries first by file name,
343: * then by modify time.
344: */
345: qucmp(p1, p2)
346: struct svfile *p1, *p2;
347: {
348: register int t;
349:
350: if (t = strcmp(p1->sf_name, p2->sf_name))
351: return(t);
352: if (p1->sf_time > p2->sf_time)
353: return(-1);
354: return(p1->sf_time < p2->sf_time);
355: }
356:
357: /*
358: * Scratch for search.
359: */
360: char bestnb[BUFSIZ]; /* Name of the best one */
361: long besttime; /* Time at which the best file was saved */
362: int bestfd; /* Keep best file open so it dont vanish */
363:
364: /*
365: * Look for a file, both in the users directory option value
366: * (i.e. usually /tmp) and in usrpath(preserve).
367: * Want to find the newest so we search on and on.
368: */
369: findtmp(dir)
370: char *dir;
371: {
372:
373: /*
374: * No name or file so far.
375: */
376: bestnb[0] = 0;
377: bestfd = -1;
378:
379: /*
380: * Search usrpath(preserve) and, if we can get there, /tmp
381: * (actually the users "directory" option).
382: */
383: searchdir(dir);
384: if (chdir(mydir) == 0)
385: searchdir(mydir);
386: if (bestfd != -1) {
387: /*
388: * Gotcha.
389: * Put the file (which is already open) in the file
390: * used by the temp file routines, and save its
391: * name for later unlinking.
392: */
393: tfile = bestfd;
394: CP(nb, bestnb);
395: ignorl(lseek(tfile, 0l, 0));
396:
397: /*
398: * Gotta be able to read the header or fall through
399: * to lossage.
400: */
401: if (read(tfile, (char *) &H, sizeof H) == sizeof H)
402: return;
403: }
404:
405: /*
406: * Extreme lossage...
407: */
408: error(" File not found", 0);
409: }
410:
411: /*
412: * Search for the file in directory dirname.
413: *
414: * Don't chdir here, because the users directory
415: * may be ".", and we would move away before we searched it.
416: * Note that we actually chdir elsewhere (because it is too slow
417: * to look around in usrpath(preserve) without chdir'ing there) so we
418: * can't win, because we don't know the name of '.' and if the path
419: * name of the file we want to unlink is relative, rather than absolute
420: * we won't be able to find it again.
421: */
422: searchdir(dirname)
423: char *dirname;
424: {
425: struct direct dirent;
426: register FILE *dir;
427: char dbuf[BUFSIZ];
428:
429: dir = fopen(dirname, "r");
430: if (dir == NULL)
431: return;
432: /* setbuf(dir, dbuf); this breaks UNIX/370. */
433: while (fread((char *) &dirent, sizeof dirent, 1, dir) == 1) {
434: if (dirent.d_ino == 0)
435: continue;
436: if (dirent.d_name[0] != 'E' || dirent.d_name[DIRSIZ - 1] != 0)
437: continue;
438: /*
439: * Got a file in the directory starting with E...
440: * Save a consed up name for the file to unlink
441: * later, and check that this is really a file
442: * we are looking for.
443: */
444: ignore(strcat(strcat(strcpy(nb, dirname), "/"), dirent.d_name));
445: if (yeah(nb)) {
446: /*
447: * Well, it is the file we are looking for.
448: * Is it more recent than any version we found before?
449: */
450: if (H.Time > besttime) {
451: /*
452: * A winner.
453: */
454: ignore(close(bestfd));
455: bestfd = dup(tfile);
456: besttime = H.Time;
457: CP(bestnb, nb);
458: }
459: /*
460: * Count versions so user can be told there are
461: * ``yet more pages to be turned''.
462: */
463: vercnt++;
464: }
465: ignore(close(tfile));
466: }
467: ignore(fclose(dir));
468: }
469:
470: /*
471: * Given a candidate file to be recovered, see
472: * if its really an editor temporary and of this
473: * user and the file specified.
474: */
475: yeah(name)
476: char *name;
477: {
478:
479: tfile = open(name, 2);
480: if (tfile < 0)
481: return (0);
482: if (read(tfile, (char *) &H, sizeof H) != sizeof H) {
483: nope:
484: ignore(close(tfile));
485: return (0);
486: }
487: if (!eq(savedfile, file))
488: goto nope;
489: if (getuid() != H.Uid)
490: goto nope;
491: /*
492: * This is old and stupid code, which
493: * puts a word LOST in the header block, so that lost lines
494: * can be made to point at it.
495: */
496: ignorl(lseek(tfile, (long)(BUFSIZ*HBLKS-8), 0));
497: ignore(write(tfile, "LOST", 5));
498: return (1);
499: }
500:
501: preserve()
502: {
503:
504: }
505:
506: /*
507: * Find the true end of the scratch file, and ``LOSE''
508: * lines which point into thin air. This lossage occurs
509: * due to the sandbagging of i/o which can cause blocks to
510: * be written in a non-obvious order, different from the order
511: * in which the editor tried to write them.
512: *
513: * Lines which are lost are replaced with the text LOST so
514: * they are easy to find. We work hard at pretty formatting here
515: * as lines tend to be lost in blocks.
516: *
517: * This only seems to happen on very heavily loaded systems, and
518: * not very often.
519: */
520: scrapbad()
521: {
522: register line *ip;
523: struct stat stbuf;
524: off_t size, maxt;
525: int bno, cnt, bad, was;
526: char bk[BUFSIZ];
527:
528: ignore(fstat(tfile, &stbuf));
529: size = stbuf.st_size;
530: maxt = (size >> SHFT) | (BNDRY-1);
531: bno = (maxt >> OFFBTS) & BLKMSK;
532: #ifdef DEBUG
533: fprintf(stderr, "size %ld, maxt %o, bno %d\n", size, maxt, bno);
534: #endif
535:
536: /*
537: * Look for a null separating two lines in the temp file;
538: * if last line was split across blocks, then it is lost
539: * if the last block is.
540: */
541: while (bno > 0) {
542: ignorl(lseek(tfile, (long) BUFSIZ * bno, 0));
543: cnt = read(tfile, (char *) bk, BUFSIZ);
544: while (cnt > 0)
545: if (bk[--cnt] == 0)
546: goto null;
547: bno--;
548: }
549: null:
550:
551: /*
552: * Magically calculate the largest valid pointer in the temp file,
553: * consing it up from the block number and the count.
554: */
555: maxt = ((bno << OFFBTS) | (cnt >> SHFT)) & ~1;
556: #ifdef DEBUG
557: fprintf(stderr, "bno %d, cnt %d, maxt %o\n", bno, cnt, maxt);
558: #endif
559:
560: /*
561: * Now cycle through the line pointers,
562: * trashing the Lusers.
563: */
564: was = bad = 0;
565: for (ip = one; ip <= dol; ip++)
566: if (*ip > maxt) {
567: #ifdef DEBUG
568: fprintf(stderr, "%d bad, %o > %o\n", ip - zero, *ip, maxt);
569: #endif
570: if (was == 0)
571: was = ip - zero;
572: *ip = ((HBLKS*BUFSIZ)-8) >> SHFT;
573: } else if (was) {
574: if (bad == 0)
575: fprintf(stderr, " [Lost line(s):");
576: fprintf(stderr, " %d", was);
577: if ((ip - 1) - zero > was)
578: fprintf(stderr, "-%d", (ip - 1) - zero);
579: bad++;
580: was = 0;
581: }
582: if (was != 0) {
583: if (bad == 0)
584: fprintf(stderr, " [Lost line(s):");
585: fprintf(stderr, " %d", was);
586: if (dol - zero != was)
587: fprintf(stderr, "-%d", dol - zero);
588: bad++;
589: }
590: if (bad)
591: fprintf(stderr, "]");
592: }
593:
594: /*
595: * Aw shucks, if we only had a (void) cast.
596: */
597: #ifdef lint
598: Ignorl(a)
599: long a;
600: {
601:
602: a = a;
603: }
604:
605: Ignore(a)
606: char *a;
607: {
608:
609: a = a;
610: }
611:
612: Ignorf(a)
613: int (*a)();
614: {
615:
616: a = a;
617: }
618:
619: ignorl(a)
620: long a;
621: {
622:
623: a = a;
624: }
625: #endif
626:
627: int cntch, cntln, cntodd, cntnull;
628: /*
629: * Following routines stolen mercilessly from ex.
630: */
631: putfile()
632: {
633: line *a1;
634: register char *fp, *lp;
635: register int nib;
636:
637: a1 = addr1;
638: clrstats();
639: cntln = addr2 - a1 + 1;
640: if (cntln == 0)
641: return;
642: nib = BUFSIZ;
643: fp = genbuf;
644: do {
645: getline(*a1++);
646: lp = linebuf;
647: for (;;) {
648: if (--nib < 0) {
649: nib = fp - genbuf;
650: if (write(io, genbuf, nib) != nib)
651: wrerror();
652: cntch += nib;
653: nib = 511;
654: fp = genbuf;
655: }
656: if ((*fp++ = *lp++) == 0) {
657: fp[-1] = '\n';
658: break;
659: }
660: }
661: } while (a1 <= addr2);
662: nib = fp - genbuf;
663: if (write(io, genbuf, nib) != nib)
664: wrerror();
665: cntch += nib;
666: }
667:
668: wrerror()
669: {
670:
671: syserror();
672: }
673:
674: clrstats()
675: {
676:
677: ninbuf = 0;
678: cntch = 0;
679: cntln = 0;
680: cntnull = 0;
681: cntodd = 0;
682: }
683:
684: #define READ 0
685: #define WRITE 1
686:
687: getline(tl)
688: line tl;
689: {
690: register char *bp, *lp;
691: register int nl;
692:
693: lp = linebuf;
694: bp = getblock(tl, READ);
695: nl = nleft;
696: tl &= ~OFFMSK;
697: while (*lp++ = *bp++)
698: if (--nl == 0) {
699: bp = getblock(tl += INCRMT, READ);
700: nl = nleft;
701: }
702: }
703:
704: int read();
705: int write();
706:
707: char *
708: getblock(atl, iof)
709: line atl;
710: int iof;
711: {
712: register int bno, off;
713:
714: bno = (atl >> OFFBTS) & BLKMSK;
715: off = (atl << SHFT) & LBTMSK;
716: if (bno >= NMBLKS)
717: error(" Tmp file too large");
718: nleft = BUFSIZ - off;
719: if (bno == iblock) {
720: ichanged |= iof;
721: return (ibuff + off);
722: }
723: if (bno == oblock)
724: return (obuff + off);
725: if (iof == READ) {
726: if (ichanged)
727: blkio(iblock, ibuff, write);
728: ichanged = 0;
729: iblock = bno;
730: blkio(bno, ibuff, read);
731: return (ibuff + off);
732: }
733: if (oblock >= 0)
734: blkio(oblock, obuff, write);
735: oblock = bno;
736: return (obuff + off);
737: }
738:
739: blkio(b, buf, iofcn)
740: short b;
741: char *buf;
742: int (*iofcn)();
743: {
744:
745: lseek(tfile, (long) (unsigned) b * BUFSIZ, 0);
746: if ((*iofcn)(tfile, buf, BUFSIZ) != BUFSIZ)
747: syserror();
748: }
749:
750: syserror()
751: {
752: extern int sys_nerr;
753: extern char *sys_errlist[];
754:
755: dirtcnt = 0;
756: write(2, " ", 1);
757: if (errno >= 0 && errno <= sys_nerr)
758: error(sys_errlist[errno]);
759: else
760: error("System error %d", errno);
761: exit(1);
762: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.