[unix-history] / usr / src / usr.bin / mail / sigretro.c

/*
 * Copyright (c) 1980 Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that this notice is preserved and that due credit is given
 * to the University of California at Berkeley. The name of the University
 * may not be used to endorse or promote products derived from this
 * software without specific prior written permission. This software
 * is provided ``as is'' without express or implied warranty.
 */

#ifdef notdef
static char sccsid[] = "@(#)sigretro.c	5.3 (Berkeley) %G%";
#endif /* notdef */

#include <signal.h>
#include <errno.h>
#include <setjmp.h>
#include "sigretro.h"

/*
 * Retrofit new signal interface to old signal primitives.
 * Supported routines:
 *	sigsys(sig, func)
 *	sigset(sig, func)
 *	sighold(sig)
 *	sigrelse(sig)
 *	sigignore(sig)
 *	sigpause(sig)
 * Also,
 *	sigchild()
 *		to set all held signals to ignored signals in the
 *		child process after fork(2)
 */

typedef	int	(*sigtype)();

sigtype	sigdisp(), sighold(), sigignore();

/*
 * The following helps us keep the extended signal semantics together.
 * We remember for each signal the address of the function we're
 * supposed to call.  s_func is SIG_DFL / SIG_IGN if appropriate.
 */
struct sigtable {
	sigtype	s_func;			/* What to call */
	int	s_flag;			/* Signal flags; see below */
} sigtable[NSIG + 1];

/*
 * Signal flag values.
 */
#define	SHELD		1		/* Signal is being held */
#define	SDEFER		2		/* Signal occured while held */
#define	SSET		4		/* s_func is believable */
#define	SPAUSE		8		/* are pausing, waiting for sig */

jmp_buf	_pause;				/* For doing sigpause() */

/*
 * Approximate sigsys() system call
 * This is almost useless since one only calls sigsys()
 * in the child of a vfork().  If you have vfork(), you have new signals
 * anyway.  The real sigsys() does all the stuff needed to support
 * the real sigset() library.  We don't bother here, assuming that
 * you are either ignoring or defaulting a signal in the child.
 */
sigtype
sigsys(sig, func)
	sigtype func;
{
	sigtype old;

	old = sigdisp(sig);
	signal(sig, func);
	return(old);
}

/*
 * Set the (permanent) disposition of a signal.
 * If the signal is subsequently (or even now) held,
 * the action you set here can be enabled using sigrelse().
 */
sigtype
sigset(sig, func)
	sigtype func;
{
	sigtype old;
	int _sigtramp();
	extern int errno;

	if (sig < 1 || sig > NSIG) {
		errno = EINVAL;
		return(BADSIG);
	}
	old = sigdisp(sig);
	/*
	 * Does anyone actually call sigset with SIG_HOLD!?
	 */
	if (func == SIG_HOLD) {
		sighold(sig);
		return(old);
	}
	sigtable[sig].s_flag |= SSET;
	sigtable[sig].s_func = func;
	if (func == SIG_DFL) {
		/*
		 * If signal has been held, must retain
		 * the catch so that we can note occurrance
		 * of signal.
		 */
		if ((sigtable[sig].s_flag & SHELD) == 0)
			signal(sig, SIG_DFL);
		else
			signal(sig, _sigtramp);
		return(old);
	}
	if (func == SIG_IGN) {
		/*
		 * Clear pending signal
		 */
		signal(sig, SIG_IGN);
		sigtable[sig].s_flag &= ~SDEFER;
		return(old);
	}
	signal(sig, _sigtramp);
	return(old);
}

/*
 * Hold a signal.
 * This CAN be tricky if the signal's disposition is SIG_DFL.
 * In that case, we still catch the signal so we can note it
 * happened and do something crazy later.
 */
sigtype
sighold(sig)
{
	sigtype old;
	extern int errno;

	if (sig < 1 || sig > NSIG) {
		errno = EINVAL;
		return(BADSIG);
	}
	old = sigdisp(sig);
	if (sigtable[sig].s_flag & SHELD)
		return(old);
	/*
	 * When the default action is required, we have to
	 * set up to catch the signal to note signal's occurrance.
	 */
	if (old == SIG_DFL) {
		sigtable[sig].s_flag |= SSET;
		signal(sig, _sigtramp);
	}
	sigtable[sig].s_flag |= SHELD;
	return(old);
}

/*
 * Release a signal
 * If the signal occurred while we had it held, cause the signal.
 */
sigtype
sigrelse(sig)
{
	sigtype old;
	extern int errno;
	int _sigtramp();

	if (sig < 1 || sig > NSIG) {
		errno = EINVAL;
		return(BADSIG);
	}
	old = sigdisp(sig);
	if ((sigtable[sig].s_flag & SHELD) == 0)
		return(old);
	sigtable[sig].s_flag &= ~SHELD;
	if (sigtable[sig].s_flag & SDEFER)
		_sigtramp(sig);
	/*
	 * If disposition was the default, then we can unset the
	 * catch to _sigtramp() and let the system do the work.
	 */
	if (sigtable[sig].s_func == SIG_DFL)
		signal(sig, SIG_DFL);
	return(old);
}

/*
 * Ignore a signal.
 */
sigtype
sigignore(sig)
{

	return(sigset(sig, SIG_IGN));
}

/*
 * Pause, waiting for sig to occur.
 * We assume LUSER called us with the signal held.
 * When we got the signal, mark the signal as having
 * occurred.  It will actually cause something when
 * the signal is released.
 *
 * This is probably useless without job control anyway.
 */
sigpause(sig)
{
	extern int errno;

	if (sig < 1 || sig > NSIG) {
		errno = EINVAL;
		return;
	}
	sigtable[sig].s_flag |= SHELD|SPAUSE;
	if (setjmp(_pause) == 0)
		pause();
	sigtable[sig].s_flag &= ~SPAUSE;
	sigtable[sig].s_flag |= SDEFER;
}

/*
 * In the child process after fork(2), set the disposition of all held
 * signals to SIG_IGN.  This is a new procedure not in the real sigset()
 * package, provided for retrofitting purposes.
 */
sigchild()
{
	register int i;

	for (i = 1; i <= NSIG; i++)
		if (sigtable[i].s_flag & SHELD)
			signal(i, SIG_IGN);
}

/*
 * Return the current disposition of a signal
 * If we have not set this signal before, we have to
 * ask the system
 */
sigtype
sigdisp(sig)
{
	extern int errno;
	sigtype old;

	if (sig < 1 || sig > NSIG) {
		errno = EINVAL;
		return(BADSIG);
	}
	/*
	 * If we have no knowledge of this signal,
	 * ask the system, then save the result for later.
	 */
	if ((sigtable[sig].s_flag & SSET) == 0) {
		old = signal(sig, SIG_IGN);
		sigtable[sig].s_func = old;
		sigtable[sig].s_flag |= SSET;
		signal(sig, old);
		return(old);
	}
	/*
	 * If we have set this signal before, then sigset()
	 * will have been careful to leave something meaningful
	 * in s_func.
	 */
	return(sigtable[sig].s_func);
}

/*
 * The following routine gets called for any signal
 * that is to be trapped to a user function.
 */
_sigtramp(sig)
{
	extern int errno;
	sigtype old;

	if (sig < 1 || sig > NSIG) {
		errno = EINVAL;
		return;
	}

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