Annotation of freem/src/sighnd.c, revision 1.3
1.1 snw 1: /*
1.3 ! snw 2: * $Id$
1.1 snw 3: * FreeM signal handlers
4: *
5: *
1.2 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.3 ! snw 8: * Copyright (C) 2020, 2025 Coherent Logic Development LLC
1.1 snw 9: *
10: *
11: * This file is part of FreeM.
12: *
13: * FreeM is free software: you can redistribute it and/or modify
14: * it under the terms of the GNU Affero Public License as published by
15: * the Free Software Foundation, either version 3 of the License, or
16: * (at your option) any later version.
17: *
18: * FreeM is distributed in the hope that it will be useful,
19: * but WITHOUT ANY WARRANTY; without even the implied warranty of
20: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21: * GNU Affero Public License for more details.
22: *
23: * You should have received a copy of the GNU Affero Public License
24: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
25: *
1.3 ! snw 26: * $Log$
! 27: *
! 28: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
! 29: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 30: **/
31:
32: #include <stddef.h>
33: #include <stdlib.h>
34: #include <setjmp.h>
35: #include <signal.h>
36: #include <unistd.h>
37: #include <stdio.h>
38:
39: #include <sys/types.h>
40: #include <sys/wait.h>
41:
42: #include <termios.h>
43: #include <sys/ioctl.h>
44:
45: #include "mpsdef.h"
46: #include "transact.h"
47: #include "init.h"
48: #include "events.h"
49: #include "jobtab.h"
50: #include "shmmgr.h"
51:
52: void m_log (int, const char *);
53: int pending_signal_type = -1;
54:
55: void sig_attach(int sig, void *handler)
56: {
57: struct sigaction act;
58:
59: act.sa_handler = handler;
60: #if !defined(__AMIGA)
61: sigaction (sig, &act, NULL);
62: #else
63: //TODO: fill in for m68k-amigaos
64: #endif
65: }
66:
67:
68: void sig_init(void)
69: {
70: /* signals stuff */
71: sig_attach (SIGINT, &onintr); /* set_up INTERRUPT */
72: sig_attach (SIGQUIT, &onquit); /* set_up ZBREAK */
73: sig_attach (SIGTERM, &onkill); /* catch kill signal */
74:
75: #if !defined(__CYGWIN__) && !defined(MSDOS)
76: sig_attach (SIGIOT, &onbus); /* catch IOT error */
77: #endif/*__CYGWIN__*/
78:
79: #ifndef LINUX
80: sig_attach (SIGEMT, &onbus); /* catch EMT error */
81: #endif/*LINUX*/
82:
83: #if !defined(MSDOS)
84: sig_attach (SIGWINCH, &onwinch);
85: #endif
86:
87: sig_attach (SIGUSR1, &oncld); /* catch son dies signal */
88: sig_attach (SIGHUP, &onhup); /* catch hangup */
89:
90: sig_attach (SIGUSR2, &onipc); /* catch IPC signal */
91: sig_attach (SIGFPE, &onfpe); /* catch floating pt except */
92: }
93:
94:
95: #if !defined(MSDOS)
96: void onwinch (void)
97: {
98: struct winsize ws;
99:
100: /* restore handler */
101: sig_attach (SIGWINCH, &onwinch);
102:
103: ioctl (STDIN_FILENO, TIOCGWINSZ, &ws);
104:
105: n_lines = ws.ws_row;
106: n_columns = ws.ws_col;
107:
108: if (evt_async_enabled) {
109: pending_signal_type = SIGWINCH;
110: merr_raise (ASYNC);
111: }
112:
113: return;
114: }
115: #endif
116:
117: void onintr (void)
118: {
119: sig_attach (SIGINT, &onintr); /* restore handler */
120:
121: //printf ("\r\nSIGINT codptr = '%s'\r\n", codptr);
122:
123: if (first_process) {
124: job_request_stop (pid);
125: }
126: else {
127: if (shm_config->hdr->maintenance_mode == 1) {
128:
129: job_slot_t *s = job_get (pid);
130:
131:
132: if ((s->flags & JFLG_FMADM) != JFLG_FMADM) {
133:
134: fprintf (stderr, "\r\n***ENVIRONMENT IN MAINTENANCE MODE***\r\n");
135:
136: while (shm_config->hdr->maintenance_mode == 1) {
137: sleep (1);
138: }
139:
140: return;
141:
142: }
143:
144: }
145: }
146:
147:
148: if (breakon) {
149: merr_raise (INRPT);
150: inrpt_after_async = TRUE;
151: if (forsw) sigint_in_for = TRUE;
152: }
153: else {
154: zcc = TRUE;
155: }
156:
157: if (evt_async_enabled) {
158: pending_signal_type = SIGINT;
159: }
160:
161: return;
162: } /* end of onintr */
163:
164: void onfpe (void)
165: {
166: sig_attach (SIGFPE, &onfpe); /* restore handler */
167:
168: if (evt_async_enabled) {
169: pending_signal_type = SIGFPE;
170: }
171:
172: merr_raise (MXNUM);
173: return;
174: } /* end of onfpe */
175:
176: void onquit (void)
177: {
178:
179: if (run_daemon == TRUE) {
180: job_request_stop (pid);
181: }
182:
183: sig_attach (SIGQUIT, &onquit); /* restore handler */
184:
185: if (zbreakon && (merr () == OK)) ierr = OK - CTRLB;
186:
187: if (evt_async_enabled) {
188: pending_signal_type = SIGQUIT;
189: }
190:
191: return;
192: } /* end of onquit */
193:
194: void onkill (void)
195: {
196: int n = 0;
197:
198: if (run_daemon == TRUE) {
199: job_request_stop (pid);
200: }
201:
202: #if !defined(AMIGA68K)
203: if (direct_mode == TRUE) {
204: set_io (UNIX);
205: fprintf (stderr, "\n\nFreeM process %d caught SIGTERM\n", pid);
206: set_io (MUMPS);
207: }
208: #endif
209:
210:
211: sig_attach (SIGTERM, &onkill); /* restore handler */
212:
213: if (killerflag == FALSE) return; /* ignore that signal */
214:
215: /* if there exists an error trap, process as an error */
216: /* otherwise terminate the job */
217:
218: if (DSM2err) { /* DSM V.2 error trapping */
219:
220:
221:
222: if (ztrap[NESTLEVLS + 1][0] != EOL) {
223: merr_raise (KILLER);
224: return;
225: }
226:
227:
228: }
229: else {
230:
231:
232: while (n >= 0) {
233: if (ztrap[n--][0] != EOL) {
234: merr_raise (KILLER);
235: return;
236: }
237: }
238:
239:
240: }
241:
242: cleanup ();
243: if (father) kill (father, SIGUSR1); /* advertise death to parent */
244:
245: exit (1); /* terminate mumps */
246: } /* end of onkill() */
247:
248: void onhup (void)
249: {
250:
251: int n = nstx;
252:
253:
254: if (run_daemon == TRUE) {
255: fprintf (stderr, "freem: daemon received SIGHUP\r\n");
256: m_log (1, "freem: daemon received SIGHUP");
257:
258: sig_attach (SIGHUP, &onhup); /* restore handler */
259:
260: return;
261: }
262:
263: sig_attach (SIGHUP, &onhup); /* restore handler */
264:
265: if (huperflag == FALSE) return; /* ignore that signal */
266:
267: /* if there exists an error trap, process as an error */
268: /* otherwise terminate the job */
269:
270: if (DSM2err) { /* DSM V.2 error trapping */
271:
272: if (ztrap[NESTLEVLS + 1][0] != EOL) {
273: merr_raise (HUPER);
274: return;
275: }
276:
277:
278: }
279: else {
280:
281: while (n >= 0) {
282: if (ztrap[n--][0] != EOL) {
283: merr_raise (HUPER);
284: return;
285: }
286: }
287:
288: }
289:
290: cleanup ();
291:
292: if (father) kill (father, SIGUSR1); /* advertise death to parent */
293:
294: exit (1); /* terminate mumps */
295:
296: } /* end of onhup() */
297:
298: void onbus (void)
299: {
300: cleanup ();
301:
302: printf ("\012\015BUS ERROR, SEGMENTATION VIOLATION\012\015");
303:
304: if (father) kill (father, SIGUSR1); /* advertise death to parent */
305:
306: exit (1); /* terminate mumps */
307: } /* end of onbus() */
308:
309: /* under XENIX processes started with JOB hang around as zombies */
310: /* if they HALT before the parent process, unless the parent process */
311: /* waits for his child to terminate. to solve the problem, the child */
312: /* sends a signal to his parent to avoid an unattended funeral which */
313: /* inevitably would result in a living dead sucking up cpu time */
314: void oncld (void)
315: {
316: int status;
317:
318: /* ignore signal while as we're here */
319: sig_attach (SIGUSR1, SIG_IGN);
320:
321: wait (&status); /* wait for report from child */
322:
323: sig_attach (SIGUSR1, &oncld);/* restore handler */
324:
325: return;
326: } /* end of oncld() */
327:
328: void onipc (void)
329: {
330: /* restore handler */
331: sig_attach (SIGUSR2, &onipc);
332:
333: ipc_pending = 1;
334:
335: return;
336: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sighnd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src