/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


/* Copyright (c) 1981 Regents of the University of California */

#include "ex.h"
#include "ex_temp.h"
#include "ex_vis.h"
#include "ex_tty.h"
#include <unistd.h>

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

unsigned char	tfname[PATH_MAX+1];
static unsigned char	rfname[PATH_MAX+1];
static unsigned char	tempname[PATH_MAX+1];
int	havetmp;
short	tfile = -1;
static short	rfile = -1;

extern int junk();

void
fileinit(void)
{
	unsigned char *p;
	pid_t j;
	int i;
	struct stat64 stbuf;

	if (tline == INCRMT * (HBLKS+2))
		return;
	cleanup(0);
	if (tfile != -1)
		close(tfile);
	tline = INCRMT * (HBLKS+2);
	blocks[0] = HBLKS;
	blocks[1] = HBLKS+1;
	blocks[2] = -1;
	dirtcnt = 0;
	iblock = -1;
	iblock2 = -1;
	oblock = -1;
	if (strlen(svalue(vi_DIRECTORY)) > (PATH_MAX -13))
		error(gettext("User set directory too long"));
	CP(tfname, svalue(vi_DIRECTORY));
	if (stat64((char *)tfname, &stbuf)) {
dumbness:
		if (setexit() == 0)
			filioerr(tfname);
		else
			putNFL();
		cleanup(1);
		exit(++errcnt);
	}
	if (!ISDIR(stbuf)) {
		errno = ENOTDIR;
		goto dumbness;
	}
	CP(tempname, tfname);
	ichanged = 0;
	ichang2 = 0;
	(void) strcat(tfname, "/ExXXXXXX");
	if ((tfile = mkstemp((char *)tfname)) < 0)
		goto dumbness;
#ifdef VMUNIX
	{
		extern int stilinc;		/* see below */
		stilinc = 0;
	}
#endif
	havetmp = 1;
/* 	brk((unsigned char *)fendcore); */
}

void
cleanup(bool all)
{
	pid_t pgrp;
	if (all) {
		if (kflag)
			crypt_close(perm);
		if (xtflag)
			crypt_close(tperm);
		putpad((unsigned char *)exit_ca_mode);
		flush();
		if (ioctl(2, TIOCGPGRP, &pgrp) == 0) {
			if (pgrp == getpgid(0)) {
#ifdef XPG4
				if (envlines != -1 || envcolumns != -1) {
					struct winsize jwin;
					jwin.ws_row = oldlines;
					jwin.ws_col = oldcolumns;
					ioctl(0, TIOCSWINSZ, &jwin);
				}
#endif /* XPG4 */
				resetterm();
				normtty--;
			}
		} else {
#ifdef XPG4
			if (envlines != -1 || envcolumns != -1) {
				struct winsize jwin;
				jwin.ws_row = oldlines;
				jwin.ws_col = oldcolumns;
				ioctl(0, TIOCSWINSZ, &jwin);
			}
#endif /* XPG4 */
			resetterm();
			normtty--;
		}
	}
	if (havetmp)
		unlink((char *)tfname);
	havetmp = 0;
	if (all && rfile >= 0) {
		unlink((char *)rfname);
		close(rfile);
		rfile = -1;
	}
	if (all == 1)
		exit(errcnt);
}

void
getaline(line tl)
{
	unsigned char *bp, *lp;
	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;
		}
}

