/*	$OpenBSD: history.c,v 1.41 2015/09/01 13:12:31 tedu Exp $	*/

/*	$OpenBSD: trap.c,v 1.23 2010/05/19 17:36:08 jasper Exp $	*/

/*-

 * Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,

 *		 2011, 2012, 2014, 2015, 2016, 2017

 *	mirabilos <m@mirbsd.org>

 *

 * Provided that these terms and disclaimer and all copyright notices

 * are retained or reproduced in an accompanying document, permission

 * is granted to deal in this work without restriction, including un-

 * limited rights to use, publicly perform, distribute, sell, modify,

 * merge, give away, or sublicence.

 *

 * This work is provided "AS IS" and WITHOUT WARRANTY of any kind, to

 * the utmost extent permitted by applicable law, neither express nor

 * implied; without malicious intent or gross negligence. In no event

 * may a licensor, author or contributor be held liable for indirect,

 * direct, other damage, loss, or other issues arising in any way out

 * of dealing in the work, even if advised of the possibility of such

 * damage or existence of a defect, except proven that it results out

 * of said person's immediate fault when using the work as intended.

 */

#include "sh.h"

#if HAVE_SYS_FILE_H

#include <sys/file.h>

#endif

__RCSID("$MirOS: src/bin/mksh/histrap.c,v 1.166 2017/08/07 23:25:09 tg Exp $");

Trap sigtraps[ksh_NSIG + 1];

static struct sigaction Sigact_ign;

#if HAVE_PERSISTENT_HISTORY

static int histload(Source *, unsigned char *, size_t);

static int writehistline(int, int, const char *);

static void writehistfile(int, const char *);

#endif

static int hist_execute(char *, Area *);

static char **hist_get(const char *, bool, bool);

static char **hist_get_oldest(void);

static bool hstarted;		/* set after hist_init() called */

static Source *hist_source;

#if HAVE_PERSISTENT_HISTORY

/*XXX imake style */

#if defined(__linux)

#define caddr_cast(x)	((void *)(x))

#else

#define caddr_cast(x)	((caddr_t)(x))

#endif

/* several OEs do not have these constants */

#ifndef MAP_FAILED

#define MAP_FAILED	caddr_cast(-1)

#endif

/* some OEs need the default mapping type specified */

#ifndef MAP_FILE

#define MAP_FILE	0

#endif

/* current history file: name, fd, size */

static char *hname;

static int histfd = -1;

static off_t histfsize;

#endif

/* HISTSIZE default: size of saved history, persistent or standard */

#ifdef MKSH_SMALL

#define MKSH_DEFHISTSIZE	255

#else

#define MKSH_DEFHISTSIZE	2047

#endif

/* maximum considered size of persistent history file */

#define MKSH_MAXHISTFSIZE	((off_t)1048576 * 96)

/* hidden option */

#define HIST_DISCARD		5

int

c_fc(const char **wp)

