/* Copyright (c) 2008, 2009
 *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
 *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
 *      Micah Cowan (micah@cowan.name)
 *      Sadrul Habib Chowdhury (sadrul@users.sourceforge.net)
 * Copyright (c) 1993-2002, 2003, 2005, 2006, 2007
 *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
 *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
 * Copyright (c) 1987 Oliver Laumann
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program (see the file COPYING); if not, see
 * https://www.gnu.org/licenses/, or contact Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 *
 ****************************************************************
 */

#include <sys/types.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <pwd.h>

#ifndef SIGINT
# include <signal.h>
#endif

#include "config.h" 
#include "screen.h"
#include "extern.h"

extern struct display *display, *displays;
extern struct win *fore;
extern struct layer *flayer;
extern int    ServerSocket;
extern int    real_uid, eff_uid;
extern int    real_gid, eff_gid;
extern char  *extra_incap, *extra_outcap;
extern char  *home, *RcFileName;
extern char   SockPath[], *SockName;
#ifdef COPY_PASTE
extern char  *BufferFile;
#endif
extern int    hardcopy_append;
extern char  *hardcopydir;

static char  *CatExtra __P((char *, char *));
static char  *findrcfile __P((char *));

char *rc_name = "";
int rc_recursion = 0;

static char *
CatExtra(register char *str1, register char *str2)
{
	register char *cp;
	register int len1, len2, add_colon;

	len1 = strlen(str1);
	if (len1 == 0)
		return str2;
	add_colon = (str1[len1 - 1] != ':');
	if (str2) {
		len2 = strlen(str2);
		if ((cp = realloc(str2, (unsigned)len1 + len2 + add_colon + 1)) == NULL)
			Panic(0, "%s", strnomem);
		bcopy(cp, cp + len1 + add_colon, len2 + 1);
	} else {
		if ((cp = malloc((unsigned)len1 + add_colon + 1)) == NULL)
			Panic(0, "%s", strnomem);
		cp[len1 + add_colon] = '\0';
	}
	bcopy(str1, cp, len1);
	if (add_colon)
		cp[len1] = ':';
	return cp;
}

static char *
findrcfile(char *rcfile)
{
	char buf[256];
	char *p;

	/* Tilde prefix support courtesy <hesso@pool.math.tu-berlin.de>,
	 * taken from a Debian patch. */
	if (rcfile && *rcfile == '~') {
		static char rcfilename_tilde_exp[MAXPATHLEN + 1];
		char *slash_position = strchr(rcfile, '/');

		if (slash_position == rcfile + 1) {
			char *home = getenv("HOME");
			if (!home) {
				Msg(0, "%s: source: tilde expansion failed", rc_name);
				return NULL;
			}
			snprintf(rcfilename_tilde_exp, MAXPATHLEN, "%s/%s", home, rcfile + 2);
		} else if (slash_position) {
			struct passwd *p;
			*slash_position = 0;
			p = getpwnam(rcfile + 1);
			if (!p) {
				Msg(0, "%s: source: tilde expansion failed for user %s", rc_name, rcfile + 1);
				return NULL;
			}
			snprintf(rcfilename_tilde_exp, MAXPATHLEN, "%s/%s", p->pw_dir, slash_position + 1);
		} else {
			Msg(0, "%s: source: illegal tilde expression.", rc_name);
			return NULL;
		}
		rcfile = rcfilename_tilde_exp;
	}

	if (rcfile) {
		char *rcend = rindex(rc_name, '/');
		if (*rcfile != '/' && rcend && (rcend - rc_name) + strlen(rcfile) + 2 < sizeof(buf)) {
			strncpy(buf, rc_name, rcend - rc_name + 1);
			strcpy(buf + (rcend - rc_name) + 1, rcfile);
			if (access(buf, R_OK) == 0)
				return SaveStr(buf);
		}
		debug1("findrcfile: you specified '%s'\n", rcfile);
		return SaveStr(rcfile);
	}

	debug("findrcfile: you specified nothing...\n");
	if ((p = getenv("SCREENRC")) != NULL && *p != '\0') {
		debug1("  $SCREENRC has: '%s'\n", p);
		return SaveStr(p);
	} else {
		debug("  ...nothing in $SCREENRC, defaulting $HOME/.screenrc\n");
		if (strlen(home) > sizeof(buf) - 12)
			Panic(0, "Rc: home too large");
		sprintf(buf, "%s/.screenrc", home);
		return SaveStr(buf);
	}
}

