module File_descr : sig .. end
File descriptor.
type t = Unix.file_descr
include Core_kernel.Std.Equal.S with type t := t
include Core_kernel.Std.Hashable.S with type t := t
include Core_kernel.Std.Stringable.S with type t := t
val of_int : int -> t
val to_int : t -> int
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
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
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
type t = error
val of_system_int : int -> t
exception Unix_error of error * 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.
val unix_error : int -> string -> string -> 'a
Raises Unix_error with a given errno, function name and argument
val error_message : error -> string
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.
type error = [ `Exit_non_zero of int ]
type t = (unit, error) Core_kernel.Std.Result.t
val to_string_hum : t -> string
val code : t -> int
val of_code : int -> t
val or_error : t -> unit Core_kernel.Std.Or_error.t
val error_of_sexp : Sexplib.Sexp.t -> error
val __error_of_sexp__ : Sexplib.Sexp.t -> error
val sexp_of_error : error -> Sexplib.Sexp.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
module Exit_or_signal : sig .. end
type error = [ `Exit_non_zero of int | `Signal of Signal.t ]
type t = (unit, error) Core_kernel.Std.Result.t
val of_unix : Unix.process_status -> t
of_unix assumes that any signal numbers in the incoming value are O'Caml internal signal numbers.
val to_string_hum : t -> string
val or_error : t -> unit Core_kernel.Std.Or_error.t
val error_of_sexp : Sexplib.Sexp.t -> error
val __error_of_sexp__ : Sexplib.Sexp.t -> error
val sexp_of_error : error -> Sexplib.Sexp.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
module Exit_or_signal_or_stop : sig .. end
type error = [ `Exit_non_zero of int | `Signal of Signal.t | `Stop of Signal.t ]
type t = (unit, error) Core_kernel.Std.Result.t
val of_unix : Unix.process_status -> t
of_unix assumes that any signal numbers in the incoming value are O'Caml internal signal numbers.
val to_string_hum : t -> string
val or_error : t -> unit Core_kernel.Std.Or_error.t
val error_of_sexp : Sexplib.Sexp.t -> error
val __error_of_sexp__ : Sexplib.Sexp.t -> error
val sexp_of_error : error -> Sexplib.Sexp.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val exec : prog:string ->
args:string list ->
?use_path:bool -> ?env:string list -> 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 is used as 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:string list -> 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.
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 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
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
type t
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.
include Core_kernel.Std.Flags.S with type t := t
val rdonly : t
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.

