summaryrefslogtreecommitdiffstats
path: root/fileio.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--fileio.c776
1 files changed, 776 insertions, 0 deletions
diff --git a/fileio.c b/fileio.c
new file mode 100644
index 0000000..3d9da04
--- /dev/null
+++ b/fileio.c
@@ -0,0 +1,776 @@
+/* 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];
+}