Annotation of freem/src/sighnd.c, revision 1.5
1.1 snw 1: /*
1.5 ! snw 2: * $Id: sighnd.c,v 1.4 2025/03/24 00:34:30 snw Exp $
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.4 snw 26: * $Log: sighnd.c,v $
1.5 ! snw 27: * Revision 1.4 2025/03/24 00:34:30 snw
! 28: * Fix termios junk in sighnd.c
! 29: *
1.4 snw 30: * Revision 1.3 2025/03/09 19:50:47 snw
31: * Second phase of REUSE compliance and header reformat
32: *
1.3 snw 33: *
34: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
35: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 36: **/
37:
38: #include <stddef.h>
39: #include <stdlib.h>
40: #include <setjmp.h>
41: #include <signal.h>
42: #include <unistd.h>
43: #include <stdio.h>
44:
45: #include <sys/types.h>
46: #include <sys/wait.h>
47:
1.4 snw 48: #if !defined(__APPLE__) && !defined(__gnu_hurd__) && !defined(EMSCRIPTEN)
49: # if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__AMIGA)
50: # include <termios.h>
51: # if !defined(__AMIGA)
52: # define TCGETA TIOCGETA
53: # define TCSETA TIOCSETA
54: # endif
55: # define termio termios
56: # else
57: # if !defined(MSDOS)
58: # include <termio.h>
59: # endif
60: # endif
61: #else
62: # include <termios.h>
63: #endif
64:
1.1 snw 65: #include <sys/ioctl.h>
66:
67: #include "mpsdef.h"
68: #include "transact.h"
69: #include "init.h"
70: #include "events.h"
71: #include "jobtab.h"
72: #include "shmmgr.h"
73:
1.4 snw 74:
75:
1.1 snw 76: void m_log (int, const char *);
77: int pending_signal_type = -1;
78:
79: void sig_attach(int sig, void *handler)
80: {
81: struct sigaction act;
82:
83: act.sa_handler = handler;
84: #if !defined(__AMIGA)
85: sigaction (sig, &act, NULL);
86: #else
87: //TODO: fill in for m68k-amigaos
88: #endif
89: }
90:
91:
92: void sig_init(void)
93: {
94: /* signals stuff */
95: sig_attach (SIGINT, &onintr); /* set_up INTERRUPT */
96: sig_attach (SIGQUIT, &onquit); /* set_up ZBREAK */
97: sig_attach (SIGTERM, &onkill); /* catch kill signal */
98:
99: #if !defined(__CYGWIN__) && !defined(MSDOS)
100: sig_attach (SIGIOT, &onbus); /* catch IOT error */
101: #endif/*__CYGWIN__*/
102:
103: #ifndef LINUX
104: sig_attach (SIGEMT, &onbus); /* catch EMT error */
105: #endif/*LINUX*/
106:
107: #if !defined(MSDOS)
108: sig_attach (SIGWINCH, &onwinch);
109: #endif
110:
111: sig_attach (SIGUSR1, &oncld); /* catch son dies signal */
112: sig_attach (SIGHUP, &onhup); /* catch hangup */
113:
114: sig_attach (SIGUSR2, &onipc); /* catch IPC signal */
115: sig_attach (SIGFPE, &onfpe); /* catch floating pt except */
116: }
117:
118:
1.5 ! snw 119: #if !defined(MSDOS) && !defined(__OS2__)
1.1 snw 120: void onwinch (void)
121: {
122: struct winsize ws;
123:
124: /* restore handler */
125: sig_attach (SIGWINCH, &onwinch);
126:
127: ioctl (STDIN_FILENO, TIOCGWINSZ, &ws);
128:
129: n_lines = ws.ws_row;
130: n_columns = ws.ws_col;
131:
132: if (evt_async_enabled) {
133: pending_signal_type = SIGWINCH;
134: merr_raise (ASYNC);
135: }
136:
137: return;
138: }
139: #endif
140:
141: void onintr (void)
142: {
143: sig_attach (SIGINT, &onintr); /* restore handler */
144:
145: //printf ("\r\nSIGINT codptr = '%s'\r\n", codptr);
146:
147: if (first_process) {
148: job_request_stop (pid);
149: }
150: else {
151: if (shm_config->hdr->maintenance_mode == 1) {
152:
153: job_slot_t *s = job_get (pid);
154:
155:
156: if ((s->flags & JFLG_FMADM) != JFLG_FMADM) {
157:
158: fprintf (stderr, "\r\n***ENVIRONMENT IN MAINTENANCE MODE***\r\n");
159:
160: while (shm_config->hdr->maintenance_mode == 1) {
161: sleep (1);
162: }
163:
164: return;
165:
166: }
167:
168: }
169: }
170:
171:
172: if (breakon) {
173: merr_raise (INRPT);
174: inrpt_after_async = TRUE;
175: if (forsw) sigint_in_for = TRUE;
176: }
177: else {
178: zcc = TRUE;
179: }
180:
181: if (evt_async_enabled) {
182: pending_signal_type = SIGINT;
183: }
184:
185: return;
186: } /* end of onintr */
187:
188: void onfpe (void)
189: {
190: sig_attach (SIGFPE, &onfpe); /* restore handler */
191:
192: if (evt_async_enabled) {
193: pending_signal_type = SIGFPE;
194: }
195:
196: merr_raise (MXNUM);
197: return;
198: } /* end of onfpe */
199:
200: void onquit (void)
201: {
202:
203: if (run_daemon == TRUE) {
204: job_request_stop (pid);
205: }
206:
207: sig_attach (SIGQUIT, &onquit); /* restore handler */
208:
209: if (zbreakon && (merr () == OK)) ierr = OK - CTRLB;
210:
211: if (evt_async_enabled) {
212: pending_signal_type = SIGQUIT;
213: }
214:
215: return;
216: } /* end of onquit */
217:
218: void onkill (void)
219: {
220: int n = 0;
221:
222: if (run_daemon == TRUE) {
223: job_request_stop (pid);
224: }
225:
226: #if !defined(AMIGA68K)
227: if (direct_mode == TRUE) {
228: set_io (UNIX);
229: fprintf (stderr, "\n\nFreeM process %d caught SIGTERM\n", pid);
230: set_io (MUMPS);
231: }
232: #endif
233:
234:
235: sig_attach (SIGTERM, &onkill); /* restore handler */
236:
237: if (killerflag == FALSE) return; /* ignore that signal */
238:
239: /* if there exists an error trap, process as an error */
240: /* otherwise terminate the job */
241:
242: if (DSM2err) { /* DSM V.2 error trapping */
243:
244:
245:
246: if (ztrap[NESTLEVLS + 1][0] != EOL) {
247: merr_raise (KILLER);
248: return;
249: }
250:
251:
252: }
253: else {
254:
255:
256: while (n >= 0) {
257: if (ztrap[n--][0] != EOL) {
258: merr_raise (KILLER);
259: return;
260: }
261: }
262:
263:
264: }
265:
266: cleanup ();
267: if (father) kill (father, SIGUSR1); /* advertise death to parent */
268:
269: exit (1); /* terminate mumps */
270: } /* end of onkill() */
271:
272: void onhup (void)
273: {
274:
275: int n = nstx;
276:
277:
278: if (run_daemon == TRUE) {
279: fprintf (stderr, "freem: daemon received SIGHUP\r\n");
280: m_log (1, "freem: daemon received SIGHUP");
281:
282: sig_attach (SIGHUP, &onhup); /* restore handler */
283:
284: return;
285: }
286:
287: sig_attach (SIGHUP, &onhup); /* restore handler */
288:
289: if (huperflag == FALSE) return; /* ignore that signal */
290:
291: /* if there exists an error trap, process as an error */
292: /* otherwise terminate the job */
293:
294: if (DSM2err) { /* DSM V.2 error trapping */
295:
296: if (ztrap[NESTLEVLS + 1][0] != EOL) {
297: merr_raise (HUPER);
298: return;
299: }
300:
301:
302: }
303: else {
304:
305: while (n >= 0) {
306: if (ztrap[n--][0] != EOL) {
307: merr_raise (HUPER);
308: return;
309: }
310: }
311:
312: }
313:
314: cleanup ();
315:
316: if (father) kill (father, SIGUSR1); /* advertise death to parent */
317:
318: exit (1); /* terminate mumps */
319:
320: } /* end of onhup() */
321:
322: void onbus (void)
323: {
324: cleanup ();
325:
326: printf ("\012\015BUS ERROR, SEGMENTATION VIOLATION\012\015");
327:
328: if (father) kill (father, SIGUSR1); /* advertise death to parent */
329:
330: exit (1); /* terminate mumps */
331: } /* end of onbus() */
332:
333: /* under XENIX processes started with JOB hang around as zombies */
334: /* if they HALT before the parent process, unless the parent process */
335: /* waits for his child to terminate. to solve the problem, the child */
336: /* sends a signal to his parent to avoid an unattended funeral which */
337: /* inevitably would result in a living dead sucking up cpu time */
338: void oncld (void)
339: {
340: int status;
341:
342: /* ignore signal while as we're here */
343: sig_attach (SIGUSR1, SIG_IGN);
344:
345: wait (&status); /* wait for report from child */
346:
347: sig_attach (SIGUSR1, &oncld);/* restore handler */
348:
349: return;
350: } /* end of oncld() */
351:
352: void onipc (void)
353: {
354: /* restore handler */
355: sig_attach (SIGUSR2, &onipc);
356:
357: ipc_pending = 1;
358:
359: return;
360: }
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