sys/security/audit/audit_bsm_errno.c

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