{

	struct shf *shf;

	struct temp *tf;

	bool gflag = false, lflag = false, nflag = false, rflag = false,

	    sflag = false;

	int optc;

	const char *p, *first = NULL, *last = NULL;

	char **hfirst, **hlast, **hp, *editor = NULL;

	if (!Flag(FTALKING_I)) {

		bi_errorf("history %ss not available", Tfunction);

		return (1);

	}

	while ((optc = ksh_getopt(wp, &builtin_opt,

	    "e:glnrs0,1,2,3,4,5,6,7,8,9,")) != -1)

		switch (optc) {

		case 'e':

			p = builtin_opt.optarg;

			if (ksh_isdash(p))

				sflag = true;

			else {

				size_t len = strlen(p);

				/* almost certainly not overflowing */

				editor = alloc(len + 4, ATEMP);

				memcpy(editor, p, len);

				memcpy(editor + len, Tspdollaru, 4);

			}

			break;

		/* non-AT&T ksh */

		case 'g':

			gflag = true;

			break;

		case 'l':

			lflag = true;

			break;

		case 'n':

			nflag = true;

			break;

		case 'r':

			rflag = true;

			break;

		/* POSIX version of -e - */

		case 's':

			sflag = true;

			break;

		/* kludge city - accept -num as -- -num (kind of) */

		case '0': case '1': case '2': case '3': case '4':

		case '5': case '6': case '7': case '8': case '9':

			p = shf_smprintf("-%c%s",

					optc, builtin_opt.optarg);

			if (!first)

				first = p;

			else if (!last)

				last = p;

			else {

				bi_errorf(Ttoo_many_args);

				return (1);

			}

			break;

		case '?':

			return (1);

		}

	wp += builtin_opt.optind;

	/* Substitute and execute command */

	if (sflag) {

		char *pat = NULL, *rep = NULL, *line;

		if (editor || lflag || nflag || rflag) {

			bi_errorf("can't use -e, -l, -n, -r with -s (-e -)");

			return (1);

		}

		/* Check for pattern replacement argument */

		if (*wp && **wp && (p = cstrchr(*wp + 1, '='))) {

			strdupx(pat, *wp, ATEMP);

			rep = pat + (p - *wp);

			*rep++ = '\0';

			wp++;

		}

		/* Check for search prefix */

		if (!first && (first = *wp))

			wp++;

		if (last || *wp) {

			bi_errorf(Ttoo_many_args);

			return (1);

		}

		hp = first ? hist_get(first, false, false) :

		    hist_get_newest(false);

		if (!hp)

			return (1);

		/* hist_replace */

		if (!pat)

			strdupx(line, *hp, ATEMP);

		else {

			char *s, *s1;

			size_t len, pat_len, rep_len;

			XString xs;

			char *xp;

			bool any_subst = false;

			pat_len = strlen(pat);

			rep_len = strlen(rep);

			Xinit(xs, xp, 128, ATEMP);

			for (s = *hp; (s1 = strstr(s, pat)) &&

			    (!any_subst || gflag); s = s1 + pat_len) {

				any_subst = true;

				len = s1 - s;

				XcheckN(xs, xp, len + rep_len);

				/*; first part */

				memcpy(xp, s, len);

				xp += len;

				/* replacement */

				memcpy(xp, rep, rep_len);

				xp += rep_len;

			}

			if (!any_subst) {

				bi_errorf(Tbadsubst);

				return (1);

			}

			len = strlen(s) + 1;

			XcheckN(xs, xp, len);

			memcpy(xp, s, len);

			xp += len;

			line = Xclose(xs, xp);

		}

		return (hist_execute(line, ATEMP));

	}

	if (editor && (lflag || nflag)) {

		bi_errorf("can't use -l, -n with -e");

		return (1);

	}

	if (!first && (first = *wp))

		wp++;

	if (!last && (last = *wp))

		wp++;

	if (*wp) {

		bi_errorf(Ttoo_many_args);

		return (1);

	}

	if (!first) {

		hfirst = lflag ? hist_get("-16", true, true) :

		    hist_get_newest(false);

		if (!hfirst)

			return (1);

		/* can't fail if hfirst didn't fail */

		hlast = hist_get_newest(false);

	} else {

		/*

		 * POSIX says not an error if first/last out of bounds

		 * when range is specified; AT&T ksh and pdksh allow out

		 * of bounds for -l as well.

		 */

		hfirst = hist_get(first, tobool(lflag || last), lflag);

		if (!hfirst)

			return (1);

		hlast = last ? hist_get(last, true, lflag) :

		    (lflag ? hist_get_newest(false) : hfirst);

		if (!hlast)

			return (1);

	}

	if (hfirst > hlast) {

		char **temp;

		temp = hfirst; hfirst = hlast; hlast = temp;

		/* POSIX */

		rflag = !rflag;

	}

	/* List history */

	if (lflag) {

		char *s, *t;

		for (hp = rflag ? hlast : hfirst;

		    hp >= hfirst && hp <= hlast; hp += rflag ? -1 : 1) {

			if (!nflag)

				shf_fprintf(shl_stdout, Tf_lu,

				    (unsigned long)hist_source->line -

				    (unsigned long)(histptr - hp));

			shf_putc('\t', shl_stdout);

			/* print multi-line commands correctly */

			s = *hp;

			while ((t = strchr(s, '\n'))) {

				*t = '\0';

				shf_fprintf(shl_stdout, "%s\n\t", s);

				*t++ = '\n';

				s = t;

			}

			shf_fprintf(shl_stdout, Tf_sN, s);

		}

		shf_flush(shl_stdout);

		return (0);

	}

	/* Run editor on selected lines, then run resulting commands */

	tf = maketemp(ATEMP, TT_HIST_EDIT, &e->temps);

	if (!(shf = tf->shf)) {

		bi_errorf(Tf_temp, Tcreate, tf->tffn, cstrerror(errno));

		return (1);

	}

	for (hp = rflag ? hlast : hfirst;

	    hp >= hfirst && hp <= hlast; hp += rflag ? -1 : 1)

		shf_fprintf(shf, Tf_sN, *hp);

	if (shf_close(shf) == -1) {

		bi_errorf(Tf_temp, Twrite, tf->tffn, cstrerror(errno));

		return (1);

	}

	/* Ignore setstr errors here (arbitrary) */

	setstr(local("_", false), tf->tffn, KSH_RETURN_ERROR);

	if ((optc = command(editor ? editor : TFCEDIT_dollaru, 0)))

		return (optc);

	{

		struct stat statb;

		XString xs;

		char *xp;

		ssize_t n;

		if (!(shf = shf_open(tf->tffn, O_RDONLY, 0, 0))) {

			bi_errorf(Tf_temp, Topen, tf->tffn, cstrerror(errno));

			return (1);

		}

		if (stat(tf->tffn, &statb) < 0)

			n = 128;

		else if ((off_t)statb.st_size > MKSH_MAXHISTFSIZE) {

			bi_errorf(Tf_toolarge, Thistory,

			    Tfile, (unsigned long)statb.st_size);

			goto errout;

		} else

			n = (size_t)statb.st_size + 1;

		Xinit(xs, xp, n, hist_source->areap);

		while ((n = shf_read(xp, Xnleft(xs, xp), shf)) > 0) {

			xp += n;

			if (Xnleft(xs, xp) <= 0)

				XcheckN(xs, xp, Xlength(xs, xp));

		}

		if (n < 0) {

			bi_errorf(Tf_temp, Tread, tf->tffn,

			    cstrerror(shf_errno(shf)));

 errout:

			shf_close(shf);

			return (1);

		}

		shf_close(shf);

		*xp = '\0';

		strip_nuls(Xstring(xs, xp), Xlength(xs, xp));

		return (hist_execute(Xstring(xs, xp), hist_source->areap));

	}

}

