home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume25 / pty4 / part08 / ptymaster.c next >
Encoding:
C/C++ Source or Header  |  1992-02-18  |  19.8 KB  |  730 lines
  1. #include <sys/types.h>
  2. #include <sys/wait.h>
  3. #include <sys/time.h>
  4. #include <sys/resource.h>
  5. #include <signal.h>
  6. #include <errno.h>
  7. extern int errno;
  8. #include "sigsched.h"
  9. #include "ralloc.h"
  10. #include "config/ttyopts.h"
  11. #include "config/ptylongname.h"
  12. #include "sesslog.h"
  13. #include "sessconnlog.h"
  14. #include "ptyget.h"
  15. #include "ptymisc.h"
  16. #include "ptyerr.h"
  17. #include "ptytty.h"
  18. #include "ptycomm.h"
  19. #include "ptymaster.h"
  20.  
  21. /*
  22. If you don't believe that sigsched makes this incredibly easy to write,
  23. try writing it without sigsched. Then try understanding what you wrote.
  24.  
  25. Apologies in advance to Billy Joel.
  26. */
  27.  
  28. #define PTYBUFSIZE 16384
  29.  
  30. char inbuf[PTYBUFSIZE];
  31. static int inbufwrite = 0;
  32. static int inbufread = 0;
  33. char outbuf[PTYBUFSIZE];
  34. static int outbufwrite = 0;
  35. static int outbufread = 0;
  36.  
  37. static char longname[PTYLONGNAMELEN] = { 0 };
  38.  
  39. static struct sessconnlog scl;
  40. static int remotelen;
  41. static char remote[SESSCONNLOG_REMOTELEN];
  42. static char *musername;
  43.  
  44. static int mflagreading;
  45. static int mflagsession;
  46. static int mflagxflowctl;
  47. static int mfdcomm;
  48. static int mfdmty;
  49. static int mfdsty;
  50. static int muid = -1;
  51. static char mext[2];
  52. static int mslavepid = -1;
  53.  
  54. static int fdctrlr = -1;
  55. static int fdsigler;
  56. /* to insure yourself you got to provide communication constantly... */
  57. static int fdsig2us;
  58. static int fdi;
  59. static int fdo;
  60. static int flagwatchchld;
  61. static int flagstopped;
  62.  
  63. static char recoext[2];
  64. /* this is a violation of modularity, but even after the sigler */
  65. /* knows what recoext is, we may have to report it to ctrlr, so we can't */
  66. /* just forget about it XXX: or should we ask sigler dynamically? no! */
  67.  
  68. static int mfdpreco;
  69. static int flagpreco;
  70.  
  71. /* This is a kludge to deal with fd passing bugs (particularly under SunOS). */
  72. /* It's also a sanity check. */
  73. void closeallbut()
  74. {
  75.  int i;
  76.  
  77.  i = getdtablesize();
  78.  while (i--)
  79.   {
  80.    if (
  81.    (i != mfdcomm)
  82. && (i != mfdmty)
  83. && (i != mfdsty)
  84. && (i != fdctrlr)
  85. && (i != fdsigler)
  86. && (i != fdsig2us)
  87. && (i != fdi)
  88. && (i != fdo)
  89. && (i != mfdpreco)
  90.       )
  91.     {
  92.      close(i);
  93.     }
  94.   }
  95. }
  96.  
  97. #define verbose 0,
  98.  
  99. static void saytasig(c0,c1,c2,c3) int c0; int c1; int c2; int c3;
  100. {
  101.  char c[4]; c[0] = c0; c[1] = c1; c[2] = c2; c[3] = c3;
  102.  verbose("master telling sigler %c %d %d %d",c0,c1,c2,c3);
  103.  if (fdsigler == -1)
  104.    return;
  105.  /* tell her all your crazy dreams... */
  106.  bwrite(fdsigler,c,4); /* XXX: error checks? */
  107. }
  108.  
  109. static void childdead()
  110. {
  111.  verbose("master entering childdead");
  112.  /* We could check specially for final output here, but since */
  113.  /* there's no way we can know when it's all done, we don't bother. */
  114.  if (fdsigler != -1)
  115.    ; /* no need for further notification or explicit EOF */
  116.  if (mslavepid != -1)
  117.   {
  118.    struct sesslog sl;
  119.    long t;
  120.    t = now();
  121.    sessconnlog_fill(&scl,mext,"",0,t);
  122.    sesslog_fill(&sl,mext,musername,muid,0,t);
  123.    if (fdsigler != -1)
  124.      sessconnlog(&scl); /* XXX: failure? */
  125.    sesslog(&sl); /* XXX: failure? */
  126.    utmp_off(mext,"",t); /* XXX: failure? */
  127.    wtmp_off(mext,"",t); /* XXX: failure? */
  128.    ungetpty(mfdmty,mfdsty,mext); /* XXX: failure? */
  129.    mslavepid = -1; /* JIC */
  130.    if (mfdcomm != -1)
  131.     {
  132.      if (comm_unlink(mext,muid) == -1)
  133.        ; /* if it fails, who cares? */
  134.      close(mfdcomm); /* goodbye, cruel world */
  135.      mfdcomm = -1;
  136.     }
  137.    ss_unforcewait();
  138.   }
  139. }
  140.  
  141. static void contchild()
  142. {
  143.  if (mslavepid != -1)
  144.   {
  145.    if (kill(mslavepid,SIGCONT) == -1) /* XXX: when would this work? */
  146.     {
  147.      int pgrp;
  148.      pgrp = getpgrp(mslavepid);
  149.      if (pgrp > 0)
  150.        killpg(pgrp,SIGCONT);
  151.        /* XXX: errors? */
  152.     }
  153.   }
  154.  flagstopped = 0;
  155.  disp_flagstopped();
  156. }
  157.  
  158. static void disconnect()
  159. {
  160.  verbose("master disconnecting");
  161.  /* oh listen boy */
  162.  /* i'm sure you think you got it all under control... */
  163.  saytasig('d',0,0,0);
  164.  
  165.  if (fdsigler != -1)
  166.   {
  167.    long t;
  168.    t = now();
  169.    sessconnlog_fill(&scl,mext,"",1/*XXX*/,t);
  170.    sessconnlog(&scl); /* XXX: failure? */
  171.   }
  172.  
  173.  if (fdsigler != -1) { close(fdsigler); fdsigler = -1; }
  174.  if (fdsig2us != -1) { close(fdsig2us); fdsig2us = -1; }
  175.  if (fdi != -1) { close(fdi); fdi = -1; }
  176.  if (fdo != -1) { close(fdo); fdo = -1; }
  177.  flagwatchchld = 0;
  178.  recoext[0] = recoext[1] = 0;
  179.  disp_fdsigler();
  180.  disp_fdsig2us();
  181.  disp_flagwatchchld();
  182.  if (!mflagsession)
  183.    childdead();
  184.    /* ... and though you may not have done anything */
  185.    /* will that be consolation when she's gone? ... */
  186.  closeallbut();
  187. }
  188.  
  189. static int reconnect()
  190. {
  191.  verbose("master starting reconnect");
  192.  
  193.  closeallbut();
  194.  /* assumes fdsigler, fdsig2us, fdi, fdo all -1 */
  195.  if ((fdsigler = comm_getfd(fdctrlr)) == -1)
  196.   {
  197.    verbose("master getting sigler failed");
  198.    return -1; }
  199.  if ((fdsig2us = comm_getfd(fdctrlr)) == -1)
  200.   {
  201.    verbose("master getting fdsig2us failed");
  202.    close(fdsigler); fdsigler = -1; return -1; }
  203.  if ((fdi = comm_getfd(fdctrlr)) == -1)
  204.   {
  205.    verbose("master getting fdi failed");
  206.    close(fdsigler); close(fdsig2us); fdsigler = fdsig2us = -1; return -1; }
  207.  if ((fdo = comm_getfd(fdctrlr)) == -1)
  208.   {
  209.    verbose("master getting fdo failed");
  210.    close(fdsigler); close(fdsig2us); close(fdi);
  211.    fdsigler = fdsig2us = fdi = -1; return -1; }
  212.  
  213.  verbose("master okay fds on reconnect %d %d %d %d",fdsigler,fdsig2us,fdi,fdo);
  214.  if (bread(fdctrlr,(char *) &mflagreading,sizeof(int)) < sizeof(int))
  215.   { close(fdsigler); close(fdsig2us); close(fdi); close(fdo);
  216.    fdsigler = fdsig2us = fdi = fdo = -1; return -1; }
  217.  if (bread(fdctrlr,(char *) &remotelen,sizeof(int)) < sizeof(int)
  218.     || (remotelen > SESSCONNLOG_REMOTELEN))
  219.   { close(fdsigler); close(fdsig2us); close(fdi); close(fdo);
  220.    fdsigler = fdsig2us = fdi = fdo = -1; return -1; }
  221.  if (bread(fdctrlr,remote,remotelen) < remotelen)
  222.   { close(fdsigler); close(fdsig2us); close(fdi); close(fdo);
  223.    fdsigler = fdsig2us = fdi = fdo = -1; return -1; }
  224.  
  225.  /* log stuff... */
  226.  sessconnlog_fill(&scl,mext,remote,-1/*XXX*/,now());
  227.  if (sessconnlog(&scl) == -1)
  228.    ; /*XXX: sessconn write failed; do we care?*/
  229.  
  230.  closeallbut();
  231.  
  232.  verbose("master succeeded on reconnect %d",mflagreading);
  233.  contchild(); /* XXX */
  234.  flagwatchchld = 1;
  235.  disp_fdsigler();
  236.  disp_fdsig2us();
  237.  disp_flagwatchchld();
  238.  disp_mflagreading();
  239.  if (flagpreco) /* talk to me if you don't understand this */
  240.   {
  241.    flagpreco = 0;
  242.    /* cause now and then she'll get to worrying */
  243.    /* just because you haven't spoken for so long... */
  244.    if (write(mfdpreco,"k",1) == -1)
  245.      ; /* pipe might be broken if child has somehow been killed; */
  246.        /* that's okay, we'll get SIGCHLD in a few moments */
  247.    close(mfdpreco);
  248.    mfdpreco = -1;
  249.   }
  250.  return 0;
  251. }
  252.  
  253. static void sigchld(n)
  254. int n;
  255. {
  256.  int w;
  257.  int pid;
  258.  
  259.  verbose("master entering sigchld");
  260.  while ((pid = wait3(&w,WNOHANG | WUNTRACED,(struct rusage *) 0)) > 0)
  261.    /* it'd be very weird if wait3 equalled 0 */ 
  262.    if (pid == mslavepid)
  263.     {
  264.      verbose("master sees pid %d",pid);
  265. #define PWIFSTOPPED(s) (((s) & 0177) == 0177)
  266. #define PWSTOPSIG(s) ((s) >> 8) /* only defined if PWIFSTOPPED */
  267.      if (PWIFSTOPPED(w))
  268.       {
  269.        flagstopped = 1;
  270.        /* just a word or two that she gets from you */
  271.        /* could be the difference that it makes... */
  272.        saytasig('z',PWSTOPSIG(w),0,0);
  273.        disp_flagstopped();
  274.       }
  275.      else
  276.       {
  277. #define PWIFEXITED(s) (!((s) & 0177))
  278. #define PWEXITSTATUS(s) ((s) >> 8)
  279. #define PWTERMSIG(s) ((s) & 0177)
  280. #define PWCOREDUMP(s) ((s) & 0200)
  281.        if (PWIFEXITED(w))
  282.      /* tell her about it... */
  283.          saytasig('e',PWEXITSTATUS(w),0,0);
  284.        else
  285.      /* tell her everything you feel... */
  286.      saytasig('s',PWTERMSIG(w),PWCOREDUMP(w),0);
  287.        childdead();
  288.       }
  289.     }
  290. }
  291. static int schedsigchld = 0;
  292. static void cksigchld()
  293. {
  294.  if (!schedsigchld && flagwatchchld && !outbufread)
  295.   { ss_sched(ss_signal(SIGCHLD),sigchld,0); schedsigchld = 1; return; }
  296.  if (schedsigchld && (!flagwatchchld || outbufread))
  297.   { ss_unsched(ss_signal(SIGCHLD),sigchld,0); schedsigchld = 0; }
  298. }
  299.  
  300. static void doacceptfdctrlr(n)
  301. int n;
  302. {
  303.  fdctrlr = comm_accept(mfdcomm);
  304.  disp_fdctrlr();
  305. }
  306. static int schedacceptfdctrlr = 0;
  307. static void ckacceptfdctrlr()
  308. {
  309.  if (!schedacceptfdctrlr && (fdctrlr == -1))
  310.   {
  311.    ss_sched(ss_sigread(mfdcomm),doacceptfdctrlr,0); schedacceptfdctrlr = 1;
  312.    return;
  313.   }
  314.  if (schedacceptfdctrlr && (fdctrlr != -1))
  315.   { ss_unsched(ss_sigread(mfdcomm),doacceptfdctrlr,0); schedacceptfdctrlr = 0; }
  316. }
  317.  
  318. static void doreadfdctrlr(n)
  319. int n;
  320. {
  321.  int r;
  322.  char mess[1];
  323.  int foo;
  324.  
  325.  verbose("master entering readfdctrlr");
  326.  r = read(fdctrlr,mess,1);
  327.  verbose("master readfdctrlr %d %c",r,mess[0]);
  328.  if (r <= 0) /* bye bye */
  329.   {
  330.    close(fdctrlr); fdctrlr = -1; disp_fdctrlr(); return;
  331.   }
  332.  switch(mess[0]) /* XXX: we tacitly assume these writes will be atomic */
  333.   {
  334.    case 'a': /* are you there? */
  335.      switch(mslavepid % 3)
  336.       {
  337.        case 0: bwrite(fdctrlr,"(nope)",6); break;
  338.        case 1: bwrite(fdctrlr,"a_y_t?",6); break;
  339.        default: bwrite(fdctrlr,"maybe.",6); break;
  340.       }
  341.      break;
  342.    case 'e': /* short name? */
  343.      bwrite(fdctrlr,mext,2);
  344.      break;
  345.    case 'l': /* long name? */
  346.      bwrite(fdctrlr,"longnm",6);
  347.      bwrite(fdctrlr,longname,sizeof(longname));
  348.      break;
  349.    case 'L': /* set long name to this: */
  350.      bread(fdctrlr,longname,sizeof(longname)); /* XXX: error checking? */
  351.      bwrite(fdctrlr,"thanks",6);
  352.      break;
  353.    case 'C': /* are you connected? */
  354.      if (fdsigler == -1)
  355.        bwrite(fdctrlr,"noaose",6);
  356.      else
  357.        bwrite(fdctrlr,"owuno?",6);
  358.      break;
  359.    case 'p': /* what's your pid? */
  360.      foo = getpid();
  361.      bwrite(fdctrlr,(char *) &foo,sizeof(foo));
  362.      break;
  363.    case 'P': /* what's your slave pid? */
  364.      bwrite(fdctrlr,(char *) &mslavepid,sizeof(mslavepid));
  365.      break;
  366.    case 'D': /* do you allow disconnects? */
  367.      bwrite(fdctrlr,(char *) &mflagsession,sizeof(mflagsession));
  368.      break;
  369.    case 'k': /* sesskill */
  370.      saytasig('k',0,0,0);
  371.      bwrite(fdctrlr,"<poof>",6);
  372.      childdead();
  373.      break;
  374.    case 'd': /* disconnect */
  375.      if (mflagsession)
  376.        if (fdsigler != -1)
  377.     {
  378.      disconnect();
  379.      bwrite(fdctrlr,"yessir",6);
  380.     }
  381.        else
  382.      bwrite(fdctrlr,"no-op!",6);
  383.      else
  384.        /* you're a big boy now and you'll never let her go */
  385.        /* but that's just the kind of thing she ought to know... */
  386.        bwrite(fdctrlr,"kinky!",6);
  387.      break;
  388.    case 'r': /* reconnect---including initial connection */
  389.      if (fdsigler == -1)
  390.       {
  391.        /* let her know you need her */
  392.        /* let her know how much she means... */
  393.        bwrite(fdctrlr,"shrtng",6);
  394.        if (reconnect() == -1)
  395.     {
  396.      bwrite(fdctrlr,"damn! ",6); /*XXXXXXX*/
  397.      closeallbut();
  398.     }
  399.        else
  400.          bwrite(fdctrlr,"phew! ",6);
  401.       }
  402.      else
  403.        bwrite(fdctrlr,"no-go!",6);
  404.      break;
  405.    case 's': /* recoset */
  406.      if (fdsigler != -1)
  407.       {
  408.        /* XXX: should ack first */
  409.        bread(fdctrlr,recoext,2); /* XXX: error checks? */
  410.        /* when she can't be with you tell her you wish you were there... */
  411.        saytasig('r',recoext[0],recoext[1],0);
  412.        bwrite(fdctrlr,"sglrok",6);
  413.       }
  414.      else
  415.        bwrite(fdctrlr,"nosglr",6);
  416.      break;
  417.    case 'S': /* report latest recoset */
  418.      bwrite(fdctrlr,"latest",6);
  419.      bwrite(fdctrlr,recoext,2);
  420.      break;
  421.    case 'Z': /* suspend */
  422.      /* XXXX: not supported yet; fall through */
  423.    /* XXX: resume? */
  424.    /* XXX: ioctl? particular ioctls? */
  425.    default:
  426.      bwrite(fdctrlr,"nosupp",6);
  427.      break;
  428.   }
  429.  verbose("master exiting readfdctrlr");
  430. }
  431. static ss_sig *sigreadfdctrlr;
  432. static void ckreadfdctrlr()
  433. {
  434.  if (!sigreadfdctrlr && (fdctrlr != -1))
  435.   { ss_sched(sigreadfdctrlr = ss_sigread(fdctrlr),doreadfdctrlr,0); return; }
  436.  if (sigreadfdctrlr && (fdctrlr == -1))
  437.   { ss_unsched(sigreadfdctrlr,doreadfdctrlr,0); sigreadfdctrlr = 0; }
  438. }
  439.  
  440. static void doreadsig2us(n)
  441. int n;
  442. {
  443.  int r;
  444.  char sigsez[1];
  445. #ifdef TTY_WINDOWS
  446.  struct ttywin twi;
  447.  struct ttymodes tmoold;
  448.  struct ttymodes tmonew;
  449. #endif
  450.  
  451.  verbose("master entering readsig2us");
  452.  /* every day before you leave */
  453.  /* pay her some attention */
  454.  /* give her something to believe... */
  455.  r = read(fdsig2us,sigsez,1);
  456.  verbose("master readsig2us %d %c",r,sigsez[0]);
  457.  if (r == -1)
  458.    disconnect(); /*XXX: should we try to handle errors better? */
  459.  else if (!r)
  460.    disconnect(); /* if it weren't for this, we'd never see sigler die! */
  461.  else
  462.    switch(sigsez[0])
  463.     {
  464.      case 'H': /* hangup */
  465.        disconnect();
  466.        break;
  467.      case 'C': /* continue */
  468.        contchild();
  469.        break;
  470.      case 'W': /* WINCH */
  471. #ifdef TTY_WINDOWS
  472.        bread(fdsig2us,(char *) &twi,sizeof(twi)); /* XXX: error checks? */
  473.        if (tty_getmodes(mfdsty,&tmoold) == 0)
  474.     {
  475.          /* XXX: race! race! race! */
  476.          tty_copymodes(&tmonew,&tmoold);
  477.          tty_win2modes(&twi,&tmonew);
  478.          if (tty_modifymodes(mfdsty,&tmonew,&tmoold) == -1)
  479.        ; /* who cares? */
  480.     }
  481. #endif
  482.        break;
  483.      default:
  484.        break; /* XXX: nothing we can reasonably do */
  485.     }
  486.  verbose("master exiting readsig2us");
  487. }
  488. static ss_sig *sigreadsig2us;
  489. static void ckreadsig2us()
  490. {
  491.  if (!sigreadsig2us && (fdsig2us != -1))
  492.   { ss_sched(sigreadsig2us = ss_sigread(fdsig2us),doreadsig2us,0); return; }
  493.  if (sigreadsig2us && (fdsig2us == -1))
  494.   { ss_unsched(sigreadsig2us,doreadsig2us,0); sigreadsig2us = 0; }
  495. }
  496.  
  497. static void doreadin(n)
  498. int n;
  499. {
  500.  int r;
  501.  
  502.  verbose("master entering readin");
  503.  /* XXX: sanity checks, like !mflagreading? */
  504.  
  505.  /* XXX: Warning! We're manipulating an outside descriptor! */
  506.  r = read(fdi,inbuf + inbufread,sizeof(inbuf) - inbufread);
  507.  /* but a girl like that won't tell you what you should do... */
  508.  if (r == -1)
  509.    switch(errno) { case EINTR: case EWOULDBLOCK: break;
  510.      default: disconnect(); /*XXXX*/ }
  511.  else if (!r)
  512.   {
  513.    /* XXX: this EOF handling is all rather slimy */
  514.    if (mflagsession)
  515.      disconnect();
  516.    else
  517.     {
  518.      mflagreading = 0;
  519.      disp_mflagreading();
  520.     }
  521.   }
  522.  else { inbufread += r; disp_inbufread(); }
  523.  verbose("master exiting readin");
  524. }
  525. static ss_sig *sigreadin = 0;
  526. static void ckreadin()
  527. {
  528.  if (!sigreadin && (fdsigler != -1) && (inbufread < sizeof(inbuf))
  529.    && mflagreading && !flagstopped)
  530.   { ss_sched(sigreadin = ss_sigread(fdi),doreadin,0); return; }
  531.  if (sigreadin && ((fdsigler == -1) || (inbufread == sizeof(inbuf))
  532.    || !mflagreading || flagstopped))
  533.   { ss_unsched(sigreadin,doreadin,0); sigreadin = 0; }
  534. }
  535.  
  536. static void dowritein(n)
  537. int n;
  538. {
  539.  int w;
  540.  
  541.  verbose("master entering writein");
  542.  if (mflagxflowctl)
  543.   {
  544.    if (tty_spaceleft(mfdsty) < 128)
  545.      return;
  546.    /* XXX: this busy-loops! */
  547.   }
  548.  if (mflagxflowctl && (inbufread - inbufwrite > 128))
  549.    w = write(mfdmty,inbuf + inbufwrite,128);
  550.  else
  551.    w = write(mfdmty,inbuf + inbufwrite,inbufread - inbufwrite);
  552.  if (w == -1)
  553.    switch(errno) { case EINTR: case EWOULDBLOCK: break;
  554.      default: ; /*XXXX*/ }
  555.  else
  556.   {
  557.    inbufwrite += w;
  558.    if (inbufwrite == inbufread)
  559.     { inbufwrite = inbufread = 0; disp_inbufread(); }
  560.    disp_inbufwrite();
  561.   }
  562.  verbose("master exiting writein");
  563. }
  564. static ss_sig *sigwritein = 0;
  565. static void ckwritein()
  566. {
  567.  if (!sigwritein && (mfdmty != -1) && (inbufwrite < inbufread))
  568.   { ss_sched(sigwritein = ss_sigwrite(mfdmty),dowritein,0); return; }
  569.  if (sigwritein && ((mfdmty == -1) || (inbufwrite == inbufread)))
  570.   { ss_unsched(sigwritein,dowritein,0); sigwritein = 0; }
  571. }
  572.  
  573. static void doreadout(n)
  574. int n;
  575. {
  576.  int r;
  577.  verbose("master entering doreadout");
  578.  
  579.  r = read(mfdmty,outbuf + outbufread,sizeof(outbuf) - outbufread);
  580.  verbose("master doreadout: %d",r);
  581.  if (r == -1)
  582.    switch(errno) { case EINTR: case EWOULDBLOCK: break;
  583.      default: ; /*XXXX*/ }
  584.  else if (!r)
  585.    ; /* XXX: EOF on a pty? utterly impossible */
  586.  else { outbufread += r; disp_outbufread(); }
  587. }
  588. static ss_sig *sigreadout = 0;
  589. static void ckreadout()
  590. {
  591.  if (!sigreadout && (mfdmty != -1) && (outbufread < sizeof(outbuf)))
  592.   { ss_sched(sigreadout = ss_sigread(mfdmty),doreadout,0); return; }
  593.  if (sigreadout && ((mfdmty == -1) || (outbufread == sizeof(outbuf))))
  594.   { ss_unsched(sigreadout,doreadout,0); sigreadout = 0; }
  595. }
  596.  
  597. static void dowriteout(n)
  598. int n;
  599. {
  600.  int w;
  601.  verbose("master entering writeout");
  602.  /* XXX: Warning! We're manipulating an outside descriptor! */
  603.  w = write(fdo,outbuf + outbufwrite,outbufread - outbufwrite);
  604.  if (w == -1)
  605.    switch(errno) { case EINTR: case EWOULDBLOCK: break;
  606.    case EPIPE: disconnect(); /* ``the master treats PIPE like EOF'' */
  607.    default: disconnect(); /*XXXX*/ }
  608.  else
  609.   {
  610.    outbufwrite += w;
  611.    if (outbufwrite == outbufread)
  612.     { outbufwrite = outbufread = 0; disp_outbufread(); }
  613.    disp_outbufwrite();
  614.   }
  615.  verbose("master exiting writeout");
  616. }
  617. static ss_sig *sigwriteout = 0;
  618. static void ckwriteout()
  619. {
  620.  if (!sigwriteout && (fdsigler != -1) && (outbufwrite < outbufread) && !flagstopped)
  621.   { ss_sched(sigwriteout = ss_sigwrite(fdo),dowriteout,0); return; }
  622.  if (sigwriteout && ((fdsigler == -1) || (outbufwrite == outbufread) || flagstopped))
  623.   { ss_unsched(sigwriteout,dowriteout,0); sigwriteout = 0; }
  624. }
  625.  
  626. /*
  627. We have ck{acceptfdctrlr,readfdctrlr,readin,writein,readout,writeout,
  628. readsig2us,sigchld}.
  629. When flagstopped changes, which ck*() have to be called?
  630. The dispatchers know. disp_flagstopped, for instance.
  631. It'd be interesting to see a programming language where these could
  632. be generated automatically---it was semi-automatic by hand.
  633. Of course, you could also look at this as an optimization problem...
  634. */
  635.  
  636. /* these aren't void 'cause forward static declarations are unportable */
  637. static disp_mflagreading() { ckreadin(); }
  638. static disp_flagstopped() { ckreadin(); ckwriteout(); }
  639. static disp_flagwatchchld() { cksigchld(); }
  640. static disp_mfdmty() { ckwritein(); ckreadout(); } /* ever? */
  641. static disp_fdctrlr() { ckacceptfdctrlr(); ckreadfdctrlr(); }
  642. static disp_fdsigler() { ckreadin(); ckwriteout(); }
  643. static disp_fdsig2us() { ckreadsig2us(); }
  644. static disp_inbufread() { ckreadin(); ckwritein(); }
  645. static disp_inbufwrite() { ckwritein(); }
  646. static disp_outbufread() { ckreadout(); ckwriteout(); cksigchld(); }
  647. static disp_outbufwrite() { ckwriteout(); }
  648.  
  649. static void disp() { ckreadin(); ckwriteout(); ckreadout(); cksigchld();
  650.   ckacceptfdctrlr(); ckreadfdctrlr(); ckwritein(); ckreadsig2us(); }
  651.  
  652. /*
  653. Signal handling:
  654.  
  655. fdctrlr == -1 and mfdcomm readable: accept fdctrlr
  656. fdctrlr != -1 and fdctrlr readable: read command (or close)
  657. fdsig2us != -1 and fdsig2us readable: read stuff from sigler
  658. fdsigler != -1 and fdi readable and ibuf okay and reading and !stopped: read
  659. fdsigler != -1 and fdo readable and obuf nonempty and !stopped: write
  660. mfdmty != -1 and mfdmty readable and obuf okay: read from mfdmty into buffer
  661. mfdmty != -1 and mfdmty writable and ibuf nonempty: write
  662.  
  663. CHLD, while flagwatchchld: if exited, tell sigler exit status, and exit
  664.   if stopped: if sigler, tell sigler to stop, else remember stop
  665. HUP, TSTP, TTIN, TTOU, WINCH, INT, QUIT: ignore
  666. PIPE: ignore (we handle EPIPE on write())
  667.  
  668. */
  669.  
  670. void master(fdcomm,fdmty,fdsty,ext,uid,pid,flagsession,fdpreco,username,flagxflowctl)
  671. int fdcomm;
  672. int fdmty;
  673. int fdsty;
  674. char *ext;
  675. int uid;
  676. int pid; /* pid of child */
  677. int flagsession;
  678. int fdpreco;
  679. char *username;
  680. int flagxflowctl;
  681. {
  682.  musername = username;
  683.  mflagsession = flagsession;
  684.  mflagxflowctl = flagxflowctl;
  685.  mflagreading = 0; /* will change with flagsigler */
  686.  mfdcomm = fdcomm;
  687.  mfdmty = fdmty;
  688.  mfdsty = fdsty;
  689.  muid = uid;
  690.  mext[0] = ext[0];
  691.  mext[1] = ext[1];
  692.  mslavepid = pid;
  693.  flagstopped = 0;
  694.  fdsigler = -1;
  695.  fdsig2us = -1;
  696.  flagwatchchld = 0;
  697.  fdi = -1;
  698.  fdo = -1;
  699.  flagpreco = 1;
  700.  mfdpreco = fdpreco;
  701.  
  702.  recoext[0] = recoext[1] = 0;
  703.  
  704.  ss_forcewait(); /* to be turned off exactly once, namely when child exits */
  705.  
  706.  rallocneverfail(childdead); /* XXX: this is, arguably, suboptimal */
  707.  
  708.  disp(); /* starts up slave I/O and CHLD handler */
  709. /*
  710. We're already ignoring HUP, INT, TSTP, TTOU, TTIN, WINCH, QUIT, PIPE.
  711.  
  712. Other signals to worry about: URG and IO are ignored by default; fine.
  713. USR1 and USR2 should never be generated.
  714. TERM should never be generated.
  715.  
  716. The user can arrange for XCPU, XFSZ, PROF, VTALRM, and ALRM to be sent:
  717. */
  718.  signal(SIGXCPU,SIG_IGN); /* XXX */
  719.  signal(SIGXFSZ,SIG_IGN); /* we'll get notice on write() */
  720.  signal(SIGALRM,SIG_IGN);
  721.  signal(SIGVTALRM,SIG_IGN);
  722.  signal(SIGPROF,SIG_IGN); /* and if we're being profiled, too bad! */
  723.  
  724.  signal(SIGTERM,SIG_IGN); /* XXX */
  725.  signal(SIGUSR1,SIG_IGN); /* XXX */
  726.  signal(SIGUSR2,SIG_IGN); /* XXX */
  727.  
  728.  closeallbut();
  729. }
  730.