[unix-history] / usr / src / usr.bin / ex / ex_temp.c

/* Copyright (c) 1980 Regents of the University of California */
static char *sccsid = "@(#)ex_temp.c	4.2 %G%";
#include "ex.h"
#include "ex_temp.h"
#include "ex_vis.h"
#include "ex_tty.h"

/*
 * Editor temporary file routines.
 * Very similar to those of ed, except uses 2 input buffers.
 */
#define	READ	0
#define	WRITE	1

char	tfname[40];
char	rfname[40];
int	havetmp;
short	tfile = -1;
short	rfile = -1;

fileinit()
{
	register char *p;
	register int i, j;
	struct stat stbuf;

	if (tline == INCRMT * (HBLKS+2))
		return;
	cleanup(0);
	close(tfile);
	tline = INCRMT * (HBLKS+2);
	blocks[0] = HBLKS;
	blocks[1] = HBLKS+1;
	blocks[2] = -1;
	dirtcnt = 0;
	iblock = -1;
	iblock2 = -1;
	oblock = -1;
	CP(tfname, svalue(DIRECTORY));
	if (stat(tfname, &stbuf)) {
dumbness:
		if (setexit() == 0)
			filioerr(tfname);
		else
			putNFL();
		cleanup(1);
		exit(1);
	}
	if ((stbuf.st_mode & S_IFMT) != S_IFDIR) {
		errno = ENOTDIR;
		goto dumbness;
	}
	ichanged = 0;
	ichang2 = 0;
	ignore(strcat(tfname, "/ExXXXXX"));
	for (p = strend(tfname), i = 5, j = getpid(); i > 0; i--, j /= 10)
		*--p = j % 10 | '0';
	tfile = creat(tfname, 0600);
	if (tfile < 0)
		goto dumbness;
#ifdef VMUNIX
	{
		extern stilinc;		/* see below */
		stilinc = 0;
	}
#endif
	havetmp = 1;
	close(tfile);
	tfile = open(tfname, 2);
	if (tfile < 0)
		goto dumbness;
/* 	brk((char *)fendcore); */
}

cleanup(all)
	bool all;
{
	if (all) {
		putpad(TE);
		flush();
	}
	if (havetmp)
		unlink(tfname);
	havetmp = 0;
	if (all && rfile >= 0) {
		unlink(rfname);
		close(rfile);
		rfile = -1;
	}
}

getline(tl)
	line tl;
{
	register char *bp, *lp;
	register int nl;

	lp = linebuf;
	bp = getblock(tl, READ);
	nl = nleft;
	tl &= ~OFFMSK;
	while (*lp++ = *bp++)
		if (--nl == 0) {
			bp = getblock(tl += INCRMT, READ);
			nl = nleft;
		}
}

putline()
{
	register char *bp, *lp;
	register int nl;
	line tl;

	dirtcnt++;
	lp = linebuf;
	change();
	tl = tline;
	bp = getblock(tl, WRITE);
	nl = nleft;
	tl &= ~OFFMSK;
	while (*bp = *lp++) {
		if (*bp++ == '\n') {
			*--bp = 0;
			linebp = lp;
			break;
		}
		if (--nl == 0) {
			bp = getblock(tl += INCRMT, WRITE);
			nl = nleft;
		}
	}
	tl = tline;
	tline += (((lp - linebuf) + BNDRY - 1) >> SHFT) & 077776;
	return (tl);
}

int	read();
int	write();