int
putline(void)
{
	unsigned char *bp, *lp;
	unsigned char tmpbp;
	int nl;
	line tl;

	dirtcnt++;
	lp = linebuf;
	change();
	tl = tline;
	bp = getblock(tl, WRITE);
	nl = nleft;
	tl &= ~OFFMSK;
	while (*bp = *lp++) {
		tmpbp = *bp;
		if (tmpbp == '\n') {
			*bp = 0;
			linebp = lp;
			break;
		} else if (junk(*bp++)) {
			checkjunk(tmpbp);
			*--bp;
		}
		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();

unsigned char *
getblock(line atl, int iof)
{
	int bno, off;
	unsigned char *p1, *p2;
	int n;
	line *tmpptr;

	bno = (atl >> OFFBTS) & BLKMSK;
	off = (atl << SHFT) & LBTMSK;
	if (bno >= NMBLKS) {
		/*
		 * When we overflow tmpfile buffers,
		 * throw away line which could not be
		 * put into buffer.
		 */
		for (tmpptr = dot; tmpptr < unddol; tmpptr++)
			*tmpptr = *(tmpptr+1);
		if (dot == dol)
			dot--;
		dol--;
		unddol--;
		error(gettext(" Tmp file too large"));
	}
	nleft = BUFSIZE - 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) {
					if (run_crypt(0L, ibuff2,
					    CRSIZE, tperm) == -1) {
						filioerr(tfname);
					}
				}
				blkio(iblock2, ibuff2, write);
			}
			ichang2 = 0;
			iblock2 = bno;
			blkio(bno, ibuff2, read);
			if (xtflag)
				if (run_crypt(0L, ibuff2, CRSIZE, tperm) == -1)
					filioerr(tfname);
			hitin2 = 1;
			return (ibuff2 + off);
		}
		hitin2 = 0;
		if (ichanged) {
			if (xtflag)
				if (run_crypt(0L, ibuff, CRSIZE, tperm) == -1)
					filioerr(tfname);
			blkio(iblock, ibuff, write);
		}
		ichanged = 0;
		iblock = bno;
		blkio(bno, ibuff, read);
		if (xtflag)
			if (run_crypt(0L, ibuff, CRSIZE, tperm) == -1)
				filioerr(tfname);
		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++;
			if (run_crypt(0L, crbuf, CRSIZE, tperm) == -1)
				filioerr(tfname);
			blkio(oblock, crbuf, write);
		} else
			blkio(oblock, obuff, write);
	}
	oblock = bno;
	return (obuff + off);
}

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

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

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

#ifdef VMUNIX
void
tlaste(void)
{

	if (stilinc)
		dirtcnt = 0;
}

void
tflush(void)
{
	int i = stilinc;

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

/*
 * Synchronize the state of the temporary file in case
 * a crash occurs.
 */
void
synctmp(void)
{
	int cnt;
	line *a;
	short *bp;
	unsigned char *p1, *p2;
	int n;

#ifdef VMUNIX
	if (stilinc)
		return;
#endif
	if (dol == zero)
		return;
	/*
	 * In theory, we need to encrypt iblock and iblock2 before writing
	 * them out, as well as oblock, but in practice ichanged and ichang2
	 * can never be set, so this isn't really needed.  Likewise, the
	 * code in getblock above for iblock+iblock2 isn't needed.
	 */
	if (ichanged)
		blkio(iblock, ibuff, write);
	ichanged = 0;
	if (ichang2)
		blkio(iblock2, ibuff2, write);
	ichang2 = 0;
	if (oblock != -1)
	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++;
		if (run_crypt(0L, crbuf, CRSIZE, tperm) == -1)
			filioerr(tfname);
		blkio(oblock, crbuf, write);
	} else
		blkio(oblock, obuff, write);
	time(&H.Time);
	uid = getuid();
	if (xtflag)
		H.encrypted = 1;
	else
		H.encrypted = 0;
	*zero = (line) H.Time;
	for (a = zero, bp = blocks; a <= dol;
	    a += BUFSIZE / sizeof (*a), bp++) {
		if (bp >= &H.Blocks[LBLKS-1])
			error(gettext(
			    "file too large to recover with -r option"));
		if (*bp < 0) {
			tline = (tline + OFFMSK) &~ OFFMSK;
			*bp = ((tline >> OFFBTS) & BLKMSK);
			if (*bp > NMBLKS)
				error(gettext(" Tmp file too large"));
			tline += INCRMT;
			oblock = *bp + 1;
			bp[1] = -1;
		}
		lseek(tfile, (long)(unsigned)*bp * BUFSIZE, 0);
		cnt = ((dol - a) + 2) * sizeof (line);
		if (cnt > BUFSIZE)
			cnt = BUFSIZE;
		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;
}

void
TSYNC(void)
{

	if (dirtcnt > MAXDIRT) {
#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;
	unsigned char	rb_text[BUFSIZE - 2 * sizeof (short)];
} *rbuf, KILLrbuf, putrbuf, YANKrbuf, regrbuf;
#ifdef VMUNIX
short	rused[256];
#else
short	rused[32];
#endif
short	rnleft;
short	rblock;
short	rnext;
unsigned char	*rbufcp;

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

	if (rfile == -1) {
		CP(rfname, tempname);
		(void) strcat(rfname, "/RxXXXXXX");
		if ((rfile = mkstemp((char *)rfname)) < 0)
			filioerr(rfname);
	}
	lseek(rfile, (long)b * BUFSIZE, 0);
	if ((*iofcn)(rfile, rbuf, BUFSIZE) != BUFSIZE)
		filioerr(rfname);
	rblock = b;
}

int
REGblk(void)
{
	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
			viprintf("allocating block %d\n", i * 16 + j);
#endif
			return (i * 16 + j);
		}
	}
	error(gettext("Out of register space (ugh)"));
	/*NOTREACHED*/
	return (0);
}

