![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex3.7recover.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ex / ex3.7recover|
Return to ex3.7recover.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / usr.bin / ex / ex3.7recover |
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.12 (Berkeley) 5/28/90"; ! 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: ! 27: char xstr[1]; /* make loader happy */ ! 28: short tfile = -1; /* ditto */ ! 29: ! 30: /* ! 31: * ! 32: * This program searches through the specified directory and then ! 33: * the directory _PATH_USRPRESERVE looking for an instance of the specified ! 34: * file from a crashed editor or a crashed system. ! 35: * If this file is found, it is unscrambled and written to ! 36: * the standard output. ! 37: * ! 38: * If this program terminates without a "broken pipe" diagnostic ! 39: * (i.e. the editor doesn't die right away) then the buffer we are ! 40: * writing from is removed when we finish. This is potentially a mistake ! 41: * as there is not enough handshaking to guarantee that the file has actually ! 42: * been recovered, but should suffice for most cases. ! 43: */ ! 44: ! 45: /* ! 46: * For lint's sake... ! 47: */ ! 48: #ifndef lint ! 49: #define ignorl(a) a ! 50: #endif ! 51: ! 52: /* ! 53: * Limit on the number of printed entries ! 54: * when an, e.g. ``ex -r'' command is given. ! 55: */ ! 56: #define NENTRY 50 ! 57: ! 58: char *ctime(); ! 59: char nb[BUFSIZ]; ! 60: int vercnt; /* Count number of versions of file found */ ! 61: ! 62: main(argc, argv) ! 63: int argc; ! 64: char *argv[]; ! 65: { ! 66: register char *cp; ! 67: register int b, i; ! 68: ! 69: /* ! 70: * Initialize as though the editor had just started. ! 71: */ ! 72: fendcore = (line *) sbrk(0); ! 73: dot = zero = dol = fendcore; ! 74: one = zero + 1; ! 75: endcore = fendcore - 2; ! 76: iblock = oblock = -1; ! 77: ! 78: /* ! 79: * If given only a -r argument, then list the saved files. ! 80: */ ! 81: if (argc == 2 && eq(argv[1], "-r")) { ! 82: listfiles(_PATH_PRESERVE); ! 83: exit(0); ! 84: } ! 85: if (argc != 3) ! 86: error(" Wrong number of arguments to exrecover", 0); ! 87: ! 88: CP(file, argv[2]); ! 89: ! 90: /* ! 91: * Search for this file. ! 92: */ ! 93: findtmp(argv[1]); ! 94: ! 95: /* ! 96: * Got (one of the versions of) it, write it back to the editor. ! 97: */ ! 98: cp = ctime(&H.Time); ! 99: cp[19] = 0; ! 100: fprintf(stderr, " [Dated: %s", cp); ! 101: fprintf(stderr, vercnt > 1 ? ", newest of %d saved]" : "]", vercnt); ! 102: H.Flines++; ! 103: ! 104: /* ! 105: * Allocate space for the line pointers from the temp file. ! 106: */ ! 107: if ((int) sbrk((int) (H.Flines * sizeof (line))) == -1) ! 108: /* ! 109: * Good grief. ! 110: */ ! 111: error(" Not enough core for lines", 0); ! 112: #ifdef DEBUG ! 113: fprintf(stderr, "%d lines\n", H.Flines); ! 114: #endif ! 115: ! 116: /* ! 117: * Now go get the blocks of seek pointers which are scattered ! 118: * throughout the temp file, reconstructing the incore ! 119: * line pointers at point of crash. ! 120: */ ! 121: b = 0; ! 122: while (H.Flines > 0) { ! 123: ignorl(lseek(tfile, (long) blocks[b] * BUFSIZ, 0)); ! 124: i = H.Flines < BUFSIZ / sizeof (line) ? ! 125: H.Flines * sizeof (line) : BUFSIZ; ! 126: if (read(tfile, (char *) dot, i) != i) { ! 127: perror(nb); ! 128: exit(1); ! 129: } ! 130: dot += i / sizeof (line); ! 131: H.Flines -= i / sizeof (line); ! 132: b++; ! 133: } ! 134: dot--; dol = dot; ! 135: ! 136: /* ! 137: * Sigh... due to sandbagging some lines may really not be there. ! 138: * Find and discard such. This shouldn't happen much. ! 139: */ ! 140: scrapbad(); ! 141: ! 142: /* ! 143: * Now if there were any lines in the recovered file ! 144: * write them to the standard output. ! 145: */ ! 146: if (dol > zero) { ! 147: addr1 = one; addr2 = dol; io = 1; ! 148: putfile(0); ! 149: } ! 150: ! 151: /* ! 152: * Trash the saved buffer. ! 153: * Hopefully the system won't crash before the editor ! 154: * syncs the new recovered buffer; i.e. for an instant here ! 155: * you may lose if the system crashes because this file ! 156: * is gone, but the editor hasn't completed reading the recovered ! 157: * file from the pipe from us to it. ! 158: * ! 159: * This doesn't work if we are coming from an non-absolute path ! 160: * name since we may have chdir'ed but what the hay, noone really ! 161: * ever edits with temporaries in "." anyways. ! 162: */ ! 163: if (nb[0] == '/') ! 164: ignore(unlink(nb)); ! 165: ! 166: /* ! 167: * Adieu. ! 168: */ ! 169: exit(0); ! 170: } ! 171: ! 172: /* ! 173: * Print an error message (notably not in error ! 174: * message file). If terminal is in RAW mode, then ! 175: * we should be writing output for "vi", so don't print ! 176: * a newline which would screw up the screen. ! 177: */ ! 178: /*VARARGS2*/ ! 179: error(str, inf) ! 180: char *str; ! 181: int inf; ! 182: { ! 183: ! 184: fprintf(stderr, str, inf); ! 185: (void)ioctl(2, TIOCGETP, &tty); ! 186: if ((tty.sg_flags & RAW) == 0) ! 187: fprintf(stderr, "\n"); ! 188: exit(1); ! 189: } ! 190: ! 191: /* ! 192: * Here we save the information about files, when ! 193: * you ask us what files we have saved for you. ! 194: * We buffer file name, number of lines, and the time ! 195: * at which the file was saved. ! 196: */ ! 197: struct svfile { ! 198: char sf_name[FNSIZE + 1]; ! 199: int sf_lines; ! 200: char sf_entry[MAXNAMLEN + 1]; ! 201: time_t sf_time; ! 202: }; ! 203: ! 204: listfiles(dirname) ! 205: char *dirname; ! 206: { ! 207: register DIR *dir; ! 208: struct direct *dirent; ! 209: int ecount, qucmp(); ! 210: register int f; ! 211: char *cp; ! 212: struct svfile *fp, svbuf[NENTRY]; ! 213: ! 214: /* ! 215: * Open _PATH_PRESERVE, and go there to make things quick. ! 216: */ ! 217: dir = opendir(dirname); ! 218: if (dir == NULL) { ! 219: perror(dirname); ! 220: return; ! 221: } ! 222: if (chdir(dirname) < 0) { ! 223: perror(dirname); ! 224: return; ! 225: } ! 226: ! 227: /* ! 228: * Look at the candidate files in _PATH_PRESERVE. ! 229: */ ! 230: fp = &svbuf[0]; ! 231: ecount = 0; ! 232: while ((dirent = readdir(dir)) != NULL) { ! 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(closedir(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 _PATH_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 _PATH_PRESERVE and, if we can get there, /tmp ! 381: * (actually the users "directory" option). ! 382: */ ! 383: searchdir(dir); ! 384: if (chdir(_PATH_PRESERVE) == 0) ! 385: searchdir(_PATH_PRESERVE); ! 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 _PATH_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 DIR *dir; ! 427: char dbuf[BUFSIZ]; ! 428: ! 429: dir = opendir(dirname); ! 430: if (dir == NULL) ! 431: return; ! 432: while ((dirent = readdir(dir)) != NULL) { ! 433: if (dirent->d_name[0] != 'E') ! 434: continue; ! 435: /* ! 436: * Got a file in the directory starting with E... ! 437: * Save a consed up name for the file to unlink ! 438: * later, and check that this is really a file ! 439: * we are looking for. ! 440: */ ! 441: ignore(strcat(strcat(strcpy(nb, dirname), "/"), dirent->d_name)); ! 442: if (yeah(nb)) { ! 443: /* ! 444: * Well, it is the file we are looking for. ! 445: * Is it more recent than any version we found before? ! 446: */ ! 447: if (H.Time > besttime) { ! 448: /* ! 449: * A winner. ! 450: */ ! 451: ignore(close(bestfd)); ! 452: bestfd = dup(tfile); ! 453: besttime = H.Time; ! 454: CP(bestnb, nb); ! 455: } ! 456: /* ! 457: * Count versions so user can be told there are ! 458: * ``yet more pages to be turned''. ! 459: */ ! 460: vercnt++; ! 461: } ! 462: ignore(close(tfile)); ! 463: } ! 464: ignore(closedir(dir)); ! 465: } ! 466: ! 467: /* ! 468: * Given a candidate file to be recovered, see ! 469: * if its really an editor temporary and of this ! 470: * user and the file specified. ! 471: */ ! 472: yeah(name) ! 473: char *name; ! 474: { ! 475: ! 476: tfile = open(name, 2); ! 477: if (tfile < 0) ! 478: return (0); ! 479: if (read(tfile, (char *) &H, sizeof H) != sizeof H) { ! 480: nope: ! 481: ignore(close(tfile)); ! 482: return (0); ! 483: } ! 484: if (!eq(savedfile, file)) ! 485: goto nope; ! 486: if (getuid() != H.Uid) ! 487: goto nope; ! 488: /* ! 489: * This is old and stupid code, which ! 490: * puts a word LOST in the header block, so that lost lines ! 491: * can be made to point at it. ! 492: */ ! 493: ignorl(lseek(tfile, (long)(BUFSIZ*HBLKS-8), 0)); ! 494: ignore(write(tfile, "LOST", 5)); ! 495: return (1); ! 496: } ! 497: ! 498: preserve() ! 499: { ! 500: ! 501: } ! 502: ! 503: /* ! 504: * Find the true end of the scratch file, and ``LOSE'' ! 505: * lines which point into thin air. This lossage occurs ! 506: * due to the sandbagging of i/o which can cause blocks to ! 507: * be written in a non-obvious order, different from the order ! 508: * in which the editor tried to write them. ! 509: * ! 510: * Lines which are lost are replaced with the text LOST so ! 511: * they are easy to find. We work hard at pretty formatting here ! 512: * as lines tend to be lost in blocks. ! 513: * ! 514: * This only seems to happen on very heavily loaded systems, and ! 515: * not very often. ! 516: */ ! 517: scrapbad() ! 518: { ! 519: register line *ip; ! 520: struct stat stbuf; ! 521: off_t size, maxt; ! 522: int bno, cnt, bad, was; ! 523: char bk[BUFSIZ]; ! 524: ! 525: ignore(fstat(tfile, &stbuf)); ! 526: size = stbuf.st_size; ! 527: maxt = (size >> SHFT) | (BNDRY-1); ! 528: bno = (maxt >> OFFBTS) & BLKMSK; ! 529: #ifdef DEBUG ! 530: fprintf(stderr, "size %ld, maxt %o, bno %d\n", size, maxt, bno); ! 531: #endif ! 532: ! 533: /* ! 534: * Look for a null separating two lines in the temp file; ! 535: * if last line was split across blocks, then it is lost ! 536: * if the last block is. ! 537: */ ! 538: while (bno > 0) { ! 539: ignorl(lseek(tfile, (long) BUFSIZ * bno, 0)); ! 540: cnt = read(tfile, (char *) bk, BUFSIZ); ! 541: while (cnt > 0) ! 542: if (bk[--cnt] == 0) ! 543: goto null; ! 544: bno--; ! 545: } ! 546: null: ! 547: ! 548: /* ! 549: * Magically calculate the largest valid pointer in the temp file, ! 550: * consing it up from the block number and the count. ! 551: */ ! 552: maxt = ((bno << OFFBTS) | (cnt >> SHFT)) & ~1; ! 553: #ifdef DEBUG ! 554: fprintf(stderr, "bno %d, cnt %d, maxt %o\n", bno, cnt, maxt); ! 555: #endif ! 556: ! 557: /* ! 558: * Now cycle through the line pointers, ! 559: * trashing the Lusers. ! 560: */ ! 561: was = bad = 0; ! 562: for (ip = one; ip <= dol; ip++) ! 563: if (*ip > maxt) { ! 564: #ifdef DEBUG ! 565: fprintf(stderr, "%d bad, %o > %o\n", ip - zero, *ip, maxt); ! 566: #endif ! 567: if (was == 0) ! 568: was = ip - zero; ! 569: *ip = ((HBLKS*BUFSIZ)-8) >> SHFT; ! 570: } else if (was) { ! 571: if (bad == 0) ! 572: fprintf(stderr, " [Lost line(s):"); ! 573: fprintf(stderr, " %d", was); ! 574: if ((ip - 1) - zero > was) ! 575: fprintf(stderr, "-%d", (ip - 1) - zero); ! 576: bad++; ! 577: was = 0; ! 578: } ! 579: if (was != 0) { ! 580: if (bad == 0) ! 581: fprintf(stderr, " [Lost line(s):"); ! 582: fprintf(stderr, " %d", was); ! 583: if (dol - zero != was) ! 584: fprintf(stderr, "-%d", dol - zero); ! 585: bad++; ! 586: } ! 587: if (bad) ! 588: fprintf(stderr, "]"); ! 589: } ! 590: ! 591: /* ! 592: * Aw shucks, if we only had a (void) cast. ! 593: */ ! 594: #ifdef lint ! 595: Ignorl(a) ! 596: long a; ! 597: { ! 598: ! 599: a = a; ! 600: } ! 601: ! 602: Ignore(a) ! 603: char *a; ! 604: { ! 605: ! 606: a = a; ! 607: } ! 608: ! 609: Ignorf(a) ! 610: int (*a)(); ! 611: { ! 612: ! 613: a = a; ! 614: } ! 615: ! 616: ignorl(a) ! 617: long a; ! 618: { ! 619: ! 620: a = a; ! 621: } ! 622: #endif ! 623: ! 624: int cntch, cntln, cntodd, cntnull; ! 625: /* ! 626: * Following routines stolen mercilessly from ex. ! 627: */ ! 628: putfile() ! 629: { ! 630: line *a1; ! 631: register char *fp, *lp; ! 632: register int nib; ! 633: ! 634: a1 = addr1; ! 635: clrstats(); ! 636: cntln = addr2 - a1 + 1; ! 637: if (cntln == 0) ! 638: return; ! 639: nib = BUFSIZ; ! 640: fp = genbuf; ! 641: do { ! 642: getline(*a1++); ! 643: lp = linebuf; ! 644: for (;;) { ! 645: if (--nib < 0) { ! 646: nib = fp - genbuf; ! 647: if (write(io, genbuf, nib) != nib) ! 648: wrerror(); ! 649: cntch += nib; ! 650: nib = 511; ! 651: fp = genbuf; ! 652: } ! 653: if ((*fp++ = *lp++) == 0) { ! 654: fp[-1] = '\n'; ! 655: break; ! 656: } ! 657: } ! 658: } while (a1 <= addr2); ! 659: nib = fp - genbuf; ! 660: if (write(io, genbuf, nib) != nib) ! 661: wrerror(); ! 662: cntch += nib; ! 663: } ! 664: ! 665: wrerror() ! 666: { ! 667: ! 668: syserror(); ! 669: } ! 670: ! 671: clrstats() ! 672: { ! 673: ! 674: ninbuf = 0; ! 675: cntch = 0; ! 676: cntln = 0; ! 677: cntnull = 0; ! 678: cntodd = 0; ! 679: } ! 680: ! 681: #define READ 0 ! 682: #define WRITE 1 ! 683: ! 684: getline(tl) ! 685: line tl; ! 686: { ! 687: register char *bp, *lp; ! 688: register int nl; ! 689: ! 690: lp = linebuf; ! 691: bp = getblock(tl, READ); ! 692: nl = nleft; ! 693: tl &= ~OFFMSK; ! 694: while (*lp++ = *bp++) ! 695: if (--nl == 0) { ! 696: bp = getblock(tl += INCRMT, READ); ! 697: nl = nleft; ! 698: } ! 699: } ! 700: ! 701: int read(); ! 702: int write(); ! 703: ! 704: char * ! 705: getblock(atl, iof) ! 706: line atl; ! 707: int iof; ! 708: { ! 709: register int bno, off; ! 710: ! 711: bno = (atl >> OFFBTS) & BLKMSK; ! 712: off = (atl << SHFT) & LBTMSK; ! 713: if (bno >= NMBLKS) ! 714: error(" Tmp file too large"); ! 715: nleft = BUFSIZ - off; ! 716: if (bno == iblock) { ! 717: ichanged |= iof; ! 718: return (ibuff + off); ! 719: } ! 720: if (bno == oblock) ! 721: return (obuff + off); ! 722: if (iof == READ) { ! 723: if (ichanged) ! 724: blkio(iblock, ibuff, write); ! 725: ichanged = 0; ! 726: iblock = bno; ! 727: blkio(bno, ibuff, read); ! 728: return (ibuff + off); ! 729: } ! 730: if (oblock >= 0) ! 731: blkio(oblock, obuff, write); ! 732: oblock = bno; ! 733: return (obuff + off); ! 734: } ! 735: ! 736: blkio(b, buf, iofcn) ! 737: short b; ! 738: char *buf; ! 739: int (*iofcn)(); ! 740: { ! 741: ! 742: lseek(tfile, (long) (unsigned) b * BUFSIZ, 0); ! 743: if ((*iofcn)(tfile, buf, BUFSIZ) != BUFSIZ) ! 744: syserror(); ! 745: } ! 746: ! 747: syserror() ! 748: { ! 749: char *strerror(); ! 750: ! 751: dirtcnt = 0; ! 752: write(2, " ", 1); ! 753: error(strerror(errno)); ! 754: exit(1); ! 755: } ! 756: ! 757: /* ! 758: * Must avoid stdio because expreserve uses sbrk to do memory ! 759: * allocation and stdio uses malloc. ! 760: */ ! 761: fprintf(fp, fmt, a1, a2, a3, a4, a5) ! 762: FILE *fp; ! 763: char *fmt; ! 764: char *a1, *a2, *a3, *a4, *a5; ! 765: { ! 766: char buf[BUFSIZ]; ! 767: ! 768: if (fp != stderr) ! 769: return; ! 770: sprintf(buf, fmt, a1, a2, a3, a4, a5); ! 771: write(2, buf, strlen(buf)); ! 772: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.