1: /*************************************************************************
   2:  * This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
   3:  * provided to you without charge for use only on a licensed Unix        *
   4:  * system.  You may copy JOVE provided that this notice is included with *
   5:  * the copy.  You may not sell copies of this program or versions        *
   6:  * modified for use on microcomputer systems, unless the copies are      *
   7:  * included with a Unix system distribution and the source is provided.  *
   8:  *************************************************************************/
   9: 
  10: /* This is a server for jove sub processes.  It runs the command and
  11:    signals jove when there is some output ready to send to jove. By the
  12:    time we get here, out standard output goes to jove's process input. */
  13: 
  14: #include "tune.h"
  15: 
  16: #ifdef PIPEPROCS    /* the whole file! */
  17: 
  18: #include "jove.h"
  19: 
  20: #include <signal.h>
  21: #include <sys/ioctl.h>
  22: #ifdef BSD4_2
  23: #   include <sys/wait.h>
  24: #else
  25: #   include <wait.h>
  26: #endif
  27: 
  28: struct header {
  29:     int pid;
  30:     int nbytes;
  31:     char    buf[512];
  32: } header;
  33: 
  34: #define HEADSIZE    ((sizeof header.pid) + sizeof (header.nbytes))
  35: 
  36: error(str)
  37: char    *str;
  38: {
  39:     header.pid = getpid();
  40:     header.nbytes = strlen(str);
  41:     strcpy(header.buf, str);
  42:     proc_write(&header, header.nbytes + 8);
  43:     exit(-2);
  44: }
  45: 
  46: int ppid,
  47:     InputFD,
  48:     JovesInput;
  49: 
  50: p_inform()
  51: {
  52:     long    nbytes;
  53: 
  54:     ioctl(JovesInput, FIONREAD, (char *) &nbytes);
  55:     if (nbytes > 0)
  56:         kill(ppid, INPUT_SIG);
  57: }
  58: 
  59: proc_write(ptr, n)
  60: char    *ptr;
  61: {
  62:     long    nbytes;
  63: 
  64:     ioctl(1, FIONREAD, (char *) &nbytes);
  65: 
  66:     if (nbytes == 0)
  67:         kill(ppid, INPUT_SIG);
  68: 
  69:     (void) write(1, ptr, n);
  70:     alarm(1);
  71: }
  72: 
  73: read_pipe()
  74: {
  75:     register int    n;
  76: 
  77:     (void) signal(SIGALRM, p_inform);
  78: 
  79:     while ((header.nbytes = read(InputFD, header.buf, sizeof header.buf)) > 0) {
  80:         n = HEADSIZE + header.nbytes;
  81:         proc_write(&header, n);
  82:     }
  83: }
  84: 
  85: /* ARGSUSED */
  86: main(argc, argv)
  87: char    *argv[];
  88: {
  89:     int p[2];
  90:     int pid;
  91: 
  92:     if (pipe(p) == -1)
  93:         error("Cannot pipe jove portsrv.\n");
  94: 
  95:     ppid = getppid();
  96:     switch (pid = fork()) {
  97:     case -1:
  98:         error("portsrv: cannot fork.\n");
  99: 
 100:     case 0:
 101:         /* We'll intercept childs output in p[0] */
 102:         (void) dup2(p[1], 1);
 103:         (void) dup2(p[1], 2);
 104:         (void) close(p[0]);
 105:         (void) close(p[1]);
 106: 
 107:         (void) setpgrp(getpid(), getpid());
 108:         execv(argv[2], &argv[3]);
 109:         _exit(-4);
 110: 
 111:     default:
 112:         (void) close(0);
 113:                 /* Don't want this guy to read anything
 114: 				   jove sends to our soon to be created
 115: 				   child */
 116: 
 117:         JovesInput = atoi(argv[1]);
 118:         (void) signal(SIGINT, SIG_IGN);
 119:         (void) signal(SIGQUIT, SIG_IGN);
 120:         (void) close(p[1]);
 121: 
 122:         /* Tell jove the pid of the real child as opposed to us. */
 123:         header.pid = getpid();
 124:         header.nbytes = sizeof (int);
 125:         *(int *) header.buf = pid;
 126:         (void) write(1, (char *) &header, sizeof pid + HEADSIZE);
 127:         p_inform(); /* Inform jove */
 128: 
 129:         /* Read proc's output and send it to jove */
 130:         InputFD = p[0];
 131:         read_pipe();
 132:         (void) close(p[0]);
 133:         header.pid = getpid();
 134:         header.nbytes = EOF;    /* Tell jove we are finished */
 135:         (void) write(1, (char *) &header, HEADSIZE);
 136:         p_inform();
 137:         /* Try to exit like our child did ... */
 138:         {
 139:             union wait  w;
 140: 
 141: #ifndef VMUNIX
 142:             while (wait2(&w.w_status, 0) != pid)
 143: #else
 144:             while (wait3(&w.w_status, 0, 0) != pid)
 145: #endif
 146:                 ;
 147:             if (WIFEXITED(w))
 148:                 exit(w.w_retcode);
 149:             else if (WIFSIGNALED(w))
 150:                 kill(getpid(), w.w_termsig);
 151:         }
 152:     }
 153: }
 154: 
 155: #else PIPEPROCS
 156: main()
 157: {
 158: }
 159: #endif

Defined functions

error defined in line 36; used 7 times
main defined in line 156; never used
p_inform defined in line 50; used 3 times
proc_write defined in line 59; used 2 times
read_pipe defined in line 73; used 1 times

Defined variables

InputFD defined in line 47; used 2 times
JovesInput defined in line 48; used 2 times
header defined in line 32; used 19 times
ppid defined in line 46; used 3 times

Defined struct's

header defined in line 28; never used

Defined macros

HEADSIZE defined in line 34; used 3 times
Last modified: 1986-03-28
Generated: 2016-12-26
Generated by src2html V0.67
page hit count: 988
Valid CSS Valid XHTML 1.0 Strict