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