libiberty/strsignal.c

   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 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
  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