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 __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 #ifndef HAVE_SYS_SIGLIST
  68   const char *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
  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 #ifndef HAVE_SYS_SIGLIST
 240
 241 static int sys_nsig;
 242 static const char **sys_siglist;
 243
 244 #else
 245
 246 #ifdef NSIG
 247 static int sys_nsig = NSIG;
 248 #else
 249 #ifdef _NSIG
 250 static int sys_nsig = _NSIG;
 251 #endif
 252 #endif
 253 extern const char * const sys_siglist[];
 254
 255 #endif
 256
 257
 258 /*
 259
 260 NAME
 261
 262         init_signal_tables -- initialize the name and message tables
 263
 264 SYNOPSIS
 265
 266         static void init_signal_tables ();
 267
 268 DESCRIPTION
 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
 274 BUGS
 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
 286 static void
 287 init_signal_tables ()
 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 NAME
 349
 350         signo_max -- return the max signo value
 351
 352 SYNOPSIS
 353
 354         int signo_max ();
 355
 356 DESCRIPTION
 357
 358         Returns the maximum signo value for which a corresponding symbolic
 359         name or message is available.  Note that in the case where
 360         we use the sys_siglist supplied by the system, it is possible for
 361         there to be more symbolic names than messages, or vice versa.
 362         In fact, the manual page for psignal(3b) explicitly warns that one
 363         should check the size of the table (NSIG) before indexing it,
 364         since new signal codes may be added to the system before they are
 365         added to the table.  Thus NSIG might be smaller than value
 366         implied by the largest signo value defined in <signal.h>.
 367
 368         We return the maximum value that can be used to obtain a meaningful
 369         symbolic name or message.
 370
 371 */
 372
 373 int
 374 signo_max ()
 375 {
 376   int maxsize;
 377
 378   if (signal_names == NULL)
 379     {
 380       init_signal_tables ();
 381     }
 382   maxsize = MAX (sys_nsig, num_signal_names);
 383   return (maxsize - 1);
 384 }
 385
 386
 387 /*
 388
 389 NAME
 390
 391         strsignal -- map a signal number to a signal message string
 392
 393 SYNOPSIS
 394
 395         const char *strsignal (int signo)
 396
 397 DESCRIPTION
 398
 399         Maps an signal number to an signal message string, the contents of
 400         which are implementation defined.  On systems which have the external
 401         variable sys_siglist, these strings will be the same as the ones used
 402         by psignal().
 403
 404         If the supplied signal number is within the valid range of indices
 405         for the sys_siglist, but no message is available for the particular
 406         signal number, then returns the string "Signal NUM", where NUM is the
 407         signal number.
 408
 409         If the supplied signal number is not a valid index into sys_siglist,
 410         returns NULL.
 411
 412         The returned string is only guaranteed to be valid only until the
 413         next call to strsignal.
 414
 415 */
 416
 417 #ifndef HAVE_STRSIGNAL
 418
 419 const char *
 420 strsignal (signo)
 421   int signo;
 422 {
 423   const char *msg;
 424   static char buf[32];
 425
 426 #ifndef HAVE_SYS_SIGLIST
 427
 428   if (signal_names == NULL)
 429     {
 430       init_signal_tables ();
 431     }
 432
 433 #endif
 434
 435   if ((signo < 0) || (signo >= sys_nsig))
 436     {
 437       /* Out of range, just return NULL */
 438       msg = NULL;
 439     }
 440   else if ((sys_siglist == NULL) || (sys_siglist[signo] == NULL))
 441     {
 442       /* In range, but no sys_siglist or no entry at this index. */
 443       sprintf (buf, "Signal %d", signo);
 444       msg = (const char *) buf;
 445     }
 446   else
 447     {
 448       /* In range, and a valid message.  Just return the message. */
 449       msg = (const char *) sys_siglist[signo];
 450     }
 451
 452   return (msg);
 453 }
 454
 455 #endif /* ! HAVE_STRSIGNAL */
 456
 457 /*
 458
 459 NAME
 460
 461         strsigno -- map an signal number to a symbolic name string
 462
 463 SYNOPSIS
 464
 465         const char *strsigno (int signo)
 466
 467 DESCRIPTION
 468
 469         Given an signal number, returns a pointer to a string containing
 470         the symbolic name of that signal number, as found in <signal.h>.
 471
 472         If the supplied signal number is within the valid range of indices
 473         for symbolic names, but no name is available for the particular
 474         signal number, then returns the string "Signal NUM", where NUM is
 475         the signal number.
 476
 477         If the supplied signal number is not within the range of valid
 478         indices, then returns NULL.
 479
 480 BUGS
 481
 482         The contents of the location pointed to are only guaranteed to be
 483         valid until the next call to strsigno.
 484
 485 */
 486
 487 const char *
 488 strsigno (signo)
 489   int signo;
 490 {
 491   const char *name;
 492   static char buf[32];
 493
 494   if (signal_names == NULL)
 495     {
 496       init_signal_tables ();
 497     }
 498
 499   if ((signo < 0) || (signo >= num_signal_names))
 500     {
 501       /* Out of range, just return NULL */
 502       name = NULL;
 503     }
 504   else if ((signal_names == NULL) || (signal_names[signo] == NULL))
 505     {
 506       /* In range, but no signal_names or no entry at this index. */
 507       sprintf (buf, "Signal %d", signo);
 508       name = (const char *) buf;
 509     }
 510   else
 511     {
 512       /* In range, and a valid name.  Just return the name. */
 513       name = signal_names[signo];
 514     }
 515
 516   return (name);
 517 }
 518
 519
 520 /*
 521
 522 NAME
 523
 524         strtosigno -- map a symbolic signal name to a numeric value
 525
 526 SYNOPSIS
 527
 528         int strtosigno (char *name)
 529
 530 DESCRIPTION
 531
 532         Given the symbolic name of a signal, map it to a signal number.
 533         If no translation is found, returns 0.
 534
 535 */
 536
 537 int
 538 strtosigno (name)
 539      const char *name;
 540 {
 541   int signo = 0;
 542
 543   if (name != NULL)
 544     {
 545       if (signal_names == NULL)
 546         {
 547           init_signal_tables ();
 548         }
 549       for (signo = 0; signo < num_signal_names; signo++)
 550         {
 551           if ((signal_names[signo] != NULL) &&
 552               (strcmp (name, signal_names[signo]) == 0))
 553             {
 554               break;
 555             }
 556         }
 557       if (signo == num_signal_names)
 558         {
 559           signo = 0;
 560         }
 561     }
 562   return (signo);
 563 }
 564
 565
 566 /*
 567
 568 NAME
 569
 570         psignal -- print message about signal to stderr
 571
 572 SYNOPSIS
 573
 574         void psignal (unsigned signo, char *message);
 575
 576 DESCRIPTION
 577
 578         Print to the standard error the message, followed by a colon,
 579         followed by the description of the signal specified by signo,
 580         followed by a newline.
 581 */
 582
 583 #ifndef HAVE_PSIGNAL
 584
 585 void
 586 psignal (signo, message)
 587   unsigned signo;
 588   char *message;
 589 {
 590   if (signal_names == NULL)
 591     {
 592       init_signal_tables ();
 593     }
 594   if ((signo <= 0) || (signo >= sys_nsig))
 595     {
 596       fprintf (stderr, "%s: unknown signal\n", message);
 597     }
 598   else
 599     {
 600       fprintf (stderr, "%s: %s\n", message, sys_siglist[signo]);
 601     }
 602 }
 603
 604 #endif  /* ! HAVE_PSIGNAL */
 605
 606
 607 /* A simple little main that does nothing but print all the signal translations
 608    if MAIN is defined and this file is compiled and linked. */
 609
 610 #ifdef MAIN
 611
 612 #include <stdio.h>
 613
 614 int
 615 main ()
 616 {
 617   int signo;
 618   int maxsigno;
 619   const char *name;
 620   const char *msg;
 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   return 0;
 642 }
 643
 644 #endif