/* save cmd in history, execute cmd (cmd gets afree’d) */

static int

hist_execute(char *cmd, Area *areap)

{

	static int last_line = -1;

	/* Back up over last histsave */

	if (histptr >= history && last_line != hist_source->line) {

		hist_source->line--;

		afree(*histptr, APERM);

		histptr--;

		last_line = hist_source->line;

	}

	histsave(&hist_source->line, cmd, HIST_STORE, true);

	/* now *histptr == cmd without all trailing newlines */

	afree(cmd, areap);

	cmd = *histptr;

	/* pdksh says POSIX doesn’t say this is done, testsuite needs it */

	shellf(Tf_sN, cmd);

	/*-

	 * Commands are executed here instead of pushing them onto the

	 * input 'cause POSIX says the redirection and variable assignments

	 * in

	 *	X=y fc -e - 42 2> /dev/null

	 * are to effect the repeated commands environment.

	 */

	return (command(cmd, 0));

}

/*

 * get pointer to history given pattern

 * pattern is a number or string

 */

static char **

hist_get(const char *str, bool approx, bool allow_cur)

{

	char **hp = NULL;

	int n;

	if (getn(str, &n)) {

		hp = histptr + (n < 0 ? n : (n - hist_source->line));

		if ((size_t)hp < (size_t)history) {

			if (approx)

				hp = hist_get_oldest();

			else {

				bi_errorf(Tf_sD_s, str, Tnot_in_history);

				hp = NULL;

			}

		} else if ((size_t)hp > (size_t)histptr) {

			if (approx)

				hp = hist_get_newest(allow_cur);

			else {

				bi_errorf(Tf_sD_s, str, Tnot_in_history);

				hp = NULL;

			}

		} else if (!allow_cur && hp == histptr) {

			bi_errorf(Tf_sD_s, str, "invalid range");

			hp = NULL;

		}

	} else {

		bool anchored = *str == '?' ? (++str, false) : true;

		/* the -1 is to avoid the current fc command */

		if ((n = findhist(histptr - history - 1, 0, str, anchored)) < 0)

			bi_errorf(Tf_sD_s, str, Tnot_in_history);

		else

			hp = &history[n];

	}

	return (hp);

}

