bsd/security/audit/audit_bsm_errno.c

   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  */
  50 struct 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  */
  81 static 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 };
 590 static const int bsm_errnos_count = sizeof(bsm_errnos) / sizeof(bsm_errnos[0]);
 591
 592 static const struct bsm_errno *
 593 bsm_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  */
 608 u_char
 609 au_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
 619 static const struct bsm_errno *
 620 bsm_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  */
 636 int
 637 au_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)
 649 const char *
 650 au_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 */