![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sigretro.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / lbin / mailx|
Return to sigretro.c CVS log | Up to [Research Unix] / researchv10no / lbin / mailx |
1.1 ! root 1: #ident "@(#)sigretro.c 1.3 'attmail mail(1) command'" ! 2: #ident "@(#)mailx:sigretro.c 1.6.1.1" ! 3: /* Copyright (c) 1984 AT&T */ ! 4: /* All Rights Reserved */ ! 5: ! 6: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T */ ! 7: /* The copyright notice above does not evidence any */ ! 8: /* actual or intended publication of such source code. */ ! 9: ! 10: #ident "@(#)mailx:sigretro.c 1.6" ! 11: ! 12: /* ! 13: * mailx -- a modified version of a University of California at Berkeley ! 14: * mail program ! 15: */ ! 16: ! 17: /* ! 18: * This code is only compiled in if SIG_HOLD is not defined! ! 19: * ! 20: * Retrofit new signal interface to old signal primitives. ! 21: * Supported routines: ! 22: * sigsys(sig, func) ! 23: * sigset(sig, func) ! 24: * sighold(sig) ! 25: * sigrelse(sig) ! 26: * sigignore(sig) ! 27: * sigpause(sig) ! 28: * Also, ! 29: * sigchild() ! 30: * to set all held signals to ignored signals in the ! 31: * child process after fork(2) ! 32: */ ! 33: #include <rcv.h> /* find out if we're in USG -- adb */ ! 34: #include <signal.h> ! 35: ! 36: #ifndef USG ! 37: # include <errno.h> ! 38: extern int errno; ! 39: ! 40: typedef void (*sigtype)(); ! 41: ! 42: #ifndef SIG_HOLD /* adb */ ! 43: #define SIG_HOLD ((sigtype) 2) ! 44: #endif ! 45: #ifndef SIG_ERR ! 46: # define SIG_ERR ((sigtype) -1) ! 47: #endif ! 48: ! 49: sigtype sigdisp(), sighold(), sigignore(); ! 50: void _Sigtramp(); ! 51: ! 52: /* ! 53: * The following helps us keep the extended signal semantics together. ! 54: * We remember for each signal the address of the function we're ! 55: * supposed to call. s_func is SIG_DFL / SIG_IGN if appropriate. ! 56: */ ! 57: static struct sigtable { ! 58: sigtype s_func; /* What to call */ ! 59: int s_flag; /* Signal flags; see below */ ! 60: } sigtable[NSIG + 1]; ! 61: ! 62: /* ! 63: * Signal flag values. ! 64: */ ! 65: #define SHELD 1 /* Signal is being held */ ! 66: #define SDEFER 2 /* Signal occured while held */ ! 67: #define SSET 4 /* s_func is believable */ ! 68: #define SPAUSE 8 /* are pausing, waiting for sig */ ! 69: ! 70: jmp_buf _pause; /* For doing sigpause() */ ! 71: ! 72: /* ! 73: * Approximate sigsys() system call ! 74: * This is almost useless since one only calls sigsys() ! 75: * in the child of a fork(). If you have vfork(), you have new signals ! 76: * anyway. The real sigsys() does all the stuff needed to support ! 77: * the real sigset() library. We don't bother here, assuming that ! 78: * you are either ignoring or defaulting a signal in the child. ! 79: */ ! 80: sigtype ! 81: sigsys(sig, func) ! 82: sigtype func; ! 83: { ! 84: sigtype old; ! 85: ! 86: old = sigdisp(sig); ! 87: signal(sig, func); ! 88: return(old); ! 89: } ! 90: ! 91: ! 92: /* ! 93: * Set the (permanent) disposition of a signal. ! 94: * If the signal is subsequently (or even now) held, ! 95: * the action you set here can be enabled using sigrelse(). ! 96: */ ! 97: sigtype ! 98: sigset(sig, func) ! 99: sigtype func; ! 100: { ! 101: sigtype old; ! 102: ! 103: if (sig < 1 || sig > NSIG) { ! 104: errno = EINVAL; ! 105: return(SIG_ERR); ! 106: } ! 107: old = sigdisp(sig); ! 108: /* ! 109: * Does anyone actually call sigset with SIG_HOLD!? ! 110: */ ! 111: if (func == (void (*)())SIG_HOLD) { /* adb */ ! 112: sighold(sig); ! 113: return(old); ! 114: } ! 115: sigtable[sig].s_flag |= SSET; ! 116: sigtable[sig].s_func = func; ! 117: if (func == (void (*)())SIG_DFL) { /* adb */ ! 118: /* ! 119: * If signal has been held, must retain ! 120: * the catch so that we can note occurrance ! 121: * of signal. ! 122: */ ! 123: if ((sigtable[sig].s_flag & SHELD) == 0) ! 124: signal(sig, SIG_DFL); ! 125: else ! 126: signal(sig, _Sigtramp); ! 127: return(old); ! 128: } ! 129: if (func == (void (*)())SIG_IGN) { /* adb */ ! 130: /* ! 131: * Clear pending signal ! 132: */ ! 133: signal(sig, SIG_IGN); ! 134: sigtable[sig].s_flag &= ~SDEFER; ! 135: return(old); ! 136: } ! 137: signal(sig, _Sigtramp); ! 138: return(old); ! 139: } ! 140: ! 141: /* ! 142: * Hold a signal. ! 143: * This CAN be tricky if the signal's disposition is SIG_DFL. ! 144: * In that case, we still catch the signal so we can note it ! 145: */ ! 146: sigtype ! 147: sighold(sig) ! 148: { ! 149: sigtype old; ! 150: ! 151: if (sig < 1 || sig > NSIG) { ! 152: errno = EINVAL; ! 153: return(SIG_ERR); ! 154: } ! 155: old = sigdisp(sig); ! 156: if (sigtable[sig].s_flag & SHELD) ! 157: return(old); ! 158: /* ! 159: * When the default action is required, we have to ! 160: * set up to catch the signal to note signal's occurrance. ! 161: */ ! 162: if (old == (void (*)())SIG_DFL) { /* adb */ ! 163: sigtable[sig].s_flag |= SSET; ! 164: signal(sig, _Sigtramp); ! 165: } ! 166: sigtable[sig].s_flag |= SHELD; ! 167: return(old); ! 168: } ! 169: ! 170: /* ! 171: * Release a signal ! 172: * If the signal occurred while we had it held, cause the signal. ! 173: */ ! 174: sigtype ! 175: sigrelse(sig) ! 176: { ! 177: sigtype old; ! 178: ! 179: if (sig < 1 || sig > NSIG) { ! 180: errno = EINVAL; ! 181: return(SIG_ERR); ! 182: } ! 183: old = sigdisp(sig); ! 184: if ((sigtable[sig].s_flag & SHELD) == 0) ! 185: return(old); ! 186: sigtable[sig].s_flag &= ~SHELD; ! 187: if (sigtable[sig].s_flag & SDEFER) ! 188: _Sigtramp(sig); ! 189: /* ! 190: * If disposition was the default, then we can unset the ! 191: * catch to _Sigtramp() and let the system do the work. ! 192: */ ! 193: if (sigtable[sig].s_func == (void (*)())SIG_DFL) /* adb */ ! 194: signal(sig, SIG_DFL); ! 195: return(old); ! 196: } ! 197: ! 198: /* ! 199: * Ignore a signal. ! 200: */ ! 201: sigtype ! 202: sigignore(sig) ! 203: { ! 204: return(sigset(sig, SIG_IGN)); ! 205: } ! 206: ! 207: /* ! 208: * Pause, waiting for sig to occur. ! 209: * We assume LUSER called us with the signal held. ! 210: * When we got the signal, mark the signal as having ! 211: * occurred. It will actually cause something when ! 212: * the signal is released. ! 213: */ ! 214: sigpause(sig) ! 215: { ! 216: if (sig < 1 || sig > NSIG) { ! 217: errno = EINVAL; ! 218: return; ! 219: } ! 220: sigtable[sig].s_flag |= SHELD|SPAUSE; ! 221: if (setjmp(_pause) == 0) ! 222: pause(); ! 223: sigtable[sig].s_flag &= ~SPAUSE; ! 224: sigtable[sig].s_flag |= SDEFER; ! 225: } ! 226: ! 227: /* ! 228: * In the child process after fork(2), set the disposition of all held ! 229: * signals to SIG_IGN. This is a new procedure not in the real sigset() ! 230: * package, provided for retrofitting purposes. ! 231: */ ! 232: void ! 233: sigchild() ! 234: { ! 235: register int i; ! 236: ! 237: for (i = 1; i <= NSIG; i++) ! 238: if (sigtable[i].s_flag & SHELD) ! 239: signal(i, SIG_IGN); ! 240: } ! 241: ! 242: ! 243: /* ! 244: * Return the current disposition of a signal ! 245: * If we have not set this signal before, we have to ! 246: * ask the system ! 247: */ ! 248: sigtype ! 249: sigdisp(sig) ! 250: { ! 251: sigtype old; ! 252: ! 253: if (sig < 1 || sig > NSIG) { ! 254: errno = EINVAL; ! 255: return(SIG_ERR); ! 256: } ! 257: /* ! 258: * If we have no knowledge of this signal, ! 259: * ask the system, then save the result for later. ! 260: */ ! 261: if ((sigtable[sig].s_flag & SSET) == 0) { ! 262: old = (void (*)())signal(sig, SIG_IGN); /* adb */ ! 263: sigtable[sig].s_func = old; ! 264: sigtable[sig].s_flag |= SSET; ! 265: signal(sig, old); ! 266: return(old); ! 267: } ! 268: /* ! 269: * If we have set this signal before, then sigset() ! 270: * will have been careful to leave something meaningful ! 271: * in s_func. ! 272: */ ! 273: return(sigtable[sig].s_func); ! 274: } ! 275: ! 276: /* ! 277: * The following routine gets called for any signal ! 278: * that is to be trapped to a user function. ! 279: */ ! 280: void ! 281: _Sigtramp(sig) ! 282: { ! 283: sigtype old; ! 284: ! 285: if (sig < 1 || sig > NSIG) { ! 286: errno = EINVAL; ! 287: return; ! 288: } ! 289: ! 290: top: ! 291: old = (void (*)())signal(sig, SIG_IGN); /* adb */ ! 292: /* ! 293: * If signal being paused on, wakeup sigpause() ! 294: */ ! 295: if (sigtable[sig].s_flag & SPAUSE) ! 296: longjmp(_pause, 1); ! 297: /* ! 298: * If signal is being held, mark its table entry ! 299: * so we can trigger it when signal is released. ! 300: * Then just return. ! 301: */ ! 302: if (sigtable[sig].s_flag & SHELD) { ! 303: sigtable[sig].s_flag |= SDEFER; ! 304: signal(sig, _Sigtramp); ! 305: return; ! 306: } ! 307: /* ! 308: * If the signal is being ignored, just return. ! 309: * This would make SIGCONT more normal, but of course ! 310: * any system with SIGCONT also has the new signal pkg, so... ! 311: */ ! 312: if (sigtable[sig].s_func == (void (*)())SIG_IGN) /* adb */ ! 313: return; ! 314: /* ! 315: * If the signal is SIG_DFL, then we probably got here ! 316: * by holding the signal, having it happen, then releasing ! 317: * the signal. ! 318: */ ! 319: if (sigtable[sig].s_func == (void (*)())SIG_DFL) { /* adb */ ! 320: signal(sig, SIG_DFL); ! 321: kill(getpid(), sig); ! 322: /* Will we get back here? */ ! 323: return; ! 324: } ! 325: /* ! 326: * Looks like we should just cause the signal... ! 327: * We hold the signal for the duration of the user's ! 328: * code with the signal re-enabled. If the signal ! 329: * happens again while in user code, we will recursively ! 330: * trap here and mark that we had another occurance ! 331: * and return to the user's trap code. When we return ! 332: * from there, we can cause the signal again. ! 333: */ ! 334: sigtable[sig].s_flag &= ~SDEFER; ! 335: sigtable[sig].s_flag |= SHELD; ! 336: signal(sig, _Sigtramp); ! 337: (*sigtable[sig].s_func)(sig); ! 338: /* ! 339: * If the signal re-occurred while in the user's routine, ! 340: * just go try it again... ! 341: */ ! 342: sigtable[sig].s_flag &= ~SHELD; ! 343: if (sigtable[sig].s_flag & SDEFER) ! 344: goto top; ! 345: } ! 346: ! 347: #else ! 348: /* ! 349: * In the child process after fork(2), set the disposition of all held ! 350: * signals to SIG_IGN. This is a new procedure not in the real sigset() ! 351: * package, provided for retrofitting purposes. With the real sigset() ! 352: * package, this function is unnecessary. ! 353: */ ! 354: void sigchild() {} ! 355: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.