struct strreg *
mapreg(int c)
{

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

int	shread();

void
KILLreg(int c)
{
	struct strreg *sp;

	rbuf = &KILLrbuf;
	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
		viprintf("freeing block %d\n", rblock);
#endif
		rused[rblock / 16] &= ~(1 << (rblock % 16));
		regio(rblock, shread);
		rblock = rbuf->rb_next;
	}
}

/*VARARGS*/
int
shread(void)
{
	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();

int
putreg(unsigned char c)
{
	line *odot = dot;
	line *odol = dol;
	int cnt;

	deletenone();
	appendnone();
	rbuf = &putrbuf;
	rnleft = 0;
	rblock = 0;
	rnext = mapreg(c)->rg_first;
	if (rnext == 0) {
		if (inopen) {
			splitw++;
			vclean();
			vgoto(WECHO, 0);
		}
		vreg = -1;
		error(gettext("Nothing in register %c"), c);
	}
	if (inopen && partreg(c)) {
		if (!FIXUNDO) {
			splitw++; vclean(); vgoto(WECHO, 0); vreg = -1;
			error(gettext("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;
	return (0);
}

short
partreg(unsigned char c)
{

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

void
notpart(int c)
{

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

int
getREG(void)
{
	unsigned char *lp = linebuf;
	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;
	}
}

int
YANKreg(int c)
{
	line *addr;
	struct strreg *sp;
	unsigned char savelb[LBSIZE];

	if (isdigit(c))
		kshift();
	if (islower(c))
		KILLreg(c);
	strp = sp = mapreg(c);
	sp->rg_flags = inopen && cursor && wcursor;
	rbuf = &YANKrbuf;
	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;
	}
	CP(savelb, linebuf);
	for (addr = addr1; addr <= addr2; addr++) {
		getaline(*addr);
		if (sp->rg_flags) {
			if (addr == addr2)
				*wcursor = 0;
			if (addr == addr1)
				strcpy(linebuf, cursor);
		}
		YANKline();
	}
	rbflush();
	killed();
	CP(linebuf, savelb);
	return (0);
}

void
kshift(void)
{
	int i;

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

void
YANKline(void)
{
	unsigned char *lp = linebuf;
	struct rbuf *rp = rbuf;
	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;
}

void
rbflush(void)
{
	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 */
void
regbuf(unsigned char c, unsigned char *buf, int buflen)
{
	unsigned char *p, *lp;

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

#ifdef TRACE

/*
 * Test code for displaying named registers.
 */

shownam()
{
	int k;

	viprintf("\nRegister   Contents\n");
	viprintf("========   ========\n");
	for (k = 'a'; k <= 'z'; k++) {
		rbuf = &putrbuf;
		rnleft = 0;
		rblock = 0;
		rnext = mapreg(k)->rg_first;
		viprintf(" %c:", k);
		if (rnext == 0)
			viprintf("\t\tNothing in register.\n");
		while (getREG() == 0) {
			viprintf("\t\t%s\n", linebuf);
		}
	}
	return (0);
}

/*
 * Test code for displaying numbered registers.
 */

shownbr()
{
	int k;

	viprintf("\nRegister   Contents\n");
	viprintf("========   ========\n");
	for (k = '1'; k <= '9'; k++) {
		rbuf = &putrbuf;
		rnleft = 0;
		rblock = 0;
		rnext = mapreg(k)->rg_first;
		viprintf(" %c:", k);
		if (rnext == 0)
			viprintf("\t\tNothing in register.\n");
		while (getREG() == 0) {
			viprintf("\t\t%s\n", linebuf);
		}
	}
	return (0);
}
#endif