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