Adding upstream version 4.9.0.upstream/4.9.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 788 insertions, 0 deletions

diff --git a/fileio.c b/fileio.c
new file mode 100644
index 0000000..d488166
--- /dev/null
+++ b/fileio.c
@@ -0,0 +1,788 @@
+/* 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];
+}