Posix_errno (posix-errno.Posix

Example

  (* Check for errors when calling a C function *)
  let fd = Posix_errno.raise_on_neg ~call:"open" (fun () ->
    (* some C binding that returns -1 on error *)
    c_open path flags mode
  ) in
  Printf.printf "Opened file descriptor: %d\n" fd

  (* Get the current errno value *)
  let err = Posix_errno.get_errno () in
  Printf.printf "Error: %s\n" (Posix_errno.strerror err)

Errno Type

type t = [

| `E2BIG
| `EACCES
| `EADDRINUSE
| `EADDRNOTAVAIL
| `EAFNOSUPPORT
| `EAGAIN
| `EALREADY
| `EBADF
| `EBADMSG
| `EBUSY
| `ECANCELED
| `ECHILD
| `ECONNABORTED
| `ECONNREFUSED
| `ECONNRESET
| `EDEADLK
| `EDESTADDRREQ
| `EDOM
| `EDQUOT
| `EEXIST
| `EFAULT
| `EFBIG
| `EHOSTDOWN
| `EHOSTUNREACH
| `EIDRM
| `EILSEQ
| `EINPROGRESS
| `EINTR
| `EINVAL
| `EIO
| `EISCONN
| `EISDIR
| `ELOOP
| `EMFILE
| `EMLINK
| `EMSGSIZE
| `EMULTIHOP
| `ENAMETOOLONG
| `ENETDOWN
| `ENETRESET
| `ENETUNREACH
| `ENFILE
| `ENOBUFS
| `ENODATA
| `ENODEV
| `ENOENT
| `ENOEXEC
| `ENOLCK
| `ENOLINK
| `ENOMEM
| `ENOMSG
| `ENOPROTOOPT
| `ENOSPC
| `ENOSR
| `ENOSTR
| `ENOSYS
| `ENOTCONN
| `ENOTDIR
| `ENOTEMPTY
| `ENOTRECOVERABLE
| `ENOTSOCK
| `ENOTSUP
| `ENOTTY
| `ENXIO
| `EOPNOTSUPP
| `EOVERFLOW
| `EOWNERDEAD
| `EPERM
| `EPFNOSUPPORT
| `EPIPE
| `EPROTO
| `EPROTONOSUPPORT
| `EPROTOTYPE
| `ERANGE
| `EREMOTE
| `EROFS
| `ESHUTDOWN
| `ESOCKTNOSUPPORT
| `ESPIPE
| `ESRCH
| `ESTALE
| `ETIME
| `ETIMEDOUT
| `ETOOMANYREFS
| `ETXTBSY
| `EUSERS
| `EWOULDBLOCK
| `EXDEV
| `EBADE
| `EBADFD
| `EBADR
| `EBADRQC
| `EBADSLT
| `ECHRNG
| `ECOMM
| `EDEADLOCK
| `EHWPOISON
| `EISNAM
| `EKEYEXPIRED
| `EKEYREJECTED
| `EKEYREVOKED
| `EL2HLT
| `EL2NSYNC
| `EL3HLT
| `EL3RST
| `ELIBACC
| `ELIBBAD
| `ELIBEXEC
| `ELIBMAX
| `ELIBSCN
| `ELNRNG
| `EMEDIUMTYPE
| `ENOANO
| `ENOKEY
| `ENOMEDIUM
| `ENONET
| `ENOPKG
| `ENOTBLK
| `ENOTUNIQ
| `EREMCHG
| `EREMOTEIO
| `ERESTART
| `ERFKILL
| `ESTRPIPE
| `ETOOBIG
| `EUCLEAN
| `EUNATCH
| `EXFULL
| `EAUTH
| `EBADRPC
| `EFTYPE
| `ENEEDAUTH
| `ENOCSI
| `EPROCLIM
| `EPROCUNAVAIL
| `EPROGMISMATCH
| `EPROGUNAVAIL
| `ERPCMISMATCH
| `EATTR
| `EBADARCH
| `EBADEXEC
| `EBADMACHO
| `EDEVERR
| `ENOATTR
| `ENOPOLICY
| `EPWROFF
| `ESHLIBVERS
| `EOTHER
| `EUNKNOWN of nativeint

]

Comprehensive errno type covering Linux, BSD, macOS, and Windows values

Errno Conversion

val of_int : nativeint -> t

Convert errno integer code to variant.

val to_int : t -> nativeint

Convert variant to errno integer code.

Errno Access

val get_errno : unit -> t

Get current errno value. See errno(3).

val get_errno_int : unit -> nativeint

Get current errno as integer.

val reset_errno : unit -> unit

Reset errno to 0. Should be called before operations that set errno.

Error Raising

val raise_on_error : ?call:string -> (unit -> 'a) -> ('a -> bool) -> 'a

Generic error-raising function.

raise_on_error ?call f check calls f() and checks the result with check. If check returns true, raises a Unix_error based on the current errno.

parameter call
Optional name of the calling function (for error messages)

parameter f
Function to execute

parameter check
Function to check if result indicates an error

returns
The result of f() if no error occurred

raises Unix_error
if check returns true

Specialized Error Checkers

val raise_on_neg : ?call:string -> (unit -> int) -> int

Check for negative integer return (common for syscalls). Raises Unix_error if result < 0.

val raise_on_null : ?call:string -> (unit -> 'a Ctypes.ptr) -> 'a Ctypes.ptr

Check for null pointer return (for C functions). Raises Unix_error if result is null.

val raise_on_zero : ?call:string -> (unit -> int) -> int

Check for zero return value (some functions return 0 on error). Raises Unix_error if result = 0.

val raise_on_none : ?call:string -> (unit -> 'a option) -> 'a

Check for None return value. Raise Unix_error if result = None.

Unix Error Conversion

val to_unix_error : t -> Unix.error

Convert errno variant to Unix.error

val int_to_unix_error : nativeint -> Unix.error

Convert errno int to Unix.error

Error String Functions

val strerror : t -> string

Get error message string for an errno value using strerror.

See strerror(3).

This function is cross-platform (works on both POSIX and Windows) but not thread-safe.

returns
Error message string.

val strerror_r : ?buflen:int -> t -> string

Get error message string for an errno value using strerror_r.

See strerror_r(3).

This function is thread-safe but only available on POSIX systems.

parameter buflen
Optional buffer length for error message (default: 1024).

returns
Error message string.

raises Invalid_argument
on Windows where strerror_r is not available.

raises Unix_error
if strerror_r fails.

Native Definition Detection

val is_native : t -> bool

Check if an errno value is natively defined on this platform. Returns true if the errno is natively defined by the system, false if it's using a placeholder fallback value.

This is useful to determine if an errno constant represents a real system error on the current platform, or if it's just a placeholder value (typically in the 10000+ range) that was assigned because the error doesn't exist on this system.

parameter errnum
The errno value to check

returns
true if natively defined, false if using placeholder