home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume25 / pty4 / part03 / sigdfl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-19  |  2.9 KB  |  112 lines
  1. /* sigdfl.c, sigdfl.h: default signal library
  2. Daniel J. Bernstein, brnstnd@nyu.edu.
  3. No dependencies.
  4. Requires BSD signal syscalls.
  5. 1/27/92: Added ABRT->IOT ifndef.
  6. 1/27/92: Switched from setting sv_flags to manually zeroing sigvecs.
  7. 7/18/91: Baseline. sigdfl 1.0, public domain.
  8. No known patent problems.
  9.  
  10. Documentation in sigdfl.3.
  11.  
  12. If you port this to System V, you don't have to worry about stop
  13. signals; you can just have sigdfl_tstp() and friends return -1 with
  14. ENOTTY. You are, however, faced with an incomplete, nearly prehistoric
  15. signal interface. Have fun.
  16. */
  17.  
  18. #include <signal.h>
  19. #include "sigdfl.h"
  20.  
  21. static int cont = 0;
  22.  
  23. static sigcont() /* XXX: should declare with right signal type */
  24. {
  25.  cont = 1;
  26. }
  27.  
  28. int sigdfl(sig)
  29. int sig;
  30. {
  31.  int oldmask;
  32.  struct sigvec oldvec;
  33.  struct sigvec vec;
  34.  struct sigvec contvec;
  35.  char *x;
  36.  
  37.  if (sig == SIGCONT)
  38.    return 0; /* strategy below simply cannot work for CONT */
  39.  if ((sig == SIGURG) || (sig == SIGCHLD) || (sig == SIGIO)
  40. #ifdef SIGWINCH
  41.    || (sig == SIGWINCH)
  42. #endif
  43.     )
  44.    return 0; /* the above signals are ignored */
  45.  /* XXX: If we're still going now, and sig can be delivered without */
  46.  /* killing the process and without stopping the process so that it'll */
  47.  /* receive CONT later, then we will enter an infinite loop. [sigh] */
  48.  /* XXX: put maximum time wastage on this? */
  49.  oldmask = sigblock(0);
  50.  sigblock(~0);
  51.  /* now we won't receive any signals */
  52.  x = (char *) &vec; while (x < sizeof(vec) + (char *) &vec) *x++ = 0;
  53.  vec.sv_handler = SIG_DFL;
  54.  vec.sv_mask = ~0;
  55.  if (sigvec(sig,&vec,&oldvec) == -1)
  56.    if ((sig != SIGSTOP) && (sig != SIGKILL))
  57.      return -1;
  58.  x = (char *) &vec; while (x < sizeof(vec) + (char *) &vec) *x++ = 0;
  59.  vec.sv_handler = sigcont;
  60.  vec.sv_mask = ~0;
  61.  if (sigvec(SIGCONT,&vec,&contvec) == -1)
  62.    return -1;
  63.  cont = 0;
  64.  if (kill(getpid(),sig) == -1)
  65.    return -1;
  66.  /* now a sig should be queued, and we have control over sig and CONT */
  67.  /* exception: SIGSTOP and SIGKILL can't be blocked, so those signals
  68.     might already have been delivered. in the SIGSTOP case, if we've
  69.     reached this point, sigcont() might already have been run. that's
  70.     why cont must be set to 0 before the kill(). */
  71.  /* after this next bit we may receive sig and/or CONT */
  72.  sigsetmask(~(sigmask(sig) | sigmask(SIGCONT)));
  73.  /* in the near future, sig will in fact be received */
  74.  while (!cont) /* dead loop until we receive CONT */
  75.    ; /* XXX: there should be a syscall so we don't have to loop here */
  76.  sigblock(~0);
  77.  /* now we won't receive any signals */
  78.  (void) sigvec(sig,&oldvec,&vec); /* we don't care if it fails */
  79.  (void) sigvec(SIGCONT,&contvec,&vec);
  80.  /* now signal handlers are back to normal */
  81.  (void) sigsetmask(oldmask);
  82.  return 0;
  83. }
  84.  
  85. int sigdfl_tstp()
  86. {
  87.  return sigdfl(SIGTSTP);
  88. }
  89.  
  90. int sigdfl_stop()
  91. {
  92.  return sigdfl(SIGSTOP);
  93. }
  94.  
  95. int sigdfl_ttin()
  96. {
  97.  return sigdfl(SIGTTIN);
  98. }
  99.  
  100. int sigdfl_ttou()
  101. {
  102.  return sigdfl(SIGTTOU);
  103. }
  104.  
  105. int sigdfl_abrt()
  106. {
  107. #ifndef SIGABRT
  108. #define SIGABRT SIGIOT
  109. #endif
  110.  return sigdfl(SIGABRT);
  111. }
  112.