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