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 782