1 /*-
2 * Copyright (c) 2008 Apple Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of Apple Inc. ("Apple") nor the names of
14 * its contributors may be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR
21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
25 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
26 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 *
29 * P4: //depot/projects/trustedbsd/openbsm/libbsm/bsm_errno.c#22
30 */
31
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34
35 #include <sys/param.h>
36
37 #include <security/audit/audit.h>
38
39 #include <bsm/audit_errno.h>
40 #include <bsm/audit_record.h>
41
42 #include <sys/errno.h>
43
44 /*
45 * Different operating systems use different numeric constants for different
46 * error numbers, and sometimes error numbers don't exist in more than one
47 * operating system. These routines convert between BSM and local error
48 * number spaces, subject to the above realities. BSM error numbers are
49 * stored in a single 8-bit character, so don't have a byte order.
50 *
51 * Don't include string definitions when this code is compiled into a kernel.
52 */
53 struct bsm_errno {
54 int be_bsm_errno;
55 int be_local_errno;
56 #if !defined(KERNEL) && !defined(_KERNEL)
57 const char *be_strerror;
58 #endif
59 };
60
61 #define ERRNO_NO_LOCAL_MAPPING -600
62
63 #if !defined(KERNEL) && !defined(_KERNEL)
64 #define ES(x) x
65 #else
66 #define ES(x)
67 #endif
68
69 /*
70 * Mapping table -- please maintain in numeric sorted order with respect to
71 * the BSM constant. Today we do a linear lookup, but could switch to a
72 * binary search if it makes sense. We only ifdef errors that aren't
73 * generally available, but it does make the table a lot more ugly.
74 *
75 * XXXRW: It would be nice to have a similar ordered table mapping to BSM
76 * constant from local constant, but the order of local constants varies by
77 * OS. Really we need to build that table at compile-time but don't do that
78 * yet.
79 *
80 * XXXRW: We currently embed English-language error strings here, but should
81 * support catalogues; these are only used if the OS doesn't have an error
82 * string using strerror(3).
83 */
84 static const struct bsm_errno bsm_errnos[] = {
85 { BSM_ERRNO_ESUCCESS, 0, ES("Success") },
86 { BSM_ERRNO_EPERM, EPERM, ES("Operation not permitted") },
87 { BSM_ERRNO_ENOENT, ENOENT, ES("No such file or directory") },
88 { BSM_ERRNO_ESRCH, ESRCH, ES("No such process") },
89 { BSM_ERRNO_EINTR, EINTR, ES("Interrupted system call") },
90 { BSM_ERRNO_EIO, EIO, ES("Input/output error") },
91 { BSM_ERRNO_ENXIO, ENXIO, ES("Device not configured") },
92 { BSM_ERRNO_E2BIG, E2BIG, ES("Argument list too long") },
93 { BSM_ERRNO_ENOEXEC, ENOEXEC, ES("Exec format error") },
94 { BSM_ERRNO_EBADF, EBADF, ES("Bad file descriptor") },
95 { BSM_ERRNO_ECHILD, ECHILD, ES("No child processes") },
96 { BSM_ERRNO_EAGAIN, EAGAIN, ES("Resource temporarily unavailable") },
97 { BSM_ERRNO_ENOMEM, ENOMEM, ES("Cannot allocate memory") },
98 { BSM_ERRNO_EACCES, EACCES, ES("Permission denied") },
99 { BSM_ERRNO_EFAULT, EFAULT, ES("Bad address") },
100 { BSM_ERRNO_ENOTBLK, ENOTBLK, ES("Block device required") },
101 { BSM_ERRNO_EBUSY, EBUSY, ES("Device busy") },
102 { BSM_ERRNO_EEXIST, EEXIST, ES("File exists") },
103 { BSM_ERRNO_EXDEV, EXDEV, ES("Cross-device link") },
104 { BSM_ERRNO_ENODEV, ENODEV, ES("Operation not supported by device") },
105 { BSM_ERRNO_ENOTDIR, ENOTDIR, ES("Not a directory") },
106 { BSM_ERRNO_EISDIR, EISDIR, ES("Is a directory") },
107 { BSM_ERRNO_EINVAL, EINVAL, ES("Invalid argument") },
108 { BSM_ERRNO_ENFILE, ENFILE, ES("Too many open files in system") },
109 { BSM_ERRNO_EMFILE, EMFILE, ES("Too many open files") },
110 { BSM_ERRNO_ENOTTY, ENOTTY, ES("Inappropriate ioctl for device") },
111 { BSM_ERRNO_ETXTBSY, ETXTBSY, ES("Text file busy") },
112 { BSM_ERRNO_EFBIG, EFBIG, ES("File too large") },
113 { BSM_ERRNO_ENOSPC, ENOSPC, ES("No space left on device") },
114 { BSM_ERRNO_ESPIPE, ESPIPE, ES("Illegal seek") },
115 { BSM_ERRNO_EROFS, EROFS, ES("Read-only file system") },
116 { BSM_ERRNO_EMLINK, EMLINK, ES("Too many links") },
117 { BSM_ERRNO_EPIPE, EPIPE, ES("Broken pipe") },
118 { BSM_ERRNO_EDOM, EDOM, ES("Numerical argument out of domain") },
119 { BSM_ERRNO_ERANGE, ERANGE, ES("Result too large") },
120 { BSM_ERRNO_ENOMSG, ENOMSG, ES("No message of desired type") },
121 { BSM_ERRNO_EIDRM, EIDRM, ES("Identifier removed") },
122 { BSM_ERRNO_ECHRNG,
123 #ifdef ECHRNG
124 ECHRNG,
125 #else
126 ERRNO_NO_LOCAL_MAPPING,
127 #endif
128 ES("Channel number out of range") },
129 { BSM_ERRNO_EL2NSYNC,
130 #ifdef EL2NSYNC
131 EL2NSYNC,
132 #else
133 ERRNO_NO_LOCAL_MAPPING,
134 #endif
135 ES("Level 2 not synchronized") },
136 { BSM_ERRNO_EL3HLT,
137 #ifdef EL3HLT
138 EL3HLT,
139 #else
140 ERRNO_NO_LOCAL_MAPPING,
141 #endif
142 ES("Level 3 halted") },
143 { BSM_ERRNO_EL3RST,
144 #ifdef EL3RST
145 EL3RST,
146 #else
147 ERRNO_NO_LOCAL_MAPPING,
148 #endif
149 ES("Level 3 reset") },
150 { BSM_ERRNO_ELNRNG,
151 #ifdef ELNRNG
152 ELNRNG,
153 #else
154 ERRNO_NO_LOCAL_MAPPING,
155 #endif
156 ES("Link number out of range") },
157 { BSM_ERRNO_EUNATCH,
158 #ifdef EUNATCH
159 EUNATCH,
160 #else
161 ERRNO_NO_LOCAL_MAPPING,
162 #endif
163 ES("Protocol driver not attached") },
164 { BSM_ERRNO_ENOCSI,
165 #ifdef ENOCSI
166 ENOCSI,
167 #else
168 ERRNO_NO_LOCAL_MAPPING,
169 #endif
170 ES("No CSI structure available") },
171 { BSM_ERRNO_EL2HLT,
172 #ifdef EL2HLT
173 EL2HLT,
174 #else
175 ERRNO_NO_LOCAL_MAPPING,
176 #endif
177 ES("Level 2 halted") },
178 { BSM_ERRNO_EDEADLK, EDEADLK, ES("Resource deadlock avoided") },
179 { BSM_ERRNO_ENOLCK, ENOLCK, ES("No locks available") },
180 { BSM_ERRNO_ECANCELED, ECANCELED, ES("Operation canceled") },
181 { BSM_ERRNO_ENOTSUP, ENOTSUP, ES("Operation not supported") },
182 { BSM_ERRNO_EDQUOT, EDQUOT, ES("Disc quota exceeded") },
183 { BSM_ERRNO_EBADE,
184 #ifdef EBADE
185 EBADE,
186 #else
187 ERRNO_NO_LOCAL_MAPPING,
188 #endif
189 ES("Invalid exchange") },
190 { BSM_ERRNO_EBADR,
191 #ifdef EBADR
192 EBADR,
193 #else
194 ERRNO_NO_LOCAL_MAPPING,
195 #endif
196 ES("Invalid request descriptor") },
197 { BSM_ERRNO_EXFULL,
198 #ifdef EXFULL
199 EXFULL,
200 #else
201 ERRNO_NO_LOCAL_MAPPING,
202 #endif
203 ES("Exchange full") },
204 { BSM_ERRNO_ENOANO,
205 #ifdef ENOANO
206 ENOANO,
207 #else
208 ERRNO_NO_LOCAL_MAPPING,
209 #endif
210 ES("No anode") },
211 { BSM_ERRNO_EBADRQC,
212 #ifdef EBADRQC
213 EBADRQC,
214 #else
215 ERRNO_NO_LOCAL_MAPPING,
216 #endif
217 ES("Invalid request descriptor") },
218 { BSM_ERRNO_EBADSLT,
219 #ifdef EBADSLT
220 EBADSLT,
221 #else
222 ERRNO_NO_LOCAL_MAPPING,
223 #endif
224 ES("Invalid slot") },
225 { BSM_ERRNO_EDEADLOCK,
226 #ifdef EDEADLOCK
227 EDEADLOCK,
228 #else
229 ERRNO_NO_LOCAL_MAPPING,
230 #endif
231 ES("Resource deadlock avoided") },
232 { BSM_ERRNO_EBFONT,
233 #ifdef EBFONT
234 EBFONT,
235 #else
236 ERRNO_NO_LOCAL_MAPPING,
237 #endif
238 ES("Bad font file format") },
239 { BSM_ERRNO_EOWNERDEAD,
240 #ifdef EOWNERDEAD
241 EOWNERDEAD,
242 #else
243 ERRNO_NO_LOCAL_MAPPING,
244 #endif
245 ES("Process died with the lock") },
246 { BSM_ERRNO_ENOTRECOVERABLE,
247 #ifdef ENOTRECOVERABLE
248 ENOTRECOVERABLE,
249 #else
250 ERRNO_NO_LOCAL_MAPPING,
251 #endif
252 ES("Lock is not recoverable") },
253 { BSM_ERRNO_ENOSTR,
254 #ifdef ENOSTR
255 ENOSTR,
256 #else
257 ERRNO_NO_LOCAL_MAPPING,
258 #endif
259 ES("Device not a stream") },
260 { BSM_ERRNO_ENONET,
261 #ifdef ENONET
262 ENONET,
263 #else
264 ERRNO_NO_LOCAL_MAPPING,
265 #endif
266 ES("Machine is not on the network") },
267 { BSM_ERRNO_ENOPKG,
268 #ifdef ENOPKG
269 ENOPKG,
270 #else
271 ERRNO_NO_LOCAL_MAPPING,
272 #endif
273 ES("Package not installed") },
274 { BSM_ERRNO_EREMOTE, EREMOTE,
275 ES("Too many levels of remote in path") },
276 { BSM_ERRNO_ENOLINK,
277 #ifdef ENOLINK
278 ENOLINK,
279 #else
280 ERRNO_NO_LOCAL_MAPPING,
281 #endif
282 ES("Link has been severed") },
283 { BSM_ERRNO_EADV,
284 #ifdef EADV
285 EADV,
286 #else
287 ERRNO_NO_LOCAL_MAPPING,
288 #endif
289 ES("Advertise error") },
290 { BSM_ERRNO_ESRMNT,
291 #ifdef ESRMNT
292 ESRMNT,
293 #else
294 ERRNO_NO_LOCAL_MAPPING,
295 #endif
296 ES("srmount error") },
297 { BSM_ERRNO_ECOMM,
298 #ifdef ECOMM
299 ECOMM,
300 #else
301 ERRNO_NO_LOCAL_MAPPING,
302 #endif
303 ES("Communication error on send") },
304 { BSM_ERRNO_EPROTO,
305 #ifdef EPROTO
306 EPROTO,
307 #else
308 ERRNO_NO_LOCAL_MAPPING,
309 #endif
310 ES("Protocol error") },
311 { BSM_ERRNO_ELOCKUNMAPPED,
312 #ifdef ELOCKUNMAPPED
313 ELOCKUNMAPPED,
314 #else
315 ERRNO_NO_LOCAL_MAPPING,
316 #endif
317 ES("Locked lock was unmapped") },
318 { BSM_ERRNO_ENOTACTIVE,
319 #ifdef ENOTACTIVE
320 ENOTACTIVE,
321 #else
322 ERRNO_NO_LOCAL_MAPPING,
323 #endif
324 ES("Facility is not active") },
325 { BSM_ERRNO_EMULTIHOP,
326 #ifdef EMULTIHOP
327 EMULTIHOP,
328 #else
329 ERRNO_NO_LOCAL_MAPPING,
330 #endif
331 ES("Multihop attempted") },
332 { BSM_ERRNO_EBADMSG,
333 #ifdef EBADMSG
334 EBADMSG,
335 #else
336 ERRNO_NO_LOCAL_MAPPING,
337 #endif
338 ES("Bad message") },
339 { BSM_ERRNO_ENAMETOOLONG, ENAMETOOLONG, ES("File name too long") },
340 { BSM_ERRNO_EOVERFLOW, EOVERFLOW,
341 ES("Value too large to be stored in data type") },
342 { BSM_ERRNO_ENOTUNIQ,
343 #ifdef ENOTUNIQ
344 ENOTUNIQ,
345 #else
346 ERRNO_NO_LOCAL_MAPPING,
347 #endif
348 ES("Given log name not unique") },
349 { BSM_ERRNO_EBADFD,
350 #ifdef EBADFD
351 EBADFD,
352 #else
353 ERRNO_NO_LOCAL_MAPPING,
354 #endif
355 ES("Given f.d. invalid for this operation") },
356 { BSM_ERRNO_EREMCHG,
357 #ifdef EREMCHG
358 EREMCHG,
359 #else
360 ERRNO_NO_LOCAL_MAPPING,
361 #endif
362 ES("Remote address changed") },
363 { BSM_ERRNO_ELIBACC,
364 #ifdef ELIBACC
365 ELIBACC,
366 #else
367 ERRNO_NO_LOCAL_MAPPING,
368 #endif
369 ES("Can't access a needed shared lib") },
370 { BSM_ERRNO_ELIBBAD,
371 #ifdef ELIBBAD
372 ELIBBAD,
373 #else
374 ERRNO_NO_LOCAL_MAPPING,
375 #endif
376 ES("Accessing a corrupted shared lib") },
377 { BSM_ERRNO_ELIBSCN,
378 #ifdef ELIBSCN
379 ELIBSCN,
380 #else
381 ERRNO_NO_LOCAL_MAPPING,
382 #endif
383 ES(".lib section in a.out corrupted") },
384 { BSM_ERRNO_ELIBMAX,
385 #ifdef ELIBMAX
386 ELIBMAX,
387 #else
388 ERRNO_NO_LOCAL_MAPPING,
389 #endif
390 ES("Attempting to link in too many libs") },
391 { BSM_ERRNO_ELIBEXEC,
392 #ifdef ELIBEXEC
393 ELIBEXEC,
394 #else
395 ERRNO_NO_LOCAL_MAPPING,
396 #endif
397 ES("Attempting to exec a shared library") },
398 { BSM_ERRNO_EILSEQ, EILSEQ, ES("Illegal byte sequence") },
399 { BSM_ERRNO_ENOSYS, ENOSYS, ES("Function not implemented") },
400 { BSM_ERRNO_ELOOP, ELOOP, ES("Too many levels of symbolic links") },
401 { BSM_ERRNO_ERESTART,
402 #ifdef ERESTART
403 ERESTART,
404 #else
405 ERRNO_NO_LOCAL_MAPPING,
406 #endif
407 ES("Restart syscall") },
408 { BSM_ERRNO_ESTRPIPE,
409 #ifdef ESTRPIPE
410 ESTRPIPE,
411 #else
412 ERRNO_NO_LOCAL_MAPPING,
413 #endif
414 ES("If pipe/FIFO, don't sleep in stream head") },
415 { BSM_ERRNO_ENOTEMPTY, ENOTEMPTY, ES("Directory not empty") },
416 { BSM_ERRNO_EUSERS, EUSERS, ES("Too many users") },
417 { BSM_ERRNO_ENOTSOCK, ENOTSOCK,
418 ES("Socket operation on non-socket") },
419 { BSM_ERRNO_EDESTADDRREQ, EDESTADDRREQ,
420 ES("Destination address required") },
421 { BSM_ERRNO_EMSGSIZE, EMSGSIZE, ES("Message too long") },
422 { BSM_ERRNO_EPROTOTYPE, EPROTOTYPE,
423 ES("Protocol wrong type for socket") },
424 { BSM_ERRNO_ENOPROTOOPT, ENOPROTOOPT, ES("Protocol not available") },
425 { BSM_ERRNO_EPROTONOSUPPORT, EPROTONOSUPPORT,
426 ES("Protocol not supported") },
427 { BSM_ERRNO_ESOCKTNOSUPPORT, ESOCKTNOSUPPORT,
428 ES("Socket type not supported") },
429 { BSM_ERRNO_EOPNOTSUPP, EOPNOTSUPP, ES("Operation not supported") },
430 { BSM_ERRNO_EPFNOSUPPORT, EPFNOSUPPORT,
431 ES("Protocol family not supported") },
432 { BSM_ERRNO_EAFNOSUPPORT, EAFNOSUPPORT,
433 ES("Address family not supported by protocol family") },
434 { BSM_ERRNO_EADDRINUSE, EADDRINUSE, ES("Address already in use") },
435 { BSM_ERRNO_EADDRNOTAVAIL, EADDRNOTAVAIL,
436 ES("Can't assign requested address") },
437 { BSM_ERRNO_ENETDOWN, ENETDOWN, ES("Network is down") },
438 { BSM_ERRNO_ENETRESET, ENETRESET,
439 ES("Network dropped connection on reset") },
440 { BSM_ERRNO_ECONNABORTED, ECONNABORTED,
441 ES("Software caused connection abort") },
442 { BSM_ERRNO_ECONNRESET, ECONNRESET, ES("Connection reset by peer") },
443 { BSM_ERRNO_ENOBUFS, ENOBUFS, ES("No buffer space available") },
444 { BSM_ERRNO_EISCONN, EISCONN, ES("Socket is already connected") },
445 { BSM_ERRNO_ENOTCONN, ENOTCONN, ES("Socket is not connected") },
446 { BSM_ERRNO_ESHUTDOWN, ESHUTDOWN,
447 ES("Can't send after socket shutdown") },
448 { BSM_ERRNO_ETOOMANYREFS, ETOOMANYREFS,
449 ES("Too many references: can't splice") },
450 { BSM_ERRNO_ETIMEDOUT, ETIMEDOUT, ES("Operation timed out") },
451 { BSM_ERRNO_ECONNREFUSED, ECONNREFUSED, ES("Connection refused") },
452 { BSM_ERRNO_EHOSTDOWN, EHOSTDOWN, ES("Host is down") },
453 { BSM_ERRNO_EHOSTUNREACH, EHOSTUNREACH, ES("No route to host") },
454 { BSM_ERRNO_EALREADY, EALREADY, ES("Operation already in progress") },
455 { BSM_ERRNO_EINPROGRESS, EINPROGRESS,
456 ES("Operation now in progress") },
457 { BSM_ERRNO_ESTALE, ESTALE, ES("Stale NFS file handle") },
458 { BSM_ERRNO_EPROCLIM,
459 #ifdef EPROCLIM
460 EPROCLIM,
461 #else
462 ERRNO_NO_LOCAL_MAPPING,
463 #endif
464 ES("Too many processes") },
465 { BSM_ERRNO_EBADRPC,
466 #ifdef EBADRPC
467 EBADRPC,
468 #else
469 ERRNO_NO_LOCAL_MAPPING,
470 #endif
471 ES("RPC struct is bad") },
472 { BSM_ERRNO_ERPCMISMATCH,
473 #ifdef ERPCMISMATCH
474 ERPCMISMATCH,
475 #else
476 ERRNO_NO_LOCAL_MAPPING,
477 #endif
478 ES("RPC version wrong") },
479 { BSM_ERRNO_EPROGUNAVAIL,
480 #ifdef EPROGUNAVAIL
481 EPROGUNAVAIL,
482 #else
483 ERRNO_NO_LOCAL_MAPPING,
484 #endif
485 ES("RPC prog. not avail") },
486 { BSM_ERRNO_EPROGMISMATCH,
487 #ifdef EPROGMISMATCH
488 EPROGMISMATCH,
489 #else
490 ERRNO_NO_LOCAL_MAPPING,
491 #endif
492 ES("RPC version wrong") },
493 { BSM_ERRNO_EPROCUNAVAIL,
494 #ifdef EPROCUNAVAIL
495 EPROCUNAVAIL,
496 #else
497 ERRNO_NO_LOCAL_MAPPING,
498 #endif
499 ES("Bad procedure for program") },
500 { BSM_ERRNO_EFTYPE,
501 #ifdef EFTYPE
502 EFTYPE,
503 #else
504 ERRNO_NO_LOCAL_MAPPING,
505 #endif
506 ES("Inappropriate file type or format") },
507 { BSM_ERRNO_EAUTH,
508 #ifdef EAUTH
509 EAUTH,
510 #else
511 ERRNO_NO_LOCAL_MAPPING,
512 #endif
513 ES("Authenticateion error") },
514 { BSM_ERRNO_ENEEDAUTH,
515 #ifdef ENEEDAUTH
516 ENEEDAUTH,
517 #else
518 ERRNO_NO_LOCAL_MAPPING,
519 #endif
520 ES("Need authenticator") },
521 { BSM_ERRNO_ENOATTR,
522 #ifdef ENOATTR
523 ENOATTR,
524 #else
525 ERRNO_NO_LOCAL_MAPPING,
526 #endif
527 ES("Attribute not found") },
528 { BSM_ERRNO_EDOOFUS,
529 #ifdef EDOOFUS
530 EDOOFUS,
531 #else
532 ERRNO_NO_LOCAL_MAPPING,
533 #endif
534 ES("Programming error") },
535 { BSM_ERRNO_EJUSTRETURN,
536 #ifdef EJUSTRETURN
537 EJUSTRETURN,
538 #else
539 ERRNO_NO_LOCAL_MAPPING,
540 #endif
541 ES("Just return") },
542 { BSM_ERRNO_ENOIOCTL,
543 #ifdef ENOIOCTL
544 ENOIOCTL,
545 #else
546 ERRNO_NO_LOCAL_MAPPING,
547 #endif
548 ES("ioctl not handled by this layer") },
549 { BSM_ERRNO_EDIRIOCTL,
550 #ifdef EDIRIOCTL
551 EDIRIOCTL,
552 #else
553 ERRNO_NO_LOCAL_MAPPING,
554 #endif
555 ES("do direct ioctl in GEOM") },
556 { BSM_ERRNO_EPWROFF,
557 #ifdef EPWROFF
558 EPWROFF,
559 #else
560 ERRNO_NO_LOCAL_MAPPING,
561 #endif
562 ES("Device power is off") },
563 { BSM_ERRNO_EDEVERR,
564 #ifdef EDEVERR
565 EDEVERR,
566 #else
567 ERRNO_NO_LOCAL_MAPPING,
568 #endif
569 ES("Device error") },
570 { BSM_ERRNO_EBADEXEC,
571 #ifdef EBADEXEC
572 EBADEXEC,
573 #else
574 ERRNO_NO_LOCAL_MAPPING,
575 #endif
576 ES("Bad executable") },
577 { BSM_ERRNO_EBADARCH,
578 #ifdef EBADARCH
579 EBADARCH,
580 #else
581 ERRNO_NO_LOCAL_MAPPING,
582 #endif
583 ES("Bad CPU type in executable") },
584 { BSM_ERRNO_ESHLIBVERS,
585 #ifdef ESHLIBVERS
586 ESHLIBVERS,
587 #else
588 ERRNO_NO_LOCAL_MAPPING,
589 #endif
590 ES("Shared library version mismatch") },
591 { BSM_ERRNO_EBADMACHO,
592 #ifdef EBADMACHO
593 EBADMACHO,
594 #else
595 ERRNO_NO_LOCAL_MAPPING,
596 #endif
597 ES("Malformed Macho file") },
598 { BSM_ERRNO_EPOLICY,
599 #ifdef EPOLICY
600 EPOLICY,
601 #else
602 ERRNO_NO_LOCAL_MAPPING,
603 #endif
604 ES("Operation failed by policy") },
605 { BSM_ERRNO_EDOTDOT,
606 #ifdef EDOTDOT
607 EDOTDOT,
608 #else
609 ERRNO_NO_LOCAL_MAPPING,
610 #endif
611 ES("RFS specific error") },
612 { BSM_ERRNO_EUCLEAN,
613 #ifdef EUCLEAN
614 EUCLEAN,
615 #else
616 ERRNO_NO_LOCAL_MAPPING,
617 #endif
618 ES("Structure needs cleaning") },
619 { BSM_ERRNO_ENOTNAM,
620 #ifdef ENOTNAM
621 ENOTNAM,
622 #else
623 ERRNO_NO_LOCAL_MAPPING,
624 #endif
625 ES("Not a XENIX named type file") },
626 { BSM_ERRNO_ENAVAIL,
627 #ifdef ENAVAIL
628 ENAVAIL,
629 #else
630 ERRNO_NO_LOCAL_MAPPING,
631 #endif
632 ES("No XENIX semaphores available") },
633 { BSM_ERRNO_EISNAM,
634 #ifdef EISNAM
635 EISNAM,
636 #else
637 ERRNO_NO_LOCAL_MAPPING,
638 #endif
639 ES("Is a named type file") },
640 { BSM_ERRNO_EREMOTEIO,
641 #ifdef EREMOTEIO
642 EREMOTEIO,
643 #else
644 ERRNO_NO_LOCAL_MAPPING,
645 #endif
646 ES("Remote I/O error") },
647 { BSM_ERRNO_ENOMEDIUM,
648 #ifdef ENOMEDIUM
649 ENOMEDIUM,
650 #else
651 ERRNO_NO_LOCAL_MAPPING,
652 #endif
653 ES("No medium found") },
654 { BSM_ERRNO_EMEDIUMTYPE,
655 #ifdef EMEDIUMTYPE
656 EMEDIUMTYPE,
657 #else
658 ERRNO_NO_LOCAL_MAPPING,
659 #endif
660 ES("Wrong medium type") },
661 { BSM_ERRNO_ENOKEY,
662 #ifdef ENOKEY
663 ENOKEY,
664 #else
665 ERRNO_NO_LOCAL_MAPPING,
666 #endif
667 ES("Required key not available") },
668 { BSM_ERRNO_EKEYEXPIRED,
669 #ifdef EKEYEXPIRED
670 EKEYEXPIRED,
671 #else
672 ERRNO_NO_LOCAL_MAPPING,
673 #endif
674 ES("Key has expired") },
675 { BSM_ERRNO_EKEYREVOKED,
676 #ifdef EKEYREVOKED
677 EKEYREVOKED,
678 #else
679 ERRNO_NO_LOCAL_MAPPING,
680 #endif
681 ES("Key has been revoked") },
682 { BSM_ERRNO_EKEYREJECTED,
683 #ifdef EKEYREJECTED
684 EKEYREJECTED,
685 #else
686 ERRNO_NO_LOCAL_MAPPING,
687 #endif
688 ES("Key was rejected by service") },
689 { BSM_ERRNO_ENOTCAPABLE,
690 #ifdef ENOTCAPABLE
691 ENOTCAPABLE,
692 #else
693 ERRNO_NO_LOCAL_MAPPING,
694 #endif
695 ES("Capabilities insufficient") },
696 { BSM_ERRNO_ECAPMODE,
697 #ifdef ECAPMODE
698 ECAPMODE,
699 #else
700 ERRNO_NO_LOCAL_MAPPING,
701 #endif
702 ES("Not permitted in capability mode") },
703 };
704 static const int bsm_errnos_count = sizeof(bsm_errnos) / sizeof(bsm_errnos[0]);
705
706 static const struct bsm_errno *
707 bsm_lookup_errno_local(int local_errno)
708 {
709 int i;
710
711 for (i = 0; i < bsm_errnos_count; i++) {
712 if (bsm_errnos[i].be_local_errno == local_errno)
713 return (&bsm_errnos[i]);
714 }
715 return (NULL);
716 }
717
718 /*
719 * Conversion to the BSM errno space isn't allowed to fail; we simply map to
720 * BSM_ERRNO_UNKNOWN and let the remote endpoint deal with it.
721 */
722 u_char
723 au_errno_to_bsm(int local_errno)
724 {
725 const struct bsm_errno *bsme;
726
727 bsme = bsm_lookup_errno_local(local_errno);
728 if (bsme == NULL)
729 return (BSM_ERRNO_UNKNOWN);
730 return (bsme->be_bsm_errno);
731 }
732
733 static const struct bsm_errno *
734 bsm_lookup_errno_bsm(u_char bsm_errno)
735 {
736 int i;
737
738 for (i = 0; i < bsm_errnos_count; i++) {
739 if (bsm_errnos[i].be_bsm_errno == bsm_errno)
740 return (&bsm_errnos[i]);
741 }
742 return (NULL);
743 }
744
745 /*
746 * Converstion from a BSM error to a local error number may fail if either
747 * OpenBSM doesn't recognize the error on the wire, or because there is no
748 * appropriate local mapping.
749 */
750 int
751 au_bsm_to_errno(u_char bsm_errno, int *errorp)
752 {
753 const struct bsm_errno *bsme;
754
755 bsme = bsm_lookup_errno_bsm(bsm_errno);
756 if (bsme == NULL || bsme->be_local_errno == ERRNO_NO_LOCAL_MAPPING)
757 return (-1);
758 *errorp = bsme->be_local_errno;
759 return (0);
760 }
761
762 #if !defined(KERNEL) && !defined(_KERNEL)
763 const char *
764 au_strerror(u_char bsm_errno)
765 {
766 const struct bsm_errno *bsme;
767
768 bsme = bsm_lookup_errno_bsm(bsm_errno);
769 if (bsme == NULL)
770 return ("Unrecognized BSM error");
771 if (bsme->be_local_errno != ERRNO_NO_LOCAL_MAPPING)
772 return (strerror(bsme->be_local_errno));
773 return (bsme->be_strerror);
774 }
775 #endif
Cache object: 12989ea45f46aea04e3992b564c5d5da
|