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