2.11BSD#431 - /usr/src/new/jove/recover.c

   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 is
  11:    move all the jove tmp files from TMP_DIR to REC_DIR.
  12: 
  13:    The -d option lets you specify the directory to search for tmp files when
  14:    the default isn't the right one.
  15: 
  16:    Look in Makefile to change the default directories. */
  17: 
  18: #include <stdio.h>  /* Do stdio first so it doesn't override OUR
  19: 			   definitions. */
  20: #undef EOF
  21: #undef BUFSIZ
  22: #undef putchar
  23: #undef getchar
  24: 
  25: #define STDIO
  26: 
  27: #include "jove.h"
  28: #include "temp.h"
  29: #include "rec.h"
  30: #include <signal.h>
  31: #include <sys/file.h>
  32: #include <sys/stat.h>
  33: #include <sys/dir.h>
  34: 
  35: #ifndef L_SET
  36: #	define L_SET  0
  37: #	define L_INCR 1
  38: #endif
  39: 
  40: char    blk_buf[BUFSIZ];
  41: int nleft;
  42: FILE    *ptrs_fp;
  43: int data_fd;
  44: struct rec_head Header;
  45: char    datafile[40],
  46:     pntrfile[40];
  47: long    Nchars,
  48:     Nlines;
  49: char    tty[] = "/dev/tty";
  50: int UserID,
  51:     Verbose = 0;
  52: char    *Directory = 0;     /* the directory we're looking in */
  53: 
  54: struct file_pair {
  55:     char    *file_data,
  56:         *file_rec;
  57: #define INSPECTED   01
  58:     int file_flags;
  59:     struct file_pair    *file_next;
  60: } *First = 0,
  61:   *Last = 0;
  62: 
  63: struct rec_entry    *buflist[100] = {0};
  64: 
  65: #ifndef BSD4_2
  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: getline(tl, buf)
 117: disk_line   tl;
 118: char    *buf;
 119: {
 120:     register char   *bp,
 121:             *lp;
 122:     register int    nl;
 123:     char    *getblock();
 124: 
 125:     lp = buf;
 126:     bp = getblock(tl >> 1);
 127:     nl = nleft;
 128:     tl = blk_round(tl);
 129: 
 130:     while (*lp++ = *bp++) {
 131:         if (--nl == 0) {
 132:             tl = forward_block(tl);
 133:             bp = getblock(tl >> 1);
 134:             nl = nleft;
 135:         }
 136:     }
 137: }
 138: 
 139: char *
 140: getblock(atl)
 141: disk_line   atl;
 142: {
 143:     int bno,
 144:         off;
 145:     static int  curblock = -1;
 146: 
 147:     bno = da_to_bno(atl);
 148:     off = da_to_off(atl);
 149:     nleft = BUFSIZ - off;
 150: 
 151:     if (bno != curblock) {
 152:         lseek(data_fd, (long) bno * BUFSIZ, L_SET);
 153:         read(data_fd, blk_buf, BUFSIZ);
 154:         curblock = bno;
 155:     }
 156:     return blk_buf + off;
 157: }
 158: 
 159: char *
 160: copystr(s)
 161: char    *s;
 162: {
 163:     char    *str;
 164: 
 165:     str = malloc(strlen(s) + 1);
 166:     strcpy(str, s);
 167: 
 168:     return str;
 169: }
 170: 
 171: /* Scandir returns the number of entries or -1 if the directory cannoot
 172:    be opened or malloc fails. */
 173: 
 174: scandir(dir, nmptr, qualify, sorter)
 175: char    *dir;
 176: struct direct   ***nmptr;
 177: int (*qualify)();
 178: struct direct   *(*sorter)();
 179: {
 180:     DIR *dirp;
 181:     struct direct   *entry,
 182:             **ourarray;
 183:     int nalloc = 10,
 184:         nentries = 0;
 185: 
 186:     if ((dirp = opendir(dir)) == NULL)
 187:         return -1;
 188:     ourarray = (struct direct **) malloc(nalloc * sizeof (struct direct *));
 189:     while ((entry = readdir(dirp)) != NULL) {
 190:         if (qualify != 0 && (*qualify)(entry) == 0)
 191:             continue;
 192:         if (nentries == nalloc) {
 193:             ourarray = (struct direct **) realloc(ourarray, (nalloc += 10) * sizeof (struct direct));
 194:             if (ourarray == NULL)
 195:                 return -1;
 196:         }
 197:         ourarray[nentries] = (struct direct *) malloc(sizeof *entry);
 198:         *ourarray[nentries] = *entry;
 199:         nentries += 1;
 200:     }
 201:     closedir(dirp);
 202:     if (nentries != nalloc)
 203:         ourarray = (struct direct **) realloc(ourarray,
 204:                     (nentries * sizeof (struct direct)));
 205:     if (sorter != 0)
 206:         qsort(ourarray, nentries, sizeof (struct direct **), sorter);
 207:     *nmptr = ourarray;
 208: 
 209:     return nentries;
 210: }
 211: 
 212: alphacomp(a, b)
 213: struct direct   **a,
 214:         **b;
 215: {
 216:     return strcmp((*a)->d_name, (*b)->d_name);
 217: }
 218: 
 219: char    *CurDir;
 220: 
 221: /* Scan the DIRNAME directory for jove tmp files, and make a linked list
 222:    out of them. */
 223: 
 224: get_files(dirname)
 225: char    *dirname;
 226: {
 227:     int add_name();
 228:     struct direct   **nmptr;
 229: 
 230:     CurDir = dirname;
 231:     scandir(dirname, &nmptr, add_name, (int (*)())0);
 232: }
 233: 
 234: add_name(dp)
 235: struct direct   *dp;
 236: {
 237:     char    dfile[128],
 238:         rfile[128];
 239:     struct file_pair    *fp;
 240:     struct rec_head     header;
 241:     int fd;
 242: 
 243:     if (strncmp(dp->d_name, "jrec", 4) != 0)
 244:         return 0;
 245:     /* If we get here, we found a "recover" tmp file, so now
 246: 	   we look for the corresponding "data" tmp file.  First,
 247: 	   though, we check to see whether there is anything in
 248: 	   the "recover" file.  If it's 0 length, there's no point
 249: 	   in saving its name. */
 250:     (void) sprintf(rfile, "%s/%s", CurDir, dp->d_name);
 251:     (void) sprintf(dfile, "%s/jove%s", CurDir, dp->d_name + 4);
 252:     if ((fd = open(rfile, 0)) != -1) {
 253:         if ((read(fd, (char *) &header, sizeof header) != sizeof header)) {
 254:             close(fd);
 255:                 return 0;
 256:         } else
 257:             close(fd);
 258:     }
 259:     if (access(dfile, 0) != 0) {
 260:         fprintf(stderr, "recover: can't find the data file for %s/%s\n", Directory, dp->d_name);
 261:         fprintf(stderr, "so deleting...\n");
 262:         (void) unlink(rfile);
 263:         (void) unlink(dfile);
 264:         return 0;
 265:     }
 266:     /* If we get here, we've found both files, so we put them
 267: 	   in the list. */
 268:     fp = (struct file_pair *) malloc (sizeof *fp);
 269:     if ((char *) fp == 0) {
 270:         fprintf(stderr, "recover: cannot malloc for file_pair.\n");
 271:         exit(-1);
 272:     }
 273:     fp->file_data = copystr(dfile);
 274:     fp->file_rec = copystr(rfile);
 275:     fp->file_flags = 0;
 276:     fp->file_next = First;
 277:     First = fp;
 278: 
 279:     return 1;
 280: }
 281: 
 282: options()
 283: {
 284:     printf("Options are:\n");
 285:     printf("	?		list options.\n");
 286:     printf("	get		get a buffer to a file.\n");
 287:     printf("	list		list known buffers.\n");
 288:     printf("	print		print a buffer to terminal.\n");
 289:     printf("	quit		quit and delete jove tmp files.\n");
 290:     printf("	restore		restore all buffers.\n");
 291: }
 292: 
 293: /* Returns a legitimate buffer # */
 294: 
 295: struct rec_entry **
 296: getsrc()
 297: {
 298:     char    name[128];
 299:     int number;
 300: 
 301:     for (;;) {
 302:         tellme("Which buffer ('?' for list)? ", name);
 303:         if (name[0] == '?')
 304:             list();
 305:         else if (name[0] == '\0')
 306:             return 0;
 307:         else if ((number = atoi(name)) > 0 && number <= Header.Nbuffers)
 308:             return &buflist[number];
 309:         else {
 310:             int i;
 311: 
 312:             for (i = 1; i <= Header.Nbuffers; i++)
 313:                 if (strcmp(buflist[i]->r_bname, name) == 0)
 314:                     return &buflist[i];
 315:             printf("%s: unknown buffer.\n", name);
 316:         }
 317:     }
 318: }
 319: 
 320: /* Get a destination file name. */
 321: 
 322: static char *
 323: getdest()
 324: {
 325:     static char filebuf[256];
 326: 
 327:     tellme("Output file: ", filebuf);
 328:     if (filebuf[0] == '\0')
 329:         return 0;
 330:     return filebuf;
 331: }
 332: 
 333: #include "ctype.h"
 334: 
 335: char *
 336: readword(buf)
 337: char    *buf;
 338: {
 339:     int c;
 340:     char    *bp = buf;
 341: 
 342:     while (index(" \t\n", c = getchar()))
 343:         ;
 344: 
 345:     do {
 346:         if (index(" \t\n", c))
 347:             break;
 348:         *bp++ = c;
 349:     } while ((c = getchar()) != EOF);
 350:     *bp = 0;
 351: 
 352:     return buf;
 353: }
 354: 
 355: tellme(quest, answer)
 356: char    *quest,
 357:     *answer;
 358: {
 359:     if (stdin->_cnt <= 0) {
 360:         printf("%s", quest);
 361:         fflush(stdout);
 362:     }
 363:     readword(answer);
 364: }
 365: 
 366: /* Print the specified file to strandard output. */
 367: 
 368: jmp_buf int_env;
 369: 
 370: catch()
 371: {
 372:     longjmp(int_env, 1);
 373: }
 374: 
 375: restore()
 376: {
 377:     register int    i;
 378:     char    tofile[100],
 379:         answer[30];
 380:     int nrecovered = 0;
 381: 
 382:     for (i = 1; i <= Header.Nbuffers; i++) {
 383:         (void) sprintf(tofile, "#%s", buflist[i]->r_bname);
 384: tryagain:
 385:         printf("Restoring %s to %s, okay?", buflist[i]->r_bname,
 386:                              tofile);
 387:         tellme(" ", answer);
 388:         switch (answer[0]) {
 389:         case 'y':
 390:             break;
 391: 
 392:         case 'n':
 393:             continue;
 394: 
 395:         default:
 396:             tellme("What file should I use instead? ", tofile);
 397:             goto tryagain;
 398:         }
 399:         get(&buflist[i], tofile);
 400:         nrecovered += 1;
 401:     }
 402:     printf("Recovered %d buffers.\n", nrecovered);
 403: }
 404: 
 405: get(src, dest)
 406: struct rec_entry    **src;
 407: char    *dest;
 408: {
 409:     FILE    *outfile;
 410: 
 411:     if (src == 0 || dest == 0)
 412:         return;
 413:     (void) signal(SIGINT, catch);
 414:     if (setjmp(int_env) == 0) {
 415:         if ((outfile = fopen(dest, "w")) == NULL) {
 416:             printf("recover: cannot create %s.\n", dest);
 417:             return;
 418:         }
 419:         if (dest != tty)
 420:             printf("\"%s\"", dest);
 421:         dump_file(src - buflist, outfile);
 422:     } else
 423:         printf("\nAborted!\n");
 424:     fclose(outfile);
 425:     if (dest != tty)
 426:         printf(" %ld lines, %ld characters.\n", Nlines, Nchars);
 427:     (void) signal(SIGINT, SIG_DFL);
 428: }
 429: 
 430: char **
 431: scanvec(args, str)
 432: register char   **args,
 433:         *str;
 434: {
 435:     while (*args) {
 436:         if (strcmp(*args, str) == 0)
 437:             return args;
 438:         args += 1;
 439:     }
 440:     return 0;
 441: }
 442: 
 443: read_rec(recptr)
 444: struct rec_entry    *recptr;
 445: {
 446:     if (fread((char *) recptr, sizeof *recptr, 1, ptrs_fp) != 1)
 447:         fprintf(stderr, "recover: cannot read record.\n");
 448: }
 449: 
 450: seekto(which)
 451: {
 452:     struct rec_entry    rec;
 453:     long    offset;
 454:     int i;
 455: 
 456:     offset = sizeof (Header) + (Header.Nbuffers * sizeof (rec));
 457:     for (i = 1; i < which; i++)
 458:         offset += buflist[i]->r_nlines * sizeof (disk_line);
 459:     fseek(ptrs_fp, offset, L_SET);
 460: }
 461: 
 462: makblist()
 463: {
 464:     int i;
 465: 
 466:     fseek(ptrs_fp, (long) sizeof (Header), L_SET);
 467:     for (i = 1; i <= Header.Nbuffers; i++) {
 468:         if (buflist[i] == 0)
 469:             buflist[i] = (struct rec_entry *) malloc (sizeof (struct rec_entry));
 470:         read_rec(buflist[i]);
 471:     }
 472:     while (buflist[i]) {
 473:         free((char *) buflist[i]);
 474:         buflist[i] = 0;
 475:         i += 1;
 476:     }
 477: }
 478: 
 479: disk_line
 480: getaddr(fp)
 481: register FILE   *fp;
 482: {
 483:     register int    nchars = sizeof (disk_line);
 484:     disk_line   addr;
 485:     register char   *cp = (char *) &addr;
 486: 
 487:     while (--nchars >= 0)
 488:         *cp++ = getc(fp);
 489: 
 490:     return addr;
 491: }
 492: 
 493: dump_file(which, out)
 494: FILE    *out;
 495: {
 496:     register int    nlines;
 497:     register disk_line  daddr;
 498:     char    buf[BUFSIZ];
 499: 
 500:     seekto(which);
 501:     nlines = buflist[which]->r_nlines;
 502:     Nchars = Nlines = 0L;
 503:     while (--nlines >= 0) {
 504:         daddr = getaddr(ptrs_fp);
 505:         getline(daddr, buf);
 506:         Nlines += 1;
 507:         Nchars += 1 + strlen(buf);
 508:         fputs(buf, out);
 509:         if (nlines > 0)
 510:             fputc('\n', out);
 511:     }
 512:     if (out != stdout)
 513:         fclose(out);
 514: }
 515: 
 516: /* List all the buffers. */
 517: 
 518: list()
 519: {
 520:     int i;
 521: 
 522:     for (i = 1; i <= Header.Nbuffers; i++)
 523:         printf("%d) buffer %s  \"%s\" (%d lines)\n", i,
 524:             buflist[i]->r_bname,
 525:             buflist[i]->r_fname,
 526:             buflist[i]->r_nlines);
 527: }
 528: 
 529: doit(fp)
 530: struct file_pair    *fp;
 531: {
 532:     char    answer[30];
 533:     char    *datafile = fp->file_data,
 534:         *pntrfile = fp->file_rec;
 535: 
 536:     ptrs_fp = fopen(pntrfile, "r");
 537:     if (ptrs_fp == NULL) {
 538:         if (Verbose)
 539:             fprintf(stderr, "recover: cannot read rec file (%s).\n", pntrfile);
 540:         return 0;
 541:     }
 542:     fread((char *) &Header, sizeof Header, 1, ptrs_fp);
 543:     if (Header.Uid != UserID)
 544:         return 0;
 545: 
 546:     /* Don't ask about JOVE's that are still running ... */
 547: #ifdef KILL0
 548:     if (kill(Header.Pid, 0) == 0)
 549:         return 0;
 550: #endif /* KILL0 */
 551: 
 552:     if (Header.Nbuffers == 0) {
 553:         printf("There are no modified buffers in %s; should I delete the tmp file?", pntrfile);
 554:         ask_del(" ", fp);
 555:         return 1;
 556:     }
 557: 
 558:     if (Header.Nbuffers < 0) {
 559:         fprintf(stderr, "recover: %s doesn't look like a jove file.\n", pntrfile);
 560:         ask_del("Should I delete it? ", fp);
 561:         return 1;   /* We'll, we sort of found something. */
 562:     }
 563:     printf("Found %d buffer%s last updated: %s",
 564:         Header.Nbuffers,
 565:         Header.Nbuffers != 1 ? "s" : "",
 566:         ctime(&Header.UpdTime));
 567:     data_fd = open(datafile, 0);
 568:     if (data_fd == -1) {
 569:         fprintf(stderr, "recover: but I can't read the data file (%s).\n", datafile);
 570:         ask_del("Should I delete the tmp files? ", fp);
 571:         return 1;
 572:     }
 573:     makblist();
 574:     list();
 575: 
 576:     for (;;) {
 577:         tellme("(Type '?' for options): ", answer);
 578:         switch (answer[0]) {
 579:         case '\0':
 580:             continue;
 581: 
 582:         case '?':
 583:             options();
 584:             break;
 585: 
 586:         case 'l':
 587:             list();
 588:             break;
 589: 
 590:         case 'p':
 591:             get(getsrc(), tty);
 592:             break;
 593: 
 594:         case 'q':
 595:             ask_del("Shall I delete the tmp files? ", fp);
 596:             return 1;
 597: 
 598:         case 'g':
 599:             {   /* So it asks for src first. */
 600:                 char    *dest;
 601:                 struct rec_entry    **src;
 602: 
 603:                 if ((src = getsrc()) == 0)
 604:                     break;
 605:                 dest = getdest();
 606:             get(src, dest);
 607:             break;
 608:             }
 609: 
 610:         case 'r':
 611:             restore();
 612:             break;
 613: 
 614:         default:
 615:             printf("I don't know how to \"%s\"!\n", answer);
 616:             break;
 617:         }
 618:     }
 619: }
 620: 
 621: ask_del(prompt, fp)
 622: char    *prompt;
 623: struct file_pair    *fp;
 624: {
 625:     char    yorn[20];
 626: 
 627:     tellme(prompt, yorn);
 628:     if (yorn[0] == 'y')
 629:         del_files(fp);
 630: }
 631: 
 632: del_files(fp)
 633: struct file_pair    *fp;
 634: {
 635:     (void) unlink(fp->file_data);
 636:     (void) unlink(fp->file_rec);
 637: }
 638: 
 639: #ifdef notdef
 640: savetmps()
 641: {
 642:     struct file_pair    *fp;
 643:     int status,
 644:         pid;
 645: 
 646:     if (strcmp(TMP_DIR, REC_DIR) == 0)
 647:         return;     /* Files are moved to the same place. */
 648:     get_files(TMP_DIR);
 649:     for (fp = First; fp != 0; fp = fp->file_next) {
 650:         switch (pid = fork()) {
 651:         case -1:
 652:             fprintf(stderr, "recover: can't fork\n!");
 653:             exit(-1);
 654: 
 655:         case 0:
 656:             execl("/bin/cp", "cp", fp->file_data, fp->file_rec,
 657:                   REC_DIR, (char *)0);
 658:             fprintf(stderr, "recover: cannot execl /bin/cp.\n");
 659:             exit(-1);
 660: 
 661:         default:
 662:             while (wait(&status) != pid)
 663:                 ;
 664:             if (status != 0)
 665:                 fprintf(stderr, "recover: non-zero status (%d) returned from copy.\n", status);
 666:         }
 667:     }
 668: }
 669: #endif
 670: 
 671: lookup(dir)
 672: char    *dir;
 673: {
 674:     struct file_pair    *fp;
 675:     struct rec_head     header;
 676:     char    yorn[20];
 677:     int nfound = 0,
 678:         this_one;
 679: 
 680:     printf("Checking %s ...\n", dir);
 681:     Directory = dir;
 682:     get_files(dir);
 683:     for (fp = First; fp != 0; fp = fp->file_next) {
 684:         nfound += doit(fp);
 685:         if (ptrs_fp)
 686:             (void) fclose(ptrs_fp);
 687:         if (data_fd > 0)
 688:             (void) close(data_fd);
 689:     }
 690:     return nfound;
 691: }
 692: 
 693: main(argc, argv)
 694: int argc;
 695: char    *argv[];
 696: {
 697:     int nfound;
 698:     char    **argvp;
 699: 
 700:     UserID = getuid();
 701: 
 702:     if (scanvec(argv, "-help")) {
 703:         printf("recover: usage: recover [-d directory]\n");
 704:         printf("Use \"recover\" after JOVE has died for some\n");
 705:         printf("unknown reason.\n\n");
 706: /*		printf("Use \"recover -syscrash\" when the system is in the process\n");
 707: 		printf("of rebooting.  This is done automatically at reboot time\n");
 708: 		printf("and so most of you don't have to worry about that.\n\n");
 709:  */
 710:         printf("Use \"recover -d directory\" when the tmp files are store\n");
 711:         printf("in DIRECTORY instead of the default one (/tmp).\n");
 712:         exit(0);
 713:     }
 714:     if (scanvec(argv, "-v"))
 715:         Verbose = YES;
 716: /*	if (scanvec(argv, "-syscrash")) {
 717: 		printf("Recovering jove files ... ");
 718: 		savetmps();
 719: 		printf("Done.\n");
 720: 		exit(0);
 721: 	} */
 722:     if (argvp = scanvec(argv, "-uid"))
 723:         UserID = atoi(argvp[1]);
 724:     if (argvp = scanvec(argv, "-d"))
 725:         nfound = lookup(argvp[1]);
 726:     else
 727:         nfound = lookup(TmpFilePath);
 728:     if (nfound == 0)
 729:         printf("There's nothing to recover.\n");
 730: }

Defined functions

Defined variables

Defined struct's

Defined macros