Commit | Line | Data |
---|---|---|
252b5132 RH |
1 | /* Extended support for using signal values. |
2 | Written by Fred Fish. fnf@cygnus.com | |
3 | This file is in the public domain. */ | |
4 | ||
5 | #include "ansidecl.h" | |
6 | #include "libiberty.h" | |
7 | ||
8 | #include "config.h" | |
9 | ||
10 | /* We need to declare sys_siglist, because even if the system provides | |
11 | it we can't assume that it is declared in <signal.h> (for example, | |
12 | SunOS provides sys_siglist, but it does not declare it in any | |
13 | header file). fHowever, we can't declare sys_siglist portably, | |
14 | because on some systems it is declared with const and on some | |
15 | systems it is declared without const. If we were using autoconf, | |
16 | we could work out the right declaration. Until, then we just | |
17 | ignore any declaration in the system header files, and always | |
18 | declare it ourselves. With luck, this will always work. */ | |
19 | #define sys_siglist no_such_symbol | |
20 | ||
21 | #include <stdio.h> | |
22 | #include <signal.h> | |
23 | ||
24 | /* Routines imported from standard C runtime libraries. */ | |
25 | ||
5c82d20a ZW |
26 | #ifdef HAVE_STDLIB_H |
27 | #include <stdlib.h> | |
28 | #else | |
29 | extern PTR malloc (); | |
30 | #endif | |
31 | ||
32 | #ifdef HAVE_STRING_H | |
33 | #include <string.h> | |
34 | #else | |
35 | extern PTR memset (); | |
36 | #endif | |
252b5132 RH |
37 | |
38 | /* Undefine the macro we used to hide the definition of sys_siglist | |
39 | found in the system header files. */ | |
40 | #undef sys_siglist | |
41 | ||
42 | #ifndef NULL | |
43 | # ifdef __STDC__ | |
44 | # define NULL (void *) 0 | |
45 | # else | |
46 | # define NULL 0 | |
47 | # endif | |
48 | #endif | |
49 | ||
50 | #ifndef MAX | |
51 | # define MAX(a,b) ((a) > (b) ? (a) : (b)) | |
52 | #endif | |
53 | ||
54 | static void init_signal_tables PARAMS ((void)); | |
55 | ||
56 | /* Translation table for signal values. | |
57 | ||
58 | Note that this table is generally only accessed when it is used at runtime | |
59 | to initialize signal name and message tables that are indexed by signal | |
60 | value. | |
61 | ||
62 | Not all of these signals will exist on all systems. This table is the only | |
63 | thing that should have to be updated as new signal numbers are introduced. | |
64 | It's sort of ugly, but at least its portable. */ | |
65 | ||
66 | struct signal_info | |
67 | { | |
68 | int value; /* The numeric value from <signal.h> */ | |
69 | const char *name; /* The equivalent symbolic value */ | |
70 | #ifndef HAVE_SYS_SIGLIST | |
71 | const char *msg; /* Short message about this value */ | |
72 | #endif | |
73 | }; | |
74 | ||
75 | #ifndef HAVE_SYS_SIGLIST | |
76 | # define ENTRY(value, name, msg) {value, name, msg} | |
77 | #else | |
78 | # define ENTRY(value, name, msg) {value, name} | |
79 | #endif | |
80 | ||
81 | static const struct signal_info signal_table[] = | |
82 | { | |
83 | #if defined (SIGHUP) | |
84 | ENTRY(SIGHUP, "SIGHUP", "Hangup"), | |
85 | #endif | |
86 | #if defined (SIGINT) | |
87 | ENTRY(SIGINT, "SIGINT", "Interrupt"), | |
88 | #endif | |
89 | #if defined (SIGQUIT) | |
90 | ENTRY(SIGQUIT, "SIGQUIT", "Quit"), | |
91 | #endif | |
92 | #if defined (SIGILL) | |
93 | ENTRY(SIGILL, "SIGILL", "Illegal instruction"), | |
94 | #endif | |
95 | #if defined (SIGTRAP) | |
96 | ENTRY(SIGTRAP, "SIGTRAP", "Trace/breakpoint trap"), | |
97 | #endif | |
98 | /* Put SIGIOT before SIGABRT, so that if SIGIOT==SIGABRT then SIGABRT | |
99 | overrides SIGIOT. SIGABRT is in ANSI and POSIX.1, and SIGIOT isn't. */ | |
100 | #if defined (SIGIOT) | |
101 | ENTRY(SIGIOT, "SIGIOT", "IOT trap"), | |
102 | #endif | |
103 | #if defined (SIGABRT) | |
104 | ENTRY(SIGABRT, "SIGABRT", "Aborted"), | |
105 | #endif | |
106 | #if defined (SIGEMT) | |
107 | ENTRY(SIGEMT, "SIGEMT", "Emulation trap"), | |
108 | #endif | |
109 | #if defined (SIGFPE) | |
110 | ENTRY(SIGFPE, "SIGFPE", "Arithmetic exception"), | |
111 | #endif | |
112 | #if defined (SIGKILL) | |
113 | ENTRY(SIGKILL, "SIGKILL", "Killed"), | |
114 | #endif | |
115 | #if defined (SIGBUS) | |
116 | ENTRY(SIGBUS, "SIGBUS", "Bus error"), | |
117 | #endif | |
118 | #if defined (SIGSEGV) | |
119 | ENTRY(SIGSEGV, "SIGSEGV", "Segmentation fault"), | |
120 | #endif | |
121 | #if defined (SIGSYS) | |
122 | ENTRY(SIGSYS, "SIGSYS", "Bad system call"), | |
123 | #endif | |
124 | #if defined (SIGPIPE) | |
125 | ENTRY(SIGPIPE, "SIGPIPE", "Broken pipe"), | |
126 | #endif | |
127 | #if defined (SIGALRM) | |
128 | ENTRY(SIGALRM, "SIGALRM", "Alarm clock"), | |
129 | #endif | |
130 | #if defined (SIGTERM) | |
131 | ENTRY(SIGTERM, "SIGTERM", "Terminated"), | |
132 | #endif | |
133 | #if defined (SIGUSR1) | |
134 | ENTRY(SIGUSR1, "SIGUSR1", "User defined signal 1"), | |
135 | #endif | |
136 | #if defined (SIGUSR2) | |
137 | ENTRY(SIGUSR2, "SIGUSR2", "User defined signal 2"), | |
138 | #endif | |
139 | /* Put SIGCLD before SIGCHLD, so that if SIGCLD==SIGCHLD then SIGCHLD | |
140 | overrides SIGCLD. SIGCHLD is in POXIX.1 */ | |
141 | #if defined (SIGCLD) | |
142 | ENTRY(SIGCLD, "SIGCLD", "Child status changed"), | |
143 | #endif | |
144 | #if defined (SIGCHLD) | |
145 | ENTRY(SIGCHLD, "SIGCHLD", "Child status changed"), | |
146 | #endif | |
147 | #if defined (SIGPWR) | |
148 | ENTRY(SIGPWR, "SIGPWR", "Power fail/restart"), | |
149 | #endif | |
150 | #if defined (SIGWINCH) | |
151 | ENTRY(SIGWINCH, "SIGWINCH", "Window size changed"), | |
152 | #endif | |
153 | #if defined (SIGURG) | |
154 | ENTRY(SIGURG, "SIGURG", "Urgent I/O condition"), | |
155 | #endif | |
156 | #if defined (SIGIO) | |
157 | /* "I/O pending" has also been suggested, but is misleading since the | |
158 | signal only happens when the process has asked for it, not everytime | |
159 | I/O is pending. */ | |
160 | ENTRY(SIGIO, "SIGIO", "I/O possible"), | |
161 | #endif | |
162 | #if defined (SIGPOLL) | |
163 | ENTRY(SIGPOLL, "SIGPOLL", "Pollable event occurred"), | |
164 | #endif | |
165 | #if defined (SIGSTOP) | |
166 | ENTRY(SIGSTOP, "SIGSTOP", "Stopped (signal)"), | |
167 | #endif | |
168 | #if defined (SIGTSTP) | |
169 | ENTRY(SIGTSTP, "SIGTSTP", "Stopped (user)"), | |
170 | #endif | |
171 | #if defined (SIGCONT) | |
172 | ENTRY(SIGCONT, "SIGCONT", "Continued"), | |
173 | #endif | |
174 | #if defined (SIGTTIN) | |
175 | ENTRY(SIGTTIN, "SIGTTIN", "Stopped (tty input)"), | |
176 | #endif | |
177 | #if defined (SIGTTOU) | |
178 | ENTRY(SIGTTOU, "SIGTTOU", "Stopped (tty output)"), | |
179 | #endif | |
180 | #if defined (SIGVTALRM) | |
181 | ENTRY(SIGVTALRM, "SIGVTALRM", "Virtual timer expired"), | |
182 | #endif | |
183 | #if defined (SIGPROF) | |
184 | ENTRY(SIGPROF, "SIGPROF", "Profiling timer expired"), | |
185 | #endif | |
186 | #if defined (SIGXCPU) | |
187 | ENTRY(SIGXCPU, "SIGXCPU", "CPU time limit exceeded"), | |
188 | #endif | |
189 | #if defined (SIGXFSZ) | |
190 | ENTRY(SIGXFSZ, "SIGXFSZ", "File size limit exceeded"), | |
191 | #endif | |
192 | #if defined (SIGWIND) | |
193 | ENTRY(SIGWIND, "SIGWIND", "SIGWIND"), | |
194 | #endif | |
195 | #if defined (SIGPHONE) | |
196 | ENTRY(SIGPHONE, "SIGPHONE", "SIGPHONE"), | |
197 | #endif | |
198 | #if defined (SIGLOST) | |
199 | ENTRY(SIGLOST, "SIGLOST", "Resource lost"), | |
200 | #endif | |
201 | #if defined (SIGWAITING) | |
202 | ENTRY(SIGWAITING, "SIGWAITING", "Process's LWPs are blocked"), | |
203 | #endif | |
204 | #if defined (SIGLWP) | |
205 | ENTRY(SIGLWP, "SIGLWP", "Signal LWP"), | |
206 | #endif | |
207 | #if defined (SIGDANGER) | |
208 | ENTRY(SIGDANGER, "SIGDANGER", "Swap space dangerously low"), | |
209 | #endif | |
210 | #if defined (SIGGRANT) | |
211 | ENTRY(SIGGRANT, "SIGGRANT", "Monitor mode granted"), | |
212 | #endif | |
213 | #if defined (SIGRETRACT) | |
214 | ENTRY(SIGRETRACT, "SIGRETRACT", "Need to relinguish monitor mode"), | |
215 | #endif | |
216 | #if defined (SIGMSG) | |
217 | ENTRY(SIGMSG, "SIGMSG", "Monitor mode data available"), | |
218 | #endif | |
219 | #if defined (SIGSOUND) | |
220 | ENTRY(SIGSOUND, "SIGSOUND", "Sound completed"), | |
221 | #endif | |
222 | #if defined (SIGSAK) | |
223 | ENTRY(SIGSAK, "SIGSAK", "Secure attention"), | |
224 | #endif | |
225 | ENTRY(0, NULL, NULL) | |
226 | }; | |
227 | ||
228 | /* Translation table allocated and initialized at runtime. Indexed by the | |
229 | signal value to find the equivalent symbolic value. */ | |
230 | ||
231 | static const char **signal_names; | |
232 | static int num_signal_names = 0; | |
233 | ||
234 | /* Translation table allocated and initialized at runtime, if it does not | |
235 | already exist in the host environment. Indexed by the signal value to find | |
236 | the descriptive string. | |
237 | ||
238 | We don't export it for use in other modules because even though it has the | |
239 | same name, it differs from other implementations in that it is dynamically | |
240 | initialized rather than statically initialized. */ | |
241 | ||
242 | #ifndef HAVE_SYS_SIGLIST | |
243 | ||
244 | static int sys_nsig; | |
245 | static const char **sys_siglist; | |
246 | ||
247 | #else | |
248 | ||
249 | #ifdef NSIG | |
250 | static int sys_nsig = NSIG; | |
251 | #else | |
252 | #ifdef _NSIG | |
253 | static int sys_nsig = _NSIG; | |
254 | #endif | |
255 | #endif | |
256 | extern const char * const sys_siglist[]; | |
257 | ||
258 | #endif | |
259 | ||
260 | ||
261 | /* | |
262 | ||
263 | NAME | |
264 | ||
265 | init_signal_tables -- initialize the name and message tables | |
266 | ||
267 | SYNOPSIS | |
268 | ||
269 | static void init_signal_tables (); | |
270 | ||
271 | DESCRIPTION | |
272 | ||
273 | Using the signal_table, which is initialized at compile time, generate | |
274 | the signal_names and the sys_siglist (if needed) tables, which are | |
275 | indexed at runtime by a specific signal value. | |
276 | ||
277 | BUGS | |
278 | ||
279 | The initialization of the tables may fail under low memory conditions, | |
280 | in which case we don't do anything particularly useful, but we don't | |
281 | bomb either. Who knows, it might succeed at a later point if we free | |
282 | some memory in the meantime. In any case, the other routines know | |
283 | how to deal with lack of a table after trying to initialize it. This | |
284 | may or may not be considered to be a bug, that we don't specifically | |
285 | warn about this particular failure mode. | |
286 | ||
287 | */ | |
288 | ||
289 | static void | |
290 | init_signal_tables () | |
291 | { | |
292 | const struct signal_info *eip; | |
293 | int nbytes; | |
294 | ||
295 | /* If we haven't already scanned the signal_table once to find the maximum | |
296 | signal value, then go find it now. */ | |
297 | ||
298 | if (num_signal_names == 0) | |
299 | { | |
300 | for (eip = signal_table; eip -> name != NULL; eip++) | |
301 | { | |
302 | if (eip -> value >= num_signal_names) | |
303 | { | |
304 | num_signal_names = eip -> value + 1; | |
305 | } | |
306 | } | |
307 | } | |
308 | ||
309 | /* Now attempt to allocate the signal_names table, zero it out, and then | |
310 | initialize it from the statically initialized signal_table. */ | |
311 | ||
312 | if (signal_names == NULL) | |
313 | { | |
314 | nbytes = num_signal_names * sizeof (char *); | |
315 | if ((signal_names = (const char **) malloc (nbytes)) != NULL) | |
316 | { | |
317 | memset (signal_names, 0, nbytes); | |
318 | for (eip = signal_table; eip -> name != NULL; eip++) | |
319 | { | |
320 | signal_names[eip -> value] = eip -> name; | |
321 | } | |
322 | } | |
323 | } | |
324 | ||
325 | #ifndef HAVE_SYS_SIGLIST | |
326 | ||
327 | /* Now attempt to allocate the sys_siglist table, zero it out, and then | |
328 | initialize it from the statically initialized signal_table. */ | |
329 | ||
330 | if (sys_siglist == NULL) | |
331 | { | |
332 | nbytes = num_signal_names * sizeof (char *); | |
333 | if ((sys_siglist = (const char **) malloc (nbytes)) != NULL) | |
334 | { | |
335 | memset (sys_siglist, 0, nbytes); | |
336 | sys_nsig = num_signal_names; | |
337 | for (eip = signal_table; eip -> name != NULL; eip++) | |
338 | { | |
339 | sys_siglist[eip -> value] = eip -> msg; | |
340 | } | |
341 | } | |
342 | } | |
343 | ||
344 | #endif | |
345 | ||
346 | } | |
347 | ||
348 | ||
349 | /* | |
350 | ||
351 | NAME | |
352 | ||
353 | signo_max -- return the max signo value | |
354 | ||
355 | SYNOPSIS | |
356 | ||
357 | int signo_max (); | |
358 | ||
359 | DESCRIPTION | |
360 | ||
361 | Returns the maximum signo value for which a corresponding symbolic | |
362 | name or message is available. Note that in the case where | |
363 | we use the sys_siglist supplied by the system, it is possible for | |
364 | there to be more symbolic names than messages, or vice versa. | |
365 | In fact, the manual page for psignal(3b) explicitly warns that one | |
366 | should check the size of the table (NSIG) before indexing it, | |
367 | since new signal codes may be added to the system before they are | |
368 | added to the table. Thus NSIG might be smaller than value | |
369 | implied by the largest signo value defined in <signal.h>. | |
370 | ||
371 | We return the maximum value that can be used to obtain a meaningful | |
372 | symbolic name or message. | |
373 | ||
374 | */ | |
375 | ||
376 | int | |
377 | signo_max () | |
378 | { | |
379 | int maxsize; | |
380 | ||
381 | if (signal_names == NULL) | |
382 | { | |
383 | init_signal_tables (); | |
384 | } | |
385 | maxsize = MAX (sys_nsig, num_signal_names); | |
386 | return (maxsize - 1); | |
387 | } | |
388 | ||
389 | ||
390 | /* | |
391 | ||
392 | NAME | |
393 | ||
394 | strsignal -- map a signal number to a signal message string | |
395 | ||
396 | SYNOPSIS | |
397 | ||
398 | const char *strsignal (int signo) | |
399 | ||
400 | DESCRIPTION | |
401 | ||
402 | Maps an signal number to an signal message string, the contents of | |
403 | which are implementation defined. On systems which have the external | |
404 | variable sys_siglist, these strings will be the same as the ones used | |
405 | by psignal(). | |
406 | ||
407 | If the supplied signal number is within the valid range of indices | |
408 | for the sys_siglist, but no message is available for the particular | |
409 | signal number, then returns the string "Signal NUM", where NUM is the | |
410 | signal number. | |
411 | ||
412 | If the supplied signal number is not a valid index into sys_siglist, | |
413 | returns NULL. | |
414 | ||
415 | The returned string is only guaranteed to be valid only until the | |
416 | next call to strsignal. | |
417 | ||
418 | */ | |
419 | ||
420 | #ifndef HAVE_STRSIGNAL | |
421 | ||
422 | const char * | |
423 | strsignal (signo) | |
424 | int signo; | |
425 | { | |
426 | const char *msg; | |
427 | static char buf[32]; | |
428 | ||
429 | #ifndef HAVE_SYS_SIGLIST | |
430 | ||
431 | if (signal_names == NULL) | |
432 | { | |
433 | init_signal_tables (); | |
434 | } | |
435 | ||
436 | #endif | |
437 | ||
438 | if ((signo < 0) || (signo >= sys_nsig)) | |
439 | { | |
440 | /* Out of range, just return NULL */ | |
441 | msg = NULL; | |
442 | } | |
443 | else if ((sys_siglist == NULL) || (sys_siglist[signo] == NULL)) | |
444 | { | |
445 | /* In range, but no sys_siglist or no entry at this index. */ | |
446 | sprintf (buf, "Signal %d", signo); | |
447 | msg = (const char *) buf; | |
448 | } | |
449 | else | |
450 | { | |
451 | /* In range, and a valid message. Just return the message. */ | |
452 | msg = (const char *) sys_siglist[signo]; | |
453 | } | |
454 | ||
455 | return (msg); | |
456 | } | |
457 | ||
458 | #endif /* ! HAVE_STRSIGNAL */ | |
459 | ||
460 | /* | |
461 | ||
462 | NAME | |
463 | ||
464 | strsigno -- map an signal number to a symbolic name string | |
465 | ||
466 | SYNOPSIS | |
467 | ||
468 | const char *strsigno (int signo) | |
469 | ||
470 | DESCRIPTION | |
471 | ||
472 | Given an signal number, returns a pointer to a string containing | |
473 | the symbolic name of that signal number, as found in <signal.h>. | |
474 | ||
475 | If the supplied signal number is within the valid range of indices | |
476 | for symbolic names, but no name is available for the particular | |
477 | signal number, then returns the string "Signal NUM", where NUM is | |
478 | the signal number. | |
479 | ||
480 | If the supplied signal number is not within the range of valid | |
481 | indices, then returns NULL. | |
482 | ||
483 | BUGS | |
484 | ||
485 | The contents of the location pointed to are only guaranteed to be | |
486 | valid until the next call to strsigno. | |
487 | ||
488 | */ | |
489 | ||
490 | const char * | |
491 | strsigno (signo) | |
492 | int signo; | |
493 | { | |
494 | const char *name; | |
495 | static char buf[32]; | |
496 | ||
497 | if (signal_names == NULL) | |
498 | { | |
499 | init_signal_tables (); | |
500 | } | |
501 | ||
502 | if ((signo < 0) || (signo >= num_signal_names)) | |
503 | { | |
504 | /* Out of range, just return NULL */ | |
505 | name = NULL; | |
506 | } | |
507 | else if ((signal_names == NULL) || (signal_names[signo] == NULL)) | |
508 | { | |
509 | /* In range, but no signal_names or no entry at this index. */ | |
510 | sprintf (buf, "Signal %d", signo); | |
511 | name = (const char *) buf; | |
512 | } | |
513 | else | |
514 | { | |
515 | /* In range, and a valid name. Just return the name. */ | |
516 | name = signal_names[signo]; | |
517 | } | |
518 | ||
519 | return (name); | |
520 | } | |
521 | ||
522 | ||
523 | /* | |
524 | ||
525 | NAME | |
526 | ||
527 | strtosigno -- map a symbolic signal name to a numeric value | |
528 | ||
529 | SYNOPSIS | |
530 | ||
531 | int strtosigno (char *name) | |
532 | ||
533 | DESCRIPTION | |
534 | ||
535 | Given the symbolic name of a signal, map it to a signal number. | |
536 | If no translation is found, returns 0. | |
537 | ||
538 | */ | |
539 | ||
540 | int | |
541 | strtosigno (name) | |
542 | const char *name; | |
543 | { | |
544 | int signo = 0; | |
545 | ||
546 | if (name != NULL) | |
547 | { | |
548 | if (signal_names == NULL) | |
549 | { | |
550 | init_signal_tables (); | |
551 | } | |
552 | for (signo = 0; signo < num_signal_names; signo++) | |
553 | { | |
554 | if ((signal_names[signo] != NULL) && | |
555 | (strcmp (name, signal_names[signo]) == 0)) | |
556 | { | |
557 | break; | |
558 | } | |
559 | } | |
560 | if (signo == num_signal_names) | |
561 | { | |
562 | signo = 0; | |
563 | } | |
564 | } | |
565 | return (signo); | |
566 | } | |
567 | ||
568 | ||
569 | /* | |
570 | ||
571 | NAME | |
572 | ||
573 | psignal -- print message about signal to stderr | |
574 | ||
575 | SYNOPSIS | |
576 | ||
577 | void psignal (unsigned signo, char *message); | |
578 | ||
579 | DESCRIPTION | |
580 | ||
581 | Print to the standard error the message, followed by a colon, | |
582 | followed by the description of the signal specified by signo, | |
583 | followed by a newline. | |
584 | */ | |
585 | ||
586 | #ifndef HAVE_PSIGNAL | |
587 | ||
588 | void | |
589 | psignal (signo, message) | |
590 | unsigned signo; | |
591 | char *message; | |
592 | { | |
593 | if (signal_names == NULL) | |
594 | { | |
595 | init_signal_tables (); | |
596 | } | |
597 | if ((signo <= 0) || (signo >= sys_nsig)) | |
598 | { | |
599 | fprintf (stderr, "%s: unknown signal\n", message); | |
600 | } | |
601 | else | |
602 | { | |
603 | fprintf (stderr, "%s: %s\n", message, sys_siglist[signo]); | |
604 | } | |
605 | } | |
606 | ||
607 | #endif /* ! HAVE_PSIGNAL */ | |
608 | ||
609 | ||
610 | /* A simple little main that does nothing but print all the signal translations | |
611 | if MAIN is defined and this file is compiled and linked. */ | |
612 | ||
613 | #ifdef MAIN | |
614 | ||
615 | #include <stdio.h> | |
616 | ||
617 | int | |
618 | main () | |
619 | { | |
620 | int signo; | |
621 | int maxsigno; | |
622 | const char *name; | |
623 | const char *msg; | |
624 | ||
625 | maxsigno = signo_max (); | |
626 | printf ("%d entries in names table.\n", num_signal_names); | |
627 | printf ("%d entries in messages table.\n", sys_nsig); | |
628 | printf ("%d is max useful index.\n", maxsigno); | |
629 | ||
630 | /* Keep printing values until we get to the end of *both* tables, not | |
631 | *either* table. Note that knowing the maximum useful index does *not* | |
632 | relieve us of the responsibility of testing the return pointer for | |
633 | NULL. */ | |
634 | ||
635 | for (signo = 0; signo <= maxsigno; signo++) | |
636 | { | |
637 | name = strsigno (signo); | |
638 | name = (name == NULL) ? "<NULL>" : name; | |
639 | msg = strsignal (signo); | |
640 | msg = (msg == NULL) ? "<NULL>" : msg; | |
641 | printf ("%-4d%-18s%s\n", signo, name, msg); | |
642 | } | |
643 | ||
644 | return 0; | |
645 | } | |
646 | ||
647 | #endif |