val wronly : t
val rdwr : t
val creat : t
creation
val excl : t
val noctty : t
val trunc : t
val append : t
val nonblock : t
val dsync : t
val sync : t
val rsync : t
val can_read : t -> bool
can_read t iff t has rdonly or rdwr
val can_write : t -> bool
can_read t iff t has wronly or rdwr
val sexp_of_t : t -> Sexplib.Sexp.t
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
POSITIONING modes for UnixLabels.lseek.
val lseek : File_descr.t -> int64 -> mode:seek_command -> int64
Set the current position for a file descriptor
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
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
}
The informations returned by the UnixLabels.stat calls.
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
type stats = Unix.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 : int;
Size in bytes
st_atime : float;
Last access time
st_mtime : float;
Last modification time
st_ctime : float;
Last status change time
}
The informations returned by the UnixLabels.stat calls.
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.
val lseek : File_descr.t -> int -> mode:seek_command -> int
val truncate : string -> len:int -> unit
val ftruncate : File_descr.t -> len:int -> unit
val stats_of_sexp : Sexplib.Sexp.t -> stats
val sexp_of_stats : stats -> Sexplib.Sexp.t
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
Commands for lockf.
val lockf : File_descr.t -> mode:lock_command -> len:Core_kernel.Std.Int64.t -> unit
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.
module Flock_command : sig .. end
type t
val lock_shared : t
val lock_exclusive : t
val unlock : t
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 fd1 fd2 duplicates fd1 to fd2, closing fd2 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
type t = {
pid : Core_kernel.Std.Pid.t;
stdin : File_descr.t;
stdout : File_descr.t;
stderr : File_descr.t;
}
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
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.
type env = [ `Extend of (string * string) list | `Replace of (string * string) list ]
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 create_process_env : ?working_dir:string ->
prog:string -> args:string list -> env:env -> unit -> Process_info.t
val open_process_in : string -> 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 -> out_channel
See UnixLabels.open_process_in.
val open_process : string -> in_channel * 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. The result is a triple of channels connected to the standard output, standard input, and standard error of the command.
type t = {
stdin : out_channel;
stdout : in_channel;
stderr : in_channel;
}
val open_process_full : string -> env:string array -> Process_channels.t
val close_process_in : 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 : 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 : in_channel * 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. 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).
type t = {
read : File_descr.t list;
write : File_descr.t list;
except : File_descr.t list;
}
val empty : t
val sexp_of_t : t -> Sexplib.Sexp.t
type select_timeout = [ `After of float | `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 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
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
}
The type describing the status of an interval 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
type t = {
name : string;
passwd : string;
uid : int;
gid : int;
gecos : string;
dir : string;
shell : string;
}
val getbyname : string -> t option
val getbyname_exn : string -> t
val getbyuid : int -> t option
val getbyuid_exn : int -> t
val getpwents : unit -> t list
getpwents is a thread-safe wrapper over the low-level passwd database functions.
module Low_level : sig .. end
val setpwent : unit -> unit
val getpwent : unit -> t option
val getpwent_exn : unit -> t
val endpwent : unit -> unit
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
module Group : sig .. end
Structure of entries in the groups database.
type t = {
name : string;
passwd : string;
gid : int;
mem : string array;
}
val getbyname : string -> t option
val getbyname_exn : string -> t
val getbygid : int -> t option
val getbygid_exn : int -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val getlogin : unit -> string
Return the login name of the user executing the process.
module Protocol_family : sig .. end
type t = [ `Inet | `Inet6 | `Unix ]
val t_of_sexp : Sexplib.Sexp.t -> t
val __t_of_sexp__ : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
Internet addresses
module Inet_addr : sig .. end
type t = Unix.inet_addr
include Core_kernel.Std.Comparable.S with type t := t
val of_string : string -> t
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.
val of_string_or_getbyname : string -> t
Call of_string and if that fails, use Host.getbyname.
val to_string : t -> string
Return the printable representation of the given Internet address. See of_string for a description of the printable representation.
val bind_any : t
A special address, for use only with bind, representing all the Internet addresses that the host machine possesses.
val bind_any_inet6 : t
val localhost : t
Special addresses representing the host machine.
val localhost_inet6 : t
val inet4_addr_of_int32 : Core_kernel.Std.Int32.t -> t
Some things (like the kernel) report addresses as hex or decimal strings. Provide conversion functions.
val inet4_addr_to_int32_exn : t -> Core_kernel.Std.Int32.t
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.
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
module Cidr : sig .. end
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.
type t
include Core_kernel.Std.Stringable.S with type t := t
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.
val base_address : t -> Inet_addr.t
Accessors.
  • base_address 192.168.0.0/24 = 192.168.0.0
  • bits 192.168.0.0/24 = 24.
val bits : t -> int
val multicast : t
IPv4 multicast address can be represented by the CIDR prefix 224.0.0.0/4, (i.e. addreses from 224.0.0.0 to 239.255.255.255, inclusive)
val does_match : t -> Inet_addr.t -> bool
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.
val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
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
The type of commands for shutdown.
val shutdown : File_descr.t -> mode:shutdown_command -> unit
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).
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 an unconnected 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 an unconnected 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
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
The socket options that can be consulted with UnixLabels.getsockopt_int and modified with UnixLabels.setsockopt_int. These options have an integer value.
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
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
Return the current status of a boolean-valued option in the given socket.
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 -> in_channel * 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 : 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 : (in_channel -> 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
type t = {
name : string;
aliases : string array;
family : Protocol_family.t;
addresses : Inet_addr.t array;
}
Structure of entries in the hosts database.
val getbyname : string -> t option
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.

val getbyname_exn : string -> t
val getbyaddr : Inet_addr.t -> t option
Find an entry in hosts with the given address.
val getbyaddr_exn : Inet_addr.t -> t
val have_address_in_common : t -> t -> bool
val sexp_of_t : t -> Sexplib.Sexp.t
module Protocol : sig .. end
type t = {
name : string;
aliases : string array;
proto : int;
}
Structure of entries in the protocols database.
val getbyname : string -> t option
Find an entry in protocols with the given name.
val getbyname_exn : string -> t
val getbynumber : int -> t option
Find an entry in protocols with the given protocol number.
val getbynumber_exn : int -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
module Service : sig .. end
type t = {
name : string;
aliases : string array;
port : int;
proto : string;
}
Structure of entries in the services database.
val getbyname : string -> protocol:string -> t option
Find an entry in services with the given name.
val getbyname_exn : string -> protocol:string -> t
val getbyport : int -> protocol:string -> t option
Find an entry in services with the given service number.
val getbyport_exn : int -> protocol:string -> t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
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.
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
Options to Unix.getnameinfo.
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
type t = Unix.terminal_io = {
mutable c_ignbrk : bool;
Ignore the break condition.
mutable c_brkint : bool;
Signal interrupt on break condition.
mutable c_ignpar : bool;
Ignore characters with parity errors.
mutable c_parmrk : bool;
Mark parity errors.
mutable c_inpck : bool;
Enable parity check on input.
mutable c_istrip : bool;
Strip 8th bit on input characters.
mutable c_inlcr : bool;
Map NL to CR on input.
mutable c_igncr : bool;
Ignore CR on input.
mutable c_icrnl : bool;
Map CR to NL on input.
mutable c_ixon : bool;
Recognize XON/XOFF characters on input.
mutable c_ixoff : bool;
Emit XON/XOFF chars to control input flow.
mutable c_opost : bool;
Enable output processing.
mutable c_obaud : int;
Output baud rate (0 means close connection).
mutable c_ibaud : int;
Input baud rate.
mutable c_csize : int;
Number of bits per character (5-8).
mutable c_cstopb : int;
Number of stop bits (1-2).
mutable c_cread : bool;
Reception is enabled.
mutable c_parenb : bool;
Enable parity generation and detection.
mutable c_parodd : bool;
Specify odd parity instead of even.
mutable c_hupcl : bool;
Hang up on last close.
mutable c_clocal : bool;
Ignore modem status lines.
mutable c_isig : bool;
Generate signal on INTR, QUIT, SUSP.
mutable c_icanon : bool;
Enable canonical processing (line buffering and editing)
mutable c_noflsh : bool;
Disable flush after INTR, QUIT, SUSP.
mutable c_echo : bool;
Echo input characters.
mutable c_echoe : bool;
Echo ERASE (to erase previous character).
mutable c_echok : bool;
Echo KILL (to erase the current line).
mutable c_echonl : bool;
Echo NL even if c_echo is not set.
mutable c_vintr : char;
Interrupt character (usually ctrl-C).
mutable c_vquit : char;
Quit character (usually ctrl-\).
mutable c_verase : char;
Erase character (usually DEL or ctrl-H).
mutable c_vkill : char;
Kill line character (usually ctrl-U).
mutable c_veof : char;
End-of-file character (usually ctrl-D).
mutable c_veol : char;
Alternate end-of-line char. (usually none).
mutable c_vmin : int;
Minimum number of characters to read before the read request is satisfied.
mutable c_vtime : int;
Maximum read wait (in 0.1s units).
mutable c_vstart : char;
Start character (usually ctrl-Q).
mutable c_vstop : char;
Stop character (usually ctrl-S).
}
type setattr_when = Unix.setattr_when = 
|TCSANOW
|TCSADRAIN
|TCSAFLUSH
val tcgetattr : File_descr.t -> t
Return the status of the terminal referred to by the given file descriptor.
val tcsetattr : t -> File_descr.t -> mode:setattr_when -> unit
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.
val tcsendbreak : File_descr.t -> duration:int -> unit
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).
val tcdrain : File_descr.t -> unit
Waits until all output written on the given file descriptor has been transmitted.
type flush_queue = Unix.flush_queue = 
|TCIFLUSH
|TCOFLUSH
|TCIOFLUSH
val tcflush : File_descr.t -> mode:flush_queue -> unit
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.
type flow_action = Unix.flow_action = 
|TCOOFF
|TCOON
|TCIOFF
|TCION
val tcflow : File_descr.t -> mode:flow_action -> unit
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.
val setsid : unit -> int
Put the calling process in a new session and detach it from its controlling terminal.
val sexp_of_t : t -> Sexplib.Sexp.t
val sexp_of_setattr_when : setattr_when -> Sexplib.Sexp.t
val flush_queue_of_sexp : Sexplib.Sexp.t -> flush_queue
val sexp_of_flush_queue : flush_queue -> Sexplib.Sexp.t
val flow_action_of_sexp : Sexplib.Sexp.t -> flow_action
val sexp_of_flow_action : flow_action -> Sexplib.Sexp.t
val get_sockaddr : string -> int -> sockaddr
Get a sockaddr from a hostname or IP, and a port
val set_in_channel_timeout : in_channel -> float -> unit
Set a timeout for a socket associated with an in_channel
val set_out_channel_timeout : 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.
file_kind : default = S_REG (= regular file)
perm : default = 0o600 (= read/write for user only)
major : default = 0
minor : default = 0
Raises Invalid_argument if an unsupported file kind is used.
Unix_error if the system call fails.

I/O vectors

module IOVec : sig .. end
I/O-vectors for scatter/gather-operations
type 'buf t = private {
buf : 'buf;
Buffer holding the I/O-vector
pos : int;
Position of I/O-vector in buffer
len : int;
Length of I/O-vector in buffer
}
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.
type 'buf kind
Kind of I/O-vector buffers
type bigstring = (char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
val string_kind : string kind
val bigstring_kind : bigstring kind
val empty : 'buf kind -> 'buf t
empty the empty I/O-vector.
val of_string : ?pos:int -> ?len:int -> string -> string t
of_string ?pos ?len str
pos : default = 0
len : default = String.length str - pos
Raises Invalid_argument if designated substring out of bounds.
Returns an I/O-vector designated by position pos and length len in string str.
val of_bigstring : ?pos:int -> ?len:int -> bigstring -> bigstring t
of_bigstring ?pos ?len bstr
pos : default = 0
len : default = String.length str - pos
Raises Invalid_argument if designated substring out of bounds.
Returns an I/O-vector designated by position pos and length len in bigstring bstr.
val drop : 'buf t -> int -> 'buf t
drop iovec n drops n characters from iovec. Raises Failure if n is greater than length of iovec.
Returns resulting I/O-vector.
val max_iovecs : int
val t_of_sexp : (Sexplib.Sexp.t -> 'buf) -> Sexplib.Sexp.t -> 'buf t
val sexp_of_t : ('buf -> Sexplib.Sexp.t) -> 'buf t -> Sexplib.Sexp.t

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.
pos : = 0
len : = String.length buf - pos
Raises Invalid_argument if buffer range out of bounds.
Unix_error on Unix-errors.
Returns the number of bytes actually read.
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.
pos : = 0
len : = String.length buf - pos
Raises Invalid_argument if buffer range out of bounds.
Unix_error on Unix-errors.
Returns the number of bytes actually written.
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 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

type limit = 
|Limit of int64
|Infinity
type t = {
cur : limit;
max : limit;
}
type resource
val core_file_size : resource
val cpu_seconds : resource
val data_segment : resource
val file_size : resource
val num_file_descriptors : resource
val stack : resource
val virtual_memory : resource Core_kernel.Std.Or_error.t
val nice : resource Core_kernel.Std.Or_error.t
val get : resource -> t
val set : resource -> t -> unit
val limit_of_sexp : Sexplib.Sexp.t -> limit
val sexp_of_limit : limit -> Sexplib.Sexp.t
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val resource_of_sexp : Sexplib.Sexp.t -> resource
val sexp_of_resource : resource -> Sexplib.Sexp.t
module Resource_usage : sig .. end

Resource usage

-- For details, "man getrusage"
type t = {
utime : float;
stime : float;
maxrss : int64;
ixrss : int64;
idrss : int64;
isrss : int64;
minflt : int64;
majflt : int64;
nswap : int64;
inblock : int64;
oublock : int64;
msgsnd : int64;
msgrcv : int64;
nsignals : int64;
nvcsw : int64;
nivcsw : int64;
}
val nivcsw : t -> int64
val nvcsw : t -> int64
val nsignals : t -> int64
val msgrcv : t -> int64
val msgsnd : t -> int64
val oublock : t -> int64
val inblock : t -> int64
val nswap : t -> int64
val majflt : t -> int64
val minflt : t -> int64
val isrss : t -> int64
val idrss : t -> int64
val ixrss : t -> int64
val maxrss : t -> int64
val stime : t -> float
val utime : t -> float
module Fields : sig .. end
val names : string list
val nivcsw : (t, int64) Fieldslib.Field.t
val nvcsw : (t, int64) Fieldslib.Field.t
val nsignals : (t, int64) Fieldslib.Field.t
val msgrcv : (t, int64) Fieldslib.Field.t
val msgsnd : (t, int64) Fieldslib.Field.t
val oublock : (t, int64) Fieldslib.Field.t
val inblock : (t, int64) Fieldslib.Field.t
val nswap : (t, int64) Fieldslib.Field.t
val majflt : (t, int64) Fieldslib.Field.t
val minflt : (t, int64) Fieldslib.Field.t
val isrss : (t, int64) Fieldslib.Field.t
val idrss : (t, int64) Fieldslib.Field.t
val ixrss : (t, int64) Fieldslib.Field.t
val maxrss : (t, int64) Fieldslib.Field.t
val stime : (t, float) Fieldslib.Field.t
val utime : (t, float) Fieldslib.Field.t
val fold : init:'acc__ ->
utime:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
stime:('acc__ -> (t, float) Fieldslib.Field.t -> 'acc__) ->
maxrss:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
ixrss:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
idrss:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
isrss:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
minflt:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
majflt:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
nswap:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
inblock:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
oublock:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
msgsnd:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
msgrcv:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
nsignals:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
nvcsw:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) ->
nivcsw:('acc__ -> (t, int64) Fieldslib.Field.t -> 'acc__) -> 'acc__
val make_creator : utime:((t, float) Fieldslib.Field.t ->
       'compile_acc__ -> ('input__ -> float) * 'compile_acc__) ->
stime:((t, float) Fieldslib.Field.t ->
       'compile_acc__ -> ('input__ -> float) * 'compile_acc__) ->
maxrss:((t, int64) Fieldslib.Field.t ->
        'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
ixrss:((t, int64) Fieldslib.Field.t ->
       'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
idrss:((t, int64) Fieldslib.Field.t ->
       'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
isrss:((t, int64) Fieldslib.Field.t ->
       'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
minflt:((t, int64) Fieldslib.Field.t ->
        'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
majflt:((t, int64) Fieldslib.Field.t ->
        'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
nswap:((t, int64) Fieldslib.Field.t ->
       'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
inblock:((t, int64) Fieldslib.Field.t ->
         'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
oublock:((t, int64) Fieldslib.Field.t ->
         'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
msgsnd:((t, int64) Fieldslib.Field.t ->
        'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
msgrcv:((t, int64) Fieldslib.Field.t ->
        'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
nsignals:((t, int64) Fieldslib.Field.t ->
          'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
nvcsw:((t, int64) Fieldslib.Field.t ->
       'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
nivcsw:((t, int64) Fieldslib.Field.t ->
        'compile_acc__ -> ('input__ -> int64) * 'compile_acc__) ->
'compile_acc__ -> ('input__ -> t) * 'compile_acc__
val create : utime:float ->
stime:float ->
maxrss:int64 ->
ixrss:int64 ->
idrss:int64 ->
isrss:int64 ->
minflt:int64 ->
majflt:int64 ->
nswap:int64 ->
inblock:int64 ->
oublock:int64 ->
msgsnd:int64 ->
msgrcv:int64 -> nsignals:int64 -> nvcsw:int64 -> nivcsw:int64 -> t
val map : utime:((t, float) Fieldslib.Field.t -> float) ->
stime:((t, float) Fieldslib.Field.t -> float) ->
maxrss:((t, int64) Fieldslib.Field.t -> int64) ->
ixrss:((t, int64) Fieldslib.Field.t -> int64) ->
idrss:((t, int64) Fieldslib.Field.t -> int64) ->
isrss:((t, int64) Fieldslib.Field.t -> int64) ->
minflt:((t, int64) Fieldslib.Field.t -> int64) ->
majflt:((t, int64) Fieldslib.Field.t -> int64) ->
nswap:((t, int64) Fieldslib.Field.t -> int64) ->
inblock:((t, int64) Fieldslib.Field.t -> int64) ->
oublock:((t, int64) Fieldslib.Field.t -> int64) ->
msgsnd:((t, int64) Fieldslib.Field.t -> int64) ->
msgrcv:((t, int64) Fieldslib.Field.t -> int64) ->
nsignals:((t, int64) Fieldslib.Field.t -> int64) ->
nvcsw:((t, int64) Fieldslib.Field.t -> int64) ->
nivcsw:((t, int64) Fieldslib.Field.t -> int64) -> t
val iter : utime:((t, float) Fieldslib.Field.t -> unit) ->
stime:((t, float) Fieldslib.Field.t -> unit) ->
maxrss:((t, int64) Fieldslib.Field.t -> unit) ->
ixrss:((t, int64) Fieldslib.Field.t -> unit) ->
idrss:((t, int64) Fieldslib.Field.t -> unit) ->
isrss:((t, int64) Fieldslib.Field.t -> unit) ->
minflt:((t, int64) Fieldslib.Field.t -> unit) ->
majflt:((t, int64) Fieldslib.Field.t -> unit) ->
nswap:((t, int64) Fieldslib.Field.t -> unit) ->
inblock:((t, int64) Fieldslib.Field.t -> unit) ->
oublock:((t, int64) Fieldslib.Field.t -> unit) ->
msgsnd:((t, int64) Fieldslib.Field.t -> unit) ->
msgrcv:((t, int64) Fieldslib.Field.t -> unit) ->
nsignals:((t, int64) Fieldslib.Field.t -> unit) ->
nvcsw:((t, int64) Fieldslib.Field.t -> unit) ->
nivcsw:((t, int64) Fieldslib.Field.t -> unit) -> unit
val for_all : utime:((t, float) Fieldslib.Field.t -> bool) ->
stime:((t, float) Fieldslib.Field.t -> bool) ->
maxrss:((t, int64) Fieldslib.Field.t -> bool) ->
ixrss:((t, int64) Fieldslib.Field.t -> bool) ->
idrss:((t, int64) Fieldslib.Field.t -> bool) ->
isrss:((t, int64) Fieldslib.Field.t -> bool) ->
minflt:((t, int64) Fieldslib.Field.t -> bool) ->
majflt:((t, int64) Fieldslib.Field.t -> bool) ->
nswap:((t, int64) Fieldslib.Field.t -> bool) ->
inblock:((t, int64) Fieldslib.Field.t -> bool) ->
oublock:((t, int64) Fieldslib.Field.t -> bool) ->
msgsnd:((t, int64) Fieldslib.Field.t -> bool) ->
msgrcv:((t, int64) Fieldslib.Field.t -> bool) ->
nsignals:((t, int64) Fieldslib.Field.t -> bool) ->
nvcsw:((t, int64) Fieldslib.Field.t -> bool) ->
nivcsw:((t, int64) Fieldslib.Field.t -> bool) -> bool
val exists : utime:((t, float) Fieldslib.Field.t -> bool) ->
stime:((t, float) Fieldslib.Field.t -> bool) ->
maxrss:((t, int64) Fieldslib.Field.t -> bool) ->
ixrss:((t, int64) Fieldslib.Field.t -> bool) ->
idrss:((t, int64) Fieldslib.Field.t -> bool) ->
isrss:((t, int64) Fieldslib.Field.t -> bool) ->
minflt:((t, int64) Fieldslib.Field.t -> bool) ->
majflt:((t, int64) Fieldslib.Field.t -> bool) ->
nswap:((t, int64) Fieldslib.Field.t -> bool) ->
inblock:((t, int64) Fieldslib.Field.t -> bool) ->
oublock:((t, int64) Fieldslib.Field.t -> bool) ->
msgsnd:((t, int64) Fieldslib.Field.t -> bool) ->
msgrcv:((t, int64) Fieldslib.Field.t -> bool) ->
nsignals:((t, int64) Fieldslib.Field.t -> bool) ->
nvcsw:((t, int64) Fieldslib.Field.t -> bool) ->
nivcsw:((t, int64) Fieldslib.Field.t -> bool) -> bool
val to_list : utime:((t, float) Fieldslib.Field.t -> 'elem__) ->
stime:((t, float) Fieldslib.Field.t -> 'elem__) ->
maxrss:((t, int64) Fieldslib.Field.t -> 'elem__) ->
ixrss:((t, int64) Fieldslib.Field.t -> 'elem__) ->
idrss:((t, int64) Fieldslib.Field.t -> 'elem__) ->
isrss:((t, int64) Fieldslib.Field.t -> 'elem__) ->
minflt:((t, int64) Fieldslib.Field.t -> 'elem__) ->
majflt:((t, int64) Fieldslib.Field.t -> 'elem__) ->
nswap:((t, int64) Fieldslib.Field.t -> 'elem__) ->
inblock:((t, int64) Fieldslib.Field.t -> 'elem__) ->
oublock:((t, int64) Fieldslib.Field.t -> 'elem__) ->
msgsnd:((t, int64) Fieldslib.Field.t -> 'elem__) ->
msgrcv:((t, int64) Fieldslib.Field.t -> 'elem__) ->
nsignals:((t, int64) Fieldslib.Field.t -> 'elem__) ->
nvcsw:((t, int64) Fieldslib.Field.t -> 'elem__) ->
nivcsw:((t, int64) Fieldslib.Field.t -> 'elem__) -> 'elem__ list
val map_poly : ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user -> 'x0 list
module Direct : sig .. end
val iter : t ->
utime:((t, float) Fieldslib.Field.t -> t -> float -> unit) ->
stime:((t, float) Fieldslib.Field.t -> t -> float -> unit) ->
maxrss:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
ixrss:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
idrss:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
isrss:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
minflt:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
majflt:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
nswap:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
inblock:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
oublock:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
msgsnd:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
msgrcv:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
nsignals:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
nvcsw:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) ->
nivcsw:((t, int64) Fieldslib.Field.t -> t -> int64 -> unit) -> unit
val fold : t ->
init:'acc__ ->
utime:('acc__ -> (t, float) Fieldslib.Field.t -> t -> float -> 'acc__) ->
stime:('acc__ -> (t, float) Fieldslib.Field.t -> t -> float -> 'acc__) ->
maxrss:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
ixrss:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
idrss:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
isrss:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
minflt:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
majflt:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
nswap:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
inblock:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
oublock:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
msgsnd:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
msgrcv:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
nsignals:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
nvcsw:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
nivcsw:('acc__ -> (t, int64) Fieldslib.Field.t -> t -> int64 -> 'acc__) ->
'acc__
val get : [ `Children | `Self ] -> t
val add : t -> t -> t
add ru1 ru2 adds two rusage structures (e.g. your resource usage and your children's).
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
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
type t
val sysname : t -> string
val nodename : t -> string
val release : t -> string
val version : t -> string
val machine : t -> string
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
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.
module Scheduler : sig .. end
module Policy : sig .. end
type t = [ `Fifo | `Other | `Round_robin ]
val t_of_sexp : Sexplib.Sexp.t -> t
val __t_of_sexp__ : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val set : pid:Core_kernel.Std.Pid.t option -> policy:Policy.t -> priority:int -> unit
module Priority : sig .. end
val nice : int -> int
module Mman : sig .. end
module Mcl_flags : sig .. end
type t = 
|Current
|Future
val t_of_sexp : Sexplib.Sexp.t -> t
val sexp_of_t : t -> Sexplib.Sexp.t
val mlockall : Mcl_flags.t list -> unit
val munlockall : unit -> unit
module Syslog : module type of Syslog
val error_of_sexp : Sexplib.Sexp.t -> error
val sexp_of_error : error -> Sexplib.Sexp.t
Unknown error
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
val file_perm_of_sexp : Sexplib.Sexp.t -> file_perm
val sexp_of_file_perm : file_perm -> Sexplib.Sexp.t
val seek_command_of_sexp : Sexplib.Sexp.t -> seek_command
val sexp_of_seek_command : seek_command -> Sexplib.Sexp.t
indicates positions relative to the end of the file
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
val sexp_of_stats : stats -> Sexplib.Sexp.t
val lock_command_of_sexp : Sexplib.Sexp.t -> lock_command
val sexp_of_lock_command : lock_command -> Sexplib.Sexp.t
Lock a region for reading, or fail if already locked
val env_of_sexp : Sexplib.Sexp.t -> env
val __env_of_sexp__ : Sexplib.Sexp.t -> env
val sexp_of_env : env -> Sexplib.Sexp.t
val sexp_of_select_timeout : select_timeout -> Sexplib.Sexp.t
val process_times_of_sexp : Sexplib.Sexp.t -> process_times
val sexp_of_process_times : process_times -> Sexplib.Sexp.t
val tm_of_sexp : Sexplib.Sexp.t -> tm
val sexp_of_tm : tm -> Sexplib.Sexp.t
val interval_timer_of_sexp : Sexplib.Sexp.t -> interval_timer
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
val sexp_of_interval_timer_status : interval_timer_status -> Sexplib.Sexp.t
val bin_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Type_class.t
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
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
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
val shutdown_command_of_sexp : Sexplib.Sexp.t -> shutdown_command
val sexp_of_shutdown_command : shutdown_command -> Sexplib.Sexp.t
Close both
val msg_flag_of_sexp : Sexplib.Sexp.t -> msg_flag
val sexp_of_msg_flag : msg_flag -> Sexplib.Sexp.t
val socket_bool_option_of_sexp : Sexplib.Sexp.t -> socket_bool_option
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
val sexp_of_socket_int_option : socket_int_option -> Sexplib.Sexp.t
val socket_float_option_of_sexp : Sexplib.Sexp.t -> socket_float_option
val sexp_of_socket_float_option : socket_float_option -> Sexplib.Sexp.t
Timeout for output operations
val addr_info_of_sexp : Sexplib.Sexp.t -> addr_info
val sexp_of_addr_info : addr_info -> Sexplib.Sexp.t
val getaddrinfo_option_of_sexp : Sexplib.Sexp.t -> getaddrinfo_option
val sexp_of_getaddrinfo_option : getaddrinfo_option -> Sexplib.Sexp.t
val name_info_of_sexp : Sexplib.Sexp.t -> name_info
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
val sexp_of_getnameinfo_option : getnameinfo_option -> Sexplib.Sexp.t
val sysconf_of_sexp : Sexplib.Sexp.t -> sysconf
val sexp_of_sysconf : sysconf -> Sexplib.Sexp.t