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