/* Return a pointer to the newest command in the history */

char **

hist_get_newest(bool allow_cur)

{

	if (histptr < history || (!allow_cur && histptr == history)) {

		bi_errorf("no history (yet)");

		return (NULL);

	}

	return (allow_cur ? histptr : histptr - 1);

}

/* Return a pointer to the oldest command in the history */

static char **

hist_get_oldest(void)

{

	if (histptr <= history) {

		bi_errorf("no history (yet)");

		return (NULL);

	}

	return (history);

}

#if !defined(MKSH_NO_CMDLINE_EDITING) && !MKSH_S_NOVI

/* current position in history[] */

static char **current;

/*

 * Return the current position.

 */

char **

histpos(void)

{

	return (current);

}

int

histnum(int n)

{

	int last = histptr - history;

	if (n < 0 || n >= last) {

		current = histptr;

		return (last);

	} else {

		current = &history[n];

		return (n);

	}

}

#endif

/*

 * This will become unnecessary if hist_get is modified to allow

 * searching from positions other than the end, and in either

 * direction.

 */

int

findhist(int start, int fwd, const char *str, bool anchored)

{

	char **hp;

	int maxhist = histptr - history;

	int incr = fwd ? 1 : -1;

	size_t len = strlen(str);

	if (start < 0 || start >= maxhist)

		start = maxhist;

	hp = &history[start];

	for (; hp >= history && hp <= histptr; hp += incr)

		if ((anchored && strncmp(*hp, str, len) == 0) ||

		    (!anchored && strstr(*hp, str)))

			return (hp - history);

	return (-1);

}

/*

 * set history; this means reallocating the dataspace

 */

void

sethistsize(mksh_ari_t n)

{

	if (n > 0 && n != histsize) {

		int cursize = histptr - history;

		/* save most recent history */

		if (n < cursize) {

			memmove(history, histptr - n + 1, n * sizeof(char *));

			cursize = n - 1;

		}

		history = aresize2(history, n, sizeof(char *), APERM);

		histsize = n;

		histptr = history + cursize;

	}

}

#if HAVE_PERSISTENT_HISTORY

/*

 * set history file; this can mean reloading/resetting/starting

 * history file maintenance

 */

void

sethistfile(const char *name)

{

	/* if not started then nothing to do */

	if (hstarted == false)

		return;

	/* if the name is the same as the name we have */

	if (hname && name && !strcmp(hname, name))

		return;

	/*

	 * it's a new name - possibly

	 */

	if (histfd != -1) {

		/* yes the file is open */

		(void)close(histfd);

		histfd = -1;

		histfsize = 0;

		afree(hname, APERM);

		hname = NULL;

		/* let's reset the history */

		histsave(NULL, NULL, HIST_DISCARD, true);

		histptr = history - 1;

		hist_source->line = 0;

	}

	if (name)

		hist_init(hist_source);

}

#endif

/*

 * initialise the history vector

 */

void

init_histvec(void)

{

	if (history == (char **)NULL) {

		histsize = MKSH_DEFHISTSIZE;

		history = alloc2(histsize, sizeof(char *), APERM);

		histptr = history - 1;

	}

}

/*

 * It turns out that there is a lot of ghastly hackery here

 */

#if !defined(MKSH_SMALL) && HAVE_PERSISTENT_HISTORY

/* do not save command in history but possibly sync */

bool

histsync(void)

{

	bool changed = false;

	/* called by histsave(), may not HIST_DISCARD, caller should flush */

	if (histfd != -1) {

		int lno = hist_source->line;

		hist_source->line++;

		writehistfile(0, NULL);

		hist_source->line--;

		if (lno != hist_source->line)

			changed = true;

	}

	return (changed);

}