char *
getblock(atl, iof)
	line atl;
	int iof;
{
	register int bno, off;
        register char *p1, *p2;
        register int n;
	
	bno = (atl >> OFFBTS) & BLKMSK;
	off = (atl << SHFT) & LBTMSK;
	if (bno >= NMBLKS)
		error(" Tmp file too large");
	nleft = BUFSIZ - off;
	if (bno == iblock) {
		ichanged |= iof;
		hitin2 = 0;
		return (ibuff + off);
	}
	if (bno == iblock2) {
		ichang2 |= iof;
		hitin2 = 1;
		return (ibuff2 + off);
	}
	if (bno == oblock)
		return (obuff + off);
	if (iof == READ) {
		if (hitin2 == 0) {
			if (ichang2) {
				if(xtflag)
					crblock(tperm, ibuff2, CRSIZE, (long)0);
				blkio(iblock2, ibuff2, write);
			}
			ichang2 = 0;
			iblock2 = bno;
			blkio(bno, ibuff2, read);
			if(xtflag)
				crblock(tperm, ibuff2, CRSIZE, (long)0);
			hitin2 = 1;
			return (ibuff2 + off);
		}
		hitin2 = 0;
		if (ichanged) {
			if(xtflag)
				crblock(tperm, ibuff, CRSIZE, (long)0);
			blkio(iblock, ibuff, write);
		}
		ichanged = 0;
		iblock = bno;
		blkio(bno, ibuff, read);
		if(xtflag)
			crblock(tperm, ibuff, CRSIZE, (long)0);
		return (ibuff + off);
	}
	if (oblock >= 0) {
		if(xtflag) {
			/*
			 * Encrypt block before writing, so some devious
			 * person can't look at temp file while editing.
			 */
			p1 = obuff;
			p2 = crbuf;
			n = CRSIZE;
			while(n--)
				*p2++ = *p1++;
			crblock(tperm, crbuf, CRSIZE, (long)0);
			blkio(oblock, crbuf, write);
		} else
			blkio(oblock, obuff, write);
	}
	oblock = bno;
	return (obuff + off);
}

#ifdef	VMUNIX
#define	INCORB	64
char	incorb[INCORB+1][BUFSIZ];
#define	pagrnd(a)	((char *)(((int)a)&~(BUFSIZ-1)))
int	stilinc;	/* up to here not written yet */
#endif

blkio(b, buf, iofcn)
	short b;
	char *buf;
	int (*iofcn)();
{

#ifdef VMUNIX
	if (b < INCORB) {
		if (iofcn == read) {
			bcopy(pagrnd(incorb[b+1]), buf, BUFSIZ);
			return;
		}
		bcopy(buf, pagrnd(incorb[b+1]), BUFSIZ);
		if (laste) {
			if (b >= stilinc)
				stilinc = b + 1;
			return;
		}
	} else if (stilinc)
		tflush();
#endif
	lseek(tfile, (long) (unsigned) b * BUFSIZ, 0);
	if ((*iofcn)(tfile, buf, BUFSIZ) != BUFSIZ)
		filioerr(tfname);
}

#ifdef VMUNIX
tlaste()
{

	if (stilinc)
		dirtcnt = 0;
}

tflush()
{
	int i = stilinc;
	
	stilinc = 0;
	lseek(tfile, (long) 0, 0);
	if (write(tfile, pagrnd(incorb[1]), i * BUFSIZ) != (i * BUFSIZ))
		filioerr(tfname);
}
#endif

/*
 * Synchronize the state of the temporary file in case
 * a crash occurs.
 */
synctmp()
{
	register int cnt;
	register line *a;
	register short *bp;

#ifdef VMUNIX
	if (stilinc)
		return;
#endif
	if (dol == zero)
		return;
	if (ichanged)
		blkio(iblock, ibuff, write);
	ichanged = 0;
	if (ichang2)
		blkio(iblock2, ibuff2, write);
	ichang2 = 0;
	if (oblock != -1)
		blkio(oblock, obuff, write);
	time(&H.Time);
	uid = getuid();
	*zero = (line) H.Time;
	for (a = zero, bp = blocks; a <= dol; a += BUFSIZ / sizeof *a, bp++) {
		if (*bp < 0) {
			tline = (tline + OFFMSK) &~ OFFMSK;
			*bp = ((tline >> OFFBTS) & BLKMSK);
			if (*bp > NMBLKS)
				error(" Tmp file too large");
			tline += INCRMT;
			oblock = *bp + 1;
			bp[1] = -1;
		}
		lseek(tfile, (long) (unsigned) *bp * BUFSIZ, 0);
		cnt = ((dol - a) + 2) * sizeof (line);
		if (cnt > BUFSIZ)
			cnt = BUFSIZ;
		if (write(tfile, (char *) a, cnt) != cnt) {
oops:
			*zero = 0;
			filioerr(tfname);
		}
		*zero = 0;
	}
	flines = lineDOL();
	lseek(tfile, 0l, 0);
	if (write(tfile, (char *) &H, sizeof H) != sizeof H)
		goto oops;
}