/*
 * this will be called twice:
 * 1) rcfilename = "/etc/screenrc"
 * 2) rcfilename = RcFileName
 */
int
StartRc(char *rcfilename, int nopanic)
{
	register int argc, len;
	register char *p, *cp;
	char buf[2048];
	char *args[MAXARGS];
	int argl[MAXARGS];
	FILE *fp;
	char *oldrc_name = rc_name;

	/* always fix termcap/info capabilities */
	extra_incap = CatExtra("TF", extra_incap);

	/* Special settings for vt100 and others */
	if (display && (!strncmp(D_termname, "vt", 2) || !strncmp(D_termname, "xterm", 5)))
		extra_incap = CatExtra("xn:f0=\033Op:f1=\033Oq:f2=\033Or:f3=\033Os:f4=\033Ot:f5=\033Ou:f6=\033Ov:f7=\033Ow:f8=\033Ox:f9=\033Oy:f.=\033On:f,=\033Ol:fe=\033OM:f+=\033Ok:f-=\033Om:f*=\033Oj:f/=\033Oo:fq=\033OX", extra_incap);

	rc_name = findrcfile(rcfilename);
	if (rc_name == NULL || (fp = secfopen(rc_name, "r")) == NULL) {
		const char *rc_nonnull = rc_name ? rc_name : rcfilename;
		if (!rc_recursion && RcFileName && !strcmp(RcFileName, rc_nonnull)) {
		/*
		 * User explicitly gave us that name,
		 * this is the only case, where we get angry, if we can't read
		 * the file.
		 */
			debug3("StartRc: '%s','%s', '%s'\n", RcFileName, rc_name ? rc_name : "(null)", rcfilename);
			if (!nopanic)
				Panic(0, "Unable to open \"%s\".", rc_nonnull);
				/* possibly NOTREACHED */
		}

		debug1("StartRc: '%s' no good. ignored\n", rc_nonnull);
		if (rc_name)
			Free(rc_name);
		rc_name = oldrc_name;
		return 1;
	}
	while (fgets(buf, sizeof buf, fp) != NULL) {
		if ((p = rindex(buf, '\n')) != NULL)
			*p = '\0';

		if ((argc = Parse(buf, sizeof buf, args, argl)) == 0)
			continue;

		if (strcmp(args[0], "echo") == 0) {
			if (!display)
				continue;
			if (argc < 2 || (argc == 3 && strcmp(args[1], "-n")) || argc > 3) {
				Msg(0, "%s: 'echo [-n] \"string\"' expected.", rc_name);
				continue;
			}
			AddStr(args[argc - 1]);
			if (argc != 3) {
				AddStr("\r\n");
				Flush(0);
			}
		} else if (strcmp(args[0], "sleep") == 0) {
			if (!display)
				continue;
			debug("sleeeeeeep\n");
			if (argc != 2) {
				Msg(0, "%s: sleep: one numeric argument expected.", rc_name);
				continue;
			}
			DisplaySleep1000(1000 * atoi(args[1]), 1);
		}
#ifdef TERMINFO
    else if (!strcmp(args[0], "termcapinfo") || !strcmp(args[0], "terminfo")) {
#else
		else if (!strcmp(args[0], "termcapinfo") || !strcmp(args[0], "termcap")) {
#endif
			if (!display)
				continue;
			if (argc < 3 || argc > 4) {
				Msg(0, "%s: %s: incorrect number of arguments.", rc_name, args[0]);
				continue;
			}

			for (p = args[1]; p && *p; p = cp) {
				if ((cp = index(p, '|')) != 0)
					*cp++ = '\0';
				len = strlen(p);
				if (p[len - 1] == '*') {
					if (!(len - 1) || !strncmp(p, D_termname, len - 1))
						break;
				} else if (!strcmp(p, D_termname))
					break;
			}
			if (!(p && *p))
				continue;
			extra_incap = CatExtra(args[2], extra_incap);
			if (argc == 4)
				extra_outcap = CatExtra(args[3], extra_outcap);
		} else if (!strcmp(args[0], "source")) {
			if (rc_recursion <= 10) {
				rc_recursion++;
				(void)StartRc(args[1], 0);
				rc_recursion--;
			}
		}
	}
	fclose(fp);
	Free(rc_name);
	rc_name = oldrc_name;
	return 0;
}

void
FinishRc(char *rcfilename)
{
	char buf[2048];
	FILE *fp;
	char *oldrc_name = rc_name;

	rc_name = findrcfile(rcfilename);

	if (rc_name == NULL || (fp = secfopen(rc_name, "r")) == NULL) {
		const char *rc_nonnull = rc_name ? rc_name : rcfilename;
		if (rc_recursion)
			Msg(errno, "%s: source %s", oldrc_name, rc_nonnull);
		else if (RcFileName && !strcmp(RcFileName, rc_nonnull)) {
      /*
       * User explicitly gave us that name,
       * this is the only case, where we get angry, if we can't read
       * the file.
       */
			debug3("FinishRc:'%s','%s','%s'\n", RcFileName, rc_name ? rc_name : "(null)", rcfilename);
			Panic(0, "Unable to open \"%s\".", rc_nonnull);
			/* NOTREACHED */
		}
		debug1("FinishRc: '%s' no good. ignored\n", rc_nonnull);
		if (rc_name)
			Free(rc_name);
		rc_name = oldrc_name;
		return;
	}

	debug("finishrc is going...\n");
	while (fgets(buf, sizeof buf, fp) != NULL)
		RcLine(buf, sizeof buf);
	(void)fclose(fp);
	Free(rc_name);
	rc_name = oldrc_name;
}

void
do_source(char *rcfilename)
{
	if (rc_recursion > 10) {
		Msg(0, "%s: source: recursion limit reached", rc_name);
		return;
	}
	rc_recursion++;
	FinishRc(rcfilename);
	rc_recursion--;
}

/*
 * Running a Command Line in the environment determined by the display.
 * The fore window is taken from the display as well as the user.
 * This is bad when we run detached.
 */
void
RcLine(char *ubuf, int ubufl)
{
	char *args[MAXARGS];
	int argl[MAXARGS];
#ifdef MULTIUSER
	extern struct acluser *EffectiveAclUser;      /* acl.c */
	extern struct acluser *users;                 /* acl.c */
#endif

	if (display) {
		fore = D_fore;
		flayer = D_forecv->c_layer;
	} else
		flayer = fore ? fore->w_savelayer : 0;
	if (Parse(ubuf, ubufl, args, argl) <= 0)
		return;

#ifdef MULTIUSER
	if (!display) {
      /* the session owner does it, when there is no display here */
		EffectiveAclUser = users;
		debug("RcLine: WARNING, no display no user! Session owner executes command\n");
	}
#endif

	DoCommand(args, argl);

#ifdef MULTIUSER
	EffectiveAclUser = 0;
#endif
}

/*  needs display for copybuffer access and termcap dumping  */
void
WriteFile(struct acluser *user, char *fn, int dump)
{
  /* dump==0:	create .termcap,
   * dump==1:	hardcopy,
   * #ifdef COPY_PASTE
   * dump==2:	BUFFERFILE
   * #endif COPY_PASTE
   * dump==1:	scrollback,
   */
	register int i, j, k;
	register char *p;
	register FILE *f;
	char fnbuf[1024];
	char *mode = "w";

#ifdef COPY_PASTE
	int public = 0;
# ifdef HAVE_LSTAT
	struct stat stb, stb2;
	int fd, exists = 0;
# endif
#endif

	switch (dump) {
	case DUMP_TERMCAP:
		if (fn == 0) {
			i = SockName - SockPath;
			if (i > (int)sizeof(fnbuf) - 9)
				i = 0;
			strncpy(fnbuf, SockPath, i);
			strcpy(fnbuf + i, ".termcap");
			fn = fnbuf;
		}
		break;

	case DUMP_HARDCOPY:
	case DUMP_SCROLLBACK:
		if (fn == 0) {
			if (fore == 0)
				return;
			if (hardcopydir && *hardcopydir && strlen(hardcopydir) < sizeof(fnbuf) - 21)
				sprintf(fnbuf, "%s/hardcopy.%d", hardcopydir, fore->w_number);
			else
				sprintf(fnbuf, "hardcopy.%d", fore->w_number);
			fn = fnbuf;
		}
		if (hardcopy_append && !access(fn, W_OK))
			mode = "a";
		break;

#ifdef COPY_PASTE
	case DUMP_EXCHANGE:
		if (fn == 0) {
			strncpy(fnbuf, BufferFile, sizeof(fnbuf) - 1);
			fnbuf[sizeof(fnbuf) - 1] = 0;
			fn = fnbuf;
		}
		public = !strcmp(fn, DEFAULT_BUFFERFILE);
# ifdef HAVE_LSTAT
		exists = !lstat(fn, &stb);
		if (public && exists && (S_ISLNK(stb.st_mode) || stb.st_nlink > 1)) {
			Msg(0, "No write to links, please.");
			return;
		}
# endif
		break;
#endif
	}

	debug2("WriteFile(%d) %s\n", dump, fn);
	if (UserContext() > 0) {
		debug("Writefile: usercontext\n");
#ifdef COPY_PASTE
		if (dump == DUMP_EXCHANGE && public) {
# ifdef HAVE_LSTAT
			if (exists) {
				if ((fd = open(fn, O_WRONLY, 0666)) >= 0) {
					if (fstat(fd, &stb2) == 0 && stb.st_dev == stb2.st_dev && stb.st_ino == stb2.st_ino)
						ftruncate(fd, 0);
					else {
						close(fd);
						fd = -1;
					}
				}
			} else
				fd = open(fn, O_WRONLY|O_CREAT|O_EXCL, 0666);
			f = fd >= 0 ? fdopen(fd, mode) : 0;
# else
			f = fopen(fn, mode);
# endif
		} else
#endif /* COPY_PASTE */
			f = fopen(fn, mode);
		if (f == NULL) {
			debug2("WriteFile: fopen(%s,\"%s\") failed\n", fn, mode);
			UserReturn(0);
		} else {
			switch (dump) {
			case DUMP_HARDCOPY:
			case DUMP_SCROLLBACK:
				if (!fore)
					break;
				if (*mode == 'a') {
					putc('>', f);
					for (j = fore->w_width - 2; j > 0; j--)
						putc('=', f);
					fputs("<\n", f);
				}
				if (dump == DUMP_SCROLLBACK) {
#ifdef COPY_PASTE
					for (i = fore->w_histheight - fore->w_scrollback_height; i < fore->w_histheight; i++) {
						p = (char *)(WIN(i)->image);
						for (k = fore->w_width - 1;
						    k >= 0 && p[k] == ' '; k--)
							;
						for (j = 0; j <= k; j++)
							putc(p[j], f);
						putc('\n', f);
					}
#endif
				}
				for (i = 0; i < fore->w_height; i++) {
					p = (char *)fore->w_mlines[i].image;
					for (k = fore->w_width - 1;
					    k >= 0 && p[k] == ' '; k--)
						;
					for (j = 0; j <= k; j++)
						putc(p[j], f);
					putc('\n', f);
				}
				break;

			case DUMP_TERMCAP:
				DumpTermcap(fore->w_aflag, f);
				break;

#ifdef COPY_PASTE
			case DUMP_EXCHANGE:
				p = user->u_plop.buf;
				for (i = user->u_plop.len; i-- > 0; p++)
					if (*p == '\r' && (i == 0 || p[1] != '\n'))
						putc('\n', f);
					else
						putc(*p, f);
				break;
#endif
			}
			(void)fclose(f);
			UserReturn(1);
		}
	}
	if (UserStatus() <= 0)
		Msg(0, "Cannot open \"%s\"", fn);
	else if (display && !*rc_name) {
		switch (dump) {
		case DUMP_TERMCAP:
			Msg(0, "Termcap entry written to \"%s\".", fn);
			break;
		case DUMP_HARDCOPY:
		case DUMP_SCROLLBACK:
			Msg(0, "Screen image %s to \"%s\".", (*mode == 'a') ? "appended" : "written", fn);
			break;
#ifdef COPY_PASTE
		case DUMP_EXCHANGE:
			Msg(0, "Copybuffer written to \"%s\".", fn);
#endif
		}
	}
}

#ifdef COPY_PASTE

/*
 * returns an allocated buffer which holds a copy of the file named fn.
 * lenp (if nonzero) points to a location, where the buffer size should be
 * stored.
 */
char *
ReadFile(char *fn, int *lenp)
{
	int i, l, size;
	char c, *bp, *buf;
	struct stat stb;

	ASSERT(lenp);
	debug1("ReadFile(%s)\n", fn);

	if ((i = secopen(fn, O_RDONLY, 0)) < 0) {
		Msg(errno, "no %s -- no slurp", fn);
		return NULL;
	}

	if (fstat(i, &stb)) {
		Msg(errno, "no good %s -- no slurp", fn);
		close(i);
		return NULL;
	}
	size = stb.st_size;

	if ((buf = malloc(size)) == NULL) {
		close(i);
		Msg(0, "%s", strnomem);
		return NULL;
	}
	errno = 0;

	if ((l = read(i, buf, size)) != size) {
		if (l < 0)
			l = 0;
		Msg(errno, "Got only %d bytes from %s", l, fn);
	} else {
		if (read(i, &c, 1) > 0)
			Msg(0, "Slurped only %d characters (of %d) into buffer - try again", l, size);
		else
			Msg(0, "Slurped %d characters into buffer", l);
	}
	close(i);
	*lenp = l;
	for (bp = buf; l-- > 0; bp++)
		if (*bp == '\n' && (bp == buf || bp[-1] != '\r'))
			*bp = '\r';
	return buf;
}

void
KillBuffers()
{
	if (UserContext() > 0)
		UserReturn(unlink(BufferFile) ? errno : 0);
	errno = UserStatus();
	Msg(errno, "%s %sremoved", BufferFile, errno ? "not " : "");
}
#endif	/* COPY_PASTE */


/* (Almost) secure open and fopen...  */

FILE *
secfopen(char *name, char *mode)
{
	FILE *fi;
#ifndef USE_SETEUID
	int flags, fd;
#endif

	debug2("secfopen(%s, %s)\n", name, mode);
#ifdef USE_SETEUID
	xseteuid(real_uid);
	xsetegid(real_gid);
	fi = fopen(name, mode);
	xseteuid(eff_uid);
	xsetegid(eff_gid);
	return fi;
#else
	if (eff_uid == real_uid)
		return fopen(name, mode);
	if (mode[0] && mode[1] == '+')
		flags = O_RDWR;
	else
		flags = (mode[0] == 'r') ? O_RDONLY : O_WRONLY;
	if (mode[0] == 'w')
		flags |= O_CREAT | O_TRUNC;
	else if (mode[0] == 'a')
		flags |= O_CREAT | O_APPEND;
	else if (mode[0] != 'r') {
		errno = EINVAL;
		return 0;
	}
	if ((fd = secopen(name, flags, 0666)) < 0)
		return 0;
	if ((fi = fdopen(fd, mode)) == 0) {
		close(fd);
		return 0;
	}
	return fi;
#endif
}

int
secopen(char *name, int flags, int mode)
{
	int fd;
#ifndef USE_SETEUID
	int q;
	struct stat stb;
#endif

	debug3("secopen(%s, 0x%x, 0%03o)\n", name, flags, mode);
#ifdef USE_SETEUID
	xseteuid(real_uid);
	xsetegid(real_gid);
	fd = open(name, flags, mode);
	xseteuid(eff_uid);
	xsetegid(eff_gid);
	return fd;
#else
	if (eff_uid == real_uid)
		return open(name, flags, mode);

	/* Truncation/creation is done in UserContext */
	if ((flags & O_TRUNC) || ((flags & O_CREAT) && access(name, F_OK))) {
		if (UserContext() > 0) {
			if ((fd = open(name, flags, mode)) >= 0) {
				close(fd);
				UserReturn(0);
			}
			if (errno == 0)
				errno = EACCES;
			UserReturn(errno);
		}
		if ((q = UserStatus())) {
			if (q > 0)
				errno = q;
			return -1;
		}
	}
	if (access(name, F_OK))
		return -1;
	if ((fd = open(name, flags & ~(O_TRUNC | O_CREAT), 0)) < 0)
		return -1;
	debug("open successful\n");
	if (fstat(fd, &stb)) {
		close(fd);
		return -1;
	}
	debug("fstat successful\n");
	if (stb.st_uid != real_uid) {
		switch (flags & (O_RDONLY | O_WRONLY | O_RDWR)) {
		case O_RDONLY:
			q = 0004;
			break;
		case O_WRONLY:
			q = 0002;
			break;
		default:
			q = 0006;
			break;
		}
		if ((stb.st_mode & q) != q) {
			debug1("secopen: permission denied (%03o)\n", stb.st_mode & 07777);
			close(fd);
			errno = EACCES;
			return -1;
		}
	}
	debug1("secopen ok - returning %d\n", fd);
	return fd;
#endif
}

int
printpipe(struct win *p, char *cmd)
{
	int pi[2];
	if (pipe(pi)) {
		WMsg(p, errno, "printing pipe");
		return -1;
	}
	switch (fork()) {
	case -1:
		WMsg(p, errno, "printing fork");
		return -1;
	case 0:
		display = p->w_pdisplay;
		displays = 0;
		ServerSocket = -1;
#ifdef DEBUG
		if (dfp && dfp != stderr)
			fclose(dfp);
#endif
		close(0);
		dup(pi[0]);
		closeallfiles(0);
		if (setgid(real_gid) || setuid(real_uid))
			Panic(errno, "printpipe setuid");
		eff_uid = real_uid;
		eff_gid = real_gid;

#ifdef SIGPIPE
		signal(SIGPIPE, SIG_DFL);
#endif
		execl("/bin/sh", "sh", "-c", cmd, (char *)0);
		Panic(errno, "/bin/sh");
	default:
		break;
	}
	close(pi[0]);
	return pi[1];
}

int
readpipe(char **cmdv)
{
	int pi[2];

	if (pipe(pi)) {
		Msg(errno, "pipe");
		return -1;
	}

	switch (fork()) {
	case -1:
		Msg(errno, "fork");
		return -1;
	case 0:
		displays = 0;
		ServerSocket = -1;
#ifdef DEBUG
		if (dfp && dfp != stderr)
			fclose(dfp);
#endif
		close(1);
		if (dup(pi[1]) != 1) {
			close(pi[1]);
			Panic(0, "dup");
		}
		closeallfiles(1);

		if (setgid(real_gid) || setuid(real_uid)) {
			close(1);
			Panic(errno, "setuid/setgid");
		}
		eff_uid = real_uid;
		eff_gid = real_gid;
#ifdef SIGPIPE
		signal(SIGPIPE, SIG_DFL);
#endif
		execvp(*cmdv, cmdv);
		close(1);
		Panic(errno, "%s", *cmdv);
	default:
		break;
	}
	close(pi[1]);
	return pi[0];
}