#endif

/*

 * save command in history

 */

void

histsave(int *lnp, const char *cmd, int svmode, bool ignoredups)

{

	static char *enqueued = NULL;

	char **hp, *c;

	const char *ccp;

	if (svmode == HIST_DISCARD) {

		afree(enqueued, APERM);

		enqueued = NULL;

		return;

	}

	if (svmode == HIST_APPEND) {

		if (!enqueued)

			svmode = HIST_STORE;

	} else if (enqueued) {

		c = enqueued;

		enqueued = NULL;

		--*lnp;

		histsave(lnp, c, HIST_STORE, true);

		afree(c, APERM);

	}

	if (svmode == HIST_FLUSH)

		return;

	ccp = strnul(cmd);

	while (ccp > cmd && ccp[-1] == '\n')

		--ccp;

	strndupx(c, cmd, ccp - cmd, APERM);

	if (svmode != HIST_APPEND) {

		if (ignoredups &&

		    histptr >= history &&

		    !strcmp(c, *histptr)

#if !defined(MKSH_SMALL) && HAVE_PERSISTENT_HISTORY

		    && !histsync()

#endif

		    ) {

			afree(c, APERM);

			return;

		}

		++*lnp;

	}

#if HAVE_PERSISTENT_HISTORY

	if (svmode == HIST_STORE && histfd != -1)

		writehistfile(*lnp, c);

#endif

	if (svmode == HIST_QUEUE || svmode == HIST_APPEND) {

		size_t nenq, ncmd;

		if (!enqueued) {

			if (*c)

				enqueued = c;

			else

				afree(c, APERM);

			return;

		}

		nenq = strlen(enqueued);

		ncmd = strlen(c);

		enqueued = aresize(enqueued, nenq + 1 + ncmd + 1, APERM);

		enqueued[nenq] = '\n';

		memcpy(enqueued + nenq + 1, c, ncmd + 1);

		afree(c, APERM);

		return;

	}

	hp = histptr;

	if (++hp >= history + histsize) {

		/* remove oldest command */

		afree(*history, APERM);

		for (hp = history; hp < history + histsize - 1; hp++)

			hp[0] = hp[1];

	}

	*hp = c;

	histptr = hp;

}

/*

 * Write history data to a file nominated by HISTFILE;

 * if HISTFILE is unset then history still happens, but

 * the data is not written to a file. All copies of ksh

 * looking at the file will maintain the same history.

 * This is ksh behaviour.

 *

 * This stuff uses mmap()

 *

 * This stuff is so totally broken it must eventually be

 * redesigned, without mmap, better checks, support for

 * larger files, etc. and handle partially corrupted files

 */

/*-

 * Open a history file

 * Format is:

 * Bytes 1, 2:

 *	HMAGIC - just to check that we are dealing with the correct object

 * Then follows a number of stored commands

 * Each command is

 *	<command byte><command number(4 octets, big endian)><bytes><NUL>

 */

#define HMAGIC1		0xAB

#define HMAGIC2		0xCD

#define COMMAND		0xFF

#if HAVE_PERSISTENT_HISTORY

static const unsigned char sprinkle[2] = { HMAGIC1, HMAGIC2 };

static int

hist_persist_back(int srcfd)

{

	off_t tot, mis;

	ssize_t n, w;

	char *buf, *cp;

	int rv = 0;

#define MKSH_HS_BUFSIZ 4096

	if ((tot = lseek(srcfd, (off_t)0, SEEK_END)) < 0 ||

	    lseek(srcfd, (off_t)0, SEEK_SET) < 0 ||

	    lseek(histfd, (off_t)0, SEEK_SET) < 0)

		return (1);

	if ((buf = malloc_osfunc(MKSH_HS_BUFSIZ)) == NULL)

		return (1);

	mis = tot;

	while (mis > 0) {

		if ((n = blocking_read(srcfd, (cp = buf),

		    MKSH_HS_BUFSIZ)) == -1) {

			if (errno == EINTR) {

				intrcheck();

				continue;

			}

			goto copy_error;

		}

		mis -= n;

		while (n) {

			if (intrsig)

				goto has_intrsig;

			if ((w = write(histfd, cp, n)) != -1) {

				n -= w;

				cp += w;

				continue;

			}

			if (errno == EINTR) {

 has_intrsig:

				intrcheck();

				continue;

			}

			goto copy_error;

		}

	}

	if (ftruncate(histfd, tot)) {

 copy_error:

		rv = 1;

	}

	free_osfunc(buf);

	return (rv);

}

