# Module Core_unix

    module Core_unix: sig .. end

File descriptor.

    module File_descr: sig .. end

File descriptor.

###### Error report

    type error = Unix.error =

`|` | `E2BIG` | `(*` | Argument list too long | `*)`
`|` | `EACCES` | `(*` | Permission denied | `*)`
`|` | `EAGAIN` | `(*` | Resource temporarily unavailable; try again | `*)`
`|` | `EBADF` | `(*` | Bad file descriptor | `*)`
`|` | `EBUSY` | `(*` | Resource unavailable | `*)`
`|` | `ECHILD` | `(*` | No child process | `*)`
`|` | `EDEADLK` | `(*` | Resource deadlock would occur | `*)`
`|` | `EDOM` | `(*` | Domain error for math functions, etc. | `*)`
`|` | `EEXIST` | `(*` | File exists | `*)`
`|` | `EFAULT` | `(*` | Bad address | `*)`
`|` | `EFBIG` | `(*` | File too large | `*)`
`|` | `EINTR` | `(*` | Function interrupted by signal | `*)`
`|` | `EINVAL` | `(*` | Invalid argument | `*)`
`|` | `EIO` | `(*` | Hardware I/O error | `*)`
`|` | `EISDIR` | `(*` | Is a directory | `*)`
`|` | `EMFILE` | `(*` | Too many open files by the process | `*)`
`|` | `EMLINK` | `(*` | Too many links | `*)`
`|` | `ENAMETOOLONG` | `(*` | Filename too long | `*)`
`|` | `ENFILE` | `(*` | Too many open files in the system | `*)`
`|` | `ENODEV` | `(*` | No such device | `*)`
`|` | `ENOENT` | `(*` | No such file or directory | `*)`
`|` | `ENOEXEC` | `(*` | Not an executable file | `*)`
`|` | `ENOLCK` | `(*` | No locks available | `*)`
`|` | `ENOMEM` | `(*` | Not enough memory | `*)`
`|` | `ENOSPC` | `(*` | No space left on device | `*)`
`|` | `ENOSYS` | `(*` | Function not supported | `*)`
`|` | `ENOTDIR` | `(*` | Not a directory | `*)`
`|` | `ENOTEMPTY` | `(*` | Directory not empty | `*)`
`|` | `ENOTTY` | `(*` | Inappropriate I/O control operation | `*)`
`|` | `ENXIO` | `(*` | No such device or address | `*)`
`|` | `EPERM` | `(*` | Operation not permitted | `*)`
`|` | `EPIPE` | `(*` | Broken pipe | `*)`
`|` | `ERANGE` | `(*` | Result too large | `*)`
`|` | `EROFS` | `(*` | Read-only file system | `*)`
`|` | `ESPIPE` | `(*` | Invalid seek e.g. on a pipe | `*)`
`|` | `ESRCH` | `(*` | No such process | `*)`
`|` | `EXDEV` | `(*` | Invalid link | `*)`
`|` | `EWOULDBLOCK` | `(*` | Operation would block | `*)`
`|` | `EINPROGRESS` | `(*` | Operation now in progress | `*)`
`|` | `EALREADY` | `(*` | Operation already in progress | `*)`
`|` | `ENOTSOCK` | `(*` | Socket operation on non-socket | `*)`
`|` | `EDESTADDRREQ` | `(*` | Destination address required | `*)`
`|` | `EMSGSIZE` | `(*` | Message too long | `*)`
`|` | `EPROTOTYPE` | `(*` | Protocol wrong type for socket | `*)`
`|` | `ENOPROTOOPT` | `(*` | Protocol not available | `*)`
`|` | `EPROTONOSUPPORT` | `(*` | Protocol not supported | `*)`
`|` | `ESOCKTNOSUPPORT` | `(*` | Socket type not supported | `*)`
`|` | `EOPNOTSUPP` | `(*` | Operation not supported on socket | `*)`
`|` | `EPFNOSUPPORT` | `(*` | Protocol family not supported | `*)`
`|` | `EAFNOSUPPORT` | `(*` | Address family not supported by protocol family | `*)`
`|` | `EADDRINUSE` | `(*` | Address already in use | `*)`
`|` | `EADDRNOTAVAIL` | `(*` | Can't assign requested address | `*)`
`|` | `ENETDOWN` | `(*` | Network is down | `*)`
`|` | `ENETUNREACH` | `(*` | Network is unreachable | `*)`
`|` | `ENETRESET` | `(*` | Network dropped connection on reset | `*)`
`|` | `ECONNABORTED` | `(*` | Software caused connection abort | `*)`
`|` | `ECONNRESET` | `(*` | Connection reset by peer | `*)`
`|` | `ENOBUFS` | `(*` | No buffer space available | `*)`
`|` | `EISCONN` | `(*` | Socket is already connected | `*)`
`|` | `ENOTCONN` | `(*` | Socket is not connected | `*)`
`|` | `ESHUTDOWN` | `(*` | Can't send after socket shutdown | `*)`
`|` | `ETOOMANYREFS` | `(*` | Too many references: can't splice | `*)`
`|` | `ETIMEDOUT` | `(*` | Connection timed out | `*)`
`|` | `ECONNREFUSED` | `(*` | Connection refused | `*)`
`|` | `EHOSTDOWN` | `(*` | Host is down | `*)`
`|` | `EHOSTUNREACH` | `(*` | No route to host | `*)`
`|` | `ELOOP` | `(*` | Too many levels of symbolic links | `*)`
`|` | `EOVERFLOW` | `(*` | File size or position not representable | `*)`
`|` | `EUNKNOWNERR of `int`` | `(*` | Unknown error | `*)`

Deprecated.in favor of `Core_unix.Error.t` below.
The type of error codes. Errors defined in the POSIX standard and additional errors, mostly BSD. All other errors are mapped to `EUNKNOWNERR`.

    module Error: sig .. end

    exception Unix_error of Error.t * string * string

Raised by the system calls below when an error is encountered. The first component is the error code; the second component is the function name; the third component is the string parameter to the function, if it has one, or the empty string otherwise.

    module Syscall_result: module type of Syscall_result  with type 'a t = 'a Syscall_result.t

    val unix_error : int -> string -> string -> 'a

Raises `Unix_error` with a given errno, function name and argument

    val error_message : error -> string

