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 "config.h"
6#include "ansidecl.h"
7#include "libiberty.h"
8
9/* We need to declare sys_siglist, because even if the system provides
10   it we can't assume that it is declared in <signal.h> (for example,
11   SunOS provides sys_siglist, but it does not declare it in any
12   header file).  However, we can't declare sys_siglist portably,
13   because on some systems it is declared with const and on some
14   systems it is declared without const.  If we were using autoconf,
15   we could work out the right declaration.  Until, then we just
16   ignore any declaration in the system header files, and always
17   declare it ourselves.  With luck, this will always work.  */
18#define sys_siglist no_such_symbol
19#define sys_nsig sys_nsig__no_such_symbol
20
21#include <stdio.h>
22#include <signal.h>
23
24/*  Routines imported from standard C runtime libraries. */
25
26#ifdef HAVE_STDLIB_H
27#include <stdlib.h>
28#else
29extern PTR malloc ();
30#endif
31
32#ifdef HAVE_STRING_H
33#include <string.h>
34#else
35extern PTR memset ();
36#endif
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#undef sys_nsig
42
43#ifndef NULL
44#  define NULL (void *) 0
45#endif
46
47#ifndef MAX
48#  define MAX(a,b) ((a) > (b) ? (a) : (b))
49#endif
50
51static void init_signal_tables (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
63struct signal_info
64{
65  const int value;		/* The numeric value from <signal.h> */
66  const char *const name;	/* The equivalent symbolic value */
67#ifndef HAVE_SYS_SIGLIST
68  const char *const msg;	/* Short message about this value */
69#endif
70};
71
72#ifndef HAVE_SYS_SIGLIST
73#   define ENTRY(value, name, msg)	{value, name, msg}
74#else
75#   define ENTRY(value, name, msg)	{value, name}
76#endif
77
78static 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
228static const char **signal_names;
229static 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#ifndef HAVE_SYS_SIGLIST
240
241static int sys_nsig;
242static const char **sys_siglist;
243
244#else
245
246#ifdef NSIG
247static int sys_nsig = NSIG;
248#else
249#ifdef _NSIG
250static int sys_nsig = _NSIG;
251#endif
252#endif
253extern const char * const sys_siglist[];
254
255#endif
256
257
258/*
259
260NAME
261
262	init_signal_tables -- initialize the name and message tables
263
264SYNOPSIS
265
266	static void init_signal_tables ();
267
268DESCRIPTION
269
270	Using the signal_table, which is initialized at compile time, generate
271	the signal_names and the sys_siglist (if needed) tables, which are
272	indexed at runtime by a specific signal value.
273
274BUGS
275
276	The initialization of the tables may fail under low memory conditions,
277	in which case we don't do anything particularly useful, but we don't
278	bomb either.  Who knows, it might succeed at a later point if we free
279	some memory in the meantime.  In any case, the other routines know
280	how to deal with lack of a table after trying to initialize it.  This
281	may or may not be considered to be a bug, that we don't specifically
282	warn about this particular failure mode.
283
284*/
285
286static void
287init_signal_tables (void)
288{
289  const struct signal_info *eip;
290  int nbytes;
291
292  /* If we haven't already scanned the signal_table once to find the maximum
293     signal value, then go find it now. */
294
295  if (num_signal_names == 0)
296    {
297      for (eip = signal_table; eip -> name != NULL; eip++)
298	{
299	  if (eip -> value >= num_signal_names)
300	    {
301	      num_signal_names = eip -> value + 1;
302	    }
303	}
304    }
305
306  /* Now attempt to allocate the signal_names table, zero it out, and then
307     initialize it from the statically initialized signal_table. */
308
309  if (signal_names == NULL)
310    {
311      nbytes = num_signal_names * sizeof (char *);
312      if ((signal_names = (const char **) malloc (nbytes)) != NULL)
313	{
314	  memset (signal_names, 0, nbytes);
315	  for (eip = signal_table; eip -> name != NULL; eip++)
316	    {
317	      signal_names[eip -> value] = eip -> name;
318	    }
319	}
320    }
321
322#ifndef HAVE_SYS_SIGLIST
323
324  /* Now attempt to allocate the sys_siglist table, zero it out, and then
325     initialize it from the statically initialized signal_table. */
326
327  if (sys_siglist == NULL)
328    {
329      nbytes = num_signal_names * sizeof (char *);
330      if ((sys_siglist = (const char **) malloc (nbytes)) != NULL)
331	{
332	  memset (sys_siglist, 0, nbytes);
333	  sys_nsig = num_signal_names;
334	  for (eip = signal_table; eip -> name != NULL; eip++)
335	    {
336	      sys_siglist[eip -> value] = eip -> msg;
337	    }
338	}
339    }
340
341#endif
342
343}
344
345
346/*
347
348@deftypefn Extension int signo_max (void)
349
350Returns the maximum signal value for which a corresponding symbolic
351name or message is available.  Note that in the case where we use the
352@code{sys_siglist} supplied by the system, it is possible for there to
353be more symbolic names than messages, or vice versa.  In fact, the
354manual page for @code{psignal(3b)} explicitly warns that one should
355check the size of the table (@code{NSIG}) before indexing it, since
356new signal codes may be added to the system before they are added to
357the table.  Thus @code{NSIG} might be smaller than value implied by
358the largest signo value defined in @code{<signal.h>}.
359
360We return the maximum value that can be used to obtain a meaningful
361symbolic name or message.
362
363@end deftypefn
364
365*/
366
367int
368signo_max (void)
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@deftypefn Supplemental {const char *} strsignal (int @var{signo})
384
385Maps an signal number to an signal message string, the contents of
386which are implementation defined.  On systems which have the external
387variable @code{sys_siglist}, these strings will be the same as the
388ones used by @code{psignal()}.
389
390If the supplied signal number is within the valid range of indices for
391the @code{sys_siglist}, but no message is available for the particular
392signal number, then returns the string @samp{Signal @var{num}}, where
393@var{num} is the signal number.
394
395If the supplied signal number is not a valid index into
396@code{sys_siglist}, returns @code{NULL}.
397
398The returned string is only guaranteed to be valid only until the next
399call to @code{strsignal}.
400
401@end deftypefn
402
403*/
404
405#ifndef HAVE_STRSIGNAL
406
407const char *
408strsignal (int signo)
409{
410  const char *msg;
411  static char buf[32];
412
413#ifndef HAVE_SYS_SIGLIST
414
415  if (signal_names == NULL)
416    {
417      init_signal_tables ();
418    }
419
420#endif
421
422  if ((signo < 0) || (signo >= sys_nsig))
423    {
424      /* Out of range, just return NULL */
425      msg = NULL;
426    }
427  else if ((sys_siglist == NULL) || (sys_siglist[signo] == NULL))
428    {
429      /* In range, but no sys_siglist or no entry at this index. */
430      sprintf (buf, "Signal %d", signo);
431      msg = (const char *) buf;
432    }
433  else
434    {
435      /* In range, and a valid message.  Just return the message. */
436      msg = (const char *) sys_siglist[signo];
437    }
438
439  return (msg);
440}
441
442#endif /* ! HAVE_STRSIGNAL */
443
444/*
445
446@deftypefn Extension {const char*} strsigno (int @var{signo})
447
448Given an signal number, returns a pointer to a string containing the
449symbolic name of that signal number, as found in @code{<signal.h>}.
450
451If the supplied signal number is within the valid range of indices for
452symbolic names, but no name is available for the particular signal
453number, then returns the string @samp{Signal @var{num}}, where
454@var{num} is the signal number.
455
456If the supplied signal number is not within the range of valid
457indices, then returns @code{NULL}.
458
459The contents of the location pointed to are only guaranteed to be
460valid until the next call to @code{strsigno}.
461
462@end deftypefn
463
464*/
465
466const char *
467strsigno (int signo)
468{
469  const char *name;
470  static char buf[32];
471
472  if (signal_names == NULL)
473    {
474      init_signal_tables ();
475    }
476
477  if ((signo < 0) || (signo >= num_signal_names))
478    {
479      /* Out of range, just return NULL */
480      name = NULL;
481    }
482  else if ((signal_names == NULL) || (signal_names[signo] == NULL))
483    {
484      /* In range, but no signal_names or no entry at this index. */
485      sprintf (buf, "Signal %d", signo);
486      name = (const char *) buf;
487    }
488  else
489    {
490      /* In range, and a valid name.  Just return the name. */
491      name = signal_names[signo];
492    }
493
494  return (name);
495}
496
497
498/*
499
500@deftypefn Extension int strtosigno (const char *@var{name})
501
502Given the symbolic name of a signal, map it to a signal number.  If no
503translation is found, returns 0.
504
505@end deftypefn
506
507*/
508
509int
510strtosigno (const char *name)
511{
512  int signo = 0;
513
514  if (name != NULL)
515    {
516      if (signal_names == NULL)
517	{
518	  init_signal_tables ();
519	}
520      for (signo = 0; signo < num_signal_names; signo++)
521	{
522	  if ((signal_names[signo] != NULL) &&
523	      (strcmp (name, signal_names[signo]) == 0))
524	    {
525	      break;
526	    }
527	}
528      if (signo == num_signal_names)
529	{
530	  signo = 0;
531	}
532    }
533  return (signo);
534}
535
536
537/*
538
539@deftypefn Supplemental void psignal (int @var{signo}, char *@var{message})
540
541Print @var{message} to the standard error, followed by a colon,
542followed by the description of the signal specified by @var{signo},
543followed by a newline.
544
545@end deftypefn
546
547*/
548
549#ifndef HAVE_PSIGNAL
550
551void
552psignal (int signo, char *message)
553{
554  if (signal_names == NULL)
555    {
556      init_signal_tables ();
557    }
558  if ((signo <= 0) || (signo >= sys_nsig))
559    {
560      fprintf (stderr, "%s: unknown signal\n", message);
561    }
562  else
563    {
564      fprintf (stderr, "%s: %s\n", message, sys_siglist[signo]);
565    }
566}
567
568#endif	/* ! HAVE_PSIGNAL */
569
570
571/* A simple little main that does nothing but print all the signal translations
572   if MAIN is defined and this file is compiled and linked. */
573
574#ifdef MAIN
575
576#include <stdio.h>
577
578int
579main (void)
580{
581  int signo;
582  int maxsigno;
583  const char *name;
584  const char *msg;
585
586  maxsigno = signo_max ();
587  printf ("%d entries in names table.\n", num_signal_names);
588  printf ("%d entries in messages table.\n", sys_nsig);
589  printf ("%d is max useful index.\n", maxsigno);
590
591  /* Keep printing values until we get to the end of *both* tables, not
592     *either* table.  Note that knowing the maximum useful index does *not*
593     relieve us of the responsibility of testing the return pointer for
594     NULL. */
595
596  for (signo = 0; signo <= maxsigno; signo++)
597    {
598      name = strsigno (signo);
599      name = (name == NULL) ? "<NULL>" : name;
600      msg = strsignal (signo);
601      msg = (msg == NULL) ? "<NULL>" : msg;
602      printf ("%-4d%-18s%s\n", signo, name, msg);
603    }
604
605  return 0;
606}
607
608#endif
609