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