TSYNC()
{

	if (dirtcnt > 12) {
#ifdef VMUNIX
		if (stilinc)
			tflush();
#endif
		dirtcnt = 0;
		synctmp();
	}
}

/*
 * Named buffer routines.
 * These are implemented differently than the main buffer.
 * Each named buffer has a chain of blocks in the register file.
 * Each block contains roughly 508 chars of text,
 * and a previous and next block number.  We also have information
 * about which blocks came from deletes of multiple partial lines,
 * e.g. deleting a sentence or a LISP object.
 *
 * We maintain a free map for the temp file.  To free the blocks
 * in a register we must read the blocks to find how they are chained
 * together.
 *
 * BUG:		The default savind of deleted lines in numbered
 *		buffers may be rather inefficient; it hasn't been profiled.
 */
struct	strreg {
	short	rg_flags;
	short	rg_nleft;
	short	rg_first;
	short	rg_last;
} strregs[('z'-'a'+1) + ('9'-'0'+1)], *strp;

struct	rbuf {
	short	rb_prev;
	short	rb_next;
	char	rb_text[BUFSIZ - 2 * sizeof (short)];
} *rbuf;
#ifdef VMUNIX
short	rused[256];
#else
short	rused[32];
#endif
short	rnleft;
short	rblock;
short	rnext;
char	*rbufcp;

regio(b, iofcn)
	short b;
	int (*iofcn)();
{

	if (rfile == -1) {
		CP(rfname, tfname);
		*(strend(rfname) - 7) = 'R';
		rfile = creat(rfname, 0600);
		if (rfile < 0)
oops:
			filioerr(rfname);
		close(rfile);
		rfile = open(rfname, 2);
		if (rfile < 0)
			goto oops;
	}
	lseek(rfile, (long) b * BUFSIZ, 0);
	if ((*iofcn)(rfile, rbuf, BUFSIZ) != BUFSIZ)
		goto oops;
	rblock = b;
}

REGblk()
{
	register int i, j, m;

	for (i = 0; i < sizeof rused / sizeof rused[0]; i++) {
		m = (rused[i] ^ 0177777) & 0177777;
		if (i == 0)
			m &= ~1;
		if (m != 0) {
			j = 0;
			while ((m & 1) == 0)
				j++, m >>= 1;
			rused[i] |= (1 << j);
#ifdef RDEBUG
			printf("allocating block %d\n", i * 16 + j);
#endif
			return (i * 16 + j);
		}
	}
	error("Out of register space (ugh)");
	/*NOTREACHED*/
}

struct	strreg *
mapreg(c)
	register int c;
{

	if (isupper(c))
		c = tolower(c);
	return (isdigit(c) ? &strregs[('z'-'a'+1)+(c-'0')] : &strregs[c-'a']);
}

int	shread();

KILLreg(c)
	register int c;
{
	struct rbuf arbuf;
	register struct strreg *sp;

	rbuf = &arbuf;
	sp = mapreg(c);
	rblock = sp->rg_first;
	sp->rg_first = sp->rg_last = 0;
	sp->rg_flags = sp->rg_nleft = 0;
	while (rblock != 0) {
#ifdef RDEBUG
		printf("freeing block %d\n", rblock);
#endif
		rused[rblock / 16] &= ~(1 << (rblock % 16));
		regio(rblock, shread);
		rblock = rbuf->rb_next;
	}
}