static void

hist_persist_init(void)

{

	unsigned char *base;

	int lines, fd;

	enum { hist_init_first, hist_init_retry, hist_use_it } hs;

	if (((hname = str_val(global("HISTFILE"))) == NULL) || !*hname) {

		hname = NULL;

		return;

	}

	strdupx(hname, hname, APERM);

	hs = hist_init_first;

 retry:

	/* we have a file and are interactive */

	if ((fd = binopen3(hname, O_RDWR | O_CREAT | O_APPEND, 0600)) < 0)

		return;

	if ((histfd = savefd(fd)) < 0)

		return;

	if (histfd != fd)

		close(fd);

	mksh_lockfd(histfd);

	histfsize = lseek(histfd, (off_t)0, SEEK_END);

	if (histfsize > MKSH_MAXHISTFSIZE) {

		/* we ignore too large files but still append to them */

		goto hist_init_tail;

	} else if (histfsize > 2) {

		/* we have some data, check its validity */

		base = (void *)mmap(NULL, (size_t)histfsize, PROT_READ,

		    MAP_FILE | MAP_PRIVATE, histfd, (off_t)0);

		if (base == (unsigned char *)MAP_FAILED)

			goto hist_init_fail;

		if (base[0] != HMAGIC1 || base[1] != HMAGIC2) {

			munmap(caddr_cast(base), (size_t)histfsize);

			goto hist_init_fail;

		}

		/* load _all_ data */

		lines = histload(hist_source, base + 2, (size_t)histfsize - 2);

		munmap(caddr_cast(base), (size_t)histfsize);

		/* check if the file needs to be truncated */

		if (lines > histsize && histptr >= history) {

			/* you're fucked up with the current code, trust me */

			char *nhname, **hp;

			struct stat sb;

			/* create temporary file */

			nhname = shf_smprintf("%s.%d", hname, (int)procpid);

			if ((fd = binopen3(nhname, O_RDWR | O_CREAT | O_TRUNC |

			    O_EXCL, 0600)) < 0) {

				/* just don't truncate then, meh. */

				hs = hist_use_it;

				goto hist_trunc_dont;

			}

			if (fstat(histfd, &sb) >= 0 &&

			    chown(nhname, sb.st_uid, sb.st_gid)) {

				/* abort the truncation then, meh. */

				goto hist_trunc_abort;

			}

			/* we definitively want some magic in that file */

			if (write(fd, sprinkle, 2) != 2)

				goto hist_trunc_abort;

			/* and of course the entries */

			hp = history;

			while (hp < histptr) {

				if (!writehistline(fd,

				    hist_source->line - (histptr - hp), *hp))

					goto hist_trunc_abort;

				++hp;

			}

			/* now transfer back */

			if (!hist_persist_back(fd)) {

				/* success! */

				hs = hist_use_it;

			}

 hist_trunc_abort:

			/* remove temporary file */

			close(fd);

			fd = -1;

			unlink(nhname);

			/* use whatever is in the file now */

 hist_trunc_dont:

			afree(nhname, ATEMP);

			if (hs == hist_use_it)

				goto hist_trunc_done;

			goto hist_init_fail;

		}

	} else if (histfsize != 0) {

		/* negative or too small... */

 hist_init_fail:

		/* ... or mmap failed or illegal */

		hist_finish();

		/* nuke the bogus file then retry, at most once */

		if (!unlink(hname) && hs != hist_init_retry) {

			hs = hist_init_retry;

			goto retry;

		}

		if (hs != hist_init_retry)

			bi_errorf(Tf_cant_ss_s,

			    "unlink HISTFILE", hname, cstrerror(errno));

		histfsize = 0;

		return;

	} else {

		/* size 0, add magic to the history file */

		if (write(histfd, sprinkle, 2) != 2) {

			hist_finish();

			return;

		}

	}