/contrib/tcsh/tc.sig.c

https://bitbucket.org/freebsd/freebsd-head/ · C · 151 lines · 104 code · 15 blank · 32 comment · 12 complexity · a6fae47b769967acc173389166d6bc48 MD5 · raw file

  1. /* $Header: /p/tcsh/cvsroot/tcsh/tc.sig.c,v 3.40 2012/01/25 15:34:41 christos Exp $ */
  2. /*
  3. * tc.sig.c: Signal routine emulations
  4. */
  5. /*-
  6. * Copyright (c) 1980, 1991 The Regents of the University of California.
  7. * All rights reserved.
  8. *
  9. * Redistribution and use in source and binary forms, with or without
  10. * modification, are permitted provided that the following conditions
  11. * are met:
  12. * 1. Redistributions of source code must retain the above copyright
  13. * notice, this list of conditions and the following disclaimer.
  14. * 2. Redistributions in binary form must reproduce the above copyright
  15. * notice, this list of conditions and the following disclaimer in the
  16. * documentation and/or other materials provided with the distribution.
  17. * 3. Neither the name of the University nor the names of its contributors
  18. * may be used to endorse or promote products derived from this software
  19. * without specific prior written permission.
  20. *
  21. * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24. * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31. * SUCH DAMAGE.
  32. */
  33. #include "sh.h"
  34. RCSID("$tcsh: tc.sig.c,v 3.40 2012/01/25 15:34:41 christos Exp $")
  35. #include "tc.wait.h"
  36. void
  37. sigset_interrupting(int sig, void (*fn) (int))
  38. {
  39. struct sigaction act;
  40. act.sa_handler = fn;
  41. sigemptyset(&act.sa_mask);
  42. act.sa_flags = 0;
  43. if (sigaction(sig, &act, NULL) == 0) {
  44. sigset_t set;
  45. sigemptyset(&set);
  46. sigaddset(&set, sig);
  47. sigprocmask(SIG_UNBLOCK, &set, NULL);
  48. }
  49. }
  50. static volatile sig_atomic_t alrmcatch_pending; /* = 0; */
  51. static volatile sig_atomic_t pchild_pending; /* = 0; */
  52. static volatile sig_atomic_t phup_pending; /* = 0; */
  53. static volatile sig_atomic_t pintr_pending; /* = 0; */
  54. int alrmcatch_disabled; /* = 0; */
  55. int phup_disabled; /* = 0; */
  56. int pchild_disabled; /* = 0; */
  57. int pintr_disabled; /* = 0; */
  58. int handle_interrupt; /* = 0; */
  59. int
  60. handle_pending_signals(void)
  61. {
  62. int rv = 0;
  63. if (!phup_disabled && phup_pending) {
  64. phup_pending = 0;
  65. handle_interrupt++;
  66. phup();
  67. handle_interrupt--;
  68. }
  69. if (!pintr_disabled && pintr_pending) {
  70. pintr_pending = 0;
  71. handle_interrupt++;
  72. pintr();
  73. handle_interrupt--;
  74. rv = 1;
  75. }
  76. if (!pchild_disabled && pchild_pending) {
  77. pchild_pending = 0;
  78. handle_interrupt++;
  79. pchild();
  80. handle_interrupt--;
  81. }
  82. if (!alrmcatch_disabled && alrmcatch_pending) {
  83. alrmcatch_pending = 0;
  84. handle_interrupt++;
  85. alrmcatch();
  86. handle_interrupt--;
  87. }
  88. return rv;
  89. }
  90. void
  91. queue_alrmcatch(int sig)
  92. {
  93. USE(sig);
  94. alrmcatch_pending = 1;
  95. }
  96. void
  97. queue_pchild(int sig)
  98. {
  99. USE(sig);
  100. pchild_pending = 1;
  101. }
  102. void
  103. queue_phup(int sig)
  104. {
  105. USE(sig);
  106. phup_pending = 1;
  107. }
  108. void
  109. queue_pintr(int sig)
  110. {
  111. USE(sig);
  112. pintr_pending = 1;
  113. }
  114. void
  115. disabled_cleanup(void *xdisabled)
  116. {
  117. int *disabled;
  118. disabled = xdisabled;
  119. if (--*disabled == 0)
  120. handle_pending_signals();
  121. }
  122. void
  123. pintr_disabled_restore(void *xold)
  124. {
  125. int *old;
  126. old = xold;
  127. pintr_disabled = *old;
  128. }
  129. void
  130. pintr_push_enable(int *saved)
  131. {
  132. *saved = pintr_disabled;
  133. pintr_disabled = 0;
  134. cleanup_push(saved, pintr_disabled_restore);
  135. handle_pending_signals();
  136. }