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