![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_temp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / ex|
Return to ex_temp.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / 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: static char *sccsid = "@(#)ex_temp.c 7.6 (Berkeley) 3/9/87"; ! 9: #endif not lint ! 10: ! 11: #include "ex.h" ! 12: #include "ex_temp.h" ! 13: #include "ex_vis.h" ! 14: #include "ex_tty.h" ! 15: ! 16: /* ! 17: * Editor temporary file routines. ! 18: * Very similar to those of ed, except uses 2 input buffers. ! 19: */ ! 20: #define READ 0 ! 21: #define WRITE 1 ! 22: ! 23: #ifndef vms ! 24: #define EPOSITION 7 ! 25: #else ! 26: #define EPOSITION 13 ! 27: #endif ! 28: ! 29: char tfname[40]; ! 30: char rfname[40]; ! 31: int havetmp; ! 32: short tfile = -1; ! 33: short rfile = -1; ! 34: ! 35: fileinit() ! 36: { ! 37: register char *p; ! 38: register int i, j; ! 39: struct stat stbuf; ! 40: ! 41: if (tline == INCRMT * (HBLKS+2)) ! 42: return; ! 43: cleanup(0); ! 44: if (tfile >= 0) ! 45: close(tfile); ! 46: tline = INCRMT * (HBLKS+2); ! 47: blocks[0] = HBLKS; ! 48: blocks[1] = HBLKS+1; ! 49: blocks[2] = -1; ! 50: dirtcnt = 0; ! 51: iblock = -1; ! 52: iblock2 = -1; ! 53: oblock = -1; ! 54: CP(tfname, svalue(DIRECTORY)); ! 55: #ifndef vms ! 56: if (stat(tfname, &stbuf)) ! 57: #else ! 58: goto vms_no_check_dir; ! 59: #endif ! 60: { ! 61: dumbness: ! 62: if (setexit() == 0) ! 63: filioerr(tfname); ! 64: else ! 65: putNFL(); ! 66: cleanup(1); ! 67: ex_exit(1); ! 68: } ! 69: #ifndef vms ! 70: if ((stbuf.st_mode & S_IFMT) != S_IFDIR) { ! 71: errno = ENOTDIR; ! 72: goto dumbness; ! 73: } ! 74: #else ! 75: vms_no_check_dir: ! 76: #endif ! 77: ichanged = 0; ! 78: ichang2 = 0; ! 79: #ifndef vms ! 80: ignore(strcat(tfname, "/ExXXXXX")); ! 81: #else ! 82: ignore(strcat(tfname, "ExXXXXX")); ! 83: #endif ! 84: for (p = strend(tfname), i = 5, j = getpid(); i > 0; i--, j /= 10) ! 85: *--p = j % 10 | '0'; ! 86: #ifdef vms ! 87: ignore(strcat(tfname, ".txt.1")); ! 88: unlink(tfname); ! 89: #endif ! 90: tfile = creat(tfname, 0600); ! 91: if (tfile < 0) ! 92: goto dumbness; ! 93: #ifdef VMUNIX ! 94: { ! 95: extern stilinc; /* see below */ ! 96: stilinc = 0; ! 97: } ! 98: #endif ! 99: havetmp = 1; ! 100: if (tfile >= 0) ! 101: close(tfile); ! 102: tfile = open(tfname, 2); ! 103: if (tfile < 0) ! 104: goto dumbness; ! 105: #ifdef UNIX_SBRK ! 106: /* brk((char *)fendcore); */ ! 107: #endif ! 108: } ! 109: ! 110: cleanup(all) ! 111: bool all; ! 112: { ! 113: if (all) { ! 114: putpad(TE); ! 115: flush(); ! 116: } ! 117: if (havetmp) { ! 118: if (tfile >= 0) ! 119: close(tfile); ! 120: unlink(tfname); ! 121: } ! 122: havetmp = 0; ! 123: if (all && rfile >= 0) { ! 124: if (rfile >= 0) ! 125: close(rfile); ! 126: unlink(rfname); ! 127: rfile = -1; ! 128: } ! 129: } ! 130: ! 131: getline(tl) ! 132: line tl; ! 133: { ! 134: register char *bp, *lp; ! 135: register int nl; ! 136: ! 137: lp = linebuf; ! 138: bp = getblock(tl, READ); ! 139: nl = nleft; ! 140: tl &= ~OFFMSK; ! 141: while (*lp++ = *bp++) ! 142: if (--nl == 0) { ! 143: bp = getblock(tl += INCRMT, READ); ! 144: nl = nleft; ! 145: } ! 146: } ! 147: ! 148: putline() ! 149: { ! 150: register char *bp, *lp; ! 151: register int nl; ! 152: line tl; ! 153: ! 154: dirtcnt++; ! 155: lp = linebuf; ! 156: change(); ! 157: tl = tline; ! 158: bp = getblock(tl, WRITE); ! 159: nl = nleft; ! 160: tl &= ~OFFMSK; ! 161: while (*bp = *lp++) { ! 162: if (*bp++ == '\n') { ! 163: *--bp = 0; ! 164: linebp = lp; ! 165: break; ! 166: } ! 167: if (--nl == 0) { ! 168: bp = getblock(tl += INCRMT, WRITE); ! 169: nl = nleft; ! 170: } ! 171: } ! 172: tl = tline; ! 173: tline += (((lp - linebuf) + BNDRY - 1) >> SHFT) & 077776; ! 174: return (tl); ! 175: } ! 176: ! 177: int read(); ! 178: int write(); ! 179: ! 180: char * ! 181: getblock(atl, iof) ! 182: line atl; ! 183: int iof; ! 184: { ! 185: register int bno, off; ! 186: #ifdef CRYPT ! 187: register char *p1, *p2; ! 188: register int n; ! 189: #endif ! 190: ! 191: bno = (atl >> OFFBTS) & BLKMSK; ! 192: off = (atl << SHFT) & LBTMSK; ! 193: if (bno >= NMBLKS) ! 194: error(" Tmp file too large"); ! 195: nleft = BUFSIZ - off; ! 196: if (bno == iblock) { ! 197: ichanged |= iof; ! 198: hitin2 = 0; ! 199: return (ibuff + off); ! 200: } ! 201: if (bno == iblock2) { ! 202: ichang2 |= iof; ! 203: hitin2 = 1; ! 204: return (ibuff2 + off); ! 205: } ! 206: if (bno == oblock) ! 207: return (obuff + off); ! 208: if (iof == READ) { ! 209: if (hitin2 == 0) { ! 210: if (ichang2) { ! 211: #ifdef CRYPT ! 212: if(xtflag) ! 213: crblock(tperm, ibuff2, CRSIZE, (long)0); ! 214: #endif ! 215: blkio(iblock2, ibuff2, write); ! 216: } ! 217: ichang2 = 0; ! 218: iblock2 = bno; ! 219: blkio(bno, ibuff2, read); ! 220: #ifdef CRYPT ! 221: if(xtflag) ! 222: crblock(tperm, ibuff2, CRSIZE, (long)0); ! 223: #endif ! 224: hitin2 = 1; ! 225: return (ibuff2 + off); ! 226: } ! 227: hitin2 = 0; ! 228: if (ichanged) { ! 229: #ifdef CRYPT ! 230: if(xtflag) ! 231: crblock(tperm, ibuff, CRSIZE, (long)0); ! 232: #endif ! 233: blkio(iblock, ibuff, write); ! 234: } ! 235: ichanged = 0; ! 236: iblock = bno; ! 237: blkio(bno, ibuff, read); ! 238: #ifdef CRYPT ! 239: if(xtflag) ! 240: crblock(tperm, ibuff, CRSIZE, (long)0); ! 241: #endif ! 242: return (ibuff + off); ! 243: } ! 244: if (oblock >= 0) { ! 245: #ifdef CRYPT ! 246: if(xtflag) { ! 247: /* ! 248: * Encrypt block before writing, so some devious ! 249: * person can't look at temp file while editing. ! 250: */ ! 251: p1 = obuff; ! 252: p2 = crbuf; ! 253: n = CRSIZE; ! 254: while(n--) ! 255: *p2++ = *p1++; ! 256: crblock(tperm, crbuf, CRSIZE, (long)0); ! 257: blkio(oblock, crbuf, write); ! 258: } else ! 259: #endif ! 260: blkio(oblock, obuff, write); ! 261: } ! 262: oblock = bno; ! 263: return (obuff + off); ! 264: } ! 265: ! 266: #ifdef VMUNIX ! 267: #ifdef vms ! 268: #define INCORB 32 ! 269: #else ! 270: #define INCORB 64 ! 271: #endif ! 272: char incorb[INCORB+1][BUFSIZ]; ! 273: #define pagrnd(a) ((char *)(((int)a)&~(BUFSIZ-1))) ! 274: int stilinc; /* up to here not written yet */ ! 275: #endif ! 276: ! 277: blkio(b, buf, iofcn) ! 278: short b; ! 279: char *buf; ! 280: int (*iofcn)(); ! 281: { ! 282: ! 283: #ifdef VMUNIX ! 284: if (b < INCORB) { ! 285: if (iofcn == read) { ! 286: bcopy(pagrnd(incorb[b+1]), buf, BUFSIZ); ! 287: return; ! 288: } ! 289: bcopy(buf, pagrnd(incorb[b+1]), BUFSIZ); ! 290: if (laste) { ! 291: if (b >= stilinc) ! 292: stilinc = b + 1; ! 293: return; ! 294: } ! 295: } else if (stilinc) ! 296: tflush(); ! 297: #endif ! 298: lseek(tfile, (long) (unsigned) b * BUFSIZ, 0); ! 299: if ((*iofcn)(tfile, buf, BUFSIZ) != BUFSIZ) ! 300: filioerr(tfname); ! 301: } ! 302: ! 303: #ifdef VMUNIX ! 304: tlaste() ! 305: { ! 306: ! 307: if (stilinc) ! 308: dirtcnt = 0; ! 309: } ! 310: ! 311: tflush() ! 312: { ! 313: int i = stilinc; ! 314: ! 315: stilinc = 0; ! 316: lseek(tfile, (long) 0, 0); ! 317: if (write(tfile, pagrnd(incorb[1]), i * BUFSIZ) != (i * BUFSIZ)) ! 318: filioerr(tfname); ! 319: } ! 320: #endif ! 321: ! 322: /* ! 323: * Synchronize the state of the temporary file in case ! 324: * a crash occurs. ! 325: */ ! 326: synctmp() ! 327: { ! 328: register int cnt; ! 329: register line *a; ! 330: register short *bp; ! 331: ! 332: #ifdef VMUNIX ! 333: if (stilinc) ! 334: return; ! 335: #endif ! 336: if (dol == zero) ! 337: return; ! 338: if (ichanged) ! 339: blkio(iblock, ibuff, write); ! 340: ichanged = 0; ! 341: if (ichang2) ! 342: blkio(iblock2, ibuff2, write); ! 343: ichang2 = 0; ! 344: if (oblock != -1) ! 345: blkio(oblock, obuff, write); ! 346: time(&H.Time); ! 347: uid = getuid(); ! 348: *zero = (line) H.Time; ! 349: for (a = zero, bp = blocks; a <= dol; a += BUFSIZ / sizeof *a, bp++) { ! 350: if (*bp < 0) { ! 351: tline = (tline + OFFMSK) &~ OFFMSK; ! 352: *bp = ((tline >> OFFBTS) & BLKMSK); ! 353: if (*bp > NMBLKS) ! 354: error(" Tmp file too large"); ! 355: tline += INCRMT; ! 356: oblock = *bp + 1; ! 357: bp[1] = -1; ! 358: } ! 359: lseek(tfile, (long) (unsigned) *bp * BUFSIZ, 0); ! 360: cnt = ((dol - a) + 2) * sizeof (line); ! 361: if (cnt > BUFSIZ) ! 362: cnt = BUFSIZ; ! 363: if (write(tfile, (char *) a, cnt) != cnt) { ! 364: oops: ! 365: *zero = 0; ! 366: filioerr(tfname); ! 367: } ! 368: *zero = 0; ! 369: } ! 370: flines = lineDOL(); ! 371: lseek(tfile, 0l, 0); ! 372: if (write(tfile, (char *) &H, sizeof H) != sizeof H) ! 373: goto oops; ! 374: #ifdef notdef ! 375: /* ! 376: * This will insure that exrecover gets as much ! 377: * back after a crash as is absolutely possible, ! 378: * but can result in pregnant pauses between commands ! 379: * when the TSYNC call is made, so... ! 380: */ ! 381: #ifndef vms ! 382: (void) fsync(tfile); ! 383: #endif ! 384: #endif ! 385: } ! 386: ! 387: TSYNC() ! 388: { ! 389: ! 390: if (dirtcnt > MAXDIRT) { /* mjm: 12 --> MAXDIRT */ ! 391: #ifdef VMUNIX ! 392: if (stilinc) ! 393: tflush(); ! 394: #endif ! 395: dirtcnt = 0; ! 396: synctmp(); ! 397: } ! 398: } ! 399: ! 400: /* ! 401: * Named buffer routines. ! 402: * These are implemented differently than the main buffer. ! 403: * Each named buffer has a chain of blocks in the register file. ! 404: * Each block contains roughly 508 chars of text, ! 405: * and a previous and next block number. We also have information ! 406: * about which blocks came from deletes of multiple partial lines, ! 407: * e.g. deleting a sentence or a LISP object. ! 408: * ! 409: * We maintain a free map for the temp file. To free the blocks ! 410: * in a register we must read the blocks to find how they are chained ! 411: * together. ! 412: * ! 413: * BUG: The default savind of deleted lines in numbered ! 414: * buffers may be rather inefficient; it hasn't been profiled. ! 415: */ ! 416: struct strreg { ! 417: short rg_flags; ! 418: short rg_nleft; ! 419: short rg_first; ! 420: short rg_last; ! 421: } strregs[('z'-'a'+1) + ('9'-'0'+1)], *strp; ! 422: ! 423: struct rbuf { ! 424: short rb_prev; ! 425: short rb_next; ! 426: char rb_text[BUFSIZ - 2 * sizeof (short)]; ! 427: } *rbuf, KILLrbuf, putrbuf, YANKrbuf, regrbuf; ! 428: #ifdef VMUNIX ! 429: short rused[256]; ! 430: #else ! 431: short rused[32]; ! 432: #endif ! 433: short rnleft; ! 434: short rblock; ! 435: short rnext; ! 436: char *rbufcp; ! 437: ! 438: regio(b, iofcn) ! 439: short b; ! 440: int (*iofcn)(); ! 441: { ! 442: ! 443: if (rfile == -1) { ! 444: CP(rfname, tfname); ! 445: *(strend(rfname) - EPOSITION) = 'R'; ! 446: rfile = creat(rfname, 0600); ! 447: if (rfile < 0) ! 448: oops: ! 449: filioerr(rfname); ! 450: else ! 451: close(rfile); ! 452: rfile = open(rfname, 2); ! 453: if (rfile < 0) ! 454: goto oops; ! 455: } ! 456: lseek(rfile, (long) b * BUFSIZ, 0); ! 457: if ((*iofcn)(rfile, rbuf, BUFSIZ) != BUFSIZ) ! 458: goto oops; ! 459: rblock = b; ! 460: } ! 461: ! 462: REGblk() ! 463: { ! 464: register int i, j, m; ! 465: ! 466: for (i = 0; i < sizeof rused / sizeof rused[0]; i++) { ! 467: m = (rused[i] ^ 0177777) & 0177777; ! 468: if (i == 0) ! 469: m &= ~1; ! 470: if (m != 0) { ! 471: j = 0; ! 472: while ((m & 1) == 0) ! 473: j++, m >>= 1; ! 474: rused[i] |= (1 << j); ! 475: #ifdef RDEBUG ! 476: ex_printf("allocating block %d\n", i * 16 + j); ! 477: #endif ! 478: return (i * 16 + j); ! 479: } ! 480: } ! 481: error("Out of register space (ugh)"); ! 482: /*NOTREACHED*/ ! 483: } ! 484: ! 485: struct strreg * ! 486: mapreg(c) ! 487: register int c; ! 488: { ! 489: ! 490: if (isupper(c)) ! 491: c = tolower(c); ! 492: return (isdigit(c) ? &strregs[('z'-'a'+1)+(c-'0')] : &strregs[c-'a']); ! 493: } ! 494: ! 495: int shread(); ! 496: ! 497: KILLreg(c) ! 498: register int c; ! 499: { ! 500: register struct strreg *sp; ! 501: ! 502: rbuf = &KILLrbuf; ! 503: sp = mapreg(c); ! 504: rblock = sp->rg_first; ! 505: sp->rg_first = sp->rg_last = 0; ! 506: sp->rg_flags = sp->rg_nleft = 0; ! 507: while (rblock != 0) { ! 508: #ifdef RDEBUG ! 509: ex_printf("freeing block %d\n", rblock); ! 510: #endif ! 511: rused[rblock / 16] &= ~(1 << (rblock % 16)); ! 512: regio(rblock, shread); ! 513: rblock = rbuf->rb_next; ! 514: } ! 515: } ! 516: ! 517: /*VARARGS*/ ! 518: shread() ! 519: { ! 520: struct front { short a; short b; }; ! 521: ! 522: if (read(rfile, (char *) rbuf, sizeof (struct front)) == sizeof (struct front)) ! 523: return (sizeof (struct rbuf)); ! 524: return (0); ! 525: } ! 526: ! 527: int getREG(); ! 528: ! 529: putreg(c) ! 530: char c; ! 531: { ! 532: register line *odot = dot; ! 533: register line *odol = dol; ! 534: register int cnt; ! 535: ! 536: deletenone(); ! 537: appendnone(); ! 538: rbuf = &putrbuf; ! 539: rnleft = 0; ! 540: rblock = 0; ! 541: rnext = mapreg(c)->rg_first; ! 542: if (rnext == 0) { ! 543: if (inopen) { ! 544: splitw++; ! 545: vclean(); ! 546: vgoto(WECHO, 0); ! 547: } ! 548: vreg = -1; ! 549: error("Nothing in register %c", c); ! 550: } ! 551: if (inopen && partreg(c)) { ! 552: if (!FIXUNDO) { ! 553: splitw++; vclean(); vgoto(WECHO, 0); vreg = -1; ! 554: error("Can't put partial line inside macro"); ! 555: } ! 556: squish(); ! 557: addr1 = addr2 = dol; ! 558: } ! 559: cnt = append(getREG, addr2); ! 560: if (inopen && partreg(c)) { ! 561: unddol = dol; ! 562: dol = odol; ! 563: dot = odot; ! 564: pragged(0); ! 565: } ! 566: killcnt(cnt); ! 567: notecnt = cnt; ! 568: } ! 569: ! 570: partreg(c) ! 571: char c; ! 572: { ! 573: ! 574: return (mapreg(c)->rg_flags); ! 575: } ! 576: ! 577: notpart(c) ! 578: register int c; ! 579: { ! 580: ! 581: if (c) ! 582: mapreg(c)->rg_flags = 0; ! 583: } ! 584: ! 585: getREG() ! 586: { ! 587: register char *lp = linebuf; ! 588: register int c; ! 589: ! 590: for (;;) { ! 591: if (rnleft == 0) { ! 592: if (rnext == 0) ! 593: return (EOF); ! 594: regio(rnext, read); ! 595: rnext = rbuf->rb_next; ! 596: rbufcp = rbuf->rb_text; ! 597: rnleft = sizeof rbuf->rb_text; ! 598: } ! 599: c = *rbufcp; ! 600: if (c == 0) ! 601: return (EOF); ! 602: rbufcp++, --rnleft; ! 603: if (c == '\n') { ! 604: *lp++ = 0; ! 605: return (0); ! 606: } ! 607: *lp++ = c; ! 608: } ! 609: } ! 610: ! 611: YANKreg(c) ! 612: register int c; ! 613: { ! 614: register line *addr; ! 615: register struct strreg *sp; ! 616: char savelb[LBSIZE]; ! 617: ! 618: if (isdigit(c)) ! 619: kshift(); ! 620: if (islower(c)) ! 621: KILLreg(c); ! 622: strp = sp = mapreg(c); ! 623: sp->rg_flags = inopen && cursor && wcursor; ! 624: rbuf = &YANKrbuf; ! 625: if (sp->rg_last) { ! 626: regio(sp->rg_last, read); ! 627: rnleft = sp->rg_nleft; ! 628: rbufcp = &rbuf->rb_text[sizeof rbuf->rb_text - rnleft]; ! 629: } else { ! 630: rblock = 0; ! 631: rnleft = 0; ! 632: } ! 633: CP(savelb,linebuf); ! 634: for (addr = addr1; addr <= addr2; addr++) { ! 635: getline(*addr); ! 636: if (sp->rg_flags) { ! 637: if (addr == addr2) ! 638: *wcursor = 0; ! 639: if (addr == addr1) ! 640: strcpy(linebuf, cursor); ! 641: } ! 642: YANKline(); ! 643: } ! 644: rbflush(); ! 645: killed(); ! 646: CP(linebuf,savelb); ! 647: } ! 648: ! 649: kshift() ! 650: { ! 651: register int i; ! 652: ! 653: KILLreg('9'); ! 654: for (i = '8'; i >= '0'; i--) ! 655: copy(mapreg(i+1), mapreg(i), sizeof (struct strreg)); ! 656: } ! 657: ! 658: YANKline() ! 659: { ! 660: register char *lp = linebuf; ! 661: register struct rbuf *rp = rbuf; ! 662: register int c; ! 663: ! 664: do { ! 665: c = *lp++; ! 666: if (c == 0) ! 667: c = '\n'; ! 668: if (rnleft == 0) { ! 669: rp->rb_next = REGblk(); ! 670: rbflush(); ! 671: rblock = rp->rb_next; ! 672: rp->rb_next = 0; ! 673: rp->rb_prev = rblock; ! 674: rnleft = sizeof rp->rb_text; ! 675: rbufcp = rp->rb_text; ! 676: } ! 677: *rbufcp++ = c; ! 678: --rnleft; ! 679: } while (c != '\n'); ! 680: if (rnleft) ! 681: *rbufcp = 0; ! 682: } ! 683: ! 684: rbflush() ! 685: { ! 686: register struct strreg *sp = strp; ! 687: ! 688: if (rblock == 0) ! 689: return; ! 690: regio(rblock, write); ! 691: if (sp->rg_first == 0) ! 692: sp->rg_first = rblock; ! 693: sp->rg_last = rblock; ! 694: sp->rg_nleft = rnleft; ! 695: } ! 696: ! 697: /* Register c to char buffer buf of size buflen */ ! 698: regbuf(c, buf, buflen) ! 699: char c; ! 700: char *buf; ! 701: int buflen; ! 702: { ! 703: register char *p, *lp; ! 704: ! 705: rbuf = ®rbuf; ! 706: rnleft = 0; ! 707: rblock = 0; ! 708: rnext = mapreg(c)->rg_first; ! 709: if (rnext==0) { ! 710: *buf = 0; ! 711: error("Nothing in register %c",c); ! 712: } ! 713: p = buf; ! 714: while (getREG()==0) { ! 715: for (lp=linebuf; *lp;) { ! 716: if (p >= &buf[buflen]) ! 717: error("Register too long@to fit in memory"); ! 718: *p++ = *lp++; ! 719: } ! 720: *p++ = '\n'; ! 721: } ! 722: if (partreg(c)) p--; ! 723: *p = '\0'; ! 724: getDOT(); ! 725: } ! 726: ! 727: /* ! 728: * Encryption routines. These are essentially unmodified from ed. ! 729: */ ! 730: ! 731: #ifdef CRYPT ! 732: /* ! 733: * crblock: encrypt/decrypt a block of text. ! 734: * buf is the buffer through which the text is both input and ! 735: * output. nchar is the size of the buffer. permp is a work ! 736: * buffer, and startn is the beginning of a sequence. ! 737: */ ! 738: crblock(permp, buf, nchar, startn) ! 739: char *permp; ! 740: char *buf; ! 741: int nchar; ! 742: long startn; ! 743: { ! 744: register char *p1; ! 745: int n1; ! 746: int n2; ! 747: register char *t1, *t2, *t3; ! 748: ! 749: t1 = permp; ! 750: t2 = &permp[256]; ! 751: t3 = &permp[512]; ! 752: ! 753: n1 = startn&0377; ! 754: n2 = (startn>>8)&0377; ! 755: p1 = buf; ! 756: while(nchar--) { ! 757: *p1 = t2[(t3[(t1[(*p1+n1)&0377]+n2)&0377]-n2)&0377]-n1; ! 758: n1++; ! 759: if(n1==256){ ! 760: n1 = 0; ! 761: n2++; ! 762: if(n2==256) n2 = 0; ! 763: } ! 764: p1++; ! 765: } ! 766: } ! 767: ! 768: /* ! 769: * makekey: initialize buffers based on user key a. ! 770: */ ! 771: makekey(a, b) ! 772: char *a, *b; ! 773: { ! 774: register int i; ! 775: long t; ! 776: char temp[KSIZE + 1]; ! 777: ! 778: for(i = 0; i < KSIZE; i++) ! 779: temp[i] = *a++; ! 780: time(&t); ! 781: t += getpid(); ! 782: for(i = 0; i < 4; i++) ! 783: temp[i] ^= (t>>(8*i))&0377; ! 784: crinit(temp, b); ! 785: } ! 786: ! 787: /* ! 788: * crinit: besides initializing the encryption machine, this routine ! 789: * returns 0 if the key is null, and 1 if it is non-null. ! 790: */ ! 791: crinit(keyp, permp) ! 792: char *keyp, *permp; ! 793: { ! 794: register char *t1, *t2, *t3; ! 795: register i; ! 796: int ic, k, temp; ! 797: unsigned random; ! 798: char buf[13]; ! 799: long seed; ! 800: ! 801: t1 = permp; ! 802: t2 = &permp[256]; ! 803: t3 = &permp[512]; ! 804: if(*keyp == 0) ! 805: return(0); ! 806: strncpy(buf, keyp, 8); ! 807: while (*keyp) ! 808: *keyp++ = '\0'; ! 809: ! 810: buf[8] = buf[0]; ! 811: buf[9] = buf[1]; ! 812: domakekey(buf); ! 813: ! 814: seed = 123; ! 815: for (i=0; i<13; i++) ! 816: seed = seed*buf[i] + i; ! 817: for(i=0;i<256;i++){ ! 818: t1[i] = i; ! 819: t3[i] = 0; ! 820: } ! 821: for(i=0; i<256; i++) { ! 822: seed = 5*seed + buf[i%13]; ! 823: random = seed % 65521; ! 824: k = 256-1 - i; ! 825: ic = (random&0377) % (k+1); ! 826: random >>= 8; ! 827: temp = t1[k]; ! 828: t1[k] = t1[ic]; ! 829: t1[ic] = temp; ! 830: if(t3[k]!=0) continue; ! 831: ic = (random&0377) % k; ! 832: while(t3[ic]!=0) ic = (ic+1) % k; ! 833: t3[k] = ic; ! 834: t3[ic] = k; ! 835: } ! 836: for(i=0; i<256; i++) ! 837: t2[t1[i]&0377] = i; ! 838: return(1); ! 839: } ! 840: ! 841: /* ! 842: * domakekey: the following is the major nonportable part of the encryption ! 843: * mechanism. A 10 character key is supplied in buffer. ! 844: * This string is fed to makekey (an external program) which ! 845: * responds with a 13 character result. This result is placed ! 846: * in buffer. ! 847: */ ! 848: domakekey(buffer) ! 849: char *buffer; ! 850: { ! 851: int pf[2]; ! 852: ! 853: if (pipe(pf)<0) ! 854: pf[0] = pf[1] = -1; ! 855: if (fork()==0) { ! 856: close(0); ! 857: close(1); ! 858: dup(pf[0]); ! 859: dup(pf[1]); ! 860: execl("/usr/lib/makekey", "-", 0); ! 861: execl("/lib/makekey", "-", 0); ! 862: ex_exit(1); ! 863: } ! 864: write(pf[1], buffer, 10); ! 865: if (wait((int *)NULL)==-1 || read(pf[0], buffer, 13)!=13) ! 866: error("crypt: cannot generate key"); ! 867: close(pf[0]); ! 868: close(pf[1]); ! 869: /* end of nonportable part */ ! 870: } ! 871: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.