![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to recover.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove|
Return to recover.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: /* Recovers JOVE files after a system/editor crash.
9: Usage: recover [-d directory] [-syscrash]
10: The -syscrash option is specified in /etc/rc and what it does it
11: move all the jove tmp files from TMP_DIR (/tmp) to REC_DIR (/usr/preserve).
12: recover -syscrash must be invoked in /ect/rc BEFORE /tmp gets cleared out.
13: (about the same place as expreserve gets invoked to save ed/vi/ex files.
14:
15: The -d option lets you specify the directory to search for tmp files when
16: the default isn't the right one.
17:
18: Look in Makefile to change the default directories. */
19:
20: #include <stdio.h> /* Do stdio first so it doesn't override OUR
21: definitions. */
22: #include "jove.h"
23: #include "temp.h"
24: #include "rec.h"
25: #include "rectune.h"
26: #include <signal.h>
27: #include <sys/file.h>
28: #include <sys/stat.h>
29: #include <sys/dir.h>
30: #include <pwd.h>
31: #include <time.h>
32: #ifdef SYSV
33: # include <sys/utsname.h>
34: #endif
35:
36: #ifndef L_SET
37: # define L_SET 0
38: # define L_INCR 1
39: #endif
40:
41: extern char *ctime proto((const time_t *));
42:
43: private char blk_buf[JBUFSIZ];
44: private int nleft;
45: private FILE *ptrs_fp;
46: private int data_fd;
47: private struct rec_head Header;
48: private long Nchars,
49: Nlines;
50: private char tty[] = "/dev/tty";
51: private int UserID,
52: Verbose = 0;
53: private char *Directory = 0; /* the directory we're looking in */
54:
55: private struct file_pair {
56: char *file_data,
57: *file_rec;
58: #define INSPECTED 01
59: int file_flags;
60: struct file_pair *file_next;
61: } *First = 0;
62:
63: private struct rec_entry *buflist[100]; /* system initializes to 0 */
64:
65: #ifndef BSD_DIR
66:
67: typedef struct {
68: int d_fd; /* File descriptor for this directory */
69: } DIR;
70:
71: DIR *
72: opendir(dir)
73: char *dir;
74: {
75: DIR *dp = (DIR *) malloc(sizeof *dp);
76:
77: if ((dp->d_fd = open(dir, 0)) == -1)
78: return NULL;
79: return dp;
80: }
81:
82: closedir(dp)
83: DIR *dp;
84: {
85: (void) close(dp->d_fd);
86: free(dp);
87: }
88:
89: struct direct *
90: readdir(dp)
91: DIR *dp;
92: {
93: static struct direct dir;
94:
95: do
96: if (read(dp->d_fd, &dir, sizeof dir) != sizeof dir)
97: return NULL;
98: #if defined(elxsi) && defined(SYSV)
99: /*
100: * Elxsi has a BSD4.2 implementation which may or may not use
101: * `twisted inodes' ... Anyone able to check?
102: */
103: while (*(unsigned short *)&dir.d_ino == 0);
104: #else
105: while (dir.d_ino == 0);
106: #endif
107:
108: return &dir;
109: }
110:
111: #endif /* BSD4_2 */
112:
113: /* Get a line at `tl' in the tmp file into `buf' which should be LBSIZE
114: long. */
115:
116: private char *getblock proto((daddr atl));
117:
118: void
119: getline(tl, buf)
120: daddr tl;
121: char *buf;
122: {
123: register char *bp,
124: *lp;
125: register int nl;
126:
127: lp = buf;
128: bp = getblock(tl >> 1);
129: nl = nleft;
130: tl = blk_round(tl);
131:
132: while ((*lp++ = *bp++) != '\0') {
133: if (--nl == 0) {
134: tl = forward_block(tl);
135: bp = getblock(tl >> 1);
136: nl = nleft;
137: }
138: }
139: }
140:
141: private char *
142: getblock(atl)
143: daddr atl;
144: {
145: int bno,
146: off;
147: static int curblock = -1;
148:
149: bno = da_to_bno(atl);
150: off = da_to_off(atl);
151: nleft = JBUFSIZ - off;
152:
153: if (bno != curblock) {
154: extern long lseek proto((int, long, int));
155:
156: lseek(data_fd, (long) bno * JBUFSIZ, L_SET);
157: read(data_fd, blk_buf, (size_t)JBUFSIZ);
158: curblock = bno;
159: }
160: return blk_buf + off;
161: }
162:
163: char *
164: copystr(s)
165: char *s;
166: {
167: char *str;
168:
169: str = malloc((size_t) (strlen(s) + 1));
170: strcpy(str, s);
171:
172: return str;
173: }
174:
175: /* Scandir returns the number of entries or -1 if the directory cannoot
176: be opened or malloc fails. */
177:
178: private int
179: scandir(dir, nmptr, qualify, sorter)
180: char *dir;
181: struct direct ***nmptr;
182: int (*qualify) proto((struct direct *));
183: int (*sorter) proto((UnivConstPtr, UnivConstPtr));
184: {
185: DIR *dirp;
186: struct direct *entry,
187: **ourarray;
188: int nalloc = 10,
189: nentries = 0;
190:
191: if ((dirp = opendir(dir)) == NULL)
192: return -1;
193: ourarray = (struct direct **) malloc(nalloc * sizeof (struct direct *));
194: while ((entry = readdir(dirp)) != NULL) {
195: if (qualify != NULL && (*qualify)(entry) == 0)
196: continue;
197: if (nentries == nalloc) {
198: ourarray = (struct direct **) realloc((char *)ourarray,
199: (nalloc += 10) * sizeof (struct direct));
200: if (ourarray == NULL)
201: return -1;
202: }
203: ourarray[nentries] = (struct direct *) malloc(sizeof *entry);
204: *ourarray[nentries] = *entry;
205: nentries += 1;
206: }
207: closedir(dirp);
208: if (nentries != nalloc)
209: ourarray = (struct direct **) realloc((char *)ourarray,
210: (nentries * sizeof (struct direct)));
211: if (sorter != NULL)
212: qsort((UnivPtr)ourarray, (size_t) nentries, sizeof (struct direct **), sorter);
213: *nmptr = ourarray;
214:
215: return nentries;
216: }
217:
218: private char *CurDir;
219:
220: /* Scan the DIRNAME directory for jove tmp files, and make a linked list
221: out of them. */
222:
223: private int add_name proto((struct direct *dp));
224:
225: private void
226: get_files(dirname)
227: char *dirname;
228: {
229: struct direct **nmptr;
230:
231: CurDir = dirname;
232: First = NULL;
233: scandir(dirname, &nmptr, add_name,
234: (int (*) proto((UnivConstPtr, UnivConstPtr)))NULL);
235: }
236:
237: private int
238: add_name(dp)
239: struct direct *dp;
240: {
241: char dfile[128],
242: rfile[128];
243: struct file_pair *fp;
244: struct rec_head header;
245: int fd;
246:
247: if (strncmp(dp->d_name, "jrec", (size_t)4) != 0)
248: return 0;
249: /* If we get here, we found a "recover" tmp file, so now
250: we look for the corresponding "data" tmp file. First,
251: though, we check to see whether there is anything in
252: the "recover" file. If it's 0 length, there's no point
253: in saving its name. */
254: (void) sprintf(rfile, "%s/%s", CurDir, dp->d_name);
255: (void) sprintf(dfile, "%s/jove%s", CurDir, dp->d_name + 4);
256: if ((fd = open(rfile, 0)) != -1) {
257: if ((read(fd, (char *) &header, sizeof header) != sizeof header)) {
258: close(fd);
259: return 0;
260: } else
261: close(fd);
262: }
263: if (access(dfile, 0) != 0) {
264: fprintf(stderr, "recover: can't find the data file for %s/%s\n", Directory, dp->d_name);
265: fprintf(stderr, "so deleting...\n");
266: (void) unlink(rfile);
267: (void) unlink(dfile);
268: return 0;
269: }
270: /* If we get here, we've found both files, so we put them
271: in the list. */
272: fp = (struct file_pair *) malloc (sizeof *fp);
273: if ((char *) fp == 0) {
274: fprintf(stderr, "recover: cannot malloc for file_pair.\n");
275: exit(-1);
276: }
277: fp->file_data = copystr(dfile);
278: fp->file_rec = copystr(rfile);
279: fp->file_flags = 0;
280: fp->file_next = First;
281: First = fp;
282:
283: return 1;
284: }
285:
286: private void
287: options()
288: {
289: printf("Options are:\n");
290: printf(" ? list options.\n");
291: printf(" get get a buffer to a file.\n");
292: printf(" list list known buffers.\n");
293: printf(" print print a buffer to terminal.\n");
294: printf(" quit quit and delete jove tmp files.\n");
295: printf(" restore restore all buffers.\n");
296: }
297:
298: /* Returns a legitimate buffer # */
299:
300: private void tellme proto((char *, char *)),
301: list proto((void));
302:
303: private struct rec_entry **
304: getsrc()
305: {
306: char name[128];
307: int number;
308:
309: for (;;) {
310: tellme("Which buffer ('?' for list)? ", name);
311: if (name[0] == '?')
312: list();
313: else if (name[0] == '\0')
314: return 0;
315: else if ((number = atoi(name)) > 0 && number <= Header.Nbuffers)
316: return &buflist[number];
317: else {
318: int i;
319:
320: for (i = 1; i <= Header.Nbuffers; i++)
321: if (strcmp(buflist[i]->r_bname, name) == 0)
322: return &buflist[i];
323: printf("%s: unknown buffer.\n", name);
324: }
325: }
326: }
327:
328: /* Get a destination file name. */
329:
330: static char *
331: getdest()
332: {
333: static char filebuf[256];
334:
335: tellme("Output file: ", filebuf);
336: if (filebuf[0] == '\0')
337: return 0;
338: return filebuf;
339: }
340:
341: #include "ctype.h"
342:
343: private char *
344: readword(buf)
345: char *buf;
346: {
347: int c;
348: char *bp = buf;
349:
350: while (strchr(" \t\n", c = getchar()))
351: ;
352:
353: do {
354: if (strchr(" \t\n", c))
355: break;
356: *bp++ = c;
357: } while ((c = getchar()) != EOF);
358: *bp = 0;
359:
360: return buf;
361: }
362:
363: private void
364: tellme(quest, answer)
365: char *quest,
366: *answer;
367: {
368: if (stdin->_cnt <= 0) {
369: printf("%s", quest);
370: fflush(stdout);
371: }
372: readword(answer);
373: }
374:
375: /* Print the specified file to standard output. */
376:
377: private jmp_buf int_env;
378:
379: private SIGRESULT
380: catch(junk)
381: int junk;
382: {
383: longjmp(int_env, 1);
384: /*NOTREACHED*/
385: }
386:
387: private void get proto((struct rec_entry **src, char *dest));
388:
389: private void
390: restore()
391: {
392: register int i;
393: char tofile[100],
394: answer[30];
395: int nrecovered = 0;
396:
397: for (i = 1; i <= Header.Nbuffers; i++) {
398: (void) sprintf(tofile, "#%s", buflist[i]->r_bname);
399: tryagain:
400: printf("Restoring %s to %s, okay?", buflist[i]->r_bname,
401: tofile);
402: tellme(" ", answer);
403: switch (answer[0]) {
404: case 'y':
405: break;
406:
407: case 'n':
408: continue;
409:
410: default:
411: tellme("What file should I use instead? ", tofile);
412: goto tryagain;
413: }
414: get(&buflist[i], tofile);
415: nrecovered += 1;
416: }
417: printf("Recovered %d buffers.\n", nrecovered);
418: }
419:
420: private void dump_file proto((int which, FILE *out));
421:
422: private void
423: get(src, dest)
424: struct rec_entry **src;
425: char *dest;
426: {
427: FILE *outfile;
428:
429: if (src == 0 || dest == 0)
430: return;
431: (void) signal(SIGINT, catch);
432: if (setjmp(int_env) == 0) {
433: if (dest == tty)
434: outfile = stdout;
435: else {
436: if ((outfile = fopen(dest, "w")) == NULL) {
437: printf("recover: cannot create %s.\n", dest);
438: (void) signal(SIGINT, SIG_DFL);
439: return;
440: }
441: printf("\"%s\"", dest);
442: }
443: dump_file(src - buflist, outfile);
444: } else
445: printf("\nAborted!\n");
446: (void) signal(SIGINT, SIG_DFL);
447: if (dest != tty) {
448: fclose(outfile);
449: printf(" %ld lines, %ld characters.\n", Nlines, Nchars);
450: }
451: }
452:
453: private char **
454: scanvec(args, str)
455: register char **args,
456: *str;
457: {
458: while (*args) {
459: if (strcmp(*args, str) == 0)
460: return args;
461: args += 1;
462: }
463: return 0;
464: }
465:
466: private void
467: read_rec(recptr)
468: struct rec_entry *recptr;
469: {
470: if (fread((char *) recptr, sizeof *recptr, (size_t)1, ptrs_fp) != 1)
471: fprintf(stderr, "recover: cannot read record.\n");
472: }
473:
474: private void
475: seekto(which)
476: int which;
477: {
478: long offset;
479: int i;
480:
481: offset = sizeof (Header) + (Header.Nbuffers * sizeof (struct rec_entry));
482: for (i = 1; i < which; i++)
483: offset += buflist[i]->r_nlines * sizeof (daddr);
484: fseek(ptrs_fp, offset, L_SET);
485: }
486:
487: private void
488: makblist()
489: {
490: int i;
491:
492: fseek(ptrs_fp, (long) sizeof (Header), L_SET);
493: for (i = 1; i <= Header.Nbuffers; i++) {
494: if (buflist[i] == 0)
495: buflist[i] = (struct rec_entry *) malloc (sizeof (struct rec_entry));
496: read_rec(buflist[i]);
497: }
498: while (buflist[i]) {
499: free((char *) buflist[i]);
500: buflist[i] = 0;
501: i += 1;
502: }
503: }
504:
505: private daddr
506: getaddr(fp)
507: register FILE *fp;
508: {
509: register int nchars = sizeof (daddr);
510: daddr addr;
511: register char *cp = (char *) &addr;
512:
513: while (--nchars >= 0)
514: *cp++ = getc(fp);
515:
516: return addr;
517: }
518:
519: private void
520: dump_file(which, out)
521: int which;
522: FILE *out;
523: {
524: register int nlines;
525: register daddr addr;
526: char buf[JBUFSIZ];
527:
528: seekto(which);
529: nlines = buflist[which]->r_nlines;
530: Nchars = Nlines = 0L;
531: while (--nlines >= 0) {
532: addr = getaddr(ptrs_fp);
533: getline(addr, buf);
534: Nlines += 1;
535: Nchars += 1 + strlen(buf);
536: fputs(buf, out);
537: if (nlines > 0)
538: fputc('\n', out);
539: }
540: }
541:
542: /* List all the buffers. */
543:
544: private void
545: list()
546: {
547: int i;
548:
549: for (i = 1; i <= Header.Nbuffers; i++)
550: printf("%d) buffer %s \"%s\" (%d lines)\n", i,
551: buflist[i]->r_bname,
552: buflist[i]->r_fname,
553: buflist[i]->r_nlines);
554: }
555:
556: private void ask_del proto((char *prompt, struct file_pair *fp));
557:
558: private int
559: doit(fp)
560: struct file_pair *fp;
561: {
562: char answer[30];
563: char *datafile = fp->file_data,
564: *pntrfile = fp->file_rec;
565:
566: ptrs_fp = fopen(pntrfile, "r");
567: if (ptrs_fp == NULL) {
568: if (Verbose)
569: fprintf(stderr, "recover: cannot read rec file (%s).\n", pntrfile);
570: return 0;
571: }
572: fread((char *) &Header, sizeof Header, (size_t)1, ptrs_fp);
573: if (Header.Uid != UserID)
574: return 0;
575:
576: /* Don't ask about JOVE's that are still running ... */
577: #ifdef KILL0
578: if (kill(Header.Pid, 0) == 0)
579: return 0;
580: #endif /* KILL0 */
581:
582: if (Header.Nbuffers == 0) {
583: printf("There are no modified buffers in %s; should I delete the tmp file?", pntrfile);
584: ask_del(" ", fp);
585: return 1;
586: }
587:
588: if (Header.Nbuffers < 0) {
589: fprintf(stderr, "recover: %s doesn't look like a jove file.\n", pntrfile);
590: ask_del("Should I delete it? ", fp);
591: return 1; /* We'll, we sort of found something. */
592: }
593: printf("Found %d buffer%s last updated: %s",
594: Header.Nbuffers,
595: Header.Nbuffers != 1 ? "s" : "",
596: ctime(&Header.UpdTime));
597: data_fd = open(datafile, 0);
598: if (data_fd == -1) {
599: fprintf(stderr, "recover: but I can't read the data file (%s).\n", datafile);
600: ask_del("Should I delete the tmp files? ", fp);
601: return 1;
602: }
603: makblist();
604: list();
605:
606: for (;;) {
607: tellme("(Type '?' for options): ", answer);
608: switch (answer[0]) {
609: case '\0':
610: continue;
611:
612: case '?':
613: options();
614: break;
615:
616: case 'l':
617: list();
618: break;
619:
620: case 'p':
621: get(getsrc(), tty);
622: break;
623:
624: case 'q':
625: ask_del("Shall I delete the tmp files? ", fp);
626: return 1;
627:
628: case 'g':
629: { /* So it asks for src first. */
630: char *dest;
631: struct rec_entry **src;
632:
633: if ((src = getsrc()) == 0)
634: break;
635: dest = getdest();
636: get(src, dest);
637: break;
638: }
639:
640: case 'r':
641: restore();
642: break;
643:
644: default:
645: printf("I don't know how to \"%s\"!\n", answer);
646: break;
647: }
648: }
649: }
650:
651: private void del_files proto((struct file_pair *fp));
652:
653: private void
654: ask_del(prompt, fp)
655: char *prompt;
656: struct file_pair *fp;
657: {
658: char yorn[20];
659:
660: tellme(prompt, yorn);
661: if (yorn[0] == 'y')
662: del_files(fp);
663: }
664:
665: private void
666: del_files(fp)
667: struct file_pair *fp;
668: {
669: (void) unlink(fp->file_data);
670: (void) unlink(fp->file_rec);
671: }
672:
673:
674:
675: MailUser(rec)
676: struct rec_head *rec;
677: {
678: #ifdef SYSV
679: struct utsname mach;
680: #else
681: char mach[BUFSIZ];
682: #endif
683: char mail_cmd[BUFSIZ];
684: char *last_update;
685: char *buf_string;
686: FILE *mail_pipe;
687: struct passwd *pw;
688: extern struct passwd *getpwuid proto((int));
689:
690: if ((pw = getpwuid(rec->Uid))== NULL)
691: return;
692: #ifdef SYSV
693: if (uname(&mach) < 0)
694: strcpy(mach.sysname, "unknown");
695: #else
696: gethostname(mach, sizeof(mach));
697: #endif
698: last_update = ctime(&(rec->UpdTime));
699: /* Start up mail */
700: sprintf(mail_cmd, "/bin/mail %s", pw->pw_name);
701: setuid(getuid());
702: if ((mail_pipe = popen(mail_cmd, "w")) == NULL)
703: return;
704: setbuf(mail_pipe, mail_cmd);
705: /* Let's be grammatically correct! */
706: if (rec->Nbuffers == 1)
707: buf_string = "buffer";
708: else
709: buf_string = "buffers";
710: fprintf(mail_pipe, "Subject: System crash\n");
711: fprintf(mail_pipe, " \n");
712: fprintf(mail_pipe, "Jove saved %d %s when the system \"%s\"\n",
713: rec->Nbuffers, buf_string,
714: #ifdef SYSV
715: mach.sysname
716: #else
717: mach
718: #endif
719: );
720: fprintf(mail_pipe, "crashed on %s\n\n", last_update);
721: fprintf(mail_pipe, "You can retrieve the %s using Jove's -r\n",
722: buf_string);
723: fprintf(mail_pipe, "(recover option) i.e. give the command.\n");
724: fprintf(mail_pipe, "\tjove -r\n");
725: fprintf(mail_pipe, "See the Jove manual for more details\n");
726: pclose(mail_pipe);
727: }
728:
729:
730: savetmps()
731: {
732: struct file_pair *fp;
733: int status,
734: pid,
735: fd;
736: struct rec_head header;
737: char buf[BUFSIZ];
738: char *fname;
739: struct stat stbuf;
740:
741: if (strcmp(TMP_DIR, REC_DIR) == 0)
742: return; /* Files are moved to the same place. */
743: get_files(TMP_DIR);
744: for (fp = First; fp != 0; fp = fp->file_next) {
745: stat(fp->file_data, &stbuf);
746: switch (pid = fork()) {
747: case -1:
748: fprintf(stderr, "recover: can't fork\n!");
749: exit(-1);
750:
751: case 0:
752: fprintf(stderr, "Recovering: %s, %s\n", fp->file_data,
753: fp->file_rec);
754: if ((fd = open(fp->file_rec, 0)) != -1) {
755: if ((read(fd, (char *) &header, sizeof header) != sizeof header)) {
756: close(fd);
757: return 0;
758: } else
759: close(fd);
760: }
761: MailUser(&header);
762: execl("/bin/mv", "mv", fp->file_data, fp->file_rec,
763: REC_DIR, (char *)0);
764: fprintf(stderr, "recover: cannot execl /bin/mv.\n");
765: exit(-1);
766:
767: default:
768: while (wait(&status) != pid)
769: ;
770: if (status != 0)
771: fprintf(stderr, "recover: non-zero status (%d) returned from copy.\n", status);
772: fname = fp->file_data + strlen(TMP_DIR);
773: strcpy(buf, REC_DIR);
774: strcat(buf, fname);
775: if(chown(buf, (int) stbuf.st_uid, (int) stbuf.st_gid) != 0)
776: perror("recover: chown failed.");
777: fname = fp->file_rec + strlen(TMP_DIR);
778: strcpy(buf, REC_DIR);
779: strcat(buf, fname);
780: if(chown(buf, (int) stbuf.st_uid, (int) stbuf.st_gid) != 0)
781: perror("recover: chown failed.");
782: }
783: }
784: }
785:
786: private int
787: lookup(dir)
788: char *dir;
789: {
790: struct file_pair *fp;
791: int nfound = 0;
792:
793: printf("Checking %s ...\n", dir);
794: Directory = dir;
795: get_files(dir);
796: for (fp = First; fp != 0; fp = fp->file_next) {
797: nfound += doit(fp);
798: if (ptrs_fp)
799: (void) fclose(ptrs_fp);
800: if (data_fd > 0)
801: (void) close(data_fd);
802: }
803: return nfound;
804: }
805:
806: void
807: main(argc, argv)
808: int argc;
809: char *argv[];
810: {
811: int nfound;
812: char **argvp;
813: char *tmp_dir;
814:
815: UserID = getuid();
816:
817: if (scanvec(argv, "-help")) {
818: printf("recover: usage: recover [-d directory] [-syscrash]\n");
819: printf("Use \"jove -r\" after JOVE has died for some\n");
820: printf("unknown reason.\n\n");
821: printf("Use \"%s -syscrash\"\n", Recover);
822: printf("when the system is in the process of rebooting.");
823: printf("This is done automatically at reboot time\n");
824: printf("and so most of you don't have to worry about that.\n\n");
825: printf("Use \"recover -d directory\" when the tmp files are store\n");
826: printf("in DIRECTORY instead of the default one (/tmp).\n");
827: exit(0);
828: }
829: if (scanvec(argv, "-v"))
830: Verbose = YES;
831: if (scanvec(argv, "-syscrash")) {
832: printf("Recovering jove files ... ");
833: savetmps();
834: printf("Done.\n");
835: exit(0);
836: }
837: if ((argvp = scanvec(argv, "-uid")) != NULL)
838: UserID = atoi(argvp[1]);
839: if ((argvp = scanvec(argv, "-d")) != NULL)
840: tmp_dir = argvp[1];
841: else
842: tmp_dir = TmpFilePath;
843: /* Check default directory */
844: nfound = lookup(tmp_dir);
845: /* Check whether anything was saved when system died? */
846: if (strcmp(tmp_dir, REC_DIR) != 0)
847: nfound += lookup(REC_DIR);
848: if (nfound == 0)
849: printf("There's nothing to recover.\n");
850: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.