The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/security/audit/audit_bsm_errno.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10  
    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#18
   30  */
   31 
   32 #include <sys/cdefs.h>
   33 __FBSDID("$FreeBSD: releng/9.1/sys/security/audit/audit_bsm_errno.c 219128 2011-03-01 13:14:28Z rwatson $");
   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 EKEEXPIRED
  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 EKEREJECTED
  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

Cache object: e9c0fae8fb4956307b491faa2b004579

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.