1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 2008 Apple Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of Apple Inc. ("Apple") nor the names of
16 * its contributors may be used to endorse or promote products derived
17 * from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR
23 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
27 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
28 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
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_EINTEGRITY,
247 #ifdef EINTEGRITY
248 EINTEGRITY,
249 #else
250 ERRNO_NO_LOCAL_MAPPING,
251 #endif
252 ES("Integrity check failed") },
253 { BSM_ERRNO_ENOTRECOVERABLE,
254 #ifdef ENOTRECOVERABLE
255 ENOTRECOVERABLE,
256 #else
257 ERRNO_NO_LOCAL_MAPPING,
258 #endif
259 ES("Lock is not recoverable") },
260 { BSM_ERRNO_ENOSTR,
261 #ifdef ENOSTR
262 ENOSTR,
263 #else
264 ERRNO_NO_LOCAL_MAPPING,
265 #endif
266 ES("Device not a stream") },
267 { BSM_ERRNO_ENONET,
268 #ifdef ENONET
269 ENONET,
270 #else
271 ERRNO_NO_LOCAL_MAPPING,
272 #endif
273 ES("Machine is not on the network") },
274 { BSM_ERRNO_ENOPKG,
275 #ifdef ENOPKG
276 ENOPKG,
277 #else
278 ERRNO_NO_LOCAL_MAPPING,
279 #endif
280 ES("Package not installed") },
281 { BSM_ERRNO_EREMOTE, EREMOTE,
282 ES("Too many levels of remote in path") },
283 { BSM_ERRNO_ENOLINK,
284 #ifdef ENOLINK
285 ENOLINK,
286 #else
287 ERRNO_NO_LOCAL_MAPPING,
288 #endif
289 ES("Link has been severed") },
290 { BSM_ERRNO_EADV,
291 #ifdef EADV
292 EADV,
293 #else
294 ERRNO_NO_LOCAL_MAPPING,
295 #endif
296 ES("Advertise error") },
297 { BSM_ERRNO_ESRMNT,
298 #ifdef ESRMNT
299 ESRMNT,
300 #else
301 ERRNO_NO_LOCAL_MAPPING,
302 #endif
303 ES("srmount error") },
304 { BSM_ERRNO_ECOMM,
305 #ifdef ECOMM
306 ECOMM,
307 #else
308 ERRNO_NO_LOCAL_MAPPING,
309 #endif
310 ES("Communication error on send") },
311 { BSM_ERRNO_EPROTO,
312 #ifdef EPROTO
313 EPROTO,
314 #else
315 ERRNO_NO_LOCAL_MAPPING,
316 #endif
317 ES("Protocol error") },
318 { BSM_ERRNO_ELOCKUNMAPPED,
319 #ifdef ELOCKUNMAPPED
320 ELOCKUNMAPPED,
321 #else
322 ERRNO_NO_LOCAL_MAPPING,
323 #endif
324 ES("Locked lock was unmapped") },
325 { BSM_ERRNO_ENOTACTIVE,
326 #ifdef ENOTACTIVE
327 ENOTACTIVE,
328 #else
329 ERRNO_NO_LOCAL_MAPPING,
330 #endif
331 ES("Facility is not active") },
332 { BSM_ERRNO_EMULTIHOP,
333 #ifdef EMULTIHOP
334 EMULTIHOP,
335 #else
336 ERRNO_NO_LOCAL_MAPPING,
337 #endif
338 ES("Multihop attempted") },
339 { BSM_ERRNO_EBADMSG,
340 #ifdef EBADMSG
341 EBADMSG,
342 #else
343 ERRNO_NO_LOCAL_MAPPING,
344 #endif
345 ES("Bad message") },
346 { BSM_ERRNO_ENAMETOOLONG, ENAMETOOLONG, ES("File name too long") },
347 { BSM_ERRNO_EOVERFLOW, EOVERFLOW,
348 ES("Value too large to be stored in data type") },
349 { BSM_ERRNO_ENOTUNIQ,
350 #ifdef ENOTUNIQ
351 ENOTUNIQ,
352 #else
353 ERRNO_NO_LOCAL_MAPPING,
354 #endif
355 ES("Given log name not unique") },
356 { BSM_ERRNO_EBADFD,
357 #ifdef EBADFD
358 EBADFD,
359 #else
360 ERRNO_NO_LOCAL_MAPPING,
361 #endif
362 ES("Given f.d. invalid for this operation") },
363 { BSM_ERRNO_EREMCHG,
364 #ifdef EREMCHG
365 EREMCHG,
366 #else
367 ERRNO_NO_LOCAL_MAPPING,
368 #endif
369 ES("Remote address changed") },
370 { BSM_ERRNO_ELIBACC,
371 #ifdef ELIBACC
372 ELIBACC,
373 #else
374 ERRNO_NO_LOCAL_MAPPING,
375 #endif
376 ES("Can't access a needed shared lib") },
377 { BSM_ERRNO_ELIBBAD,
378 #ifdef ELIBBAD
379 ELIBBAD,
380 #else
381 ERRNO_NO_LOCAL_MAPPING,
382 #endif
383 ES("Accessing a corrupted shared lib") },
384 { BSM_ERRNO_ELIBSCN,
385 #ifdef ELIBSCN
386 ELIBSCN,
387 #else
388 ERRNO_NO_LOCAL_MAPPING,
389 #endif
390 ES(".lib section in a.out corrupted") },
391 { BSM_ERRNO_ELIBMAX,
392 #ifdef ELIBMAX
393 ELIBMAX,
394 #else
395 ERRNO_NO_LOCAL_MAPPING,
396 #endif
397 ES("Attempting to link in too many libs") },
398 { BSM_ERRNO_ELIBEXEC,
399 #ifdef ELIBEXEC
400 ELIBEXEC,
401 #else
402 ERRNO_NO_LOCAL_MAPPING,
403 #endif
404 ES("Attempting to exec a shared library") },
405 { BSM_ERRNO_EILSEQ, EILSEQ, ES("Illegal byte sequence") },
406 { BSM_ERRNO_ENOSYS, ENOSYS, ES("Function not implemented") },
407 { BSM_ERRNO_ELOOP, ELOOP, ES("Too many levels of symbolic links") },
408 { BSM_ERRNO_ERESTART,
409 #ifdef ERESTART
410 ERESTART,
411 #else
412 ERRNO_NO_LOCAL_MAPPING,
413 #endif
414 ES("Restart syscall") },
415 { BSM_ERRNO_ESTRPIPE,
416 #ifdef ESTRPIPE
417 ESTRPIPE,
418 #else
419 ERRNO_NO_LOCAL_MAPPING,
420 #endif
421 ES("If pipe/FIFO, don't sleep in stream head") },
422 { BSM_ERRNO_ENOTEMPTY, ENOTEMPTY, ES("Directory not empty") },
423 { BSM_ERRNO_EUSERS, EUSERS, ES("Too many users") },
424 { BSM_ERRNO_ENOTSOCK, ENOTSOCK,
425 ES("Socket operation on non-socket") },
426 { BSM_ERRNO_EDESTADDRREQ, EDESTADDRREQ,
427 ES("Destination address required") },
428 { BSM_ERRNO_EMSGSIZE, EMSGSIZE, ES("Message too long") },
429 { BSM_ERRNO_EPROTOTYPE, EPROTOTYPE,
430 ES("Protocol wrong type for socket") },
431 { BSM_ERRNO_ENOPROTOOPT, ENOPROTOOPT, ES("Protocol not available") },
432 { BSM_ERRNO_EPROTONOSUPPORT, EPROTONOSUPPORT,
433 ES("Protocol not supported") },
434 { BSM_ERRNO_ESOCKTNOSUPPORT, ESOCKTNOSUPPORT,
435 ES("Socket type not supported") },
436 { BSM_ERRNO_EOPNOTSUPP, EOPNOTSUPP, ES("Operation not supported") },
437 { BSM_ERRNO_EPFNOSUPPORT, EPFNOSUPPORT,
438 ES("Protocol family not supported") },
439 { BSM_ERRNO_EAFNOSUPPORT, EAFNOSUPPORT,
440 ES("Address family not supported by protocol family") },
441 { BSM_ERRNO_EADDRINUSE, EADDRINUSE, ES("Address already in use") },
442 { BSM_ERRNO_EADDRNOTAVAIL, EADDRNOTAVAIL,
443 ES("Can't assign requested address") },
444 { BSM_ERRNO_ENETDOWN, ENETDOWN, ES("Network is down") },
445 { BSM_ERRNO_ENETRESET, ENETRESET,
446 ES("Network dropped connection on reset") },
447 { BSM_ERRNO_ECONNABORTED, ECONNABORTED,
448 ES("Software caused connection abort") },
449 { BSM_ERRNO_ECONNRESET, ECONNRESET, ES("Connection reset by peer") },
450 { BSM_ERRNO_ENOBUFS, ENOBUFS, ES("No buffer space available") },
451 { BSM_ERRNO_EISCONN, EISCONN, ES("Socket is already connected") },
452 { BSM_ERRNO_ENOTCONN, ENOTCONN, ES("Socket is not connected") },
453 { BSM_ERRNO_ESHUTDOWN, ESHUTDOWN,
454 ES("Can't send after socket shutdown") },
455 { BSM_ERRNO_ETOOMANYREFS, ETOOMANYREFS,
456 ES("Too many references: can't splice") },
457 { BSM_ERRNO_ETIMEDOUT, ETIMEDOUT, ES("Operation timed out") },
458 { BSM_ERRNO_ECONNREFUSED, ECONNREFUSED, ES("Connection refused") },
459 { BSM_ERRNO_EHOSTDOWN, EHOSTDOWN, ES("Host is down") },
460 { BSM_ERRNO_EHOSTUNREACH, EHOSTUNREACH, ES("No route to host") },
461 { BSM_ERRNO_EALREADY, EALREADY, ES("Operation already in progress") },
462 { BSM_ERRNO_EINPROGRESS, EINPROGRESS,
463 ES("Operation now in progress") },
464 { BSM_ERRNO_ESTALE, ESTALE, ES("Stale NFS file handle") },
465 { BSM_ERRNO_EPROCLIM,
466 #ifdef EPROCLIM
467 EPROCLIM,
468 #else
469 ERRNO_NO_LOCAL_MAPPING,
470 #endif
471 ES("Too many processes") },
472 { BSM_ERRNO_EBADRPC,
473 #ifdef EBADRPC
474 EBADRPC,
475 #else
476 ERRNO_NO_LOCAL_MAPPING,
477 #endif
478 ES("RPC struct is bad") },
479 { BSM_ERRNO_ERPCMISMATCH,
480 #ifdef ERPCMISMATCH
481 ERPCMISMATCH,
482 #else
483 ERRNO_NO_LOCAL_MAPPING,
484 #endif
485 ES("RPC version wrong") },
486 { BSM_ERRNO_EPROGUNAVAIL,
487 #ifdef EPROGUNAVAIL
488 EPROGUNAVAIL,
489 #else
490 ERRNO_NO_LOCAL_MAPPING,
491 #endif
492 ES("RPC prog. not avail") },
493 { BSM_ERRNO_EPROGMISMATCH,
494 #ifdef EPROGMISMATCH
495 EPROGMISMATCH,
496 #else
497 ERRNO_NO_LOCAL_MAPPING,
498 #endif
499 ES("RPC version wrong") },
500 { BSM_ERRNO_EPROCUNAVAIL,
501 #ifdef EPROCUNAVAIL
502 EPROCUNAVAIL,
503 #else
504 ERRNO_NO_LOCAL_MAPPING,
505 #endif
506 ES("Bad procedure for program") },
507 { BSM_ERRNO_EFTYPE,
508 #ifdef EFTYPE
509 EFTYPE,
510 #else
511 ERRNO_NO_LOCAL_MAPPING,
512 #endif
513 ES("Inappropriate file type or format") },
514 { BSM_ERRNO_EAUTH,
515 #ifdef EAUTH
516 EAUTH,
517 #else
518 ERRNO_NO_LOCAL_MAPPING,
519 #endif
520 ES("Authenticateion error") },
521 { BSM_ERRNO_ENEEDAUTH,
522 #ifdef ENEEDAUTH
523 ENEEDAUTH,
524 #else
525 ERRNO_NO_LOCAL_MAPPING,
526 #endif
527 ES("Need authenticator") },
528 { BSM_ERRNO_ENOATTR,
529 #ifdef ENOATTR
530 ENOATTR,
531 #else
532 ERRNO_NO_LOCAL_MAPPING,
533 #endif
534 ES("Attribute not found") },
535 { BSM_ERRNO_EDOOFUS,
536 #ifdef EDOOFUS
537 EDOOFUS,
538 #else
539 ERRNO_NO_LOCAL_MAPPING,
540 #endif
541 ES("Programming error") },
542 { BSM_ERRNO_EJUSTRETURN,
543 #ifdef EJUSTRETURN
544 EJUSTRETURN,
545 #else
546 ERRNO_NO_LOCAL_MAPPING,
547 #endif
548 ES("Just return") },
549 { BSM_ERRNO_ENOIOCTL,
550 #ifdef ENOIOCTL
551 ENOIOCTL,
552 #else
553 ERRNO_NO_LOCAL_MAPPING,
554 #endif
555 ES("ioctl not handled by this layer") },
556 { BSM_ERRNO_EDIRIOCTL,
557 #ifdef EDIRIOCTL
558 EDIRIOCTL,
559 #else
560 ERRNO_NO_LOCAL_MAPPING,
561 #endif
562 ES("do direct ioctl in GEOM") },
563 { BSM_ERRNO_EPWROFF,
564 #ifdef EPWROFF
565 EPWROFF,
566 #else
567 ERRNO_NO_LOCAL_MAPPING,
568 #endif
569 ES("Device power is off") },
570 { BSM_ERRNO_EDEVERR,
571 #ifdef EDEVERR
572 EDEVERR,
573 #else
574 ERRNO_NO_LOCAL_MAPPING,
575 #endif
576 ES("Device error") },
577 { BSM_ERRNO_EBADEXEC,
578 #ifdef EBADEXEC
579 EBADEXEC,
580 #else
581 ERRNO_NO_LOCAL_MAPPING,
582 #endif
583 ES("Bad executable") },
584 { BSM_ERRNO_EBADARCH,
585 #ifdef EBADARCH
586 EBADARCH,
587 #else
588 ERRNO_NO_LOCAL_MAPPING,
589 #endif
590 ES("Bad CPU type in executable") },
591 { BSM_ERRNO_ESHLIBVERS,
592 #ifdef ESHLIBVERS
593 ESHLIBVERS,
594 #else
595 ERRNO_NO_LOCAL_MAPPING,
596 #endif
597 ES("Shared library version mismatch") },
598 { BSM_ERRNO_EBADMACHO,
599 #ifdef EBADMACHO
600 EBADMACHO,
601 #else
602 ERRNO_NO_LOCAL_MAPPING,
603 #endif
604 ES("Malformed Macho file") },
605 { BSM_ERRNO_EPOLICY,
606 #ifdef EPOLICY
607 EPOLICY,
608 #else
609 ERRNO_NO_LOCAL_MAPPING,
610 #endif
611 ES("Operation failed by policy") },
612 { BSM_ERRNO_EDOTDOT,
613 #ifdef EDOTDOT
614 EDOTDOT,
615 #else
616 ERRNO_NO_LOCAL_MAPPING,
617 #endif
618 ES("RFS specific error") },
619 { BSM_ERRNO_EUCLEAN,
620 #ifdef EUCLEAN
621 EUCLEAN,
622 #else
623 ERRNO_NO_LOCAL_MAPPING,
624 #endif
625 ES("Structure needs cleaning") },
626 { BSM_ERRNO_ENOTNAM,
627 #ifdef ENOTNAM
628 ENOTNAM,
629 #else
630 ERRNO_NO_LOCAL_MAPPING,
631 #endif
632 ES("Not a XENIX named type file") },
633 { BSM_ERRNO_ENAVAIL,
634 #ifdef ENAVAIL
635 ENAVAIL,
636 #else
637 ERRNO_NO_LOCAL_MAPPING,
638 #endif
639 ES("No XENIX semaphores available") },
640 { BSM_ERRNO_EISNAM,
641 #ifdef EISNAM
642 EISNAM,
643 #else
644 ERRNO_NO_LOCAL_MAPPING,
645 #endif
646 ES("Is a named type file") },
647 { BSM_ERRNO_EREMOTEIO,
648 #ifdef EREMOTEIO
649 EREMOTEIO,
650 #else
651 ERRNO_NO_LOCAL_MAPPING,
652 #endif
653 ES("Remote I/O error") },
654 { BSM_ERRNO_ENOMEDIUM,
655 #ifdef ENOMEDIUM
656 ENOMEDIUM,
657 #else
658 ERRNO_NO_LOCAL_MAPPING,
659 #endif
660 ES("No medium found") },
661 { BSM_ERRNO_EMEDIUMTYPE,
662 #ifdef EMEDIUMTYPE
663 EMEDIUMTYPE,
664 #else
665 ERRNO_NO_LOCAL_MAPPING,
666 #endif
667 ES("Wrong medium type") },
668 { BSM_ERRNO_ENOKEY,
669 #ifdef ENOKEY
670 ENOKEY,
671 #else
672 ERRNO_NO_LOCAL_MAPPING,
673 #endif
674 ES("Required key not available") },
675 { BSM_ERRNO_EKEYEXPIRED,
676 #ifdef EKEYEXPIRED
677 EKEYEXPIRED,
678 #else
679 ERRNO_NO_LOCAL_MAPPING,
680 #endif
681 ES("Key has expired") },
682 { BSM_ERRNO_EKEYREVOKED,
683 #ifdef EKEYREVOKED
684 EKEYREVOKED,
685 #else
686 ERRNO_NO_LOCAL_MAPPING,
687 #endif
688 ES("Key has been revoked") },
689 { BSM_ERRNO_EKEYREJECTED,
690 #ifdef EKEYREJECTED
691 EKEYREJECTED,
692 #else
693 ERRNO_NO_LOCAL_MAPPING,
694 #endif
695 ES("Key was rejected by service") },
696 { BSM_ERRNO_ENOTCAPABLE,
697 #ifdef ENOTCAPABLE
698 ENOTCAPABLE,
699 #else
700 ERRNO_NO_LOCAL_MAPPING,
701 #endif
702 ES("Capabilities insufficient") },
703 { BSM_ERRNO_ECAPMODE,
704 #ifdef ECAPMODE
705 ECAPMODE,
706 #else
707 ERRNO_NO_LOCAL_MAPPING,
708 #endif
709 ES("Not permitted in capability mode") },
710 };
711
712 static const struct bsm_errno *
713 bsm_lookup_errno_local(int local_errno)
714 {
715 int i;
716
717 for (i = 0; i < nitems(bsm_errnos); i++) {
718 if (bsm_errnos[i].be_local_errno == local_errno)
719 return (&bsm_errnos[i]);
720 }
721 return (NULL);
722 }
723
724 /*
725 * Conversion to the BSM errno space isn't allowed to fail; we simply map to
726 * BSM_ERRNO_UNKNOWN and let the remote endpoint deal with it.
727 */
728 u_char
729 au_errno_to_bsm(int local_errno)
730 {
731 const struct bsm_errno *bsme;
732
733 bsme = bsm_lookup_errno_local(local_errno);
734 if (bsme == NULL)
735 return (BSM_ERRNO_UNKNOWN);
736 return (bsme->be_bsm_errno);
737 }
738
739 static const struct bsm_errno *
740 bsm_lookup_errno_bsm(u_char bsm_errno)
741 {
742 int i;
743
744 for (i = 0; i < nitems(bsm_errnos); i++) {
745 if (bsm_errnos[i].be_bsm_errno == bsm_errno)
746 return (&bsm_errnos[i]);
747 }
748 return (NULL);
749 }
750
751 /*
752 * Converstion from a BSM error to a local error number may fail if either
753 * OpenBSM doesn't recognize the error on the wire, or because there is no
754 * appropriate local mapping.
755 */
756 int
757 au_bsm_to_errno(u_char bsm_errno, int *errorp)
758 {
759 const struct bsm_errno *bsme;
760
761 bsme = bsm_lookup_errno_bsm(bsm_errno);
762 if (bsme == NULL || bsme->be_local_errno == ERRNO_NO_LOCAL_MAPPING)
763 return (-1);
764 *errorp = bsme->be_local_errno;
765 return (0);
766 }
767
768 #if !defined(KERNEL) && !defined(_KERNEL)
769 const char *
770 au_strerror(u_char bsm_errno)
771 {
772 const struct bsm_errno *bsme;
773
774 bsme = bsm_lookup_errno_bsm(bsm_errno);
775 if (bsme == NULL)
776 return ("Unrecognized BSM error");
777 if (bsme->be_local_errno != ERRNO_NO_LOCAL_MAPPING)
778 return (strerror(bsme->be_local_errno));
779 return (bsme->be_strerror);
780 }
781 #endif
Cache object: 2806775b4e3defb5108b810f5294b61d
|