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