/************************************************************************** * This program is Copyright (C) 1986-2002 by Jonathan Payne. JOVE is * * provided by Jonathan and Jovehacks without charge and without * * warranty. You may copy, modify, and/or distribute JOVE, provided that * * this notice is included in all the source files and documentation. * **************************************************************************/ #include "jove.h" #ifdef IPROCS /* the body is the rest of this file */ #define MAX_BUSY_WAIT 3 /* seconds to ignore errors on pty */ #include #include "re.h" #include "jctype.h" #include "disp.h" #include "fp.h" #include "iproc.h" #include "ask.h" #include "extend.h" #include "fmt.h" #include "insert.h" #include "marks.h" #include "move.h" #include "proc.h" #include "wind.h" struct process { Process p_next; #ifdef PIPEPROCS int p_toproc; /* write end of pipe to process */ pid_t p_portpid, /* pid of direct child (the portsrv) */ p_pid; /* pid of real child i.e. not portsrv */ jbool p_portlive; /* is portsrv still live? */ #else int p_fd; /* file descriptor of pty? opened r/w */ # define p_portpid p_pid /* pid of direct child (the shell) */ pid_t p_pid; /* pid of child (the shell) */ time_t p_start; /* time we started this child */ #endif Buffer *p_buffer; /* add output to end of this buffer */ char *p_name; /* ... */ int p_io_state; /* state of communication with child and descendents */ # define IO_NEW 0 /* brand new, process has not yet sent output */ # define IO_RUNNING 1 /* just running */ # define IO_EOFED 2 /* we have sent EOF, or have received it */ int p_child_state; /* state of child process, as disclosed by SIGCHLD/wait */ # define C_LIVE 0 /* no news is good news */ # define C_STOPPED 1 # define C_EXITED 2 # define C_KILLED 3 int p_reason; /* If killed, p_reason is the signal; if exited, it is the the exit code */ Mark *p_mark; /* where output left us */ }; private void proc_rec(Process, char *, size_t), proc_close(Process), SendData(jbool), obituary(Process child, wait_status_t w); private jbool proc_kill(Process, int); #define child_dead(p) ((p)->p_child_state >= C_EXITED) #define io_eofed(p) ((p)->p_io_state == IO_EOFED) private jbool dead(Process p) { return p == NULL || (io_eofed(p) && child_dead(p)); } #define proc_cmd(p) ((p)->p_name) private Process procs = NULL; private Process proc_pid(pid_t pid) { Process p; for (p = procs; ; p = p->p_next) if (p == NULL || p->p_portpid == pid) return p; } private const char * proc_bufname(Process p) { Buffer *b = p->p_buffer; return (b != NULL) ? b->b_name : ""; } void ProcKill(void) { (void) proc_kill( buf_exists(ask_buf(curbuf, ALLOW_OLD | ALLOW_INDEX))->b_process, SIGKILL); } private void make_argv(char *argv[], va_list ap) { int i = 0; argv[i++] = va_arg(ap, char *); argv[i++] = (char *)jbasename(argv[0]); /* lose const (but it's safe) */ do {} while ((argv[i++] = va_arg(ap, char *)) != NULL); } /* environment manipulation for interactive processes */ private Env iproc_env; private char IEnvExpBuf[LBSIZE]; private char IEnvUnsetBuf[LBSIZE]; /* Erase misleading knowledge of the terminal type from the environment. * The value of variable TERMCAP has two interpretations: * If it starts with /, it is a path to the database. * If it does not, it is the database entry. * Only happens in child. */ private void set_process_env(void) { static const char tcn[] = "TERMCAP"; const char *tc = getenv(tcn); if (tc != NULL && tc[0] != '/') junsetenv(&iproc_env, tcn); environ = (char **) jenvdata(&iproc_env); /* avoid gcc warning */ } void IprocEnvExport(void) { jamstr(IEnvExpBuf, ask(IEnvExpBuf, ProcFmt)); jputenv(&iproc_env, IEnvExpBuf); } void IprocEnvShow(void) { const char **p; TOstart("i-shell environment"); for (p = jenvdata(&iproc_env); *p; p++) { Typeout("%s", *p); } TOstop(); } void IprocEnvUnset(void) { jamstr(IEnvUnsetBuf, ask(IEnvUnsetBuf, ProcFmt)); junsetenv(&iproc_env, IEnvUnsetBuf); } /* There are two very different implementation techniques: pipes and ptys. * The following two chunks of code implement the same operations using * the two techniques: the first uses pipes and the second uses ptys. */ #include "ttystate.h" #ifdef PIPEPROCS char Portsrv[FILESIZE]; /* path to portsrv program (in LibDir) */ const char *procarg0 = "jove-portsrv"; /* helpful identifying it in ps */ int NumProcs = 0; File *ProcInput; private int ProcOutput = -1; pid_t kbd_pid = -1; void read_pipe_proc(pid_t pid, int nbytes) { Process p = proc_pid(pid); jdbg("read_pipe_proc pid %D %d\n", (long) pid, nbytes); if (p == NULL) { writef("\riproc: unknown pid (%D)", (long) pid); } else if (p->p_io_state == IO_NEW) { /* first message: pid of real child, not of portsrv */ pid_t rpid; (void) f_readn(ProcInput, (char *) &rpid, sizeof(pid_t)); p->p_pid = rpid; p->p_io_state = IO_RUNNING; UpdModLine = YES; } else if (nbytes == -1) { /* okay to clean up this process */ wait_status_t status; (void) f_readn(ProcInput, (char *) &status, sizeof(status)); /* Reap portsrv process, if it still remains. * Note that any status for this process is uninteresting: * the interesting status came (just now) by pipe. */ while (p->p_portlive) { wait_status_t w; pid_t rpid = wait(&w); if (rpid == -1) { if (errno == ECHILD) { /* oops: no children, not even portsrv */ p->p_portlive = NO; } } else { kill_off(rpid, w); } } proc_close(p); obituary(p, status); } else { /* regular data */ while (nbytes > 0) { char ibuf[512+1]; /* NOTE: room for added NUL */ size_t n = f_readn(ProcInput, ibuf, (size_t)jmin((int)(sizeof ibuf) - 1, nbytes)); nbytes -= n; proc_rec(p, ibuf, n); } } } void ProcInt(void) { (void) proc_kill(curbuf->b_process, SIGINT); } void ProcQuit(void) { (void) proc_kill(curbuf->b_process, SIGQUIT); } private void proc_close(Process p) { if (p->p_toproc >= 0) { jdbg("closing proc fd %d pid %D NumProcs %d\n", p->p_toproc, (long) (p->p_pid), NumProcs); (void) close(p->p_toproc); p->p_toproc = -1; /* writes will fail */ NumProcs -= 1; p->p_io_state = IO_EOFED; /* process output EOF is tied to reaping */ UpdModLine = YES; } } private void proc_write(Process p, char *buf, size_t nbytes) { if (p->p_toproc >= 0) { while (nbytes != 0) { JSSIZE_T wr = write(p->p_toproc, buf, nbytes); if (wr >= 0) { nbytes -= wr; buf += wr; } else if (errno != EINTR) { complain("[error writing to iproc: %d %s]", errno, strerror(errno)); /* NOTREACHED */ } } } } private void proc_strt(char *bufname, jbool clobber, char *procname, ...) { Window *owind = curwind; int toproc[2]; pid_t pid; Process newp; Buffer *newbuf; char *argv[32]; va_list ap; untieDeadProcess(buf_exists(bufname)); isprocbuf(bufname); /* make sure BUFNAME is either nonexistant or is of type B_PROCESS */ if (access(Portsrv, J_X_OK) < 0) { complain("[Couldn't access %s: %s]", Portsrv, strerror(errno)); /* NOTREACHED */ } dopipe(toproc); jdbg("proc_strt NumProcs=%d buf \"%s\" proc \"%s\"\n", NumProcs, bufname, procname); if (NumProcs++ == 0) kbd_strt(); /* may create kbd process: must be done before fork */ switch (pid = fork()) { case -1: pipeclose(toproc); if (--NumProcs == 0) kbd_stop(); complain("[Fork failed: %s]", strerror(errno)); /* NOTREACHED */ case 0: argv[0] = (char*)procarg0; va_start(ap, procname); make_argv(&argv[1], ap); va_end(ap); (void) dup2(toproc[0], 0); (void) dup2(ProcOutput, 1); (void) dup2(ProcOutput, 2); pipeclose(toproc); jcloseall(); set_process_env(); jdbg("ready to exec %s %s %s %s\n", Portsrv, argv[0], argv[1]? argv[1] : "(null)", argv[2]? argv[2] : "(null)"); execv(Portsrv, argv); raw_complain("execl failed: %s", strerror(errno)); _exit(1); } newp = (Process) emalloc(sizeof *newp); newp->p_next = procs; newp->p_io_state = IO_NEW; newp->p_child_state = C_LIVE; newp->p_name = copystr(procname); procs = newp; newp->p_portpid = pid; newp->p_pid = -1; newp->p_portlive = YES; newbuf = do_select((Window *)NULL, bufname); newbuf->b_type = B_PROCESS; newp->p_buffer = newbuf; newbuf->b_process = newp; /* sorta circular, eh? */ pop_wind(bufname, clobber, B_PROCESS); ToLast(); if (!bolp()) LineInsert(1); /* Pop_wind() after everything is set up; important! * Bindings won't work right unless newbuf->b_process is already * set up BEFORE NEWBUF is first SetBuf()'d. */ newp->p_mark = MakeMark(curline, curchar); newp->p_toproc = toproc[1]; (void) close(toproc[0]); SetWind(owind); } void closeiprocs(void) { Process p; if (ProcOutput != -1) close(ProcOutput); for (p=procs; p!=NULL; p=p->p_next) if (p->p_toproc >= 0) close(p->p_toproc); } private void kbd_init(void) { /* Initiate the keyboard process. * We only get here after a portsrv process has been started * so we know that the portsrv program must exist -- no need to test. */ int p[2]; if (pipe(p) < 0) { complain("Cannot create pipe to kbd process! %s\n", strerror(errno)); /* NOTREACHED */ } ProcInput = fd_open("process-input", F_READ|F_LOCKED, p[0], (char *)NULL, 512); ProcOutput = p[1]; switch (kbd_pid = fork()) { case -1: complain("Cannot fork kbd process! %s\n", strerror(errno)); /* NOTREACHED */ case 0: (void) setsighandler(SIGINT, SIG_IGN); (void) setsighandler(SIGALRM, SIG_IGN); close(1); if (dup(ProcOutput) < 0) { raw_complain("Cannot dup output fd: %s", strerror(errno)); EXIT(-1); } jcloseall(); jdbg("ready to exec %s as %s --kbd\n", Portsrv, procarg0); execl(Portsrv, procarg0, "--kbd", (char *)NULL); raw_complain("kbd exec failed: %s", strerror(errno)); EXIT(-1); } } /* kbd_stop() returns true if it changes the state of (i.e. stops) * the keyboard process. This is so kbd stopping and starting in * pairs works - see finish() in jove.c. */ private jbool kbd_state = NO; void kbd_strt(void) { jdbg("kbd_strt state %d pid %D NumProcs %d\n", kbd_state, (long) kbd_pid, NumProcs); if (!kbd_state) { if (kbd_pid == -1) kbd_init(); else kill(kbd_pid, KBDSIG); kbd_state = YES; } } jbool kbd_stop(void) { jdbg("kbd_stop state %d pid %D NumProcs %d\n", kbd_state, (long) kbd_pid, NumProcs); if (kbd_state) { kbd_state = NO; kill(kbd_pid, KBDSIG); return YES; } return NO; } void kbd_kill(void) { jdbg("kbd_kill state %d pid %D Numprocs %d\n", kbd_state, (long) kbd_pid, NumProcs); if (kbd_pid != -1) { kill(kbd_pid, SIGKILL); kbd_pid = -1; } } #else /* !PIPEPROCS */ #include #include "select.h" # ifdef USE_OPENPTY /* modern BSDs have openpty(3) */ # ifdef HAVE_LIBUTIL_H /* but disagree about header! */ # include # else # ifdef HAVE_PTY_H # include # else # include # endif # endif # endif # ifdef SVR4_PTYS # include /* for grantpt and unlockpt, at least in Solaris 2.3 */ # if _XOPEN_SOURCE >= 500 /* Linux/glibc no longer pretends to support STREAMS (XSR) (2008) */ # if defined(_XOPEN_STREAMS) && _XOPEN_STREAMS != -1 # include # endif # else # include # endif extern char *ptsname(int /*filedes*/); /* get name of slave */ # endif # ifdef IRIX_PTYS # include # endif void read_pty_proc(int fd) { Process p; int n; char ibuf[1024+1]; /* NOTE: room for added NUL */ for (p = procs; ; p = p->p_next) { if (p == NULL) { writef("\riproc: unknown fd %d", fd); return; } if (p->p_fd == fd) break; } n = read(fd, ibuf, sizeof ibuf - 1); jdbg("pty read %d returned %d errno %d from %s\n", fd, n, errno, p->p_name); if (n <= 0) { if (n < 0) { if (errno == EIO || RETRY_ERRNO(errno)) { /* * ??? On some systems, pty reads fail * initially, for reasons that are not clear to * me (DHR). This code forgives these specific * kinds of failure until the process leaves the * NEW state. We hope that this does not cause * a long busy wait. */ if (p->p_io_state == IO_NEW) { time_t now = time(NULL); jdbg("IO_NEW err %d start %D now %D\n", errno, (long)p->p_start,(long)now); if (now < p->p_start+MAX_BUSY_WAIT) return; } jdbg("treating error as EOF\n"); /* We get here if the i-proc closes stdout * before exiting (eg. Bourne Shell), * so we treat it as a simple EOF. */ } else { /* true I/O error */ swritef(ibuf, sizeof(ibuf), "\n[pty read error: %s]\n", strerror(errno)); proc_rec(p, ibuf, strlen(ibuf)); /* now treat as EOF... */ } } /* else, EOF received */ proc_close(p); } else { if (p->p_io_state == IO_NEW) { p->p_io_state = IO_RUNNING; UpdModLine = YES; } proc_rec(p, ibuf, (size_t)n); } } void ProcCont(void) { Process p = curbuf->b_process; jdbg("ProcCont pid %D %s\n", (long)(p->p_pid), p->p_name); if (proc_kill(p, SIGCONT) && p->p_child_state == C_STOPPED) { p->p_child_state = C_LIVE; UpdModLine = YES; } } /* Sending non-character info through "keyboard" * * There are two kinds of "out of band" signals we wish to send * through the pty: signals (such as SIGINT) and EOF. On top * of that, there is a kind of out of band signal we wish not to * send: ERASE and KILL. Unfortunately, there are a number of ways * in which our environment may vary. Two ioctls are useful: * TIOCREMOTE and TIOCSIGNAL/TIOCSIG. * * * TIOCREMOTE: * * Some systems support the TIOCREMOTE ioctl. With this ioctl, * the "input editing" is suppressed on the characters sent * to the slave. Input editing involves interpreting ERASE, * KILL, INTERRUPT, QUIT, EOF, etc. characters. It is best * to run this way since JOVE already does input editing. * * The scant documentation on TIOCREMOTE in Solaris2.3 suggests * that the third argument to the TIOCREMOTE ioctl ought to be * an integer (but a pointer to the integer works). The SunOS4 * ldterm(4m) manpage says that the third argument is to be a * pointer to an integer. At the moment, we only use the pointer * form. * * Although IRIX defines TIOCREMOTE, it does not seem to work. * This may well be true of other systems, so as a safety, * we support "NO_TIOCREMOTE" as a feature deselect macro * for systems that define TIOCREMOTE but are broken. * * Under BSDI's BSD/386 v1.[01], the TIOCREMOTE ioctls appear to fail * for send_xc (without an error indication), but work otherwise. This * only affects dstop-process, so it is probably best not to define * NO_TIOCREMOTE. Even if we do define NO_TIOCREMOTE, the dstop-process * may require the user to do a process-newline (apparently, if the tty * input is being canonicalized). How odd. * * * TIOCSIGNAL/TIOCSIG: * * Some systems support the TIOCSIGNAL ioctl. With this ioctl, * a signal can be sent through the pty. Recent (4.3 or later?) * BSD systems seem to provide a TIOCSIG ioctl which is similar. * * The TIOCSIGNAL ioctl is not well documented and seems to be * broken on at least IRIX 5.3. Again, we provide "NO_TIOCSIGNAL" * to prevent using it on systems that define it but are broken. * * Another mystery: systems vary on how the signal number should be * passed in the TIOCSIGNAL ioctl. SunOS4 requires that the third * argument be a pointer to an integer, the signal number. Vanilla * SVR4 requires that the third argument be a an integer, the signal * number. Solaris2.3 accepts either. The SunOS 5.3 STREAMS * Programmer's Guide says that the third argument is an int. We have * not figured out, for an arbitrary system with TIOCSIGNAL, how to * tell which form the third argument should take. For now, it is * conditionalized on SVR4_PTYS. * * If TIOCSIGNAL/TIOCSIG isn't supplied (perhaps from termios.h), we * cannot send signals to the child when TIOCREMOTE is on, so we just * turn it off for a moment. This is pretty dubious because the user * might have done an stty to change or disable the characters. * * We don't know how to implement dstop using TIOCSIGNAL/TIOCSIG, so * we use the dubious trick. */ # if !defined(NO_TIOCREMOTE) && !defined(TIOCREMOTE) # define NO_TIOCREMOTE 1 # endif # if !defined(NO_TIOCSIGNAL) && !defined(TIOCSIGNAL) && !defined(TIOCSIG) # define NO_TIOCSIGNAL 1 # endif # ifdef NO_TIOCSIGNAL # define kbd_sig(sig, tch, sch) send_oxc(tch, sch) # define kbd_sig_ls(sig, tch, sch) send_oxc_ls(tch, sch) # else /* !NO_TIOCSIGNAL */ # define kbd_sig(sig, tch, sch) send_sig(sig) # define kbd_sig_ls(sig, tch, sch) kbd_sig(sig, tch, sch) private void send_sig(int sig) { Process p; jdbg("send_sig %d\n", sig); if ((p = curbuf->b_process) == NULL || p->p_fd < 0) { complain("[No process]"); /* NOTREACHED */ } ToLast(); # ifdef TIOCSIG jdbg("TIOCSIG pid %d %s\n", p->p_pid, p->p_name); if (ioctl(p->p_fd, TIOCSIG, sig) < 0) { complain("TIOCSIG failed: %d %s", errno, strerror(errno)); /* NOTREACHED */ } # else /* !TIOCSIG */ # ifdef SVR4_PTYS jdbg("SVR4 TIOCSIGNAL pid %d %s\n", p->p_pid, p->p_name); if (ioctl(p->p_fd, TIOCSIGNAL, sig) < 0) { complain("TIOCSIGNAL failed: %d %s", errno, strerror(errno)); /* NOTREACHED */ } # else /* !SVR4_PTYS */ jdbg("TIOCSIGNAL pid %d %s\n", p->p_pid, p->p_name); if (ioctl(p->p_fd, TIOCSIGNAL, (void *) &sig) < 0) { complain("TIOCSIGNAL failed: %d %s", errno, strerror(errno)); /* NOTREACHED */ } # endif /* !SVR4_PTYS */ # endif /* !TIOCSIG */ } # endif /* !NO_TIOCSIGNAL */ # if defined(NO_TIOCREMOTE) || defined(NO_TIOCSIGNAL) || defined(VDSUSP) # define send_oxc(tch, sch) send_xc(sg[NO].c_cc[tch]) # define send_oxc_ls(tch, sch) send_oxc(tch, sch) private void send_xc(char c) { Process p; if ((p = curbuf->b_process) == NULL || p->p_fd < 0) { complain("[No process]"); /* NOTREACHED */ } jdbg("send_xc 0x%x pid %d %s \n", c, p->p_pid, p->p_name); ToLast(); { char buf[1+1]; /* NOTE: room for added NUL */ buf[0] = c; proc_rec(p, buf, (size_t)1); { # ifndef NO_TIOCREMOTE int off = 0, on = 1; jdbg("TIOCREMOTE off pid %d %s\n", p->p_pid, p->p_name); while (ioctl(p->p_fd, TIOCREMOTE, &off) < 0) if (errno != EINTR) { complain("TIOCREMOTE OFF failed: %d %s", errno, strerror(errno)); /* NOTREACHED */ } # endif /* !NO_TIOCREMOTE */ for (;;) { switch (write(p->p_fd, &c, sizeof c)) { case -1: /* error: consider ERRNO */ if (errno == EINTR) continue; /* interrupted: try again */ complain("pty write of control failed: %d %s", errno, strerror(errno)); /* NOTREACHED */ case 0: /* nothing happened: try again */ continue; case 1: /* done */ break; } break; } # ifndef NO_TIOCREMOTE jdbg("TIOCREMOTE on pid %d %s\n", p->p_pid, p->p_name); while (ioctl(p->p_fd, TIOCREMOTE, &on) < 0) { if (errno != EINTR) { complain("TIOCREMOTE ON failed: %d %s", errno, strerror(errno)); /* NOTREACHED */ } } # endif /* !NO_TIOCREMOTE */ } } } # endif /* defined(NO_TIOCREMOTE) || defined(NO_TIOCSIGNAL) */ void ProcEof(void) { # ifdef NO_TIOCREMOTE /* we have to write a char */ send_oxc(VEOF, t_eofc); # else /* !NO_TIOCREMOTE */ /* write a zero-length record to signify EOF */ static char mess[] = " "; /* NOTE: NUL will be overwritten */ Process p; if ((p = curbuf->b_process) == NULL || p->p_fd < 0) { complain("[No process]"); /* NOTREACHED */ } ToLast(); proc_rec(p, mess, sizeof(mess)-1); jdbg("ProcEof pid %d %s\n", p->p_pid, p->p_name); while (write(p->p_fd, mess, (size_t)0) < 0) { if (errno != EINTR) { complain("[error writing EOF to iproc: %d %s]", errno, strerror(errno)); /* NOTREACHED */ } } # endif /* !NO_TIOCREMOTE */ } void ProcInt(void) { kbd_sig(SIGINT, VINTR, t_intrc); } void ProcQuit(void) { kbd_sig(SIGQUIT, VQUIT, t_quitc); } void ProcStop(void) { # if defined(VSUSP) kbd_sig_ls(SIGTSTP, VSUSP, t_suspc); # else complain("[stop-process not supported]"); /* NOTREACHED */ # endif } void ProcDStop(void) { /* we don't know how to send a dstop via TIOCSIGNAL/TIOCSIG */ # if defined(VDSUSP) send_oxc_ls(VDSUSP, t_dsuspc); # else complain("[dstop-process not supported]"); /* NOTREACHED */ # endif } private void proc_close(Process p) { jdbg("proc_close %d %s\n", p->p_pid, p->p_name); if (p->p_fd >= 0) { (void) close(p->p_fd); FD_CLR(p->p_fd, &global_fd); p->p_fd = -1; p->p_io_state = IO_EOFED; /* I/O is finished */ UpdModLine = YES; } } private void proc_write(Process p, char *buf, size_t nbytes) { jdbg("proc_write %d bytes to pid %d %s\n", nbytes, p->p_pid, p->p_name); if (p->p_fd >= 0) { fd_set mask; FD_ZERO(&mask); FD_SET(p->p_fd, &mask); while (write(p->p_fd, buf, nbytes) < 0) (void) select(p->p_fd + 1, (fd_set *)NULL, &mask, (fd_set *)NULL, (struct timeval *)NULL); } } private void proc_strt(char *bufname, jbool clobber, const char *procname, ...) { va_list ap; char *argv[32]; Window *owind = curwind; pid_t pid; Process newp; Buffer *newbuf; int ptyfd = -1; int slvptyfd = -1; char ttybuf[32]; struct termios sgt; # ifdef TIOCGWINSZ struct winsize win; # else # ifdef BTL_BLIT # include struct jwinsize jwin; # endif # endif strcpy(ttybuf, "?"); /* to safely print when debugging */ untieDeadProcess(buf_exists(bufname)); isprocbuf(bufname); /* make sure BUFNAME is either nonexistant or is of type B_PROCESS */ va_start(ap, procname); make_argv(argv, ap); va_end(ap); if (access(argv[0], J_X_OK) != 0) { complain("[Couldn't access shell %s: %s]", argv[0], strerror(errno)); /* NOTREACHED */ } # ifdef IRIX_PTYS /* _getpty may fork off a child to execute mkpts to make a slave pty * in /dev (if we need more) and set the correct ownership and * modes on the slave pty. Since _getpty uses waitpid this works * fine with regard to our other children, but we do have to be * prepared to catch a SIGCHLD for an unknown child and ignore it ... */ { char *s = _getpty(&ptyfd, O_RDWR | O_NDELAY, 0600, 0); if (s == NULL) { message("[No pty from getpty!]"); goto fail; } (void)strcpy(ttybuf, s); jdbg("IRIX_PTYS _getpty ptyfd %d %s\n", ptyfd, ttybuf); } # endif /* IRIX_PTYS */ # ifdef SVR4_PTYS if ((ptyfd = open("/dev/ptmx", O_RDWR | O_BINARY)) < 0) { message("[No pty from /dev/ptmx!]"); goto fail; } jdbg("SVR4_PTYS ptmx ptyfd %d\n", ptyfd); # ifndef GRANTPT_BUG /* grantpt() seems to be implemented using a fork/exec. * This is done to allow grantpt do do priviledged things * via a setuid program. One consequence is that JOVE's * SIGCLD/SIGCHLD handler must not do a wait that would * reap the grantpt process. So much for library routines * being black boxes. Worse, this restriction is not documented. */ if (grantpt(ptyfd) < 0) { message("[grantpt failed]"); goto fail; } if (unlockpt(ptyfd) < 0) { message("[unlockpt failed]"); goto fail; } jdbg("SVR4_PTYS grantpt and unlockpt ptyfd %d\n", ptyfd); # endif /* !GRANTPT_BUG */ #ifdef TIOCGPTPEER /* if we have TIOCGPTPEER (Linux post-2017), much better to use it! */ slvptyfd = ioctl(ptyfd, TIOCGPTPEER, O_RDWR | O_NOCTTY); if (slvptyfd == -1 && errno != EINVAL && errno != ENOTTY) { message("[ioctl TIOCGPTPEER failed]"); goto fail; } jdbg("SVR4_PTYS TIOCGPTPEER ptyfd %d slv %d\n", ptyfd, slvptyfd); #endif { char *s = ptsname(ptyfd); if (s == NULL) { message("[ptsname failed]"); goto fail; } strcpy(ttybuf, s); jdbg("SVR4_PTYS ptyfd %d %s\n", ptyfd, ttybuf); } # ifdef TIOCFLUSH jdbg("TIOCFLUSH ptyfd %d\n", ptyfd); (void) ioctl(ptyfd, TIOCFLUSH, NULL); /* ??? why? */ # endif # endif /* SVR4_PTYS */ # ifdef BSD_PTYS # ifdef USE_OPENPTY if (openpty(&ptyfd, &slvptyfd, ttybuf, NULL, NULL) < 0) { message("[No pty from openpty!]"); goto fail; } jdbg("openpty ptyfd %d slv %d %s\n", ptyfd, slvptyfd, ttybuf); # else /* !USE_OPENPTY */ { const char *s; for (s = "pqrs"; ptyfd<0; s++) { const char *t; if (*s == '\0') { message("[Out of ptys in /dev/pty*!]"); goto fail; } for (t = "0123456789abcdef"; *t; t++) { swritef(ttybuf, sizeof(ttybuf), "/dev/pty%c%c", *s, *t); jdbg("trying pty %s\n", ttybuf); if ((ptyfd = open(ttybuf, O_RDWR | O_BINARY)) >= 0) { ttybuf[5] = 't'; /* pty => tty */ /* Make sure other end is available too */ slvptyfd = open(ttybuf, O_RDWR | O_BINARY); if (slvptyfd > 0) break; /* it worked: use this one */ /* can't open, so give up on this pty */ (void) close(ptyfd); ptyfd = slvptyfd = -1; } } } } # endif /* !USE_OPENPTY */ # endif /* BSD_PTYS */ /* Check that we can write to the pty, else things will fail in the * child, where they're harder to detect. This will not work with * GRANTPT_BUG because the grantpt and unlockpt have not been done yet. */ # ifndef GRANTPT_BUG if (access(ttybuf, R_OK | W_OK) != 0) { s_mess("[Couldn't access %s: %s]", ttybuf, strerror(errno)); goto fail; } jdbg("can access pty %s\n", ttybuf); # endif /* !GRANTPT_BUG */ # ifdef TIOCGWINSZ jdbg("TIOCGWINSZ %s\n", ttybuf); (void) ioctl(0, TIOCGWINSZ, &win); # else # ifdef BTL_BLIT jdbg("JWINSIZE %s\n", ttybuf); (void) ioctl(0, JWINSIZE, &jwin); # endif /* BTL_BLIT */ # endif jdbg("before fork, ptyfd %d slv %d buf %s\n", ptyfd, slvptyfd, ttybuf); switch (pid = fork()) { case -1: /* fork failed */ s_mess("[Fork failed! %s]", strerror(errno)); goto fail; case 0: /* child process */ # ifdef GRANTPT_BUG /* grantpt() seems to be implemented using a fork/exec. * This is done to allow grantpt do do priviledged things * via a setuid program. One consequence is that JOVE's * SIGCLD/SIGCHLD handler must not do a wait that would * reap the grantpt process. So much for library routines * being black boxes. Worse, this restriction is not documented. * * Worse still, at least Solaris 2.0 and SVR4.0 appear to have * a bug: the wait is not restarted once interrupted. If the wait * is interrupted, (1) the grantpt will return a failure status * and (2) the process will not be reaped -- it will remain a * zombie until JOVE exits or happens to reap it accidentally. * Any interrupt could cause the premature end of the wait, * but SIGCHLD (actually, SIGCLD) is the most probable. * * To dodge these bullets, we moved the grantpt into the child * where we can turn off signal handling. Too bad this prevents * us giving good diagnostics for grantpt and unlockpt. * I hope I've found all the signals caught everywhere else. */ jdbg("child grantpt bug, ptyfd %d slv %d buf %s\n", ptyfd, slvptyfd, ttybuf); (void) setsighandler(SIGCHLD, SIG_DFL); (void) setsighandler(SIGWINCH, SIG_DFL); (void) setsighandler(SIGALRM, SIG_DFL); (void) setsighandler(SIGINT, SIG_DFL); /* (void) setsighandler(SIGQUIT, SIG_DFL); */ /* dead anyway */ /* (void) setsighandler(SIGHUP, SIG_DFL); */ /* dead anyway */ /* (void) setsighandler(SIGTERM, SIG_DFL); */ /* no longer used */ /* (void) setsighandler(SIGBUS, SIG_DFL); */ /* dead anyway */ /* (void) setsighandler(SIGSEGV, SIG_DFL); */ /* dead anyway */ /* (void) setsighandler(SIGPIPE, SIG_DFL); */ /* dead anyway */ if (grantpt(ptyfd) < 0) { _exit(errno + 1); } if (unlockpt(ptyfd) < 0) { _exit(errno + 1); } # endif /* GRANTPT_BUG */ jcloseall(); (void) close(0); (void) close(1); (void) close(2); jdbg("child setsid %s\n", ttybuf); setsid(); jdbg("child ptyfd %d slv %d buf %s\n", ptyfd, slvptyfd, ttybuf); if (slvptyfd < 0) { if ((slvptyfd = open(ttybuf, O_RDWR | O_BINARY)) != 0) _exit(errno+1); jdbg("child slv slv %d\n", slvptyfd); } /* else use what we got from openpty */ (void) dup2(slvptyfd, 1); (void) dup2(slvptyfd, 2); if (slvptyfd != 0) { (void) dup2(slvptyfd, 0); jdbg("child closing slv %d %s\n", slvptyfd, ttybuf); (void) close(slvptyfd); /* safe to close now that std* are open */ } jdbg("child std 0, 1, 2 duped\n"); # ifdef SVR4_PTYS # ifdef I_PUSH /* LINUX/glibc no longer even pretends to support this (2008) */ jdbg("child SVR4_PTYS I_PUSH ptem ldterm ttcompat %s\n", ttybuf); (void) ioctl(0, I_PUSH, "ptem"); (void) ioctl(0, I_PUSH, "ldterm"); (void) ioctl(0, I_PUSH, "ttcompat"); # endif # endif # ifdef TIOCSCTTY /* Make this controling tty. * This is needed by OSF. It may be needed by BSDPOSIX systems. * It should not hurt on any system that defines TIOCSCTTY. * On Solaris (OpenIndiana 2019.11), the ioctl fails with errno 25 (ENOTTY) * but that seems harmless, so we just log but ignore error returns * (as used to be the case before 4.16.0.31!) */ jdbg("child TIOCSTTY %s\n", ttybuf); if (ioctl(0, TIOCSCTTY) < 0) { jdbg("TIOCSCTTY failed errno %d %s\n", errno, strerror(errno)); } # endif # ifndef NO_TIOCREMOTE /* The TIOCREMOTE ioctl prevents the pty code from doing * input editing on characters from the master. In particular * we don't want ERASE, KILL, INTERRUPT, QUIT, etc. characters * interpreted. * On SVR4, this must be done *after* the slave side is set up. * The easiest way to ensure this is to put it here, in the child * after the slave is opened and has the STREAMS modules pushed, * and before the master is closed. */ { int on = 1; jdbg("child TIOCREMOTE on %d %s\n", ptyfd, ttybuf); if (ioctl(ptyfd, TIOCREMOTE, &on) < 0) _exit(errno+1); /* no good way to signal user */ } # endif jdbg("child closing %d %s\n", ptyfd, ttybuf); close(ptyfd); # ifdef TIOCGWINSZ jdbg("child TIOCSWINSZ %s\n", ttybuf); win.ws_row = curwind->w_height; (void) ioctl(0, TIOCSWINSZ, &win); # else /* !TIOCGWINSZ */ # ifdef BTL_BLIT jdbg("child JSWINSIZE %s\n", ttybuf); jwin.bytesy = curwind->w_height; (void) ioctl(0, JSWINSIZE, &jwin); # endif # endif /* !TIOCGWINSZ */ jdbg("child set termio(s)%s\n", ttybuf); sgt = sg[NO]; sgt.c_iflag &= ~(IGNBRK | BRKINT | ISTRIP | INLCR | IGNCR | ICRNL # ifdef IXANY /* not in QNX */ | IXANY # endif | IXON | IXOFF); sgt.c_lflag &= ~(ECHO); sgt.c_oflag &= ~(ONLCR | TABDLY); jdbg("child TCSADRAIN %s\n", ttybuf); do {} while (tcsetattr(0, TCSADRAIN, &sgt) < 0 && errno == EINTR); jdbg("child newpg %s\n", ttybuf); NEWPG(); { int i = getpid(); # ifdef POSIX_PROCS jdbg("child tcsetpgrp %d %s\n", i, ttybuf); tcsetpgrp(0, getpid()); # else /* !POSIX_PROCS */ jdbg("child TIOCSPGRP %d %s\n", i, ttybuf); (void) ioctl(0, TIOCSPGRP, &i); # endif /* POSIX_PROCS */ } set_process_env(); jdbg("child ready to exec %s %s\n", argv[0], argv[1]); execvp(argv[0], &argv[1]); raw_complain("execvp failed! %s", strerror(errno)); _exit(errno + 1); } # ifdef BSD_PTYS jdbg("closing slv %d %s\n", slvptyfd, ttybuf); close(slvptyfd); # endif /* BSD_PTYS */ newp = (Process) emalloc(sizeof *newp); # ifdef O_NDELAY jdbg("O_NDELAY %d %s\n", ptyfd, ttybuf); fcntl(ptyfd, F_SETFL, O_NDELAY); # endif # ifdef O_NONBLOCK jdbg("O_NONBLOCK %d %s\n", ptyfd, ttybuf); fcntl(ptyfd, F_SETFL, O_NONBLOCK); # endif (void) time(&(newp->p_start)); jdbg("start pid %d fd %d %s %D\n", pid, ptyfd, ttybuf, (long) newp->p_start); newp->p_fd = ptyfd; newp->p_pid = pid; newbuf = do_select((Window *)NULL, bufname); newbuf->b_type = B_PROCESS; newp->p_buffer = newbuf; newbuf->b_process = newp; /* sorta circular, eh? */ pop_wind(bufname, clobber, B_PROCESS); /* Pop_wind() after everything is set up; important! * Bindings won't work right unless newbuf->b_process is already * set up BEFORE NEWBUF is first SetBuf()'d. */ ToLast(); if (!bolp()) LineInsert(1); newp->p_name = copystr(procname); newp->p_io_state = IO_NEW; newp->p_child_state = C_LIVE; newp->p_mark = MakeMark(curline, curchar); newp->p_next = procs; procs = newp; FD_SET(newp->p_fd, &global_fd); if (global_maxfd <= newp->p_fd) global_maxfd = newp->p_fd + 1; SetWind(owind); return; fail: jdbg("pty open fail %d %d %s\n", ptyfd, slvptyfd, ttybuf); if (ptyfd >= 0) close(ptyfd); # ifdef BSD_PTYS if (slvptyfd >= 0) close(slvptyfd); # endif /* BSD_PTYS */ } /* NOTE 1: SIGCHLD is an asynchronous signal. To safely handle it, * the sigchld_handler simply sets a flag requesting later processing. * reap_procs is called synchronously to do the actual work. * * NOTE 2: SIGCHLD is "level triggered" on some systems (HPUX, IRIX, ...). * If the signal signal handler is re-established before the child is reaped, * another signal will be generated immediately. For this reason, we * defer the re-establishment until reap_procs is done. */ volatile jbool procs_to_reap = NO; /*ARGSUSED*/ SIGRESTYPE sigchld_handler(int UNUSED(junk)) { procs_to_reap = YES; return SIGRESVALUE; } void reap_procs(void) { wait_status_t w; pid_t pid; for (;;) { pid = wait_opt(&w, (WNOHANG | WUNTRACED)); if (pid <= 0) { if (procs_to_reap) { resetsighandler(SIGCHLD, sigchld_handler); procs_to_reap = NO; /* go around once more to avoid window of vulnerability */ } else { break; } } else { kill_off(pid, w); } } } void closeiprocs(void) { Process p; for (p=procs; p!=NULL; p=p->p_next) if (p->p_fd >= 0) close(p->p_fd); } #endif /* !PIPEPROCS */ /* This is for the shell window. Supports sh, csh and ksh. */ char proc_prompt[128] = "^[^%$#]*[%$#] "; /* VAR: process prompt */ const char * pstate(Process p) { static const char *const ios_name[] = { "New", "Running", "EOFed" }; if (p == NULL) return "No process"; /* Try *not* to report the whole cross-product of child and IO states. */ switch (p->p_child_state) { case C_LIVE: return ios_name[p->p_io_state]; case C_STOPPED: return io_eofed(p)? "Stopped; EOFed" : "Stopped"; case C_EXITED: if (io_eofed(p) && p->p_reason == 0) return "Done"; /* FALLTHROUGH */ default: return sprint("%s %d%s", (p->p_child_state == C_EXITED? "Exited" : "Killed"), p->p_reason, (io_eofed(p)? "" : "; not EOFed")); } } jbool KillProcs(void) { Process p; jbool asked = NO; for (p = procs; p != NULL; p = p->p_next) { if (!dead(p)) { if (!asked) { if (!yes_or_no_p("Some interactive processes are still running; leave anyway? ")) return NO; /* processes not killed */ asked = YES; } if (!child_dead(p)) (void) proc_kill(p, SIGKILL); proc_close(p); } } return YES; /* processes killed */ } /* VAR: dbx-mode parse string */ char dbx_parse_fmt[128] = "line \\([0-9]*\\) in \\{file\\|\\} *\"\\([^\"]*\\)\""; private void watch_input(Mark *m) { Bufpos save; char fname[FILESIZE], lineno[FILESIZE]; long lnum; Window *savew = curwind; Buffer *buf; DOTsave(&save); ToMark(m); if (dosearch(dbx_parse_fmt, FORWARD, YES) != NULL) { get_FL_info(fname, lineno); buf = do_find((Window *)NULL, fname, YES, YES); pop_wind(buf->b_name, NO, -1); lnum = atol(lineno); SetLine(next_line(buf->b_first, lnum - 1)); SetWind(savew); } SetDot(&save); } /* Process receive: receives the characters in buf, and appends them to * the buffer associated with p. */ private void proc_rec(Process p, char *buf, size_t len) { Buffer *saveb = curbuf; Window *w; Mark *savepoint; jbool sameplace, do_disp; if (curwind->w_bufp == p->p_buffer) w = curwind; else w = windbp(p->p_buffer); /* Is this window visible? */ do_disp = w != NULL && in_window(w, p->p_mark->m_line) != -1; SetBuf(p->p_buffer); savepoint = MakeMark(curline, curchar); ToMark(p->p_mark); /* where output last stopped */ sameplace = savepoint->m_line == curline && savepoint->m_char == curchar; /* insert contents of buffer, carefully translating NUL to ^@ */ buf[len] = '\0'; /* NUL-terminate buffer */ while (len != 0) { if (*buf == '\0') { ins_str_wrap("^@", YES, WrapProcessLines ? CO-1 : LBSIZE-1); buf++; len--; } else { size_t sublen = strlen(buf); ins_str_wrap(buf, YES, WrapProcessLines ? CO-1 : LBSIZE-1); buf += sublen; len -= sublen; } } if (do_disp && BufMinorMode(p->p_buffer, DbxMode)) watch_input(p->p_mark); MarkSet(p->p_mark, curline, curchar); if (!sameplace) ToMark(savepoint); /* back to where we were */ DelMark(savepoint); /* redisplay now, instead of right after the ins_str, so that * we don't get a bouncing effect if point is not the same as * the process output position */ if (do_disp) { w->w_line = curline; w->w_char = curchar; redisplay(); } SetBuf(saveb); } private jbool proc_kill(Process p, int sig) { if (p == NULL) { complain("[no process]"); /* NOTREACHED */ } if (!child_dead(p)) { if (killpg(p->p_pid, sig) != -1) return YES; s_mess("Cannot kill %s!", proc_bufname(p)); } return NO; } /* Free process CHILD. Do all the necessary cleaning up (closing fd's, * etc.). */ private void free_proc(Process child) { Process p, prev = NULL; if (!dead(child)) return; untieDeadProcess(child->p_buffer); for (p = procs; p != child; prev = p, p = p->p_next) ; if (prev == NULL) procs = child->p_next; else prev->p_next = child->p_next; proc_close(child); /* if not already closed */ free(child->p_name); free(child); } void untieDeadProcess(Buffer *b) { if (b != NULL) { Process p = b->b_process; if (p != NULL) { Buffer *old = curbuf; if (!dead(p)) { complain("Process %s, attached to %b, is %s.", proc_cmd(p), b, pstate(p)); /* NOTREACHED */ } SetBuf(p->p_buffer); DelMark(p->p_mark); SetBuf(old); p->p_buffer = NULL; b->b_process = NULL; } } } void ProcList(void) { Process p, next; const char fmt[] = "%-15s %-15s %-8s %s"; char pidstr[16]; if (procs == NULL) { message("[No subprocesses]"); return; } TOstart("Process list"); Typeout(fmt, "Buffer", "Status", "Pid ", "Command"); Typeout(fmt, "------", "------", "--- ", "-------"); for (p = procs; p != NULL; p = next) { next = p->p_next; swritef(pidstr, sizeof(pidstr), "%d", (int) p->p_pid); Typeout(fmt, proc_bufname(p), pstate(p), pidstr, p->p_name); if (dead(p)) { free_proc(p); UpdModLine = YES; } } TOstop(); } private void do_rtp(Mark *mp) { Process p = curbuf->b_process; LinePtr line1 = curline, line2 = mp->m_line; int char1 = curchar, char2 = mp->m_char; char *gp; size_t nbytes; if (dead(p) || p->p_buffer != curbuf) return; (void) fixorder(&line1, &char1, &line2, &char2); while (line1 != line2->l_next) { gp = ltobuf(line1, genbuf) + char1; if (line1 == line2) { nbytes = char2 - char1; } else { genbuf[Jr_Len] = EOL; /* replace NUL with EOL */ nbytes = Jr_Len - char1 + 1; /* and include it */ } if (nbytes != 0) proc_write(p, gp, nbytes); line1 = line1->l_next; char1 = 0; } } void ProcNewline(void) { #ifdef ABBREV MaybeAbbrevExpand(); #endif SendData(YES); } void ProcSendData(void) { #ifdef ABBREV MaybeAbbrevExpand(); #endif SendData(NO); } private void SendData(jbool newlinep) { Process p = curbuf->b_process; char *lp, *gp; /* JF fix for better prompt handling */ if (dead(p)) return; /* If the process mark was involved in a big deletion, because * the user hit ^W or something, then let's do some magic with * the process mark. Problem is that if the user yanks back the * text he deleted, the mark stays at the beginning of the region, * and so the next time SendData() is called the entire region * will be sent. That's not good. So, to deal with that we reset * the mark to the last line, after skipping over the prompt, etc. */ if (p->p_mark->m_big_delete) { Bufpos bp; p->p_mark->m_big_delete = NO; DOTsave(&bp); ToLast(); Bol(); /* While we're looking at a prompt, and while we're * moving forward. This is for people who accidently * set their process-prompt to ">*" which will always * match! */ while (LookingAt(proc_prompt, linebuf, curchar) && (REeom > curchar)) curchar = REeom; MarkSet(p->p_mark, curline, curchar); SetDot(&bp); } if (lastp(curline)) { Eol(); if (newlinep) LineInsert(1); do_rtp(p->p_mark); MarkSet(p->p_mark, curline, curchar); } else { /* Either we're looking at a prompt, or we're not, in * which case we want to strip off the beginning of the * line anything that looks like what the prompt at the * end of the file is. In other words, if "(dbx) stop in * ProcessNewline" is the line we're on, and the last * line in the buffer is "(dbx) ", then we strip off the * leading "(dbx) " from this line, because we know it's * part of the prompt. But this only happens if "(dbx) " * isn't one of the process prompts ... follow what I'm * saying? */ Bol(); if (LookingAt(proc_prompt, linebuf, curchar)) { do { curchar = REeom; } while (LookingAt(proc_prompt, linebuf, curchar) && (REeom > curchar)); strcpy(genbuf, linebuf + curchar); Eof(); ins_str(genbuf); } else { strcpy(genbuf, linebuf + curchar); Eof(); gp = genbuf; lp = linebuf; while (*lp == *gp && *lp != '\0') { lp += 1; gp += 1; } ins_str(gp); } } } void ShellProc(void) { char shbuf[20]; Buffer *b; swritef(shbuf, sizeof(shbuf), "[shell-%d]", arg_value()); b = buf_exists(shbuf); if (b == NULL || dead(b->b_process)) { char cbnspace[FILESIZE]; proc_strt(shbuf, NO, "i-shell", Shell, "-is", curbuf->b_fname == NULL? (char *)NULL : strcpy(cbnspace, pr_name(curbuf->b_fname, NO)), (char *)NULL); } pop_wind(shbuf, NO, -1); } void Iprocess(void) { char scratch[64], *bnm; int cnt = 1; Buffer *bp; char fnspace[FILESIZE]; char *fn = curbuf->b_fname == NULL ? (char *) NULL : strcpy(fnspace, pr_name(curbuf->b_fname, NO)); jamstr(ShcomBuf, ask(ShcomBuf, ProcFmt)); bnm = MakeName(ShcomBuf); truncstr(scratch, bnm); while ((bp = buf_exists(scratch)) != NULL && !dead(bp->b_process)) swritef(scratch, sizeof(scratch), "%s.%d", bnm, cnt++); proc_strt(scratch, YES, ShcomBuf, Shell, ShFlags, ShcomBuf, fn, fn, (char *)NULL); } pid_t DeadPid; /* info about ChildPid, if reaped by kill_off */ wait_status_t DeadStatus; void kill_off(pid_t pid, wait_status_t w) { Process child; if (pid == ChildPid) { /* we are reaping the non-iproc process: record info */ DeadPid = pid; DeadStatus = w; return; } if ((child = proc_pid(pid)) == NULL) return; UpdModLine = YES; /* we're changing state ... */ if (WIFSTOPPED(w)) child->p_child_state = C_STOPPED; else { #ifdef PIPEPROCS /* the true process status comes by pipe, not from wait(). * However, we must note the death of portsrv processes. */ child->p_portlive = NO; #else /* !PIPEPROCS */ /* record the details of the death of the process. * Kludge: see if we can get any queued EOF from pty first. * We wish to do this to make our message less confusing. */ while (!io_eofed(child)) { int nfds; fd_set reads; struct timeval notime; FD_ZERO(&reads); FD_SET(child->p_fd, &reads); notime.tv_sec = 0; notime.tv_usec = 0; nfds = select(global_maxfd, &reads, (fd_set *)NULL, (fd_set *)NULL, ¬ime); if (nfds == 1) read_pty_proc(child->p_fd); else if (nfds >= 0 || errno != EINTR) { # ifdef NO_EOF_FROM_PTY /* Certain systems never indicate EOF from a slave. * On those systems, we force a close when the direct * child terminates. */ proc_close(child); # endif break; } } obituary(child, w); #endif /* !PIPEPROCS */ } } private void obituary(Process child, wait_status_t w) { UpdModLine = YES; /* we're changing state ... */ if (WIFEXITED(w)) { child->p_child_state = C_EXITED; child->p_reason = WEXITSTATUS(w); } else if (WIFSIGNALED(w)) { child->p_child_state = C_KILLED; child->p_reason = WTERMSIG(w); } else { /* presume it died peacefully! */ child->p_child_state = C_EXITED; child->p_reason = 0; } { Buffer *save = curbuf; Bufpos bp; char mesg[128]; /* insert status message now */ swritef(mesg, sizeof(mesg), "[Process %s: %s]\n", proc_cmd(child), pstate(child)); SetBuf(child->p_buffer); DOTsave(&bp); ToLast(); ins_str(mesg); SetDot(&bp); SetBuf(save); redisplay(); } } #endif /* IPROCS */