home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume27 / screen-3.5.1 / part04 / window.c < prev   
Encoding:
C/C++ Source or Header  |  1993-08-08  |  20.4 KB  |  928 lines
  1. /* Copyright (c) 1993
  2.  *      Juergen Weigert (jnweiger@immd4.informatik.uni-erlangen.de)
  3.  *      Michael Schroeder (mlschroe@immd4.informatik.uni-erlangen.de)
  4.  * Copyright (c) 1987 Oliver Laumann
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2, or (at your option)
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program (see the file COPYING); if not, write to the
  18.  * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  ****************************************************************
  21.  */
  22.  
  23. #include "rcs.h"
  24. RCS_ID("$Id: window.c,v 1.14 1993/08/05 14:24:15 mlschroe Exp $ FAU")
  25.  
  26. #include <sys/types.h>
  27. #include <sys/stat.h>
  28. #include <signal.h>
  29. #include <fcntl.h>
  30. #ifndef sun
  31. #include <sys/ioctl.h>
  32. #endif
  33.  
  34. #include "config.h"
  35. #include "screen.h"
  36. #include "extern.h"
  37.  
  38. #ifdef SVR4    /* for solaris 2.1 */
  39. # include <sys/stropts.h>
  40. #endif
  41.  
  42. extern struct display *displays, *display;
  43. extern struct win *windows, *fore, *wtab[], *console_window;
  44. extern char *ShellArgs[];
  45. extern char *ShellProg;
  46. extern char screenterm[];
  47. extern char HostName[];
  48. extern int default_monitor, TtyMode;
  49. extern struct LayFuncs WinLf;
  50. extern int real_uid, real_gid;
  51. extern char Termcap[];
  52. extern char **NewEnv;
  53.  
  54. #if defined(TIOCSWINSZ) || defined(TIOCGWINSZ)
  55. extern struct winsize glwz;
  56. #endif
  57.  
  58.  
  59. static int OpenDevice __P((char *, int, int *, char **));
  60. static int ForkWindow __P((char **, char *, char *, char *, struct win *));
  61. static void execvpe __P((char *, char **, char **));
  62.  
  63.  
  64. char DefaultShell[] = "/bin/sh";
  65. static char DefaultPath[] = ":/usr/ucb:/bin:/usr/bin";
  66.  
  67.  
  68. struct NewWindow nwin_undef   = 
  69. {
  70.   -1, (char *)0, (char **)0, (char *)0, (char *)0, -1, -1, 
  71.   -1, -1, -1
  72. };
  73.  
  74. struct NewWindow nwin_default = 
  75. { 
  76.   0, 0, ShellArgs, 0, screenterm, 0, 1*FLOW_NOW, 
  77.   LOGINDEFAULT, DEFAULTHISTHEIGHT, -1
  78. };
  79.  
  80. struct NewWindow nwin_options;
  81.  
  82. void
  83. nwin_compose(def, new, res)
  84. struct NewWindow *def, *new, *res;
  85. {
  86.   res->StartAt = new->StartAt != nwin_undef.StartAt ? new->StartAt : def->StartAt;
  87.   res->aka = new->aka != nwin_undef.aka ? new->aka : def->aka;
  88.   res->args = new->args != nwin_undef.args ? new->args : def->args;
  89.   res->dir = new->dir != nwin_undef.dir ? new->dir : def->dir;
  90.   res->term = new->term != nwin_undef.term ? new->term : def->term;
  91.   res->aflag = new->aflag != nwin_undef.aflag ? new->aflag : def->aflag;
  92.   res->flowflag = new->flowflag != nwin_undef.flowflag ? new->flowflag : def->flowflag;
  93.   res->lflag = new->lflag != nwin_undef.lflag ? new->lflag : def->lflag;
  94.   res->histheight = new->histheight != nwin_undef.histheight ? new->histheight : def->histheight;
  95.   res->monitor = new->monitor != nwin_undef.monitor ? new->monitor : def->monitor;
  96. }
  97.  
  98. int
  99. MakeWindow(newwin)
  100. struct NewWindow *newwin;
  101. {
  102.   register struct win **pp, *p;
  103.   register int n;
  104.   int f = -1;
  105.   struct NewWindow nwin;
  106.   int ttyflag;
  107.   char *TtyName;
  108.  
  109.   debug1("NewWindow: StartAt %d\n", newwin->StartAt);
  110.   debug1("NewWindow: aka     %s\n", newwin->aka?newwin->aka:"NULL");
  111.   debug1("NewWindow: dir     %s\n", newwin->dir?newwin->dir:"NULL");
  112.   debug1("NewWindow: term    %s\n", newwin->term?newwin->term:"NULL");
  113.   nwin_compose(&nwin_default, newwin, &nwin);
  114.   debug1("NWin: aka     %s\n", nwin.aka ? nwin.aka : "NULL");
  115.   pp = wtab + nwin.StartAt;
  116.  
  117.   do
  118.     {
  119.       if (*pp == 0)
  120.     break;
  121.       if (++pp == wtab + MAXWIN)
  122.     pp = wtab;
  123.     }
  124.   while (pp != wtab + nwin.StartAt);
  125.   if (*pp)
  126.     {
  127.       Msg(0, "No more windows.");
  128.       return -1;
  129.     }
  130.  
  131. #if defined(USRLIMIT) && defined(UTMPOK)
  132.   /*
  133.    * Count current number of users, if logging windows in.
  134.    */
  135.   if (nwin.lflag && CountUsers() >= USRLIMIT)
  136.     {
  137.       Msg(0, "User limit reached.  Window will not be logged in.");
  138.       nwin.lflag = 0;
  139.     }
  140. #endif
  141.   n = pp - wtab;
  142.   debug1("Makewin creating %d\n", n);
  143.  
  144.   if ((f = OpenDevice(nwin.args[0], nwin.lflag, &ttyflag, &TtyName)) < 0)
  145.     return -1;
  146.  
  147.   if ((p = (struct win *) malloc(sizeof(struct win))) == 0)
  148.     {
  149.       close(f);
  150.       Msg(0, strnomem);
  151.       return -1;
  152.     }
  153.   bzero((char *) p, (int) sizeof(struct win)); /* looks like a calloc above */
  154. #ifdef MULTIUSER
  155.   if (NewWindowAcl(p))
  156.     {
  157.       free(p);
  158.       close(f);
  159.       Msg(0, strnomem);
  160.       return -1;
  161.     }
  162. #endif
  163.   p->w_wlock = WLOCK_AUTO;
  164.   p->w_dupto = -1;
  165.   p->w_winlay.l_next = 0;
  166.   p->w_winlay.l_layfn = &WinLf;
  167.   p->w_winlay.l_data = (char *)p;
  168.   p->w_lay = &p->w_winlay;
  169.   p->w_display = display;
  170.   if (display)
  171.     p->w_wlockuser = d_user;
  172.   p->w_number = n;
  173.   p->w_ptyfd = f;
  174.   p->w_aflag = nwin.aflag;
  175.   p->w_flow = nwin.flowflag | ((nwin.flowflag & FLOW_AUTOFLAG) ? (FLOW_AUTO|FLOW_NOW) : FLOW_AUTO);
  176.   if (!nwin.aka)
  177.     nwin.aka = Filename(nwin.args[0]);
  178.   strncpy(p->w_akabuf, nwin.aka, MAXSTR - 1);
  179.   if ((nwin.aka = rindex(p->w_akabuf, '|')) != NULL)
  180.     {
  181.       p->w_autoaka = 0;
  182.       *nwin.aka++ = 0;
  183.       p->w_title = nwin.aka;
  184.       p->w_akachange = nwin.aka + strlen(nwin.aka);
  185.     }
  186.   else
  187.     p->w_title = p->w_akachange = p->w_akabuf;
  188.   if ((p->w_monitor = nwin.monitor) == -1)
  189.     p->w_monitor = default_monitor;
  190.   p->w_norefresh = 0;
  191.   strncpy(p->w_tty, TtyName, MAXSTR - 1);
  192.  
  193.   if (ChangeWindowSize(p, display ? d_defwidth : 80, display ? d_defheight : 24))
  194.     {
  195.       FreeWindow(p);
  196.       return -1;
  197.     }
  198. #ifdef COPY_PASTE
  199.   ChangeScrollback(p, nwin.histheight, p->w_width);
  200. #endif
  201.   ResetWindow(p);    /* sets p->w_wrap */
  202.  
  203.   if (ttyflag == TTY_FLAG_PLAIN)
  204.     {
  205.       p->w_t.flags |= TTY_FLAG_PLAIN;
  206.       p->w_pid = 0;
  207.     }
  208.   else
  209.     {
  210.       debug("forking...\n");
  211. #ifdef PSEUDOS
  212.       p->w_pwin = NULL;
  213. #endif
  214.       p->w_pid = ForkWindow(nwin.args, nwin.dir, nwin.term, TtyName, p);
  215.       if (p->w_pid < 0)
  216.     {
  217.       FreeWindow(p);
  218.       return -1;
  219.     }
  220.     }
  221.   /*
  222.    * Place the newly created window at the head of the most-recently-used list.
  223.    */
  224.   if (display && d_fore)
  225.     d_other = d_fore;
  226.   *pp = p;
  227.   p->w_next = windows;
  228.   windows = p;
  229. #ifdef UTMPOK
  230.   debug1("MakeWindow will %slog in.\n", nwin.lflag?"":"not ");
  231.   if (nwin.lflag == 1)
  232.     {
  233.       if (display)
  234.         SetUtmp(p);
  235.       else
  236.     p->w_slot = (slot_t) 0;
  237.     }
  238.   else
  239.     p->w_slot = (slot_t) -1;
  240. #endif
  241.   SetForeWindow(p);
  242.   Activate(p->w_norefresh);
  243.   return n;
  244. }
  245.  
  246. void
  247. FreeWindow(wp)
  248. struct win *wp;
  249. {
  250.   struct display *d;
  251.  
  252. #ifdef PSEUDOS
  253.   if (wp->w_pwin)
  254.     FreePseudowin(wp);
  255. #endif
  256. #ifdef UTMPOK
  257.   RemoveUtmp(wp);
  258. #endif
  259.   (void) chmod(wp->w_tty, 0666);
  260.   (void) chown(wp->w_tty, 0, 0);
  261.   close(wp->w_ptyfd);
  262.   if (wp == console_window)
  263.     console_window = 0;
  264.   if (wp->w_logfp != NULL)
  265.     fclose(wp->w_logfp);
  266.   ChangeWindowSize(wp, 0, 0);
  267.   for (d = displays; d; d = d->_d_next)
  268.     if (d->_d_other == wp)
  269.       d->_d_other = 0;
  270.   free(wp);
  271. }
  272.  
  273. static int
  274. OpenDevice(arg, lflag, typep, namep)
  275. char *arg;
  276. int lflag;
  277. int *typep;
  278. char **namep;
  279. {
  280.   struct stat st;
  281.   int f;
  282.  
  283.   if ((stat(arg, &st)) == 0 && (st.st_mode & S_IFCHR))
  284.     {
  285.       if (access(arg, R_OK | W_OK) == -1)
  286.     {
  287.       Msg(errno, "Cannot access line '%s' for R/W", arg); 
  288.       return -1;
  289.     }
  290.       debug("OpenDevice: OpenTTY\n");
  291.       if ((f = OpenTTY(arg)) < 0)
  292.     return -1;
  293.       *typep = TTY_FLAG_PLAIN;
  294.       *namep = arg;
  295.     }
  296.   else
  297.     {
  298.       *typep = 0;    /* for now we hope it is a program */
  299.       f = OpenPTY(namep);
  300.       if (f == -1)
  301.     {
  302.       Msg(0, "No more PTYs.");
  303.       return -1;
  304.     }
  305. #ifdef TIOCPKT
  306.       {
  307.     int flag = 1;
  308.  
  309.     if (ioctl(f, TIOCPKT, (char *)&flag))
  310.       {
  311.         Msg(errno, "TIOCPKT ioctl");
  312.         close(f);
  313.         return -1;
  314.       }
  315.       }
  316. #endif /* TIOCPKT */
  317.     }
  318.   (void) fcntl(f, F_SETFL, FNDELAY);
  319. #ifdef PTYGROUP
  320.   (void) chown(*namep, real_uid, PTYGROUP);
  321. #else
  322.   (void) chown(*namep, real_uid, real_gid);
  323. #endif
  324. #ifdef UTMPOK
  325.   (void) chmod(*namep, lflag ? TtyMode : (TtyMode & ~022));
  326. #else
  327.   (void) chmod(*namep, TtyMode);
  328. #endif
  329.   return f;
  330. }
  331.  
  332. /*
  333.  * Fields w_width, w_height, aflag, number (and w_tty)
  334.  * are read from struct win *win. No fields written.
  335.  * If pwin is nonzero, filedescriptors are distributed 
  336.  * between win->w_tty and open(ttyn)
  337.  *
  338.  */
  339. static int 
  340. ForkWindow(args, dir, term, ttyn, win)
  341. char **args, *dir, *term, *ttyn;
  342. struct win *win;
  343. {
  344.   int pid;
  345.   char tebuf[25];
  346.   char ebuf[10];
  347.   char shellbuf[7 + MAXPATHLEN];
  348.   char *proc;
  349. #ifndef TIOCSWINSZ
  350.   char libuf[20], cobuf[20];
  351. #endif
  352.   int newfd;
  353.   int w = win->w_width;
  354.   int h = win->w_height;
  355. #ifdef PSEUDOS
  356.   int i, pat, wfdused;
  357.   struct pseudowin *pwin = win->w_pwin;
  358. #endif
  359.  
  360.   proc = *args;
  361.   if (proc == 0)
  362.     {
  363.       args = ShellArgs;
  364.       proc = *args;
  365.     }
  366.   switch (pid = fork())
  367.     {
  368.     case -1:
  369.       Msg(errno, "fork");
  370.       return -1;
  371.     case 0:
  372.       signal(SIGHUP, SIG_DFL);
  373.       signal(SIGINT, SIG_DFL);
  374.       signal(SIGQUIT, SIG_DFL);
  375.       signal(SIGTERM, SIG_DFL);
  376. #ifdef BSDJOBS
  377.       signal(SIGTTIN, SIG_DFL);
  378.       signal(SIGTTOU, SIG_DFL);
  379. #endif
  380.       if (setuid(real_uid) || setgid(real_gid))
  381.     {
  382.       SendErrorMsg("Setuid/gid: %s", sys_errlist[errno]);
  383.       eexit(1);
  384.     }
  385.       if (dir && *dir && chdir(dir) == -1)
  386.     {
  387.       SendErrorMsg("Cannot chdir to %s: %s", dir, sys_errlist[errno]);
  388.       eexit(1);
  389.     }
  390.  
  391.       if (display)
  392.     {
  393.       brktty(d_userfd);
  394.       freetty();
  395.     }
  396.       else
  397.     brktty(-1);
  398. #ifdef DEBUG
  399.       if (dfp && dfp != stderr)
  400.     fclose(dfp);
  401. #endif
  402.       closeallfiles(win->w_ptyfd);
  403. #ifdef DEBUG
  404.     {
  405.       char buf[256];
  406.       
  407.       sprintf(buf, "%s/screen.child", DEBUGDIR);
  408.       if ((dfp = fopen(buf, "a")) == 0)
  409.         dfp = stderr;
  410.       else
  411.         (void) chmod(buf, 0666);
  412.     }
  413.       debug1("=== ForkWindow: pid %d\n", getpid());
  414. #endif
  415.       /* Close the three /dev/null descriptors */
  416.       close(0);
  417.       close(1);
  418.       close(2);
  419.       newfd = -1;
  420.       /* 
  421.        * distribute filedescriptors between the ttys
  422.        */
  423. #ifdef PSEUDOS
  424.       pat = pwin ? pwin->fdpat : 
  425.            ((F_PFRONT<<(F_PSHIFT*2)) | (F_PFRONT<<F_PSHIFT) | F_PFRONT);
  426.       wfdused = 0;
  427.       for(i = 0; i < 3; i++)
  428.     {
  429.       if (pat & F_PFRONT << F_PSHIFT * i)
  430.         {
  431.           if (newfd < 0)
  432.         {
  433.           if ((newfd = open(ttyn, O_RDWR)) < 0)
  434.             {
  435.               SendErrorMsg("Cannot open %s: %s",
  436.                    ttyn, sys_errlist[errno]);
  437.               eexit(1);
  438.             }
  439.         }
  440.           else
  441.         dup(newfd);
  442.         }
  443.       else
  444.         {
  445.           dup(win->w_ptyfd);
  446.           wfdused = 1;
  447.         }
  448.     }
  449.       if (wfdused)
  450.     {
  451.         /* 
  452.          * the pseudo window process should not be surprised with a 
  453.          * nonblocking filedescriptor. Poor Backend!
  454.          */
  455.         debug1("Clearing NDELAY on window-fd(%d)\n", win->w_ptyfd);
  456.         if (fcntl(win->w_ptyfd, F_SETFL, 0))
  457.           SendErrorMsg("Warning: ForkWindow clear NDELAY fcntl failed, %d", errno);
  458.     }
  459. #else /* PSEUDOS */
  460.       if ((newfd = open(ttyn, O_RDWR)) != 0)
  461.     {
  462.       SendErrorMsg("Cannot open %s: %s", ttyn, sys_errlist[errno]);
  463.       eexit(1);
  464.     }
  465.       dup(0);
  466.       dup(0);
  467. #endif /* PSEUDOS */
  468.       close(win->w_ptyfd);
  469.  
  470.       if (newfd >= 0)
  471.     {
  472.       struct mode fakemode, *modep;
  473. #if defined(SVR4) && !defined(sgi)
  474.       if (ioctl(newfd, I_PUSH, "ptem"))
  475.         {
  476.           SendErrorMsg("Cannot I_PUSH ptem %s %s", ttyn, sys_errlist[errno]);
  477.           eexit(1);
  478.         }
  479.       if (ioctl(newfd, I_PUSH, "ldterm"))
  480.         {
  481.           SendErrorMsg("Cannot I_PUSH ldterm %s %s", ttyn, sys_errlist[errno]);
  482.           eexit(1);
  483.         }
  484.       if (ioctl(newfd, I_PUSH, "ttcompat"))
  485.         {
  486.           SendErrorMsg("Cannot I_PUSH ttcompat %s %s", ttyn, sys_errlist[errno]);
  487.           eexit(1);
  488.         }
  489. #endif
  490.       if (fgtty(newfd))
  491.         SendErrorMsg("fgtty: %s (%d)", sys_errlist[errno], errno);
  492.       if (display)
  493.         {
  494.           debug("ForkWindow: using display tty mode for new child.\n");
  495.           modep = &d_OldMode;
  496.         }
  497.       else
  498.         {
  499.           debug("No display - creating tty setting\n");
  500.           modep = &fakemode;
  501.           InitTTY(modep, 0);
  502. #ifdef DEBUG
  503.           DebugTTY(modep);
  504. #endif
  505.         }
  506.       /* We only want echo if the users input goes to the pseudo
  507.        * and the pseudo's stdout is not send to the window.
  508.        */
  509. #ifdef PSEUDOS
  510.       if (pwin && (!(pat & F_UWP) || (pat & F_PBACK << F_PSHIFT)))
  511.         {
  512.           debug1("clearing echo on pseudywin fd (pat %x)\n", pat);
  513. # if defined(POSIX) || defined(TERMIO)
  514.           modep->tio.c_lflag &= ~ECHO;
  515.           modep->tio.c_iflag &= ~ICRNL;
  516. # else
  517.           modep->m_ttyb.sg_flags &= ~ECHO;
  518. # endif
  519.         }
  520. #endif
  521.       SetTTY(newfd, modep);
  522. #ifdef TIOCSWINSZ
  523.       glwz.ws_col = w;
  524.       glwz.ws_row = h;
  525.       (void) ioctl(newfd, TIOCSWINSZ, (char *)&glwz);
  526. #endif
  527.     }
  528. #ifndef TIOCSWINSZ
  529.       sprintf(libuf, "LINES=%d", h);
  530.       sprintf(cobuf, "COLUMNS=%d", w);
  531.       NewEnv[5] = libuf;
  532.       NewEnv[6] = cobuf;
  533. #endif
  534.       if (win->w_aflag)
  535.     NewEnv[2] = MakeTermcap(1);
  536.       else
  537.     NewEnv[2] = Termcap;
  538.       strcpy(shellbuf, "SHELL=");
  539.       strncpy(shellbuf + 6, ShellProg, MAXPATHLEN);
  540.       shellbuf[MAXPATHLEN + 6] = 0;
  541.       NewEnv[4] = shellbuf;
  542.       debug1("ForkWindow: NewEnv[4] = '%s'\n", shellbuf);
  543.       if (term && *term && strcmp(screenterm, term) &&
  544.       (strlen(term) < 20))
  545.     {
  546.       char *s1, *s2, tl;
  547.  
  548.       sprintf(tebuf, "TERM=%s", term);
  549.       debug2("Makewindow %d with %s\n", win->w_number, tebuf);
  550.       tl = strlen(term);
  551.       NewEnv[1] = tebuf;
  552.       if ((s1 = index(Termcap, '|')))
  553.         {
  554.           if ((s2 = index(++s1, '|')))
  555.         {
  556.           if (strlen(Termcap) - (s2 - s1) + tl < 1024)
  557.             {
  558.               bcopy(s2, s1 + tl, strlen(s2) + 1);
  559.               bcopy(term, s1, tl);
  560.             }
  561.         }
  562.         }
  563.     }
  564.       sprintf(ebuf, "WINDOW=%d", win->w_number);
  565.       NewEnv[3] = ebuf;
  566.  
  567.       if (*proc == '-')
  568.     proc++;
  569.       debug1("calling execvpe %s\n", proc);
  570.       execvpe(proc, args, NewEnv);
  571.       debug1("exec error: %d\n", errno);
  572.       SendErrorMsg("Cannot exec %s: %s", proc, sys_errlist[errno]);
  573.       exit(1);
  574.     default:
  575.       return pid;
  576.     } /* end fork switch */
  577.   /* NOTREACHED */
  578. }
  579.  
  580. static void
  581. execvpe(prog, args, env)
  582. char *prog, **args, **env;
  583. {
  584.   register char *path = NULL, *p;
  585.   char buf[1024];
  586.   char *shargs[MAXARGS + 1];
  587.   register int i, eaccess = 0;
  588.  
  589.   for (i = 0; i < 3; i++)
  590.     if (!strncmp("../" + i, prog, 3 - i))
  591.       path = "";
  592.   if (!path && !(path = getenv("PATH")))
  593.     path = DefaultPath;
  594.   do
  595.     {
  596.       p = buf;
  597.       while (*path && *path != ':')
  598.     *p++ = *path++;
  599.       if (p > buf)
  600.     *p++ = '/';
  601.       strcpy(p, prog);
  602.       execve(buf, args, env);
  603.       switch (errno)
  604.     {
  605.     case ENOEXEC:
  606.       shargs[0] = DefaultShell;
  607.       shargs[1] = buf;
  608.       for (i = 1; (shargs[i + 1] = args[i]) != NULL; ++i)
  609.         ;
  610.       execve(DefaultShell, shargs, env);
  611.       return;
  612.     case EACCES:
  613.       eaccess = 1;
  614.       break;
  615.     case ENOMEM:
  616.     case E2BIG:
  617.     case ETXTBSY:
  618.       return;
  619.     }
  620.     } while (*path++);
  621.   if (eaccess)
  622.     errno = EACCES;
  623. }
  624.  
  625. #ifdef PSEUDOS
  626.  
  627. int
  628. winexec(av)
  629. char **av;
  630. {
  631.   char **pp;
  632.   char *p, *s, *t;
  633.   int i, r = 0, l = 0;
  634.   struct win *w;
  635.   extern struct display *display;
  636.   extern struct win *windows;
  637.   struct pseudowin *pwin;
  638.   
  639.   if ((w = display ? fore : windows) == NULL)
  640.     return -1;
  641.   if (!*av || w->w_pwin)
  642.     {
  643.       Msg(0, "Filter running: %s", w->w_pwin ? w->w_pwin->p_cmd : "(none)");
  644.       return -1;
  645.     }
  646.   if (w->w_ptyfd < 0)
  647.     {
  648.       Msg(0, "You feel dead inside.");
  649.       return -1;
  650.     }
  651.   if (!(pwin = (struct pseudowin *)malloc(sizeof(struct pseudowin))))
  652.     {
  653.       Msg(0, strnomem);
  654.       return -1;
  655.     }
  656.   bzero((char *)pwin, (int)sizeof(*pwin));
  657.  
  658.   /* allow ^a:!!./ttytest as a short form for ^a:exec !.. ./ttytest */
  659.   for (s = *av; *s == ' '; s++)
  660.     ;
  661.   for (p = s; *p == ':' || *p == '.' || *p == '!'; p++)
  662.     ;
  663.   if (*p != '|')
  664.     while (*p && p > s && p[-1] == '.')
  665.       p--;
  666.   if (*p == '|')
  667.     {
  668.       l = F_UWP;
  669.       p++;
  670.     }
  671.   if (*p) 
  672.     av[0] = p;
  673.   else
  674.     av++;
  675.  
  676.   t = pwin->p_cmd;
  677.   for (i = 0; i < 3; i++)
  678.     {
  679.       *t = (s < p) ? *s++ : '.';
  680.       switch (*t++)
  681.     {
  682.     case '.':
  683.     case '|':
  684.       l |= F_PFRONT << (i * F_PSHIFT);
  685.       break;
  686.     case '!':
  687.       l |= F_PBACK << (i * F_PSHIFT);
  688.       break;
  689.     case ':':
  690.       l |= F_PBOTH << (i * F_PSHIFT);
  691.       break;
  692.     }
  693.     }
  694.   
  695.   if (l & F_UWP)
  696.     {
  697.       *t++ = '|';
  698.       if ((l & F_PMASK) == F_PFRONT)
  699.     {
  700.       *pwin->p_cmd = '!';
  701.       l ^= F_PFRONT | F_PBACK;
  702.     }
  703.     }
  704.   if (!(l & F_PBACK))
  705.     l |= F_UWP;
  706.   *t++ = ' ';
  707.   pwin->fdpat = l;
  708.   debug1("winexec: '%#x'\n", pwin->fdpat);
  709.   
  710.   l = MAXSTR - 4;
  711.   for (pp = av; *pp; pp++)
  712.     {
  713.       p = *pp;
  714.       while (*p && l-- > 0)
  715.         *t++ = *p++;
  716.       if (l <= 0)
  717.     break;
  718.       *t++ = ' ';
  719.     }
  720.   *--t = '\0';
  721.   debug1("%s\n", pwin->p_cmd);
  722.   
  723.   if ((pwin->p_ptyfd = OpenDevice(av[0], 0, &l, &t)) < 0)
  724.     {
  725.       free(pwin);
  726.       return -1;
  727.     }
  728.   strncpy(pwin->p_tty, t, MAXSTR - 1);
  729.   w->w_pwin = pwin;
  730.   if (l == TTY_FLAG_PLAIN)
  731.     {
  732.       FreePseudowin(w);
  733.       Msg(0, "Cannot handle a TTY as a pseudo win.");
  734.       return -1;
  735.     }
  736. #ifdef TIOCPKT
  737.   {
  738.     int flag = 0;
  739.  
  740.     if (ioctl(pwin->p_ptyfd, TIOCPKT, (char *)&flag))
  741.       {
  742.     Msg(errno, "TIOCPKT ioctl");
  743.     FreePseudowin(w);
  744.     return -1;
  745.       }
  746.   }
  747. #endif /* TIOCPKT */
  748.   pwin->p_pid = ForkWindow(av, NULL, NULL, t, w);
  749.   if ((r = pwin->p_pid) < 0)
  750.     FreePseudowin(w);
  751.   return r;
  752. }
  753.  
  754. void
  755. FreePseudowin(w)
  756. struct win *w;
  757. {
  758.   struct pseudowin *pwin = w->w_pwin;
  759.  
  760.   ASSERT(pwin);
  761.   if (fcntl(w->w_ptyfd, F_SETFL, FNDELAY))
  762.     Msg(errno, "Warning: FreePseudowin: NDELAY fcntl failed");
  763.   (void) chmod(pwin->p_tty, 0666);
  764.   (void) chown(pwin->p_tty, 0, 0);
  765.   if (pwin->p_ptyfd >= 0)
  766.     close(pwin->p_ptyfd);
  767.   free(pwin);
  768.   w->w_pwin = NULL;
  769. }
  770.  
  771. #endif /* PSEUDOS */
  772.  
  773.  
  774. #ifdef MULTI
  775.  
  776. static void CloneTermcap __P((struct display *));
  777. extern char **environ;
  778.  
  779. int
  780. execclone(av)
  781. char **av;
  782. {
  783.   int f, sf;
  784.   char specialbuf[6];
  785.   struct display *old = display;
  786.   char **avp, *namep;
  787.  
  788.   sf = OpenPTY(&namep);
  789.   if (sf == -1)
  790.     {
  791.       Msg(0, "No more PTYs.");
  792.       return -1;
  793.     }
  794.   f = open(namep, O_RDWR);
  795.   if (f == -1)
  796.     {
  797.       close(sf);
  798.       Msg(errno, "Cannot open slave");
  799.       return -1;
  800.     }
  801.   brktty(f);
  802.   signal(SIGHUP, SIG_IGN);    /* No hangups, please */
  803.   if (MakeDisplay(d_username, namep, d_termname, f, -1, &d_OldMode) == 0)
  804.     {
  805.       display = old;
  806.       Msg(0, "Could not make display.");
  807.       close(f);
  808.       return -1;
  809.     }
  810.   SetMode(&d_OldMode, &d_NewMode);
  811.   SetTTY(f, &d_NewMode);
  812.   switch (fork())
  813.     {
  814.     case -1:
  815.       FreeDisplay();
  816.       display = old;
  817.       Msg(errno, "fork");
  818.       return -1;
  819.     case 0:
  820.       d_usertty[0] = 0;        /* for SendErrorMsg */
  821.       if (setuid(real_uid) || setgid(real_gid))
  822.     {
  823.       SendErrorMsg("Setuid/gid: %s", sys_errlist[errno]);
  824.       eexit(1);
  825.     }
  826.       closeallfiles(sf);
  827.       close(1);
  828.       dup(sf);
  829.       close(sf);
  830. #ifdef DEBUG
  831.     {
  832.       char buf[256];
  833.  
  834.       sprintf(buf, "%s/screen.child", DEBUGDIR);
  835.       if ((dfp = fopen(buf, "a")) == 0)
  836.         dfp = stderr;
  837.       else
  838.         (void) chmod(buf, 0666);
  839.     }
  840.       debug1("=== Clone: pid %d\n", getpid());
  841. #endif
  842.       for (avp = av; *avp; avp++)
  843.         {
  844.           if (strcmp(*avp, "%p") == 0)
  845.             *avp = namep;
  846.           if (strcmp(*avp, "%X") == 0)
  847.             *avp = specialbuf;
  848.         }
  849.       sprintf(specialbuf, "-SXX1");
  850.       namep += strlen(namep);
  851.       specialbuf[3] = *--namep;
  852.       specialbuf[2] = *--namep;
  853. #ifdef DEBUG
  854.       debug("Calling:");
  855.       for (avp = av; *avp; avp++)
  856.         debug1(" %s", *avp);
  857.       debug("\n");
  858. #endif
  859.       execvpe(*av, av, environ);
  860.       SendErrorMsg("Cannot exec %s: %s", *av, sys_errlist[errno]);
  861.       exit(1);
  862.     default:
  863.       break;
  864.     }
  865.   close(sf);
  866.   CloneTermcap(old);
  867.   InitTerm(0);
  868.   Activate(0);
  869.   if (d_fore == 0)
  870.     ShowWindows();
  871.   return 0;
  872. }
  873.  
  874. extern struct term term[];      /* terminal capabilities */
  875.  
  876. static void
  877. CloneTermcap(old)
  878. struct display *old;
  879. {
  880.   char *tp;
  881.   int i;
  882.  
  883.   tp = d_tentry;
  884.   for (i = 0; i < T_N; i++)
  885.     {
  886.       switch(term[i].type)
  887.         {
  888.         case T_FLG:
  889.           d_tcs[i].flg = old->_d_tcs[i].flg;
  890.           break;
  891.         case T_NUM:
  892.           d_tcs[i].num = old->_d_tcs[i].num;
  893.           break;
  894.         case T_STR:
  895.           d_tcs[i].str = old->_d_tcs[i].str;
  896.           if (d_tcs[i].str)
  897.             {
  898.               strcpy(tp, d_tcs[i].str);
  899.               d_tcs[i].str = tp;
  900.               tp += strlen(tp) + 1;
  901.             }
  902.       break;
  903.         default:
  904.           Panic(0, "Illegal tc type in entry #%d", i);
  905.         }
  906.     }
  907.   CheckScreenSize(0);
  908.   for (i = 0; i < NATTR; i++)
  909.     d_attrtab[i] = old->_d_attrtab[i];
  910.   for (i = 0; i < 256; i++)
  911.     d_c0_tab[i] = old->_d_c0_tab[i];
  912.   d_UPcost = old->_d_UPcost;
  913.   d_DOcost = old->_d_DOcost;
  914.   d_NLcost = old->_d_NLcost;
  915.   d_LEcost = old->_d_LEcost;
  916.   d_NDcost = old->_d_NDcost;
  917.   d_CRcost = old->_d_CRcost;
  918.   d_IMcost = old->_d_IMcost;
  919.   d_EIcost = old->_d_EIcost;
  920. #ifdef AUTO_NUKE
  921.   d_auto_nuke = old->_d_auto_nuke;
  922. #endif
  923.   d_tcinited = 1;
  924. }
  925.  
  926. #endif
  927.  
  928.