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