/*VARARGS*/
shread()
{
	struct front { short a; short b; };

	if (read(rfile, (char *) rbuf, sizeof (struct front)) == sizeof (struct front))
		return (sizeof (struct rbuf));
	return (0);
}

int	getREG();

putreg(c)
	char c;
{
	struct rbuf arbuf;
	register line *odot = dot;
	register line *odol = dol;
	register int cnt;

	deletenone();
	appendnone();
	rbuf = &arbuf;
	rnleft = 0;
	rblock = 0;
	rnext = mapreg(c)->rg_first;
	if (rnext == 0) {
		if (inopen) {
			splitw++;
			vclean();
			vgoto(WECHO, 0);
		}
		vreg = -1;
		error("Nothing in register %c", c);
	}
	if (inopen && partreg(c)) {
		if (!FIXUNDO) {
			splitw++; vclean(); vgoto(WECHO, 0); vreg = -1;
			error("Can't put partial line inside macro");
		}
		squish();
		addr1 = addr2 = dol;
	}
	cnt = append(getREG, addr2);
	if (inopen && partreg(c)) {
		unddol = dol;
		dol = odol;
		dot = odot;
		pragged(0);
	}
	killcnt(cnt);
	notecnt = cnt;
}

partreg(c)
	char c;
{

	return (mapreg(c)->rg_flags);
}

notpart(c)
	register int c;
{

	if (c)
		mapreg(c)->rg_flags = 0;
}

getREG()
{
	register char *lp = linebuf;
	register int c;

	for (;;) {
		if (rnleft == 0) {
			if (rnext == 0)
				return (EOF);
			regio(rnext, read);
			rnext = rbuf->rb_next;
			rbufcp = rbuf->rb_text;
			rnleft = sizeof rbuf->rb_text;
		}
		c = *rbufcp;
		if (c == 0)
			return (EOF);
		rbufcp++, --rnleft;
		if (c == '\n') {
			*lp++ = 0;
			return (0);
		}
		*lp++ = c;
	}
}

YANKreg(c)
	register int c;
{
	struct rbuf arbuf;
	register line *addr;
	register struct strreg *sp;

	if (isdigit(c))
		kshift();
	if (islower(c))
		KILLreg(c);
	strp = sp = mapreg(c);
	sp->rg_flags = inopen && cursor && wcursor;
	rbuf = &arbuf;
	if (sp->rg_last) {
		regio(sp->rg_last, read);
		rnleft = sp->rg_nleft;
		rbufcp = &rbuf->rb_text[sizeof rbuf->rb_text - rnleft];
	} else {
		rblock = 0;
		rnleft = 0;
	}
	for (addr = addr1; addr <= addr2; addr++) {
		getline(*addr);
		if (sp->rg_flags) {
			if (addr == addr2)
				*wcursor = 0;
			if (addr == addr1)
				strcpy(linebuf, cursor);
		}
		YANKline();
	}
	rbflush();
	killed();
}

kshift()
{
	register int i;

	KILLreg('9');
	for (i = '8'; i >= '0'; i--)
		copy(mapreg(i+1), mapreg(i), sizeof (struct strreg));
}

YANKline()
{
	register char *lp = linebuf;
	register struct rbuf *rp = rbuf;
	register int c;

	do {
		c = *lp++;
		if (c == 0)
			c = '\n';
		if (rnleft == 0) {
			rp->rb_next = REGblk();
			rbflush();
			rblock = rp->rb_next;
			rp->rb_next = 0;
			rp->rb_prev = rblock;
			rnleft = sizeof rp->rb_text;
			rbufcp = rp->rb_text;
		}
		*rbufcp++ = c;
		--rnleft;
	} while (c != '\n');
	if (rnleft)
		*rbufcp = 0;
}

rbflush()
{
	register struct strreg *sp = strp;

	if (rblock == 0)
		return;
	regio(rblock, write);
	if (sp->rg_first == 0)
		sp->rg_first = rblock;
	sp->rg_last = rblock;
	sp->rg_nleft = rnleft;
}

