libiberty/strerror.c

   1 /* Extended support for using errno values.
   2    Written by Fred Fish.  fnf@cygnus.com
   3    This file is in the public domain.  --Per Bothner.  */
   4
   5 #include "ansidecl.h"
   6 #include "libiberty.h"
   7
   8 #include "config.h"
   9
  10 #ifdef HAVE_SYS_ERRLIST
  11 /* Note that errno.h (not sure what OS) or stdio.h (BSD 4.4, at least)
  12    might declare sys_errlist in a way that the compiler might consider
  13    incompatible with our later declaration, perhaps by using const
  14    attributes.  So we hide the declaration in errno.h (if any) using a
  15    macro. */
  16 #define sys_errlist sys_errlist__
  17 #endif
  18
  19 #include <stdio.h>
  20 #include <errno.h>
  21
  22 #ifdef HAVE_SYS_ERRLIST
  23 #undef sys_errlist
  24 #endif
  25
  26 /*  Routines imported from standard C runtime libraries. */
  27
  28 #ifdef HAVE_STDLIB_H
  29 #include <stdlib.h>
  30 #else
  31 extern PTR malloc ();
  32 #endif
  33
  34 #ifdef HAVE_STRING_H
  35 #include <string.h>
  36 #else
  37 extern PTR memset ();
  38 #endif
  39
  40 #ifndef MAX
  41 #  define MAX(a,b) ((a) > (b) ? (a) : (b))
  42 #endif
  43
  44 static void init_error_tables PARAMS ((void));
  45
  46 /* Translation table for errno values.  See intro(2) in most UNIX systems
  47    Programmers Reference Manuals.
  48
  49    Note that this table is generally only accessed when it is used at runtime
  50    to initialize errno name and message tables that are indexed by errno
  51    value.
  52
  53    Not all of these errnos will exist on all systems.  This table is the only
  54    thing that should have to be updated as new error numbers are introduced.
  55    It's sort of ugly, but at least its portable. */
  56
  57 struct error_info
  58 {
  59   int value;            /* The numeric value from <errno.h> */
  60   const char *name;     /* The equivalent symbolic value */
  61 #ifndef HAVE_SYS_ERRLIST
  62   const char *msg;      /* Short message about this value */
  63 #endif
  64 };
  65
  66 #ifndef HAVE_SYS_ERRLIST
  67 #   define ENTRY(value, name, msg)      {value, name, msg}
  68 #else
  69 #   define ENTRY(value, name, msg)      {value, name}
  70 #endif
  71
  72 static const struct error_info error_table[] =
  73 {
  74 #if defined (EPERM)
  75   ENTRY(EPERM, "EPERM", "Not owner"),
  76 #endif
  77 #if defined (ENOENT)
  78   ENTRY(ENOENT, "ENOENT", "No such file or directory"),
  79 #endif
  80 #if defined (ESRCH)
  81   ENTRY(ESRCH, "ESRCH", "No such process"),
  82 #endif
  83 #if defined (EINTR)
  84   ENTRY(EINTR, "EINTR", "Interrupted system call"),
  85 #endif
  86 #if defined (EIO)
  87   ENTRY(EIO, "EIO", "I/O error"),
  88 #endif
  89 #if defined (ENXIO)
  90   ENTRY(ENXIO, "ENXIO", "No such device or address"),
  91 #endif
  92 #if defined (E2BIG)
  93   ENTRY(E2BIG, "E2BIG", "Arg list too long"),
  94 #endif
  95 #if defined (ENOEXEC)
  96   ENTRY(ENOEXEC, "ENOEXEC", "Exec format error"),
  97 #endif
  98 #if defined (EBADF)
  99   ENTRY(EBADF, "EBADF", "Bad file number"),
 100 #endif
 101 #if defined (ECHILD)
 102   ENTRY(ECHILD, "ECHILD", "No child processes"),
 103 #endif
 104 #if defined (EWOULDBLOCK)       /* Put before EAGAIN, sometimes aliased */
 105   ENTRY(EWOULDBLOCK, "EWOULDBLOCK", "Operation would block"),
 106 #endif
 107 #if defined (EAGAIN)
 108   ENTRY(EAGAIN, "EAGAIN", "No more processes"),
 109 #endif
 110 #if defined (ENOMEM)
 111   ENTRY(ENOMEM, "ENOMEM", "Not enough space"),
 112 #endif
 113 #if defined (EACCES)
 114   ENTRY(EACCES, "EACCES", "Permission denied"),
 115 #endif
 116 #if defined (EFAULT)
 117   ENTRY(EFAULT, "EFAULT", "Bad address"),
 118 #endif
 119 #if defined (ENOTBLK)
 120   ENTRY(ENOTBLK, "ENOTBLK", "Block device required"),
 121 #endif
 122 #if defined (EBUSY)
 123   ENTRY(EBUSY, "EBUSY", "Device busy"),
 124 #endif
 125 #if defined (EEXIST)
 126   ENTRY(EEXIST, "EEXIST", "File exists"),
 127 #endif
 128 #if defined (EXDEV)
 129   ENTRY(EXDEV, "EXDEV", "Cross-device link"),
 130 #endif
 131 #if defined (ENODEV)
 132   ENTRY(ENODEV, "ENODEV", "No such device"),
 133 #endif
 134 #if defined (ENOTDIR)
 135   ENTRY(ENOTDIR, "ENOTDIR", "Not a directory"),
 136 #endif
 137 #if defined (EISDIR)
 138   ENTRY(EISDIR, "EISDIR", "Is a directory"),
 139 #endif
 140 #if defined (EINVAL)
 141   ENTRY(EINVAL, "EINVAL", "Invalid argument"),
 142 #endif
 143 #if defined (ENFILE)
 144   ENTRY(ENFILE, "ENFILE", "File table overflow"),
 145 #endif
 146 #if defined (EMFILE)
 147   ENTRY(EMFILE, "EMFILE", "Too many open files"),
 148 #endif
 149 #if defined (ENOTTY)
 150   ENTRY(ENOTTY, "ENOTTY", "Not a typewriter"),
 151 #endif
 152 #if defined (ETXTBSY)
 153   ENTRY(ETXTBSY, "ETXTBSY", "Text file busy"),
 154 #endif
 155 #if defined (EFBIG)
 156   ENTRY(EFBIG, "EFBIG", "File too large"),
 157 #endif
 158 #if defined (ENOSPC)
 159   ENTRY(ENOSPC, "ENOSPC", "No space left on device"),
 160 #endif
 161 #if defined (ESPIPE)
 162   ENTRY(ESPIPE, "ESPIPE", "Illegal seek"),
 163 #endif
 164 #if defined (EROFS)
 165   ENTRY(EROFS, "EROFS", "Read-only file system"),
 166 #endif
 167 #if defined (EMLINK)
 168   ENTRY(EMLINK, "EMLINK", "Too many links"),
 169 #endif
 170 #if defined (EPIPE)
 171   ENTRY(EPIPE, "EPIPE", "Broken pipe"),
 172 #endif
 173 #if defined (EDOM)
 174   ENTRY(EDOM, "EDOM", "Math argument out of domain of func"),
 175 #endif
 176 #if defined (ERANGE)
 177   ENTRY(ERANGE, "ERANGE", "Math result not representable"),
 178 #endif
 179 #if defined (ENOMSG)
 180   ENTRY(ENOMSG, "ENOMSG", "No message of desired type"),
 181 #endif
 182 #if defined (EIDRM)
 183   ENTRY(EIDRM, "EIDRM", "Identifier removed"),
 184 #endif
 185 #if defined (ECHRNG)
 186   ENTRY(ECHRNG, "ECHRNG", "Channel number out of range"),
 187 #endif
 188 #if defined (EL2NSYNC)
 189   ENTRY(EL2NSYNC, "EL2NSYNC", "Level 2 not synchronized"),
 190 #endif
 191 #if defined (EL3HLT)
 192   ENTRY(EL3HLT, "EL3HLT", "Level 3 halted"),
 193 #endif
 194 #if defined (EL3RST)
 195   ENTRY(EL3RST, "EL3RST", "Level 3 reset"),
 196 #endif
 197 #if defined (ELNRNG)
 198   ENTRY(ELNRNG, "ELNRNG", "Link number out of range"),
 199 #endif
 200 #if defined (EUNATCH)
 201   ENTRY(EUNATCH, "EUNATCH", "Protocol driver not attached"),
 202 #endif
 203 #if defined (ENOCSI)
 204   ENTRY(ENOCSI, "ENOCSI", "No CSI structure available"),
 205 #endif
 206 #if defined (EL2HLT)
 207   ENTRY(EL2HLT, "EL2HLT", "Level 2 halted"),
 208 #endif
 209 #if defined (EDEADLK)
 210   ENTRY(EDEADLK, "EDEADLK", "Deadlock condition"),
 211 #endif
 212 #if defined (ENOLCK)
 213   ENTRY(ENOLCK, "ENOLCK", "No record locks available"),
 214 #endif
 215 #if defined (EBADE)
 216   ENTRY(EBADE, "EBADE", "Invalid exchange"),
 217 #endif
 218 #if defined (EBADR)
 219   ENTRY(EBADR, "EBADR", "Invalid request descriptor"),
 220 #endif
 221 #if defined (EXFULL)
 222   ENTRY(EXFULL, "EXFULL", "Exchange full"),
 223 #endif
 224 #if defined (ENOANO)
 225   ENTRY(ENOANO, "ENOANO", "No anode"),
 226 #endif
 227 #if defined (EBADRQC)
 228   ENTRY(EBADRQC, "EBADRQC", "Invalid request code"),
 229 #endif
 230 #if defined (EBADSLT)
 231   ENTRY(EBADSLT, "EBADSLT", "Invalid slot"),
 232 #endif
 233 #if defined (EDEADLOCK)
 234   ENTRY(EDEADLOCK, "EDEADLOCK", "File locking deadlock error"),
 235 #endif
 236 #if defined (EBFONT)
 237   ENTRY(EBFONT, "EBFONT", "Bad font file format"),
 238 #endif
 239 #if defined (ENOSTR)
 240   ENTRY(ENOSTR, "ENOSTR", "Device not a stream"),
 241 #endif
 242 #if defined (ENODATA)
 243   ENTRY(ENODATA, "ENODATA", "No data available"),
 244 #endif
 245 #if defined (ETIME)
 246   ENTRY(ETIME, "ETIME", "Timer expired"),
 247 #endif
 248 #if defined (ENOSR)
 249   ENTRY(ENOSR, "ENOSR", "Out of streams resources"),
 250 #endif
 251 #if defined (ENONET)
 252   ENTRY(ENONET, "ENONET", "Machine is not on the network"),
 253 #endif
 254 #if defined (ENOPKG)
 255   ENTRY(ENOPKG, "ENOPKG", "Package not installed"),
 256 #endif
 257 #if defined (EREMOTE)
 258   ENTRY(EREMOTE, "EREMOTE", "Object is remote"),
 259 #endif
 260 #if defined (ENOLINK)
 261   ENTRY(ENOLINK, "ENOLINK", "Link has been severed"),
 262 #endif
 263 #if defined (EADV)
 264   ENTRY(EADV, "EADV", "Advertise error"),
 265 #endif
 266 #if defined (ESRMNT)
 267   ENTRY(ESRMNT, "ESRMNT", "Srmount error"),
 268 #endif
 269 #if defined (ECOMM)
 270   ENTRY(ECOMM, "ECOMM", "Communication error on send"),
 271 #endif
 272 #if defined (EPROTO)
 273   ENTRY(EPROTO, "EPROTO", "Protocol error"),
 274 #endif
 275 #if defined (EMULTIHOP)
 276   ENTRY(EMULTIHOP, "EMULTIHOP", "Multihop attempted"),
 277 #endif
 278 #if defined (EDOTDOT)
 279   ENTRY(EDOTDOT, "EDOTDOT", "RFS specific error"),
 280 #endif
 281 #if defined (EBADMSG)
 282   ENTRY(EBADMSG, "EBADMSG", "Not a data message"),
 283 #endif
 284 #if defined (ENAMETOOLONG)
 285   ENTRY(ENAMETOOLONG, "ENAMETOOLONG", "File name too long"),
 286 #endif
 287 #if defined (EOVERFLOW)
 288   ENTRY(EOVERFLOW, "EOVERFLOW", "Value too large for defined data type"),
 289 #endif
 290 #if defined (ENOTUNIQ)
 291   ENTRY(ENOTUNIQ, "ENOTUNIQ", "Name not unique on network"),
 292 #endif
 293 #if defined (EBADFD)
 294   ENTRY(EBADFD, "EBADFD", "File descriptor in bad state"),
 295 #endif
 296 #if defined (EREMCHG)
 297   ENTRY(EREMCHG, "EREMCHG", "Remote address changed"),
 298 #endif
 299 #if defined (ELIBACC)
 300   ENTRY(ELIBACC, "ELIBACC", "Can not access a needed shared library"),
 301 #endif
 302 #if defined (ELIBBAD)
 303   ENTRY(ELIBBAD, "ELIBBAD", "Accessing a corrupted shared library"),
 304 #endif
 305 #if defined (ELIBSCN)
 306   ENTRY(ELIBSCN, "ELIBSCN", ".lib section in a.out corrupted"),
 307 #endif
 308 #if defined (ELIBMAX)
 309   ENTRY(ELIBMAX, "ELIBMAX", "Attempting to link in too many shared libraries"),
 310 #endif
 311 #if defined (ELIBEXEC)
 312   ENTRY(ELIBEXEC, "ELIBEXEC", "Cannot exec a shared library directly"),
 313 #endif
 314 #if defined (EILSEQ)
 315   ENTRY(EILSEQ, "EILSEQ", "Illegal byte sequence"),
 316 #endif
 317 #if defined (ENOSYS)
 318   ENTRY(ENOSYS, "ENOSYS", "Operation not applicable"),
 319 #endif
 320 #if defined (ELOOP)
 321   ENTRY(ELOOP, "ELOOP", "Too many symbolic links encountered"),
 322 #endif
 323 #if defined (ERESTART)
 324   ENTRY(ERESTART, "ERESTART", "Interrupted system call should be restarted"),
 325 #endif
 326 #if defined (ESTRPIPE)
 327   ENTRY(ESTRPIPE, "ESTRPIPE", "Streams pipe error"),
 328 #endif
 329 #if defined (ENOTEMPTY)
 330   ENTRY(ENOTEMPTY, "ENOTEMPTY", "Directory not empty"),
 331 #endif
 332 #if defined (EUSERS)
 333   ENTRY(EUSERS, "EUSERS", "Too many users"),
 334 #endif
 335 #if defined (ENOTSOCK)
 336   ENTRY(ENOTSOCK, "ENOTSOCK", "Socket operation on non-socket"),
 337 #endif
 338 #if defined (EDESTADDRREQ)
 339   ENTRY(EDESTADDRREQ, "EDESTADDRREQ", "Destination address required"),
 340 #endif
 341 #if defined (EMSGSIZE)
 342   ENTRY(EMSGSIZE, "EMSGSIZE", "Message too long"),
 343 #endif
 344 #if defined (EPROTOTYPE)
 345   ENTRY(EPROTOTYPE, "EPROTOTYPE", "Protocol wrong type for socket"),
 346 #endif
 347 #if defined (ENOPROTOOPT)
 348   ENTRY(ENOPROTOOPT, "ENOPROTOOPT", "Protocol not available"),
 349 #endif
 350 #if defined (EPROTONOSUPPORT)
 351   ENTRY(EPROTONOSUPPORT, "EPROTONOSUPPORT", "Protocol not supported"),
 352 #endif
 353 #if defined (ESOCKTNOSUPPORT)
 354   ENTRY(ESOCKTNOSUPPORT, "ESOCKTNOSUPPORT", "Socket type not supported"),
 355 #endif
 356 #if defined (EOPNOTSUPP)
 357   ENTRY(EOPNOTSUPP, "EOPNOTSUPP", "Operation not supported on transport endpoint"),
 358 #endif
 359 #if defined (EPFNOSUPPORT)
 360   ENTRY(EPFNOSUPPORT, "EPFNOSUPPORT", "Protocol family not supported"),
 361 #endif
 362 #if defined (EAFNOSUPPORT)
 363   ENTRY(EAFNOSUPPORT, "EAFNOSUPPORT", "Address family not supported by protocol"),
 364 #endif
 365 #if defined (EADDRINUSE)
 366   ENTRY(EADDRINUSE, "EADDRINUSE", "Address already in use"),
 367 #endif
 368 #if defined (EADDRNOTAVAIL)
 369   ENTRY(EADDRNOTAVAIL, "EADDRNOTAVAIL","Cannot assign requested address"),
 370 #endif
 371 #if defined (ENETDOWN)
 372   ENTRY(ENETDOWN, "ENETDOWN", "Network is down"),
 373 #endif
 374 #if defined (ENETUNREACH)
 375   ENTRY(ENETUNREACH, "ENETUNREACH", "Network is unreachable"),
 376 #endif
 377 #if defined (ENETRESET)
 378   ENTRY(ENETRESET, "ENETRESET", "Network dropped connection because of reset"),
 379 #endif
 380 #if defined (ECONNABORTED)
 381   ENTRY(ECONNABORTED, "ECONNABORTED", "Software caused connection abort"),
 382 #endif
 383 #if defined (ECONNRESET)
 384   ENTRY(ECONNRESET, "ECONNRESET", "Connection reset by peer"),
 385 #endif
 386 #if defined (ENOBUFS)
 387   ENTRY(ENOBUFS, "ENOBUFS", "No buffer space available"),
 388 #endif
 389 #if defined (EISCONN)
 390   ENTRY(EISCONN, "EISCONN", "Transport endpoint is already connected"),
 391 #endif
 392 #if defined (ENOTCONN)
 393   ENTRY(ENOTCONN, "ENOTCONN", "Transport endpoint is not connected"),
 394 #endif
 395 #if defined (ESHUTDOWN)
 396   ENTRY(ESHUTDOWN, "ESHUTDOWN", "Cannot send after transport endpoint shutdown"),
 397 #endif
 398 #if defined (ETOOMANYREFS)
 399   ENTRY(ETOOMANYREFS, "ETOOMANYREFS", "Too many references: cannot splice"),
 400 #endif
 401 #if defined (ETIMEDOUT)
 402   ENTRY(ETIMEDOUT, "ETIMEDOUT", "Connection timed out"),
 403 #endif
 404 #if defined (ECONNREFUSED)
 405   ENTRY(ECONNREFUSED, "ECONNREFUSED", "Connection refused"),
 406 #endif
 407 #if defined (EHOSTDOWN)
 408   ENTRY(EHOSTDOWN, "EHOSTDOWN", "Host is down"),
 409 #endif
 410 #if defined (EHOSTUNREACH)
 411   ENTRY(EHOSTUNREACH, "EHOSTUNREACH", "No route to host"),
 412 #endif
 413 #if defined (EALREADY)
 414   ENTRY(EALREADY, "EALREADY", "Operation already in progress"),
 415 #endif
 416 #if defined (EINPROGRESS)
 417   ENTRY(EINPROGRESS, "EINPROGRESS", "Operation now in progress"),
 418 #endif
 419 #if defined (ESTALE)
 420   ENTRY(ESTALE, "ESTALE", "Stale NFS file handle"),
 421 #endif
 422 #if defined (EUCLEAN)
 423   ENTRY(EUCLEAN, "EUCLEAN", "Structure needs cleaning"),
 424 #endif
 425 #if defined (ENOTNAM)
 426   ENTRY(ENOTNAM, "ENOTNAM", "Not a XENIX named type file"),
 427 #endif
 428 #if defined (ENAVAIL)
 429   ENTRY(ENAVAIL, "ENAVAIL", "No XENIX semaphores available"),
 430 #endif
 431 #if defined (EISNAM)
 432   ENTRY(EISNAM, "EISNAM", "Is a named type file"),
 433 #endif
 434 #if defined (EREMOTEIO)
 435   ENTRY(EREMOTEIO, "EREMOTEIO", "Remote I/O error"),
 436 #endif
 437   ENTRY(0, NULL, NULL)
 438 };
 439
 440 #ifdef EVMSERR
 441 /* This is not in the table, because the numeric value of EVMSERR (32767)
 442    lies outside the range of sys_errlist[].  */
 443 static struct { int value; const char *name, *msg; }
 444   evmserr = { EVMSERR, "EVMSERR", "VMS-specific error" };
 445 #endif
 446
 447 /* Translation table allocated and initialized at runtime.  Indexed by the
 448    errno value to find the equivalent symbolic value. */
 449
 450 static const char **error_names;
 451 static int num_error_names = 0;
 452
 453 /* Translation table allocated and initialized at runtime, if it does not
 454    already exist in the host environment.  Indexed by the errno value to find
 455    the descriptive string.
 456
 457    We don't export it for use in other modules because even though it has the
 458    same name, it differs from other implementations in that it is dynamically
 459    initialized rather than statically initialized. */
 460
 461 #ifndef HAVE_SYS_ERRLIST
 462
 463 static int sys_nerr;
 464 static const char **sys_errlist;
 465
 466 #else
 467
 468 extern int sys_nerr;
 469 extern char *sys_errlist[];
 470
 471 #endif
 472
 473
 474 /*
 475
 476 NAME
 477
 478         init_error_tables -- initialize the name and message tables
 479
 480 SYNOPSIS
 481
 482         static void init_error_tables ();
 483
 484 DESCRIPTION
 485
 486         Using the error_table, which is initialized at compile time, generate
 487         the error_names and the sys_errlist (if needed) tables, which are
 488         indexed at runtime by a specific errno value.
 489
 490 BUGS
 491
 492         The initialization of the tables may fail under low memory conditions,
 493         in which case we don't do anything particularly useful, but we don't
 494         bomb either.  Who knows, it might succeed at a later point if we free
 495         some memory in the meantime.  In any case, the other routines know
 496         how to deal with lack of a table after trying to initialize it.  This
 497         may or may not be considered to be a bug, that we don't specifically
 498         warn about this particular failure mode.
 499
 500 */
 501
 502 static void
 503 init_error_tables ()
 504 {
 505   const struct error_info *eip;
 506   int nbytes;
 507
 508   /* If we haven't already scanned the error_table once to find the maximum
 509      errno value, then go find it now. */
 510
 511   if (num_error_names == 0)
 512     {
 513       for (eip = error_table; eip -> name != NULL; eip++)
 514         {
 515           if (eip -> value >= num_error_names)
 516             {
 517               num_error_names = eip -> value + 1;
 518             }
 519         }
 520     }
 521
 522   /* Now attempt to allocate the error_names table, zero it out, and then
 523      initialize it from the statically initialized error_table. */
 524
 525   if (error_names == NULL)
 526     {
 527       nbytes = num_error_names * sizeof (char *);
 528       if ((error_names = (const char **) malloc (nbytes)) != NULL)
 529         {
 530           memset (error_names, 0, nbytes);
 531           for (eip = error_table; eip -> name != NULL; eip++)
 532             {
 533               error_names[eip -> value] = eip -> name;
 534             }
 535         }
 536     }
 537
 538 #ifndef HAVE_SYS_ERRLIST
 539
 540   /* Now attempt to allocate the sys_errlist table, zero it out, and then
 541      initialize it from the statically initialized error_table. */
 542
 543   if (sys_errlist == NULL)
 544     {
 545       nbytes = num_error_names * sizeof (char *);
 546       if ((sys_errlist = (const char **) malloc (nbytes)) != NULL)
 547         {
 548           memset (sys_errlist, 0, nbytes);
 549           sys_nerr = num_error_names;
 550           for (eip = error_table; eip -> name != NULL; eip++)
 551             {
 552               sys_errlist[eip -> value] = eip -> msg;
 553             }
 554         }
 555     }
 556
 557 #endif
 558
 559 }
 560
 561 /*
 562
 563 NAME
 564
 565         errno_max -- return the max errno value
 566
 567 SYNOPSIS
 568
 569         int errno_max ();
 570
 571 DESCRIPTION
 572
 573         Returns the maximum errno value for which a corresponding symbolic
 574         name or message is available.  Note that in the case where
 575         we use the sys_errlist supplied by the system, it is possible for
 576         there to be more symbolic names than messages, or vice versa.
 577         In fact, the manual page for perror(3C) explicitly warns that one
 578         should check the size of the table (sys_nerr) before indexing it,
 579         since new error codes may be added to the system before they are
 580         added to the table.  Thus sys_nerr might be smaller than value
 581         implied by the largest errno value defined in <errno.h>.
 582
 583         We return the maximum value that can be used to obtain a meaningful
 584         symbolic name or message.
 585
 586 */
 587
 588 int
 589 errno_max ()
 590 {
 591   int maxsize;
 592
 593   if (error_names == NULL)
 594     {
 595       init_error_tables ();
 596     }
 597   maxsize = MAX (sys_nerr, num_error_names);
 598   return (maxsize - 1);
 599 }
 600
 601 #ifndef HAVE_STRERROR
 602
 603 /*
 604
 605 NAME
 606
 607         strerror -- map an error number to an error message string
 608
 609 SYNOPSIS
 610
 611         char *strerror (int errnoval)
 612
 613 DESCRIPTION
 614
 615         Maps an errno number to an error message string, the contents of
 616         which are implementation defined.  On systems which have the external
 617         variables sys_nerr and sys_errlist, these strings will be the same
 618         as the ones used by perror().
 619
 620         If the supplied error number is within the valid range of indices
 621         for the sys_errlist, but no message is available for the particular
 622         error number, then returns the string "Error NUM", where NUM is the
 623         error number.
 624
 625         If the supplied error number is not a valid index into sys_errlist,
 626         returns NULL.
 627
 628         The returned string is only guaranteed to be valid only until the
 629         next call to strerror.
 630
 631 */
 632
 633 char *
 634 strerror (errnoval)
 635   int errnoval;
 636 {
 637   char *msg;
 638   static char buf[32];
 639
 640 #ifndef HAVE_SYS_ERRLIST
 641
 642   if (error_names == NULL)
 643     {
 644       init_error_tables ();
 645     }
 646
 647 #endif
 648
 649   if ((errnoval < 0) || (errnoval >= sys_nerr))
 650     {
 651 #ifdef EVMSERR
 652       if (errnoval == evmserr.value)
 653         msg = evmserr.msg;
 654       else
 655 #endif
 656       /* Out of range, just return NULL */
 657       msg = NULL;
 658     }
 659   else if ((sys_errlist == NULL) || (sys_errlist[errnoval] == NULL))
 660     {
 661       /* In range, but no sys_errlist or no entry at this index. */
 662       sprintf (buf, "Error %d", errnoval);
 663       msg = buf;
 664     }
 665   else
 666     {
 667       /* In range, and a valid message.  Just return the message. */
 668       msg = (char *) sys_errlist[errnoval];
 669     }
 670
 671   return (msg);
 672 }
 673
 674 #endif  /* ! HAVE_STRERROR */
 675
 676
 677 /*
 678
 679 NAME
 680
 681         strerrno -- map an error number to a symbolic name string
 682
 683 SYNOPSIS
 684
 685         const char *strerrno (int errnoval)
 686
 687 DESCRIPTION
 688
 689         Given an error number returned from a system call (typically
 690         returned in errno), returns a pointer to a string containing the
 691         symbolic name of that error number, as found in <errno.h>.
 692
 693         If the supplied error number is within the valid range of indices
 694         for symbolic names, but no name is available for the particular
 695         error number, then returns the string "Error NUM", where NUM is
 696         the error number.
 697
 698         If the supplied error number is not within the range of valid
 699         indices, then returns NULL.
 700
 701 BUGS
 702
 703         The contents of the location pointed to are only guaranteed to be
 704         valid until the next call to strerrno.
 705
 706 */
 707
 708 const char *
 709 strerrno (errnoval)
 710   int errnoval;
 711 {
 712   const char *name;
 713   static char buf[32];
 714
 715   if (error_names == NULL)
 716     {
 717       init_error_tables ();
 718     }
 719
 720   if ((errnoval < 0) || (errnoval >= num_error_names))
 721     {
 722 #ifdef EVMSERR
 723       if (errnoval == evmserr.value)
 724         name = evmserr.name;
 725       else
 726 #endif
 727       /* Out of range, just return NULL */
 728       name = NULL;
 729     }
 730   else if ((error_names == NULL) || (error_names[errnoval] == NULL))
 731     {
 732       /* In range, but no error_names or no entry at this index. */
 733       sprintf (buf, "Error %d", errnoval);
 734       name = (const char *) buf;
 735     }
 736   else
 737     {
 738       /* In range, and a valid name.  Just return the name. */
 739       name = error_names[errnoval];
 740     }
 741
 742   return (name);
 743 }
 744
 745 /*
 746
 747 NAME
 748
 749         strtoerrno -- map a symbolic errno name to a numeric value
 750
 751 SYNOPSIS
 752
 753         int strtoerrno (char *name)
 754
 755 DESCRIPTION
 756
 757         Given the symbolic name of a error number, map it to an errno value.
 758         If no translation is found, returns 0.
 759
 760 */
 761
 762 int
 763 strtoerrno (name)
 764      const char *name;
 765 {
 766   int errnoval = 0;
 767
 768   if (name != NULL)
 769     {
 770       if (error_names == NULL)
 771         {
 772           init_error_tables ();
 773         }
 774       for (errnoval = 0; errnoval < num_error_names; errnoval++)
 775         {
 776           if ((error_names[errnoval] != NULL) &&
 777               (strcmp (name, error_names[errnoval]) == 0))
 778             {
 779               break;
 780             }
 781         }
 782       if (errnoval == num_error_names)
 783         {
 784 #ifdef EVMSERR
 785           if (strcmp (name, evmserr.name) == 0)
 786             errnoval = evmserr.value;
 787           else
 788 #endif
 789           errnoval = 0;
 790         }
 791     }
 792   return (errnoval);
 793 }
 794
 795
 796 /* A simple little main that does nothing but print all the errno translations
 797    if MAIN is defined and this file is compiled and linked. */
 798
 799 #ifdef MAIN
 800
 801 #include <stdio.h>
 802
 803 int
 804 main ()
 805 {
 806   int errn;
 807   int errnmax;
 808   const char *name;
 809   char *msg;
 810   char *strerror ();
 811
 812   errnmax = errno_max ();
 813   printf ("%d entries in names table.\n", num_error_names);
 814   printf ("%d entries in messages table.\n", sys_nerr);
 815   printf ("%d is max useful index.\n", errnmax);
 816
 817   /* Keep printing values until we get to the end of *both* tables, not
 818      *either* table.  Note that knowing the maximum useful index does *not*
 819      relieve us of the responsibility of testing the return pointer for
 820      NULL. */
 821
 822   for (errn = 0; errn <= errnmax; errn++)
 823     {
 824       name = strerrno (errn);
 825       name = (name == NULL) ? "<NULL>" : name;
 826       msg = strerror (errn);
 827       msg = (msg == NULL) ? "<NULL>" : msg;
 828       printf ("%-4d%-18s%s\n", errn, name, msg);
 829     }
 830
 831   return 0;
 832 }
 833
 834 #endif