Deprecated.in favor of `Core_unix.Error.message`.
Return a string describing the given error code.

    val handle_unix_error : (unit -> 'a) -> 'a

`handle_unix_error f` runs `f ()` and returns the result. If the exception `Unix_error` is raised, it prints a message describing the error and exits with code 2.

    val retry_until_no_eintr : (unit -> 'a) -> 'a

`retry_until_no_eintr f` returns `f ()` unless `f ()` fails with `EINTR`; in which case `f ()` is run again until it raises a different error or returns a value.

###### Access to the process environment

If you're looking for `getenv`, that's in the Sys module.

    val environment : unit -> string array

Return the process environment, as an array of strings with the format ``variable=value''.

    val putenv : key:string -> data:string -> unit

`Unix.putenv ~key ~data` sets the value associated to a variable in the process environment. `key` is the name of the environment variable, and `data` its new associated value.

    val unsetenv : string -> unit

`unsetenv name` deletes the variable `name` from the environment.

EINVAL `name` contained an ’=’ or an '\000' character.

###### Process handling

    module Exit: sig .. end

The termination status of a process.

    module Exit_or_signal: sig .. end

    module Exit_or_signal_or_stop: sig .. end

    type env = [ `Extend of (string * string) list
           | `Replace of (string * string) list
           | `Replace_raw of string list ]

`env` is used to control the environment of a child process, and can take three forms. ``Replace_raw` replaces the entire environment with strings in the Unix style, like `"VARIABLE_NAME=value"`. ``Replace` has the same effect as ``Replace_raw`, but using bindings represented as `"VARIABLE_NAME", "value"`. ``Extend` adds entries to the existing environment rather than replacing the whole environment.

If `env` contains multiple bindings for the same variable, the last takes precedence. In the case of ``Extend`, bindings in `env` take precedence over the existing environment.

    val exec : prog:string ->
           args:string list ->
           ?use_path:bool -> ?env:env -> unit -> Core_kernel.Std.never_returns

`exec ~prog ~args ?search_path ?env` execs `prog` with `args`. If `use_path = true` (the default) and `prog` doesn't contain a slash, then `exec` searches the `PATH` environment variable for `prog`. If `env` is supplied, it determines the environment when `prog` is executed.

The first element in args should be the program itself; the correct way to call `exec` is:

        exec ~prog ~args:[ prog; arg1; arg2; ...] ()

    val fork_exec : prog:string ->
           args:string list ->
           ?use_path:bool -> ?env:env -> unit -> Core_kernel.Std.Pid.t

`fork_exec ~prog ~args ?use_path ?env ()` forks and execs `prog` with `args` in the child process, returning the child PID to the parent.

    val fork : unit -> [ `In_the_child | `In_the_parent of Core_kernel.Std.Pid.t ]

`fork ()` forks a new process. The return value indicates whether we are continuing in the child or the parent, and if the parent, includes the child's process id.
`wait{,_nohang,_untraced,_nohang_untraced} ?restart wait_on` is a family of functions that wait on a process to exit (normally or via a signal) or be stopped by a signal (if `untraced` is used). The `wait_on` argument specifies which processes to wait on. The `nohang` variants return `None` immediately if no such process exists. If `nohang` is not used, `waitpid` will block until one of the desired processes exits.

The non-nohang variants have a `restart` flag with (default true) that causes the system call to be retried upon EAGAIN|EINTR. The nohang variants do not have this flag because they don't block.

    type wait_on = [ `Any
           | `Group of Core_kernel.Std.Pid.t
           | `My_group
           | `Pid of Core_kernel.Std.Pid.t ]

    val wait : ?restart:bool ->
           wait_on -> Core_kernel.Std.Pid.t * Exit_or_signal.t

    val wait_nohang : wait_on ->
           (Core_kernel.Std.Pid.t * Exit_or_signal.t) option

    val wait_untraced : ?restart:bool ->
           wait_on ->
           Core_kernel.Std.Pid.t * Exit_or_signal_or_stop.t

    val wait_nohang_untraced : wait_on ->
           (Core_kernel.Std.Pid.t * Exit_or_signal_or_stop.t) option

    val waitpid : Core_kernel.Std.Pid.t -> Exit_or_signal.t

`waitpid pid` waits for child process `pid` to terminate, and returns its exit status. `waitpid_exn` is like `waitpid`, except it only returns if the child exits with status zero, and raises if the child terminates in any other way.

    val waitpid_exn : Core_kernel.Std.Pid.t -> unit

    val system : string -> Exit_or_signal.t

Execute the given command, wait until it terminates, and return its termination status. The string is interpreted by the shell `/bin/sh` and therefore can contain redirections, quotes, variables, etc. The result `WEXITED 127` indicates that the shell couldn't be executed.

    val getpid : unit -> Core_kernel.Std.Pid.t

Return the pid of the process.

    val getppid : unit -> Core_kernel.Std.Pid.t option

Return the pid of the parent process.

    val getppid_exn : unit -> Core_kernel.Std.Pid.t

Return the pid of the parent process, if you're really sure you're never going to be the init process.

    module Thread_id: sig .. end

    val gettid : (unit -> Thread_id.t) Core_kernel.Std.Or_error.t

Get the numeric ID of the current thread, e.g. for identifying it in top(1).

    val nice : int -> int

Change the process priority. The integer argument is added to the ``nice'' value. (Higher values of the ``nice'' value mean lower priorities.) Return the new nice value.

###### Basic file input/output

The abstract type of file descriptors.

    val stdin : File_descr.t

File descriptor for standard input.

    val stdout : File_descr.t

File descriptor for standard output.

    val stderr : File_descr.t

File descriptor for standard standard error.
The flags to `UnixLabels.openfile`.

    type open_flag = Unix.open_flag =

`|` | `O_RDONLY` | `(*` | Open for reading | `*)`
`|` | `O_WRONLY` | `(*` | Open for writing | `*)`
`|` | `O_RDWR` | `(*` | Open for reading and writing | `*)`
`|` | `O_NONBLOCK` | `(*` | Open in non-blocking mode | `*)`
`|` | `O_APPEND` | `(*` | Open for append | `*)`
`|` | `O_CREAT` | `(*` | Create if nonexistent | `*)`
`|` | `O_TRUNC` | `(*` | Truncate to 0 length if existing | `*)`
`|` | `O_EXCL` | `(*` | Fail if existing | `*)`
`|` | `O_NOCTTY` | `(*` | Don't make this dev a controlling tty | `*)`
`|` | `O_DSYNC` | `(*` | Writes complete as `Synchronised I/O data integrity completion' | `*)`
`|` | `O_SYNC` | `(*` | Writes complete as `Synchronised I/O file integrity completion' | `*)`
`|` | `O_RSYNC` | `(*` | Reads complete as writes (depending on O_SYNC/O_DSYNC) | `*)`
`|` | `O_SHARE_DELETE` | `(*` | Windows only: allow the file to be deleted while still open | `*)`
`|` | `O_CLOEXEC` | `(*` | Set the close-on-exec flag on the descriptor returned by `Core_unix.openfile` | `*)`

    val open_flag_of_sexp : Core_kernel.Std.Sexp.t -> open_flag

    val sexp_of_open_flag : open_flag -> Core_kernel.Std.Sexp.t

    type file_perm = int

The type of file access rights.

    val openfile : ?perm:file_perm ->
           mode:open_flag list -> string -> File_descr.t

Open the named file with the given flags. Third argument is the permissions to give to the file if it is created. Return a file descriptor on the named file. Default permissions 0o644.

    module Open_flags: sig .. end

    val fcntl_getfl : File_descr.t -> Open_flags.t

`fcntl_getfl fd` gets the current flags for `fd` from the open-file-descriptor table via the system call `fcntl(fd, F_GETFL)`. See "man fcntl".

    val fcntl_setfl : File_descr.t -> Open_flags.t -> unit

`fcntl_setfl fd flags` sets the flags for `fd` in the open-file-descriptor table via the system call `fcntl(fd, F_SETFL, flags)`. See "man fcntl". As per the Linux man page, on Linux this only allows `append` and `nonblock` to be set.

    val close : ?restart:bool -> File_descr.t -> unit

Close a file descriptor.

    val with_file : ?perm:file_perm ->
           string ->
           mode:open_flag list -> f:(File_descr.t -> 'a) -> 'a

`with_file file ~mode ~perm ~f` opens `file`, and applies `f` to the resulting file descriptor. When `f` finishes (or raises), `with_file` closes the descriptor and returns the result of `f` (or raises).

    val read : ?restart:bool ->
           ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int

`read fd buff ofs len` reads `len` characters from descriptor `fd`, storing them in string `buff`, starting at position `ofs` in string `buff`. Return the number of characters actually read.

    val write : ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int

`write fd buff ofs len` writes `len` characters to descriptor `fd`, taking them from string `buff`, starting at position `ofs` in string `buff`. Return the number of characters actually written.

When an error is reported some characters might have already been written. Use `single_write` instead to ensure that this is not the case.

WARNING: write is an interruptible call and has no way to handle EINTR properly. You should most probably be using single write.

    val single_write : ?restart:bool ->
           ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int

Same as `write` but ensures that all errors are reported and that no character has ever been written when an error is reported.

###### Interfacing with the standard input/output library

    val in_channel_of_descr : File_descr.t -> Core_kernel.Std.In_channel.t

Create an input channel reading from the given descriptor. The channel is initially in binary mode; use `set_binary_mode_in ic false` if text mode is desired.

    val out_channel_of_descr : File_descr.t -> Core_kernel.Std.Out_channel.t

Create an output channel writing on the given descriptor. The channel is initially in binary mode; use `set_binary_mode_out oc false` if text mode is desired.

    val descr_of_in_channel : Core_kernel.Std.In_channel.t -> File_descr.t

Return the descriptor corresponding to an input channel.

    val descr_of_out_channel : Core_kernel.Std.Out_channel.t -> File_descr.t

Return the descriptor corresponding to an output channel.

###### Seeking and truncating

    type seek_command = Unix.seek_command =

`|` | `SEEK_SET` | `(*` | indicates positions relative to the beginning of the file | `*)`
`|` | `SEEK_CUR` | `(*` | indicates positions relative to the current position | `*)`
`|` | `SEEK_END` | `(*` | indicates positions relative to the end of the file | `*)`

POSITIONING modes for `UnixLabels.lseek`.

    val lseek : File_descr.t -> int64 -> mode:seek_command -> int64

    val truncate : string -> len:int64 -> unit

Truncates the named file to the given size.

    val ftruncate : File_descr.t -> len:int64 -> unit

Truncates the file corresponding to the given descriptor to the given size.

###### File statistics

    type file_kind = Unix.file_kind =

`|` | `S_REG` | `(*` | Regular file | `*)`
`|` | `S_DIR` | `(*` | Directory | `*)`
`|` | `S_CHR` | `(*` | Character device | `*)`
`|` | `S_BLK` | `(*` | Block device | `*)`
`|` | `S_LNK` | `(*` | Symbolic link | `*)`
`|` | `S_FIFO` | `(*` | Named pipe | `*)`
`|` | `S_SOCK` | `(*` | Socket | `*)`

    type stats = Unix.LargeFile.stats = {

`` | `st_dev : `int`;` | `(*` | Device number | `*)`
`` | `st_ino : `int`;` | `(*` | Inode number | `*)`
`` | `st_kind : `file_kind`;` | `(*` | Kind of the file | `*)`
`` | `st_perm : `file_perm`;` | `(*` | Access rights | `*)`
`` | `st_nlink : `int`;` | `(*` | Number of links | `*)`
`` | `st_uid : `int`;` | `(*` | User id of the owner | `*)`
`` | `st_gid : `int`;` | `(*` | Group ID of the file's group | `*)`
`` | `st_rdev : `int`;` | `(*` | Device minor number | `*)`
`` | `st_size : `int64`;` | `(*` | Size in bytes | `*)`
`` | `st_atime : `float`;` | `(*` | Last access time | `*)`
`` | `st_mtime : `float`;` | `(*` | Last modification time | `*)`
`` | `st_ctime : `float`;` | `(*` | Last status change time | `*)`

}

    val stat : string -> stats

Return the information for the named file.

    val lstat : string -> stats

Same as `UnixLabels.stat`, but in case the file is a symbolic link, return the information for the link itself.

    val fstat : File_descr.t -> stats

Return the information for the file associated with the given descriptor.

    module Native_file: sig .. end

###### Locking

    type lock_command = Unix.lock_command =

`|` | `F_ULOCK` | `(*` | Unlock a region | `*)`
`|` | `F_LOCK` | `(*` | Lock a region for writing, and block if already locked | `*)`
`|` | `F_TLOCK` | `(*` | Lock a region for writing, or fail if already locked | `*)`
`|` | `F_TEST` | `(*` | Test a region for other process locks | `*)`
`|` | `F_RLOCK` | `(*` | Lock a region for reading, and block if already locked | `*)`
`|` | `F_TRLOCK` | `(*` | Lock a region for reading, or fail if already locked | `*)`

Commands for `Core_unix.lockf`.

    val lockf : File_descr.t ->
           mode:lock_command -> len:Core_kernel.Std.Int64.t -> unit

    module Flock_command: sig .. end

    val flock : File_descr.t -> Flock_command.t -> bool

`flock fd cmd` places or releases a lock on the fd as per the flock C call of the same name.

    val isatty : File_descr.t -> bool

Return `true` if the given file descriptor refers to a terminal or console window, `false` otherwise.

###### Operations on file names

    val unlink : string -> unit

Removes the named file

    val remove : string -> unit

Removes the named file or directory

    val rename : src:string -> dst:string -> unit

`rename old new` changes the name of a file from `old` to `new`.

    val link : ?force:bool -> target:string -> link_name:string -> unit -> unit

`link ?force ~target ~link_name ()` creates a hard link named `link_name` to the file named `target`. If `force` is true, an existing entry in place of `link_name` will be unlinked. This unlinking may raise a Unix error, e.g. if the entry is a directory.

###### File permissions and ownership

    val chmod : string -> perm:file_perm -> unit

Change the permissions of the named file.

    val fchmod : File_descr.t -> perm:file_perm -> unit

Change the permissions of an opened file.

    val chown : string -> uid:int -> gid:int -> unit

Change the owner uid and owner gid of the named file.

    val fchown : File_descr.t -> uid:int -> gid:int -> unit

Change the owner uid and owner gid of an opened file.

    val umask : int -> int

Set the process creation mask, and return the previous mask.

    val access : string ->
           [ `Exec | `Exists | `Read | `Write ] list ->
           (unit, exn) Core_kernel.Std.Result.t

Check that the process has the given permissions over the named file.

    val access_exn : string -> [ `Exec | `Exists | `Read | `Write ] list -> unit

###### Operations on file descriptors

    val dup : File_descr.t -> File_descr.t

Return a new file descriptor referencing the same file as the given descriptor.

    val dup2 : src:File_descr.t -> dst:File_descr.t -> unit

`dup2 ~src ~dst` duplicates `src` to `dst`, closing `dst` if already opened.

    val set_nonblock : File_descr.t -> unit

Set the ``non-blocking'' flag on the given descriptor. When the non-blocking flag is set, reading on a descriptor on which there is temporarily no data available raises the `EAGAIN` or `EWOULDBLOCK` error instead of blocking; writing on a descriptor on which there is temporarily no room for writing also raises `EAGAIN` or `EWOULDBLOCK`.

    val clear_nonblock : File_descr.t -> unit

Clear the ``non-blocking'' flag on the given descriptor. See `UnixLabels.set_nonblock`.

    val set_close_on_exec : File_descr.t -> unit

Set the ``close-on-exec'' flag on the given descriptor. A descriptor with the close-on-exec flag is automatically closed when the current process starts another program with one of the `exec` functions.

    val clear_close_on_exec : File_descr.t -> unit

Clear the ``close-on-exec'' flag on the given descriptor. See `UnixLabels.set_close_on_exec`.

###### Directories

    val mkdir : ?perm:file_perm -> string -> unit

Create a directory. The permissions of the created directory are (perm & ~umask & 0777). The default perm is 0777.

    val mkdir_p : ?perm:file_perm -> string -> unit

Create a directory recursively. The permissions of the created directory are those granted by `mkdir ~perm`.

    val rmdir : string -> unit

Remove an empty directory.

    val chdir : string -> unit

Change the process working directory.

    val getcwd : unit -> string

Return the name of the current working directory.

    val chroot : string -> unit

Change the process root directory.

    type dir_handle = Unix.dir_handle

The type of descriptors over opened directories.

    val opendir : ?restart:bool -> string -> dir_handle

Open a descriptor on a directory

    val readdir : dir_handle -> string

Return the next entry in a directory.
Raises `End_of_file` when the end of the directory has been reached.

    val rewinddir : dir_handle -> unit

Reposition the descriptor to the beginning of the directory

    val closedir : dir_handle -> unit

Close a directory descriptor.

###### Pipes and redirections

    val pipe : unit -> File_descr.t * File_descr.t

Create a pipe. The first component of the result is opened for reading, that's the exit to the pipe. The second component is opened for writing, that's the entrance to the pipe.

    val mkfifo : string -> perm:file_perm -> unit

Create a named pipe with the given permissions.

###### High-level process and redirection management

    module Process_info: sig .. end

Low-level process

    val create_process : prog:string -> args:string list -> Process_info.t

`create_process ~prog ~args` forks a new process that executes the program `prog` with arguments `args`. The function returns the pid of the process along with file descriptors attached to stdin, stdout, and stderr of the new process. The executable file `prog` is searched for in the path. The new process has the same environment as the current process. Unlike in `execve` the program name is automatically passed as the first argument.

    val create_process_env : ?working_dir:string ->
           prog:string ->
           args:string list -> env:env -> unit -> Process_info.t

`create_process_env ~prog ~args ~env` as `create_process`, but takes an additional parameter that extends or replaces the current environment. No effort is made to ensure that the keys passed in as env are unique, so if an environment variable is set twice the second version will override the first.

    val open_process_in : string -> Pervasives.in_channel

High-level pipe and process management. These functions (with `UnixLabels.open_process_out` and `UnixLabels.open_process`) run the given command in parallel with the program, and return channels connected to the standard input and/or the standard output of the command. The command is interpreted by the shell `/bin/sh` (cf. `system`). Warning: writes on channels are buffered, hence be careful to call `Pervasives.flush` at the right times to ensure correct synchronization.

    val open_process_out : string -> Pervasives.out_channel

See `UnixLabels.open_process_in`.

    val open_process : string -> Pervasives.in_channel * Pervasives.out_channel

See `UnixLabels.open_process_in`.

    module Process_channels: sig .. end

Similar to `UnixLabels.open_process`, but the second argument specifies the environment passed to the command.

    val open_process_full : string -> env:string array -> Process_channels.t

    val close_process_in : Pervasives.in_channel -> Exit_or_signal.t

Close channels opened by `UnixLabels.open_process_in`, wait for the associated command to terminate, and return its termination status.

    val close_process_out : Pervasives.out_channel -> Exit_or_signal.t

Close channels opened by `UnixLabels.open_process_out`, wait for the associated command to terminate, and return its termination status.

    val close_process : Pervasives.in_channel * Pervasives.out_channel -> Exit_or_signal.t

Close channels opened by `UnixLabels.open_process`, wait for the associated command to terminate, and return its termination status.

    val close_process_full : Process_channels.t -> Exit_or_signal.t

Close channels opened by `UnixLabels.open_process_full`, wait for the associated command to terminate, and return its termination status.

###### Symbolic links

    val symlink : src:string -> dst:string -> unit

`symlink source dest` creates the file `dest` as a symbolic link to the file `source`.

    val readlink : string -> string

Read the contents of a link.

###### Polling

    module Select_fds: sig .. end

Wait until some input/output operations become possible on some channels.

    type select_timeout = [ `After of Core_kernel.Time_ns.Span.t | `Immediately | `Never ]

    val select : ?restart:bool ->
           read:File_descr.t list ->
           write:File_descr.t list ->
           except:File_descr.t list ->
           timeout:select_timeout -> unit -> Select_fds.t

Setting restart to true means that we want select to restart automatically on EINTR (instead of propagating the exception)...

    val pause : unit -> unit

Wait until a non-ignored, non-blocked signal is delivered.

###### Time functions

    type process_times = Unix.process_times = {

`` | `tms_utime : `float`;` | `(*` | User time for the process | `*)`
`` | `tms_stime : `float`;` | `(*` | System time for the process | `*)`
`` | `tms_cutime : `float`;` | `(*` | User time for the children processes | `*)`
`` | `tms_cstime : `float`;` | `(*` | System time for the children processes | `*)`

}
The execution times (CPU times) of a process.

    type tm = Unix.tm = {

`` | `tm_sec : `int`;` | `(*` | Seconds 0..59 | `*)`
`` | `tm_min : `int`;` | `(*` | Minutes 0..59 | `*)`
`` | `tm_hour : `int`;` | `(*` | Hours 0..23 | `*)`
`` | `tm_mday : `int`;` | `(*` | Day of month 1..31 | `*)`
`` | `tm_mon : `int`;` | `(*` | Month of year 0..11 | `*)`
`` | `tm_year : `int`;` | `(*` | Year - 1900 | `*)`
`` | `tm_wday : `int`;` | `(*` | Day of week (Sunday is 0) | `*)`
`` | `tm_yday : `int`;` | `(*` | Day of year 0..365 | `*)`
`` | `tm_isdst : `bool`;` | `(*` | Daylight time savings in effect | `*)`

}
The type representing wallclock time and calendar date.

    val time : unit -> float

Return the current time since 00:00:00 GMT, Jan. 1, 1970, in seconds.

    val gettimeofday : unit -> float

Same as `Core_unix.time` above, but with resolution better than 1 second.

    val gmtime : float -> tm

Convert a time in seconds, as returned by `UnixLabels.time`, into a date and a time. Assumes UTC.

    val timegm : tm -> float

Convert a UTC time in a tm record to a time in seconds

    val localtime : float -> tm

Convert a time in seconds, as returned by `UnixLabels.time`, into a date and a time. Assumes the local time zone.

    val mktime : tm -> float * tm

Convert a date and time, specified by the `tm` argument, into a time in seconds, as returned by `UnixLabels.time`. Also return a normalized copy of the given `tm` record, with the `tm_wday`, `tm_yday`, and `tm_isdst` fields recomputed from the other fields. The `tm` argument is interpreted in the local time zone.

    val strftime : tm -> string -> string

Convert a date and time, specified by the `tm` argument, into a formatted string. See 'man strftime' for format options.

    val strptime : fmt:string -> string -> Unix.tm

Given a format string, convert a corresponding string to a date and time See 'man strptime' for format options.

    val alarm : int -> int

Schedule a `SIGALRM` signal after the given number of seconds.

    val sleep : int -> unit

Stop execution for the given number of seconds.

    val nanosleep : float -> float

`nanosleep f` delays execution of the program for at least `f` seconds. The function can return earlier if a signal has been delivered, in which case the number of seconds left is returned. Any other failure raises an exception.

    val times : unit -> process_times

Return the execution times of the process.

    val utimes : string -> access:float -> modif:float -> unit

Set the last access time (second arg) and last modification time (third arg) for a file. Times are expressed in seconds from 00:00:00 GMT, Jan. 1, 1970.

    type interval_timer = Unix.interval_timer =

`|` | `ITIMER_REAL` | `(*` | decrements in real time, and sends the signal `SIGALRM` when expired. | `*)`
`|` | `ITIMER_VIRTUAL` | `(*` | decrements in process virtual time, and sends `SIGVTALRM` when expired. | `*)`
`|` | `ITIMER_PROF` | `(*` | (for profiling) decrements both when the process is running and when the system is running on behalf of the process; it sends `SIGPROF` when expired. | `*)`

The three kinds of interval timers.

    type interval_timer_status = Unix.interval_timer_status = {

`` | `it_interval : `float`;` | `(*` | Period | `*)`
`` | `it_value : `float`;` | `(*` | Current value of the timer | `*)`

}

    val getitimer : interval_timer -> interval_timer_status

Return the current status of the given interval timer.

    val setitimer : interval_timer ->
           interval_timer_status -> interval_timer_status

`setitimer t s` sets the interval timer `t` and returns its previous status. The `s` argument is interpreted as follows: `s.it_value`, if nonzero, is the time to the next timer expiration; `s.it_interval`, if nonzero, specifies a value to be used in reloading it_value when the timer expires. Setting `s.it_value` to zero disable the timer. Setting `s.it_interval` to zero causes the timer to be disabled after its next expiration.

###### User id, group id

It's highly recommended to read the straight unix docs on these functions for more color. You can get that info from man pages or http://www.opengroup.org/onlinepubs/000095399/functions/setuid.html

    val getuid : unit -> int

Return the user id of the user executing the process.

    val geteuid : unit -> int

Return the effective user id under which the process runs.

    val setuid : int -> unit

Sets the real user id and effective user id for the process. Only use this when superuser. To setuid as an ordinary user, see Core_extended.Unix.seteuid.

    val getgid : unit -> int

Return the group id of the user executing the process.

    val getegid : unit -> int

Return the effective group id under which the process runs.

    val setgid : int -> unit

Set the real group id and effective group id for the process.

    module Passwd: sig .. end

Structure of entries in the `passwd` database

    module Group: sig .. end

Structure of entries in the `groups` database.

    val getlogin : unit -> string

Return the login name of the user executing the process.

    module Protocol_family: sig .. end

###### Internet addresses

    module Inet_addr: sig .. end

    module Cidr: sig .. end

A representation of CIDR netmasks (e.g.

###### Sockets

    type socket_domain = Unix.socket_domain =

`|` | `PF_UNIX` | `(*` | Unix domain | `*)`
`|` | `PF_INET` | `(*` | Internet domain | `*)`
`|` | `PF_INET6`

The type of socket domains.

    type socket_type = Unix.socket_type =

`|` | `SOCK_STREAM` | `(*` | Stream socket | `*)`
`|` | `SOCK_DGRAM` | `(*` | Datagram socket | `*)`
`|` | `SOCK_RAW` | `(*` | Raw socket | `*)`
`|` | `SOCK_SEQPACKET`

The type of socket kinds, specifying the semantics of communications.

    type sockaddr = Unix.sockaddr =

`|` | `ADDR_UNIX of `string``
`|` | `ADDR_INET of `Inet_addr.t * int``

The type of socket addresses. `ADDR_UNIX name` is a socket address in the Unix domain; `name` is a file name in the file system. `ADDR_INET(addr,port)` is a socket address in the Internet domain; `addr` is the Internet address of the machine, and `port` is the port number.

    val domain_of_sockaddr : sockaddr -> socket_domain

Return the socket domain adequate for the given socket address.

    val socket : domain:socket_domain ->
           kind:socket_type -> protocol:int -> File_descr.t

Create a new socket in the given domain, and with the given kind. The third argument is the protocol type; 0 selects the default protocol for that kind of sockets.

    val socketpair : domain:socket_domain ->
           kind:socket_type ->
           protocol:int -> File_descr.t * File_descr.t

Create a pair of unnamed sockets, connected together.

    val accept : File_descr.t -> File_descr.t * sockaddr

Accept connections on the given socket. The returned descriptor is a socket connected to the client; the returned address is the address of the connecting client.

    val bind : File_descr.t -> addr:sockaddr -> unit

Bind a socket to an address.

    val connect : File_descr.t -> addr:sockaddr -> unit

Connect a socket to an address.

    val listen : File_descr.t -> max:int -> unit

Set up a socket for receiving connection requests. The integer argument is the maximal number of pending requests.

    type shutdown_command = Unix.shutdown_command =

`|` | `SHUTDOWN_RECEIVE` | `(*` | Close for receiving | `*)`
`|` | `SHUTDOWN_SEND` | `(*` | Close for sending | `*)`
`|` | `SHUTDOWN_ALL` | `(*` | Close both | `*)`

The type of commands for `shutdown`.

    val shutdown : File_descr.t -> mode:shutdown_command -> unit

    val getsockname : File_descr.t -> sockaddr

Return the address of the given socket.

    val getpeername : File_descr.t -> sockaddr

Return the address of the host connected to the given socket.

    type msg_flag = Unix.msg_flag =

`|` | `MSG_OOB`
`|` | `MSG_DONTROUTE`
`|` | `MSG_PEEK`

The flags for `UnixLabels.recv`, `UnixLabels.recvfrom`, `UnixLabels.send` and `UnixLabels.sendto`.

    val recv : File_descr.t ->
           buf:string -> pos:int -> len:int -> mode:msg_flag list -> int

Receive data from a connected socket.

    val recvfrom : File_descr.t ->
           buf:string ->
           pos:int ->
           len:int -> mode:msg_flag list -> int * sockaddr

Receive data from an unconnected socket.

    val send : File_descr.t ->
           buf:string -> pos:int -> len:int -> mode:msg_flag list -> int

Send data over a connected socket.

    val sendto : File_descr.t ->
           buf:string ->
           pos:int ->
           len:int -> mode:msg_flag list -> addr:sockaddr -> int

Send data over an unconnected socket.

###### Socket options

    type socket_bool_option =

`|` | `SO_DEBUG` | `(*` | Record debugging information | `*)`
`|` | `SO_BROADCAST` | `(*` | Permit sending of broadcast messages | `*)`
`|` | `SO_REUSEADDR` | `(*` | Allow reuse of local addresses for bind | `*)`
`|` | `SO_KEEPALIVE` | `(*` | Keep connection active | `*)`
`|` | `SO_DONTROUTE` | `(*` | Bypass the standard routing algorithms | `*)`
`|` | `SO_OOBINLINE` | `(*` | Leave out-of-band data in line | `*)`
`|` | `SO_ACCEPTCONN`
`|` | `TCP_NODELAY` | `(*` | Control the Nagle algorithm for TCP sockets | `*)`
`|` | `IPV6_ONLY` | `(*` | Forbid binding an IPv6 socket to an IPv4 address | `*)`

The socket options that can be consulted with `UnixLabels.getsockopt` and modified with `UnixLabels.setsockopt`. These options have a boolean (`true`/`false`) value.

    type socket_int_option =

`|` | `SO_SNDBUF` | `(*` | Size of send buffer | `*)`
`|` | `SO_RCVBUF` | `(*` | Size of received buffer | `*)`
`|` | `SO_ERROR` | `(*` | Report the error status and clear it | `*)`
`|` | `SO_TYPE` | `(*` | Report the socket type | `*)`
`|` | `SO_RCVLOWAT` | `(*` | Minimum number of bytes to process for input operations | `*)`
`|` | `SO_SNDLOWAT`

    type socket_optint_option =

`|` | `SO_LINGER` | `(*` | Whether to linger on closed connections with sexp that have data present, and for how long (in seconds) | `*)`

The socket options that can be consulted with `UnixLabels.getsockopt_optint` and modified with `UnixLabels.setsockopt_optint`. These options have a value of type `int option`, with `None` meaning ``disabled''.

    type socket_float_option =

`|` | `SO_RCVTIMEO` | `(*` | Timeout for input operations | `*)`
`|` | `SO_SNDTIMEO` | `(*` | Timeout for output operations | `*)`

The socket options that can be consulted with `UnixLabels.getsockopt_float` and modified with `UnixLabels.setsockopt_float`. These options have a floating-point value representing a time in seconds. The value 0 means infinite timeout.

    val getsockopt : File_descr.t -> socket_bool_option -> bool

    val setsockopt : File_descr.t -> socket_bool_option -> bool -> unit

Set or clear a boolean-valued option in the given socket.

    val getsockopt_int : File_descr.t -> socket_int_option -> int

Same as `UnixLabels.getsockopt` for an integer-valued socket option.

    val setsockopt_int : File_descr.t -> socket_int_option -> int -> unit

Same as `UnixLabels.setsockopt` for an integer-valued socket option.

    val getsockopt_optint : File_descr.t -> socket_optint_option -> int option

Same as `UnixLabels.getsockopt` for a socket option whose value is an `int option`.

    val setsockopt_optint : File_descr.t ->
           socket_optint_option -> int option -> unit

Same as `UnixLabels.setsockopt` for a socket option whose value is an `int option`.

    val getsockopt_float : File_descr.t -> socket_float_option -> float

Same as `UnixLabels.getsockopt` for a socket option whose value is a floating-point number.

    val setsockopt_float : File_descr.t -> socket_float_option -> float -> unit

Same as `UnixLabels.setsockopt` for a socket option whose value is a floating-point number.

###### High-level network connection functions

    val open_connection : sockaddr -> Pervasives.in_channel * Pervasives.out_channel

Connect to a server at the given address. Return a pair of buffered channels connected to the server. Remember to call `Pervasives.flush` on the output channel at the right times to ensure correct synchronization.

    val shutdown_connection : Pervasives.in_channel -> unit

``Shut down'' a connection established with `UnixLabels.open_connection`; that is, transmit an end-of-file condition to the server reading on the other side of the connection.

    val establish_server : (Pervasives.in_channel -> Pervasives.out_channel -> unit) ->
           addr:sockaddr -> unit

Establish a server on the given address. The function given as first argument is called for each connection with two buffered channels connected to the client. A new process is created for each connection. The function `UnixLabels.establish_server` never returns normally.

###### Host and protocol databases

    val gethostname : unit -> string

Return the name of the local host.

    module Host: sig .. end

    module Protocol: sig .. end

    module Service: sig .. end

    type addr_info = {

`` | `ai_family : `socket_domain`;` | `(*` | Socket domain | `*)`
`` | `ai_socktype : `socket_type`;` | `(*` | Socket type | `*)`
`` | `ai_protocol : `int`;` | `(*` | Socket protocol number | `*)`
`` | `ai_addr : `sockaddr`;` | `(*` | Address | `*)`
`` | `ai_canonname : `string`;`

}
Address information returned by `Unix.getaddrinfo`.

    type getaddrinfo_option =

`|` | `AI_FAMILY of `socket_domain`` | `(*` | Impose the given socket domain | `*)`
`|` | `AI_SOCKTYPE of `socket_type`` | `(*` | Impose the given socket type | `*)`
`|` | `AI_PROTOCOL of `int`` | `(*` | Impose the given protocol | `*)`
`|` | `AI_NUMERICHOST` | `(*` | Do not call name resolver, expect numeric IP address | `*)`
`|` | `AI_CANONNAME` | `(*` | Fill the `ai_canonname` field of the result | `*)`
`|` | `AI_PASSIVE`

Options to `Unix.getaddrinfo`.

    val getaddrinfo : string ->
           string -> getaddrinfo_option list -> addr_info list

`getaddrinfo host service opts` returns a list of `Unix.addr_info` records describing socket parameters and addresses suitable for communicating with the given host and service. The empty list is returned if the host or service names are unknown, or the constraints expressed in `opts` cannot be satisfied.

`host` is either a host name or the string representation of an IP address. `host` can be given as the empty string; in this case, the ``any'' address or the ``loopback'' address are used, depending whether `opts` contains `AI_PASSIVE`. `service` is either a service name or the string representation of a port number. `service` can be given as the empty string; in this case, the port field of the returned addresses is set to 0. `opts` is a possibly empty list of options that allows the caller to force a particular socket domain (e.g. IPv6 only, or IPv4 only) or a particular socket type (e.g. TCP only or UDP only).

    type name_info = {

`` | `ni_hostname : `string`;` | `(*` | Name or IP address of host | `*)`
`` | `ni_service : `string`;`

}
Host and service information returned by `Unix.getnameinfo`.

Name of service or port number

    type getnameinfo_option =

`|` | `NI_NOFQDN` | `(*` | Do not qualify local host names | `*)`
`|` | `NI_NUMERICHOST` | `(*` | Always return host as IP address | `*)`
`|` | `NI_NAMEREQD` | `(*` | Fail if host name cannot be determined | `*)`
`|` | `NI_NUMERICSERV` | `(*` | Always return service as port number | `*)`
`|` | `NI_DGRAM`

    val getnameinfo : sockaddr ->
           getnameinfo_option list -> name_info

`getnameinfo addr opts` returns the host name and service name corresponding to the socket address `addr`. `opts` is a possibly empty list of options that governs how these names are obtained. Raise `Not_found` if an error occurs.

## Getting terminal size

###### Terminal interface

The following functions implement the POSIX standard terminal interface. They provide control over asynchronous communication ports and pseudo-terminals. Refer to the `termios` man page for a complete description.

    module Terminal_io: sig .. end

    val get_sockaddr : string -> int -> sockaddr

Get a sockaddr from a hostname or IP, and a port

    val set_in_channel_timeout : Pervasives.in_channel -> float -> unit

Set a timeout for a socket associated with an `in_channel`

    val set_out_channel_timeout : Pervasives.out_channel -> float -> unit

Set a timeout for a socket associated with an `out_channel`

    val exit_immediately : int -> 'a

`exit_immediately exit_code` immediately calls the `exit` system call with the given exit code without performing any other actions (unlike Pervasives.exit). Does not return.

## Filesystem functions

    val mknod : ?file_kind:file_kind ->
           ?perm:int -> ?major:int -> ?minor:int -> string -> unit

`mknod ?file_kind ?perm ?major ?minor path` creates a filesystem entry. Note that only FIFO-entries are guaranteed to be supported across all platforms as required by the POSIX-standard. On Linux directories and symbolic links cannot be created with this function. Use `Unix.mkdir` and `Unix.symlink` instead there respectively.
Raises

- `Invalid_argument` if an unsupported file kind is used.
- `Unix_error` if the system call fails.

`file_kind` : default = `S_REG` (= regular file)
`perm` : default = `0o600` (= read/write for user only)
`major` : default = `0`
`minor` : default = `0`

## I/O vectors

    module IOVec: sig .. end

I/O-vectors for scatter/gather-operations

## I/O functions

    val dirfd : dir_handle -> File_descr.t

Extract a file descriptor from a directory handle.

    val sync : unit -> unit

Synchronize all filesystem buffers with disk.

    val fsync : File_descr.t -> unit

    val fdatasync : File_descr.t -> unit

Synchronize the kernel buffers of a given file descriptor with disk, but do not necessarily write file attributes.

    val readdir_ino : dir_handle -> string * nativeint

`readdir_ino dh` return the next entry in a directory ((`(filename, inode)`).
Raises `End_of_file` when the end of the directory has been reached.

    val read_assume_fd_is_nonblocking : File_descr.t -> ?pos:int -> ?len:int -> string -> int

`read_assume_fd_is_nonblocking fd ?pos ?len buf` calls the system call `read` ASSUMING THAT IT IS NOT GOING TO BLOCK. Reads at most `len` bytes into buffer `buf` starting at position `pos`.
Raises

- `Invalid_argument` if buffer range out of bounds.
- `Unix_error` on Unix-errors.

Returns the number of bytes actually read.
`pos` : = 0
`len` : = `String.length buf - pos`

    val write_assume_fd_is_nonblocking : File_descr.t -> ?pos:int -> ?len:int -> string -> int

`write_assume_fd_is_nonblocking fd ?pos ?len buf` calls the system call `write` ASSUMING THAT IT IS NOT GOING TO BLOCK. Writes at most `len` bytes from buffer `buf` starting at position `pos`.
Raises

- `Invalid_argument` if buffer range out of bounds.
- `Unix_error` on Unix-errors.

Returns the number of bytes actually written.
`pos` : = 0
`len` : = `String.length buf - pos`

    val writev_assume_fd_is_nonblocking : File_descr.t -> ?count:int -> string IOVec.t array -> int

`writev_assume_fd_is_nonblocking fd ?count iovecs` calls the system call `writev` ASSUMING THAT IT IS NOT GOING TO BLOCK using `count` I/O-vectors `iovecs`.
Raises

- `Invalid_argument` if the designated ranges are invalid.
- `Unix_error` on Unix-errors.

Returns the number of bytes actually written.

    val writev : File_descr.t -> ?count:int -> string IOVec.t array -> int

`writev fd ?count iovecs` like `Core_unix.writev_assume_fd_is_nonblocking`, but does not require the descriptor to not block. If you feel you have to use this function, you should probably have chosen I/O-vectors that build on bigstrings, because this function has to internally blit the I/O-vectors (ordinary OCaml strings) to intermediate buffers on the C-heap.
Raises

- `Invalid_argument` if the designated ranges are invalid.
- `Unix_error` on Unix-errors.

Returns the number of bytes actually written.

    val pselect : File_descr.t list ->
           File_descr.t list ->
           File_descr.t list ->
           float ->
           int list ->
           File_descr.t list * File_descr.t list *
           File_descr.t list

`pselect rfds wfds efds timeout sigmask` like `Core_unix.select` but also allows one to wait for the arrival of signals.

    module RLimit: sig .. end

Resource limits

    module Resource_usage: sig .. end

Resource usage -- For details, "man getrusage"

    type sysconf =

`|` | `ARG_MAX`
`|` | `CHILD_MAX`
`|` | `HOST_NAME_MAX`
`|` | `LOGIN_NAME_MAX`
`|` | `OPEN_MAX`
`|` | `PAGESIZE`
`|` | `RE_DUP_MAX`
`|` | `STREAM_MAX`
`|` | `SYMLOOP_MAX`
`|` | `TTY_NAME_MAX`
`|` | `TZNAME_MAX`
`|` | `POSIX_VERSION`
`|` | `PHYS_PAGES`
`|` | `AVPHYS_PAGES`
`|` | `IOV_MAX`

## System configuration

    val sysconf : sysconf -> int64

## Temporary file and directory creation

    val mkstemp : string -> string * File_descr.t

`mkstemp prefix` creates and opens a unique temporary file with `prefix`, automatically appending a suffix of six random characters to make the name unique. Unlike C's `mkstemp`, `prefix` should not include six X's at the end.
Raises `Unix_error` on errors.

    val mkdtemp : string -> string

`mkdtemp prefix` creates a temporary directory with `prefix`, automatically appending a suffix of six random characters to make the name unique.
Raises `Unix_error` on errors. k

## Signal handling

    val abort : unit -> 'a

## User id, group id

    val initgroups : string -> int -> unit

    val getgrouplist : string -> int -> int array

`getgrouplist user group` returns the list of groups to which `user` belongs. See 'man getgrouplist'.

    val getgroups : unit -> int array

Return the list of groups to which the user executing the process belongs.

## Globbing and shell expansion

    val fnmatch : ?flags:[ `Casefold
                  | `File_name
                  | `Leading_dir
                  | `No_escape
                  | `Pathname
                  | `Period ] list ->
           pat:string -> string -> bool

    val wordexp : (?flags:[ `No_cmd | `Show_err | `Undef ] list -> string -> string array)
           Core_kernel.Std.Or_error.t

## System information

    module Utsname: sig .. end

    val uname : unit -> Utsname.t

## Additional IP functionality

    val if_indextoname : int -> string

    val mcast_join : ?ifname:string ->
           ?source:Inet_addr.t ->
           File_descr.t -> sockaddr -> unit

`mcast_join ?ifname sock addr` join a multicast group at `addr` with socket `sock`, from source at `source` if specified, optionally using network interface `ifname`.
`ifname` : default = any interface

    val mcast_leave : ?ifname:string -> File_descr.t -> sockaddr -> unit

`mcast_leave ?ifname sock addr` leaves a multicast group at `addr` with socket `sock`, optionally using network interface `ifname`.
`ifname` : default = any interface

    val get_mcast_ttl : File_descr.t -> int

`get_mcast_ttl sock` reads the time-to-live value of outgoing multicast packets for socket `sock`.

    val set_mcast_ttl : File_descr.t -> int -> unit

`set_mcast_ttl sock ttl` sets the time-to-live value of outgoing multicast packets for socket `sock` to `ttl`.

    val get_mcast_loop : File_descr.t -> bool

`get_mcast_loop sock` reads the boolean argument that determines whether sent multicast packets are looped back to local sockets.

    val set_mcast_loop : File_descr.t -> bool -> unit

`set_mcast_loop sock loop` sets the boolean argument that determines whether sent multicast packets are looped back to local sockets.

    val set_mcast_ifname : File_descr.t -> string -> unit

`set_mcast_ifname sock "eth0"` sets outgoing multicast traffic on IPv4 UDP socket `sock` to go out through interface `eth0`.

This uses `setsockopt` with `IP_MULTICAST_IF` and applies to multicast traffic. For non-multicast applications, see `Linux_ext.bind_to_interface`.

    module Scheduler: sig .. end

    module Priority: sig .. end

    module Mman: sig .. end

    module Syslog: module type of Syslog

    val error_of_sexp : Sexplib.Sexp.t -> error

    val sexp_of_error : error -> Sexplib.Sexp.t

Unknown error
The type of error codes. Errors defined in the POSIX standard and additional errors, mostly BSD. All other errors are mapped to `EUNKNOWNERR`.
Argument list too long
Permission denied
Resource temporarily unavailable; try again
Bad file descriptor
Resource unavailable
No child process
Resource deadlock would occur
Domain error for math functions, etc.
File exists
Bad address
File too large
Function interrupted by signal
Invalid argument
Hardware I/O error
Is a directory
Too many open files by the process
Too many links
Filename too long
Too many open files in the system
No such device
No such file or directory
Not an executable file
No locks available
Not enough memory
No space left on device
Function not supported
Not a directory
Directory not empty
Inappropriate I/O control operation
No such device or address
Operation not permitted
Broken pipe
Result too large
Read-only file system
Invalid seek e.g. on a pipe
No such process
Invalid link
Operation would block
Operation now in progress
Operation already in progress
Socket operation on non-socket
Destination address required
Message too long
Protocol wrong type for socket
Protocol not available
Protocol not supported
Socket type not supported
Operation not supported on socket
Protocol family not supported
Address family not supported by protocol family
Address already in use
Can't assign requested address
Network is down
Network is unreachable
Network dropped connection on reset
Software caused connection abort
Connection reset by peer
No buffer space available
Socket is already connected
Socket is not connected
Can't send after socket shutdown
Too many references: can't splice
Connection timed out
Connection refused
Host is down
No route to host
Too many levels of symbolic links
File size or position not representable
Unknown error
Return a string describing the given error code.
Raised by the system calls below when an error is encountered. The first component is the error code; the second component is the function name; the third component is the string parameter to the function, if it has one, or the empty string otherwise.
Return a string describing the given error code.
`handle_unix_error f` runs `f ()` and returns the result. If the exception `Unix_error` is raised, it prints a message describing the error and exits with code 2.
`retry_until_no_eintr f` returns `f ()` unless `f ()` fails with `EINTR`; in which case `f ()` is run again until it raises a different error or returns a value.

###### Access to the process environment

If you're looking for `getenv`, that's in the Sys module.
Return the process environment, as an array of strings with the format ``variable=value''.
`Unix.putenv ~key ~data` sets the value associated to a variable in the process environment. `key` is the name of the environment variable, and `data` its new associated value.
`unsetenv name` deletes the variable `name` from the environment.

EINVAL `name` contained an ’=’ or an '\000' character.

###### Process handling

The termination status of a process.
`of_unix` assumes that any signal numbers in the incoming value are O'Caml internal signal numbers.
`of_unix` assumes that any signal numbers in the incoming value are O'Caml internal signal numbers.

    val env_of_sexp : Sexplib.Sexp.t -> env

`env` is used to control the environment of a child process, and can take three forms. ``Replace_raw` replaces the entire environment with strings in the Unix style, like `"VARIABLE_NAME=value"`. ``Replace` has the same effect as ``Replace_raw`, but using bindings represented as `"VARIABLE_NAME", "value"`. ``Extend` adds entries to the existing environment rather than replacing the whole environment.

If `env` contains multiple bindings for the same variable, the last takes precedence. In the case of ``Extend`, bindings in `env` take precedence over the existing environment.

    val __env_of_sexp__ : Sexplib.Sexp.t -> env

    val sexp_of_env : env -> Sexplib.Sexp.t

`exec ~prog ~args ?search_path ?env` execs `prog` with `args`. If `use_path = true` (the default) and `prog` doesn't contain a slash, then `exec` searches the `PATH` environment variable for `prog`. If `env` is supplied, it determines the environment when `prog` is executed.

The first element in args should be the program itself; the correct way to call `exec` is:

        exec ~prog ~args:[ prog; arg1; arg2; ...] ()

default is `true`
`fork_exec ~prog ~args ?use_path ?env ()` forks and execs `prog` with `args` in the child process, returning the child PID to the parent.
default is `true`
`fork ()` forks a new process. The return value indicates whether we are continuing in the child or the parent, and if the parent, includes the child's process id.
`wait{,_nohang,_untraced,_nohang_untraced} ?restart wait_on` is a family of functions that wait on a process to exit (normally or via a signal) or be stopped by a signal (if `untraced` is used). The `wait_on` argument specifies which processes to wait on. The `nohang` variants return `None` immediately if no such process exists. If `nohang` is not used, `waitpid` will block until one of the desired processes exits.

The non-nohang variants have a `restart` flag with (default true) that causes the system call to be retried upon EAGAIN|EINTR. The nohang variants do not have this flag because they don't block.

    val wait_on_of_sexp : Sexplib.Sexp.t -> wait_on

    val __wait_on_of_sexp__ : Sexplib.Sexp.t -> wait_on

    val sexp_of_wait_on : wait_on -> Sexplib.Sexp.t

`waitpid pid` waits for child process `pid` to terminate, and returns its exit status. `waitpid_exn` is like `waitpid`, except it only returns if the child exits with status zero, and raises if the child terminates in any other way.
Execute the given command, wait until it terminates, and return its termination status. The string is interpreted by the shell `/bin/sh` and therefore can contain redirections, quotes, variables, etc. The result `WEXITED 127` indicates that the shell couldn't be executed.
Return the pid of the process.
Return the pid of the parent process.
Return the pid of the parent process, if you're really sure you're never going to be the init process.
Get the numeric ID of the current thread, e.g. for identifying it in top(1).
Change the process priority. The integer argument is added to the ``nice'' value. (Higher values of the ``nice'' value mean lower priorities.) Return the new nice value.

###### Basic file input/output

The abstract type of file descriptors.
File descriptor for standard input.
File descriptor for standard output.
File descriptor for standard standard error.
The flags to `UnixLabels.openfile`.
Open for reading
Open for writing
Open for reading and writing
Open in non-blocking mode
Open for append
Create if nonexistent
Truncate to 0 length if existing
Fail if existing
Don't make this dev a controlling tty
Writes complete as `Synchronised I/O data integrity completion'
Writes complete as `Synchronised I/O file integrity completion'
Reads complete as writes (depending on O_SYNC/O_DSYNC)
Windows only: allow the file to be deleted while still open
Set the close-on-exec flag on the descriptor returned by `Core_unix.openfile`

    val file_perm_of_sexp : Sexplib.Sexp.t -> file_perm

The type of file access rights.

    val sexp_of_file_perm : file_perm -> Sexplib.Sexp.t

Open the named file with the given flags. Third argument is the permissions to give to the file if it is created. Return a file descriptor on the named file. Default permissions 0o644.
`Open_flags.t` represents the flags associated with a file descriptor in the open-file-descriptor table. It deals with the same thing as OCaml's `open_flag` type; however, it uses Core's `Flags` approach and the underlying integer bitmask representation, and so interoperates more smoothly with C.
access mode.

These three flags are not individual bits like flags usually are. The access mode is represented by the lower two bits of the `Open_flags.t`. A particular `Open_flags.t` should include exactly one access mode. Combining different `Open_flags.t`'s using flags operations (e.g `+`) is only sensible if they have the same access mode.
creation
`can_read t` iff `t` has `rdonly` or `rdwr`
`can_read t` iff `t` has `wronly` or `rdwr`
`fcntl_getfl fd` gets the current flags for `fd` from the open-file-descriptor table via the system call `fcntl(fd, F_GETFL)`. See "man fcntl".
`fcntl_setfl fd flags` sets the flags for `fd` in the open-file-descriptor table via the system call `fcntl(fd, F_SETFL, flags)`. See "man fcntl". As per the Linux man page, on Linux this only allows `append` and `nonblock` to be set.
Close a file descriptor.
`with_file file ~mode ~perm ~f` opens `file`, and applies `f` to the resulting file descriptor. When `f` finishes (or raises), `with_file` closes the descriptor and returns the result of `f` (or raises).
`read fd buff ofs len` reads `len` characters from descriptor `fd`, storing them in string `buff`, starting at position `ofs` in string `buff`. Return the number of characters actually read.
`write fd buff ofs len` writes `len` characters to descriptor `fd`, taking them from string `buff`, starting at position `ofs` in string `buff`. Return the number of characters actually written.

When an error is reported some characters might have already been written. Use `single_write` instead to ensure that this is not the case.

WARNING: write is an interruptible call and has no way to handle EINTR properly. You should most probably be using single write.
Same as `write` but ensures that all errors are reported and that no character has ever been written when an error is reported.

###### Interfacing with the standard input/output library

Create an input channel reading from the given descriptor. The channel is initially in binary mode; use `set_binary_mode_in ic false` if text mode is desired.
Create an output channel writing on the given descriptor. The channel is initially in binary mode; use `set_binary_mode_out oc false` if text mode is desired.
Return the descriptor corresponding to an input channel.
Return the descriptor corresponding to an output channel.

###### Seeking and truncating

    val seek_command_of_sexp : Sexplib.Sexp.t -> seek_command

POSITIONING modes for `UnixLabels.lseek`.

    val sexp_of_seek_command : seek_command -> Sexplib.Sexp.t

indicates positions relative to the end of the file
Set the current position for a file descriptor
Truncates the named file to the given size.
Truncates the file corresponding to the given descriptor to the given size.

###### File statistics

    val file_kind_of_sexp : Sexplib.Sexp.t -> file_kind

    val sexp_of_file_kind : file_kind -> Sexplib.Sexp.t

Socket

    val stats_of_sexp : Sexplib.Sexp.t -> stats

The informations returned by the `UnixLabels.stat` calls.

    val sexp_of_stats : stats -> Sexplib.Sexp.t

Return the information for the named file.
Same as `UnixLabels.stat`, but in case the file is a symbolic link, return the information for the link itself.
Return the information for the file associated with the given descriptor.
The informations returned by the `UnixLabels.stat` calls.
Device number
Inode number
Kind of the file
Access rights
Number of links
User id of the owner
Group ID of the file's group
Device minor number
Size in bytes
Last access time
Last modification time
Last status change time
Return the information for the named file.
Same as `UnixLabels.stat`, but in case the file is a symbolic link, return the information for the link itself.
Return the information for the file associated with the given descriptor.

###### Locking

    val lock_command_of_sexp : Sexplib.Sexp.t -> lock_command

Commands for `Core_unix.lockf`.

    val sexp_of_lock_command : lock_command -> Sexplib.Sexp.t

Lock a region for reading, or fail if already locked
`lockf fd cmd size` place a lock on a file_descr that prevents any other process from calling lockf successfully on the same file. Due to a limitation in the current implementation the length will be converted to a native int, potentially throwing an exception if it is too large.
`flock fd cmd` places or releases a lock on the fd as per the flock C call of the same name.
Return `true` if the given file descriptor refers to a terminal or console window, `false` otherwise.

###### Operations on file names

Removes the named file
Removes the named file or directory
`rename old new` changes the name of a file from `old` to `new`.
`link ?force ~target ~link_name ()` creates a hard link named `link_name` to the file named `target`. If `force` is true, an existing entry in place of `link_name` will be unlinked. This unlinking may raise a Unix error, e.g. if the entry is a directory.

###### File permissions and ownership

Change the permissions of the named file.
Change the permissions of an opened file.
Change the owner uid and owner gid of the named file.
Change the owner uid and owner gid of an opened file.
Set the process creation mask, and return the previous mask.
Check that the process has the given permissions over the named file.

###### Operations on file descriptors

Return a new file descriptor referencing the same file as the given descriptor.
`dup2 ~src ~dst` duplicates `src` to `dst`, closing `dst` if already opened.
Set the ``non-blocking'' flag on the given descriptor. When the non-blocking flag is set, reading on a descriptor on which there is temporarily no data available raises the `EAGAIN` or `EWOULDBLOCK` error instead of blocking; writing on a descriptor on which there is temporarily no room for writing also raises `EAGAIN` or `EWOULDBLOCK`.
Clear the ``non-blocking'' flag on the given descriptor. See `UnixLabels.set_nonblock`.
Set the ``close-on-exec'' flag on the given descriptor. A descriptor with the close-on-exec flag is automatically closed when the current process starts another program with one of the `exec` functions.
Clear the ``close-on-exec'' flag on the given descriptor. See `UnixLabels.set_close_on_exec`.

###### Directories

Create a directory. The permissions of the created directory are (perm & ~umask & 0777). The default perm is 0777.
Create a directory recursively. The permissions of the created directory are those granted by `mkdir ~perm`.
Remove an empty directory.
Change the process working directory.
Return the name of the current working directory.
Change the process root directory.
The type of descriptors over opened directories.
Open a descriptor on a directory
Return the next entry in a directory.
Reposition the descriptor to the beginning of the directory
Close a directory descriptor.

###### Pipes and redirections

Create a pipe. The first component of the result is opened for reading, that's the exit to the pipe. The second component is opened for writing, that's the entrance to the pipe.
Create a named pipe with the given permissions.

###### High-level process and redirection management

Low-level process
`create_process ~prog ~args` forks a new process that executes the program `prog` with arguments `args`. The function returns the pid of the process along with file descriptors attached to stdin, stdout, and stderr of the new process. The executable file `prog` is searched for in the path. The new process has the same environment as the current process. Unlike in `execve` the program name is automatically passed as the first argument.
`create_process_env ~prog ~args ~env` as `create_process`, but takes an additional parameter that extends or replaces the current environment. No effort is made to ensure that the keys passed in as env are unique, so if an environment variable is set twice the second version will override the first.
High-level pipe and process management. These functions (with `UnixLabels.open_process_out` and `UnixLabels.open_process`) run the given command in parallel with the program, and return channels connected to the standard input and/or the standard output of the command. The command is interpreted by the shell `/bin/sh` (cf. `system`). Warning: writes on channels are buffered, hence be careful to call `Pervasives.flush` at the right times to ensure correct synchronization.
See `UnixLabels.open_process_in`.
See `UnixLabels.open_process_in`.
Similar to `UnixLabels.open_process`, but the second argument specifies the environment passed to the command. The result is a triple of channels connected to the standard output, standard input, and standard error of the command.
Close channels opened by `UnixLabels.open_process_in`, wait for the associated command to terminate, and return its termination status.
Close channels opened by `UnixLabels.open_process_out`, wait for the associated command to terminate, and return its termination status.
Close channels opened by `UnixLabels.open_process`, wait for the associated command to terminate, and return its termination status.
Close channels opened by `UnixLabels.open_process_full`, wait for the associated command to terminate, and return its termination status.

###### Symbolic links

`symlink source dest` creates the file `dest` as a symbolic link to the file `source`.
Read the contents of a link.

###### Polling

Wait until some input/output operations become possible on some channels. The three list arguments are, respectively, a set of descriptors to check for reading (first argument), for writing (second argument), or for exceptional conditions (third argument). The fourth argument is the maximal timeout, in seconds; a negative fourth argument means no timeout (unbounded wait). The result is composed of three sets of descriptors: those ready for reading (first component), ready for writing (second component), and over which an exceptional condition is pending (third component).

    val sexp_of_select_timeout : select_timeout -> Sexplib.Sexp.t

Setting restart to true means that we want select to restart automatically on EINTR (instead of propagating the exception)...
Wait until a non-ignored, non-blocked signal is delivered.

###### Time functions

    val process_times_of_sexp : Sexplib.Sexp.t -> process_times

The execution times (CPU times) of a process.

    val sexp_of_process_times : process_times -> Sexplib.Sexp.t

    val tm_of_sexp : Sexplib.Sexp.t -> tm

The type representing wallclock time and calendar date.

    val sexp_of_tm : tm -> Sexplib.Sexp.t

Return the current time since 00:00:00 GMT, Jan. 1, 1970, in seconds.
Same as `Core_unix.time` above, but with resolution better than 1 second.
Convert a time in seconds, as returned by `UnixLabels.time`, into a date and a time. Assumes UTC.
Convert a UTC time in a tm record to a time in seconds
Convert a time in seconds, as returned by `UnixLabels.time`, into a date and a time. Assumes the local time zone.
Convert a date and time, specified by the `tm` argument, into a time in seconds, as returned by `UnixLabels.time`. Also return a normalized copy of the given `tm` record, with the `tm_wday`, `tm_yday`, and `tm_isdst` fields recomputed from the other fields. The `tm` argument is interpreted in the local time zone.
Convert a date and time, specified by the `tm` argument, into a formatted string. See 'man strftime' for format options.
Given a format string, convert a corresponding string to a date and time See 'man strptime' for format options.
Schedule a `SIGALRM` signal after the given number of seconds.
Stop execution for the given number of seconds.
`nanosleep f` delays execution of the program for at least `f` seconds. The function can return earlier if a signal has been delivered, in which case the number of seconds left is returned. Any other failure raises an exception.
Return the execution times of the process.
Set the last access time (second arg) and last modification time (third arg) for a file. Times are expressed in seconds from 00:00:00 GMT, Jan. 1, 1970.

    val interval_timer_of_sexp : Sexplib.Sexp.t -> interval_timer

The three kinds of interval timers.

    val sexp_of_interval_timer : interval_timer -> Sexplib.Sexp.t

(for profiling) decrements both when the process is running and when the system is running on behalf of the process; it sends `SIGPROF` when expired.

    val interval_timer_status_of_sexp : Sexplib.Sexp.t -> interval_timer_status

The type describing the status of an interval timer

    val sexp_of_interval_timer_status : interval_timer_status -> Sexplib.Sexp.t

Return the current status of the given interval timer.
`setitimer t s` sets the interval timer `t` and returns its previous status. The `s` argument is interpreted as follows: `s.it_value`, if nonzero, is the time to the next timer expiration; `s.it_interval`, if nonzero, specifies a value to be used in reloading it_value when the timer expires. Setting `s.it_value` to zero disable the timer. Setting `s.it_interval` to zero causes the timer to be disabled after its next expiration.

###### User id, group id

It's highly recommended to read the straight unix docs on these functions for more color. You can get that info from man pages or http://www.opengroup.org/onlinepubs/000095399/functions/setuid.html
Return the user id of the user executing the process.
Return the effective user id under which the process runs.
Sets the real user id and effective user id for the process. Only use this when superuser. To setuid as an ordinary user, see Core_extended.Unix.seteuid.
Return the group id of the user executing the process.
Return the effective group id under which the process runs.
Set the real group id and effective group id for the process.
Structure of entries in the `passwd` database
`getpwents` is a thread-safe wrapper over the low-level passwd database functions.
Structure of entries in the `groups` database.
Return the login name of the user executing the process.

###### Internet addresses

Conversion from the printable representation of an Internet address to its internal representation. The argument string consists of 4 numbers separated by periods (`XXX.YYY.ZZZ.TTT`) for IPv4 addresses, and up to 8 numbers separated by colons for IPv6 addresses. Raise `Failure` when given a string that does not match these formats.
Call `of_string` and if that fails, use `Host.getbyname`.
Return the printable representation of the given Internet address. See `of_string` for a description of the printable representation.
A special address, for use only with `bind`, representing all the Internet addresses that the host machine possesses.
Special addresses representing the host machine.
Some things (like the kernel) report addresses as hex or decimal strings. Provide conversion functions.
`inet4_addr_to_int32_exn t = 0l` when `t = Inet_addr.of_string ("0.0.0.0")`. An exception is raised if `t` is a not an IPv4 address.
A representation of CIDR netmasks (e.g. "192.168.0.0/24") and functions to match if a given address is inside the range or not. Only IPv4 addresses are supported.
`of_string` Generates a Cidr.t based on a string like `"10.0.0.0/8"`. Addresses are not expanded, i.e. `"10/8"` is invalid.
Accessors.

- `base_address 192.168.0.0/24 = 192.168.0.0`
- `bits 192.168.0.0/24 = 24`.

Generate a sequence of all addresses in the block.
IPv4 multicast address can be represented by the CIDR prefix 224.0.0.0/4, (i.e. addresses from 224.0.0.0 to 239.255.255.255, inclusive)
Is the given address inside the given Cidr.t? Note that the broadcast and network addresses are considered valid so `does_match 10.0.0.0/8 10.0.0.0` is true.
Return the netmask corresponding to the number of network bits in the CIDR. For example, the netmask for a CIDR with 24 network bits (e.g. 1.2.3.0/24) is 255.255.255.0.

###### Sockets

    val bin_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Type_class.t

The type of socket domains.

    val bin_read_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Read.reader

    val __bin_read_socket_domain__ : (int -> socket_domain) Core_kernel.Std.Bin_prot.Read.reader

    val bin_reader_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Type_class.reader

    val bin_size_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Size.sizer

    val bin_write_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Write.writer

    val bin_writer_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Type_class.writer

    val socket_domain_of_sexp : Sexplib.Sexp.t -> socket_domain

    val sexp_of_socket_domain : socket_domain -> Sexplib.Sexp.t

    val bin_socket_type : socket_type Core_kernel.Std.Bin_prot.Type_class.t

The type of socket kinds, specifying the semantics of communications.

    val bin_read_socket_type : socket_type Core_kernel.Std.Bin_prot.Read.reader

    val __bin_read_socket_type__ : (int -> socket_type) Core_kernel.Std.Bin_prot.Read.reader

    val bin_reader_socket_type : socket_type Core_kernel.Std.Bin_prot.Type_class.reader

    val bin_size_socket_type : socket_type Core_kernel.Std.Bin_prot.Size.sizer

    val bin_write_socket_type : socket_type Core_kernel.Std.Bin_prot.Write.writer

    val bin_writer_socket_type : socket_type Core_kernel.Std.Bin_prot.Type_class.writer

    val socket_type_of_sexp : Sexplib.Sexp.t -> socket_type

    val sexp_of_socket_type : socket_type -> Sexplib.Sexp.t

    val bin_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.t

The type of socket addresses. `ADDR_UNIX name` is a socket address in the Unix domain; `name` is a file name in the file system. `ADDR_INET(addr,port)` is a socket address in the Internet domain; `addr` is the Internet address of the machine, and `port` is the port number.

    val bin_read_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Read.reader

    val __bin_read_sockaddr__ : (int -> sockaddr) Core_kernel.Std.Bin_prot.Read.reader

    val bin_reader_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.reader

    val bin_size_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Size.sizer

    val bin_write_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Write.writer

    val bin_writer_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.writer

    val sockaddr_of_sexp : Sexplib.Sexp.t -> sockaddr

    val sexp_of_sockaddr : sockaddr -> Sexplib.Sexp.t

Return the socket domain adequate for the given socket address.
Create a new socket in the given domain, and with the given kind. The third argument is the protocol type; 0 selects the default protocol for that kind of sockets.
Create a pair of unnamed sockets, connected together.
Accept connections on the given socket. The returned descriptor is a socket connected to the client; the returned address is the address of the connecting client.
Bind a socket to an address.
Connect a socket to an address.
Set up a socket for receiving connection requests. The integer argument is the maximal number of pending requests.

    val shutdown_command_of_sexp : Sexplib.Sexp.t -> shutdown_command

The type of commands for `shutdown`.

    val sexp_of_shutdown_command : shutdown_command -> Sexplib.Sexp.t

Close both
Shutdown a socket connection. `SHUTDOWN_SEND` as second argument causes reads on the other end of the connection to return an end-of-file condition. `SHUTDOWN_RECEIVE` causes writes on the other end of the connection to return a closed pipe condition (`SIGPIPE` signal).
Return the address of the given socket.
Return the address of the host connected to the given socket.

    val msg_flag_of_sexp : Sexplib.Sexp.t -> msg_flag

The flags for `UnixLabels.recv`, `UnixLabels.recvfrom`, `UnixLabels.send` and `UnixLabels.sendto`.

    val sexp_of_msg_flag : msg_flag -> Sexplib.Sexp.t

Receive data from a connected socket.
Receive data from an unconnected socket.
Send data over a connected socket.
Send data over an unconnected socket.

###### Socket options

    val socket_bool_option_of_sexp : Sexplib.Sexp.t -> socket_bool_option

The socket options that can be consulted with `UnixLabels.getsockopt` and modified with `UnixLabels.setsockopt`. These options have a boolean (`true`/`false`) value.

    val sexp_of_socket_bool_option : socket_bool_option -> Sexplib.Sexp.t

Forbid binding an IPv6 socket to an IPv4 address

    val socket_int_option_of_sexp : Sexplib.Sexp.t -> socket_int_option

The socket options that can be consulted with `UnixLabels.getsockopt_int` and modified with `UnixLabels.setsockopt_int`. These options have an integer value.

    val sexp_of_socket_int_option : socket_int_option -> Sexplib.Sexp.t

The socket options that can be consulted with `UnixLabels.getsockopt_optint` and modified with `UnixLabels.setsockopt_optint`. These options have a value of type `int option`, with `None` meaning ``disabled''.
Whether to linger on closed connections with sexp that have data present, and for how long (in seconds)

    val socket_float_option_of_sexp : Sexplib.Sexp.t -> socket_float_option

The socket options that can be consulted with `UnixLabels.getsockopt_float` and modified with `UnixLabels.setsockopt_float`. These options have a floating-point value representing a time in seconds. The value 0 means infinite timeout.

    val sexp_of_socket_float_option : socket_float_option -> Sexplib.Sexp.t

Timeout for output operations
Return the current status of a boolean-valued option in the given socket.
Set or clear a boolean-valued option in the given socket.
Same as `UnixLabels.getsockopt` for an integer-valued socket option.
Same as `UnixLabels.setsockopt` for an integer-valued socket option.
Same as `UnixLabels.getsockopt` for a socket option whose value is an `int option`.
Same as `UnixLabels.setsockopt` for a socket option whose value is an `int option`.
Same as `UnixLabels.getsockopt` for a socket option whose value is a floating-point number.
Same as `UnixLabels.setsockopt` for a socket option whose value is a floating-point number.

###### High-level network connection functions

Connect to a server at the given address. Return a pair of buffered channels connected to the server. Remember to call `Pervasives.flush` on the output channel at the right times to ensure correct synchronization.
``Shut down'' a connection established with `UnixLabels.open_connection`; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
Establish a server on the given address. The function given as first argument is called for each connection with two buffered channels connected to the client. A new process is created for each connection. The function `UnixLabels.establish_server` never returns normally.

###### Host and protocol databases

Return the name of the local host.
Structure of entries in the `hosts` database.
Find an entry in `hosts` with the given name.

NOTE: This function is not thread safe with certain versions of winbind using "wins" name resolution.
Find an entry in `hosts` with the given address.
Structure of entries in the `protocols` database.
Find an entry in `protocols` with the given name.
Find an entry in `protocols` with the given protocol number.
Structure of entries in the `services` database.
Find an entry in `services` with the given name.
Find an entry in `services` with the given service number.

    val addr_info_of_sexp : Sexplib.Sexp.t -> addr_info

Address information returned by `Unix.getaddrinfo`.

    val sexp_of_addr_info : addr_info -> Sexplib.Sexp.t

    val getaddrinfo_option_of_sexp : Sexplib.Sexp.t -> getaddrinfo_option

Options to `Unix.getaddrinfo`.

    val sexp_of_getaddrinfo_option : getaddrinfo_option -> Sexplib.Sexp.t

`getaddrinfo host service opts` returns a list of `Unix.addr_info` records describing socket parameters and addresses suitable for communicating with the given host and service. The empty list is returned if the host or service names are unknown, or the constraints expressed in `opts` cannot be satisfied.

`host` is either a host name or the string representation of an IP address. `host` can be given as the empty string; in this case, the ``any'' address or the ``loopback'' address are used, depending whether `opts` contains `AI_PASSIVE`. `service` is either a service name or the string representation of a port number. `service` can be given as the empty string; in this case, the port field of the returned addresses is set to 0. `opts` is a possibly empty list of options that allows the caller to force a particular socket domain (e.g. IPv6 only, or IPv4 only) or a particular socket type (e.g. TCP only or UDP only).

    val name_info_of_sexp : Sexplib.Sexp.t -> name_info

Host and service information returned by `Unix.getnameinfo`.

    val sexp_of_name_info : name_info -> Sexplib.Sexp.t

Name of service or port number

    val getnameinfo_option_of_sexp : Sexplib.Sexp.t -> getnameinfo_option

Options to `Unix.getnameinfo`.

    val sexp_of_getnameinfo_option : getnameinfo_option -> Sexplib.Sexp.t

`getnameinfo addr opts` returns the host name and service name corresponding to the socket address `addr`. `opts` is a possibly empty list of options that governs how these names are obtained. Raise `Not_found` if an error occurs.

## Getting terminal size

###### Terminal interface

The following functions implement the POSIX standard terminal interface. They provide control over asynchronous communication ports and pseudo-terminals. Refer to the `termios` man page for a complete description.
Ignore the break condition.
Signal interrupt on break condition.
Ignore characters with parity errors.
Mark parity errors.
Enable parity check on input.
Strip 8th bit on input characters.
Map NL to CR on input.
Ignore CR on input.
Map CR to NL on input.
Recognize XON/XOFF characters on input.
Emit XON/XOFF chars to control input flow.
Enable output processing.
Output baud rate (0 means close connection).
Input baud rate.
Number of bits per character (5-8).
Number of stop bits (1-2).
Reception is enabled.
Enable parity generation and detection.
Specify odd parity instead of even.
Hang up on last close.
Ignore modem status lines.
Generate signal on INTR, QUIT, SUSP.
Enable canonical processing (line buffering and editing)
Disable flush after INTR, QUIT, SUSP.
Echo input characters.
Echo ERASE (to erase previous character).
Echo KILL (to erase the current line).
Echo NL even if c_echo is not set.
Interrupt character (usually ctrl-C).
Quit character (usually ctrl-\).
Erase character (usually DEL or ctrl-H).
Kill line character (usually ctrl-U).
End-of-file character (usually ctrl-D).
Alternate end-of-line char. (usually none).
Minimum number of characters to read before the read request is satisfied.
Maximum read wait (in 0.1s units).
Start character (usually ctrl-Q).
Stop character (usually ctrl-S).
Return the status of the terminal referred to by the given file descriptor.
Set the status of the terminal referred to by the given file descriptor. The second argument indicates when the status change takes place: immediately (`TCSANOW`), when all pending output has been transmitted (`TCSADRAIN`), or after flushing all input that has been received but not read (`TCSAFLUSH`). `TCSADRAIN` is recommended when changing the output parameters; `TCSAFLUSH`, when changing the input parameters.
Send a break condition on the given file descriptor. The second argument is the duration of the break, in 0.1s units; 0 means standard duration (0.25s).
Waits until all output written on the given file descriptor has been transmitted.
Discard data written on the given file descriptor but not yet transmitted, or data received but not yet read, depending on the second argument: `TCIFLUSH` flushes data received but not read, `TCOFLUSH` flushes data written but not transmitted, and `TCIOFLUSH` flushes both.
Suspend or restart reception or transmission of data on the given file descriptor, depending on the second argument: `TCOOFF` suspends output, `TCOON` restarts output, `TCIOFF` transmits a STOP character to suspend input, and `TCION` transmits a START character to restart input.
Put the calling process in a new session and detach it from its controlling terminal.
Get a sockaddr from a hostname or IP, and a port
Set a timeout for a socket associated with an `in_channel`
Set a timeout for a socket associated with an `out_channel`
`exit_immediately exit_code` immediately calls the `exit` system call with the given exit code without performing any other actions (unlike Pervasives.exit). Does not return.

## Filesystem functions

`mknod ?file_kind ?perm ?major ?minor path` creates a filesystem entry. Note that only FIFO-entries are guaranteed to be supported across all platforms as required by the POSIX-standard. On Linux directories and symbolic links cannot be created with this function. Use `Unix.mkdir` and `Unix.symlink` instead there respectively.

## I/O vectors

I/O-vectors for scatter/gather-operations
Representation of I/O-vectors. NOTE: DO NOT CHANGE THE MEMORY LAYOUT OF THIS TYPE!!! All C-functions in our bindings that handle I/O-vectors depend on it.
Buffer holding the I/O-vector
Position of I/O-vector in buffer
Length of I/O-vector in buffer
Kind of I/O-vector buffers
`empty` the empty I/O-vector.
`of_string ?pos ?len str`
`of_bigstring ?pos ?len bstr`
`drop iovec n` drops `n` characters from `iovec`.

## I/O functions

Extract a file descriptor from a directory handle.
Synchronize all filesystem buffers with disk.
Synchronize the kernel buffers of a given file descriptor with disk, but do not necessarily write file attributes.
`readdir_ino dh` return the next entry in a directory ((`(filename, inode)`).
`read_assume_fd_is_nonblocking fd ?pos ?len buf` calls the system call `read` ASSUMING THAT IT IS NOT GOING TO BLOCK. Reads at most `len` bytes into buffer `buf` starting at position `pos`.
`write_assume_fd_is_nonblocking fd ?pos ?len buf` calls the system call `write` ASSUMING THAT IT IS NOT GOING TO BLOCK. Writes at most `len` bytes from buffer `buf` starting at position `pos`.
`writev_assume_fd_is_nonblocking fd ?count iovecs` calls the system call `writev` ASSUMING THAT IT IS NOT GOING TO BLOCK using `count` I/O-vectors `iovecs`.
`writev fd ?count iovecs` like `Core_unix.writev_assume_fd_is_nonblocking`, but does not require the descriptor to not block. If you feel you have to use this function, you should probably have chosen I/O-vectors that build on bigstrings, because this function has to internally blit the I/O-vectors (ordinary OCaml strings) to intermediate buffers on the C-heap.
`pselect rfds wfds efds timeout sigmask` like `Core_unix.select` but also allows one to wait for the arrival of signals.

## Resource limits

## Resource usage

-- For details, "man getrusage"
`add ru1 ru2` adds two rusage structures (e.g. your resource usage and your children's).

    val sysconf_of_sexp : Sexplib.Sexp.t -> sysconf

## System configuration

    val sexp_of_sysconf : sysconf -> Sexplib.Sexp.t

## Temporary file and directory creation

`mkstemp prefix` creates and opens a unique temporary file with `prefix`, automatically appending a suffix of six random characters to make the name unique. Unlike C's `mkstemp`, `prefix` should not include six X's at the end.
`mkdtemp prefix` creates a temporary directory with `prefix`, automatically appending a suffix of six random characters to make the name unique.

## Signal handling

## User id, group id

`getgrouplist user group` returns the list of groups to which `user` belongs. See 'man getgrouplist'.
Return the list of groups to which the user executing the process belongs.

## Globbing and shell expansion

## System information

## Additional IP functionality

`mcast_join ?ifname sock addr` join a multicast group at `addr` with socket `sock`, from source at `source` if specified, optionally using network interface `ifname`.
`mcast_leave ?ifname sock addr` leaves a multicast group at `addr` with socket `sock`, optionally using network interface `ifname`.
`get_mcast_ttl sock` reads the time-to-live value of outgoing multicast packets for socket `sock`.
`set_mcast_ttl sock ttl` sets the time-to-live value of outgoing multicast packets for socket `sock` to `ttl`.
`get_mcast_loop sock` reads the boolean argument that determines whether sent multicast packets are looped back to local sockets.
`set_mcast_loop sock loop` sets the boolean argument that determines whether sent multicast packets are looped back to local sockets.
`set_mcast_ifname sock "eth0"` sets outgoing multicast traffic on IPv4 UDP socket `sock` to go out through interface `eth0`.

This uses `setsockopt` with `IP_MULTICAST_IF` and applies to multicast traffic. For non-multicast applications, see `Linux_ext.bind_to_interface`.