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