/* Register c to char buffer buf of size buflen */
regbuf(c, buf, buflen)
char c;
char *buf;
int buflen;
{
	struct rbuf arbuf;
	register char *p, *lp;

	rbuf = &arbuf;
	rnleft = 0;
	rblock = 0;
	rnext = mapreg(c)->rg_first;
	if (rnext==0) {
		*buf = 0;
		error("Nothing in register %c",c);
	}
	p = buf;
	while (getREG()==0) {
		for (lp=linebuf; *lp;) {
			if (p >= &buf[buflen])
				error("Register too long@to fit in memory");
			*p++ = *lp++;
		}
		*p++ = '\n';
	}
	if (partreg(c)) p--;
	*p = '\0';
	getDOT();
}

/*
 * Encryption routines.  These are essentially unmodified from ed.
 */

/*
 * crblock: encrypt/decrypt a block of text.
 * buf is the buffer through which the text is both input and
 * output. nchar is the size of the buffer. permp is a work
 * buffer, and startn is the beginning of a sequence.
 */
crblock(permp, buf, nchar, startn)
char *permp;
char *buf;
int nchar;
long startn;
{
	register char *p1;
	int n1;
	int n2;
	register char *t1, *t2, *t3;

	t1 = permp;
	t2 = &permp[256];
	t3 = &permp[512];

	n1 = startn&0377;
	n2 = (startn>>8)&0377;
	p1 = buf;
	while(nchar--) {
		*p1 = t2[(t3[(t1[(*p1+n1)&0377]+n2)&0377]-n2)&0377]-n1;
		n1++;
		if(n1==256){
			n1 = 0;
			n2++;
			if(n2==256) n2 = 0;
		}
		p1++;
	}
}

/*
 * makekey: initialize buffers based on user key a.
 */
makekey(a, b)
char *a, *b;
{
       register int i;
	long t;
	char temp[KSIZE + 1];

	for(i = 0; i < KSIZE; i++)
		temp[i] = *a++;
	time(&t);
	t += getpid();
	for(i = 0; i < 4; i++)
		temp[i] ^= (t>>(8*i))&0377;
	crinit(temp, b);
}

/*
 * crinit: besides initializing the encryption machine, this routine
 * returns 0 if the key is null, and 1 if it is non-null.
 */
crinit(keyp, permp)
char    *keyp, *permp;
{
       register char *t1, *t2, *t3;
	register i;
	int ic, k, temp;
	unsigned random;
	char buf[13];
	long seed;

	t1 = permp;
	t2 = &permp[256];
	t3 = &permp[512];
	if(*keyp == 0)
		return(0);
	strncpy(buf, keyp, 8);
	while (*keyp)
		*keyp++ = '\0';

	buf[8] = buf[0];
	buf[9] = buf[1];
	domakekey(buf);

	seed = 123;
	for (i=0; i<13; i++)
		seed = seed*buf[i] + i;
	for(i=0;i<256;i++){
		t1[i] = i;
		t3[i] = 0;
	}
	for(i=0; i<256; i++) {
		seed = 5*seed + buf[i%13];
		random = seed % 65521;
		k = 256-1 - i;
		ic = (random&0377) % (k+1);
		random >>= 8;
		temp = t1[k];
		t1[k] = t1[ic];
		t1[ic] = temp;
		if(t3[k]!=0) continue;
		ic = (random&0377) % k;
		while(t3[ic]!=0) ic = (ic+1) % k;
		t3[k] = ic;
		t3[ic] = k;
	}
	for(i=0; i<256; i++)
		t2[t1[i]&0377] = i;
	return(1);
}

/*
 * domakekey: the following is the major nonportable part of the encryption
 * mechanism. A 10 character key is supplied in buffer.
 * This string is fed to makekey (an external program) which
 * responds with a 13 character result. This result is placed
 * in buffer.
 */
domakekey(buffer)
char *buffer;
{
       int pf[2];

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