module File_descr : sig ... end
File descriptor.
Error report
type error = Unix.error =
val sexp_of_error : Unix.error -> Core_kernel.Sexp.t
val error_of_sexp : Core_kernel.Sexp.t -> Unix.error
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 : sig ... end
Representation of Unix system call results
- raises Unix_error
with a given errno, function name and argument
val error_message : Error.t -> string
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
Return the process environment, as an array of strings with the format ``variable=value''. The returned array is empty if the process has special privileges.
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
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 = [
| `Replace of (string * string) list |
| `Extend of (string * string) list |
| `Override of (string * string option) list |
| `Replace_raw of string list |
]
env
is used to control the environment of a child process, and can take four 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. `Override
is similar to `Extend
but allows unsetting variables too.
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 sexp_of_env : env -> Ppx_sexp_conv_lib.Sexp.t
val env_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> env
val __env_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> env
val exec : prog:string -> argv:string list -> ?use_path:bool -> ?env:env -> unit -> Core_kernel.Nothing.t
exec ~prog ~argv ?search_path ?env
execs prog
with argv
. 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 argv
should be the program itself; the correct way to call exec
is:
exec ~prog ~argv:[ prog; arg1; arg2; ...] ()
val fork_exec : prog:string -> argv:string list -> ?use_path:bool -> ?env:env -> unit -> Core_kernel.Pid.t
fork_exec ~prog ~argv ?use_path ?env ()
forks and execs prog
with argv
in the child process, returning the child PID to the parent. As in exec
, the first element in argv
should be the program itself.
val fork : unit -> [ `In_the_child | `In_the_parent of Core_kernel.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.
val sexp_of_wait_on : wait_on -> Ppx_sexp_conv_lib.Sexp.t
val wait_on_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> wait_on
val __wait_on_of_sexp__ : Ppx_sexp_conv_lib.Sexp.t -> wait_on
val wait : ?restart:bool -> wait_on -> Core_kernel.Pid.t * Exit_or_signal.t
val wait_nohang : wait_on -> (Core_kernel.Pid.t * Exit_or_signal.t) option
val wait_untraced : ?restart:bool -> wait_on -> Core_kernel.Pid.t * Exit_or_signal_or_stop.t
val wait_nohang_untraced : wait_on -> (Core_kernel.Pid.t * Exit_or_signal_or_stop.t) option
val waitpid : Core_kernel.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.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.Pid.t
Return the pid of the process.
val getppid : unit -> Core_kernel.Pid.t option
Return the pid of the parent process.
val getppid_exn : unit -> Core_kernel.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.Or_error.t
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
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.
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 |
| O_KEEPEXEC |
val open_flag_of_sexp : Core_kernel.Sexp.t -> open_flag
We can't use with sexp
because pa_sexp inserts two copies of the val
specs, which leads to a spurious "unused" warning.
val sexp_of_open_flag : open_flag -> Core_kernel.Sexp.t
val sexp_of_file_perm : file_perm -> Ppx_sexp_conv_lib.Sexp.t
val file_perm_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> file_perm
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:Core_kernel.Bytes.t -> 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:Core_kernel.Bytes.t -> int
write fd buff ofs len
writes len
characters to descriptor fd
, taking them from bytes buff
, starting at position ofs
in bytes 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 write_substring : ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int
Same as write
but with a string buffer.
val single_write : ?restart:bool -> ?pos:int -> ?len:int -> File_descr.t -> buf:Core_kernel.Bytes.t -> int
Same as write
but ensures that all errors are reported and that no character has ever been written when an error is reported.
val single_write_substring : ?restart:bool -> ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int
Same as single_write
but with a string buffer.
Interfacing with the standard input/output library
val in_channel_of_descr : File_descr.t -> Stdio.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 -> Stdio.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 : Stdio.In_channel.t -> File_descr.t
Return the descriptor corresponding to an input channel.
val descr_of_out_channel : Stdio.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 sexp_of_seek_command : seek_command -> Ppx_sexp_conv_lib.Sexp.t
val seek_command_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> seek_command
val lseek : File_descr.t -> int64 -> mode:seek_command -> int64
Set the current position for a file descriptor
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 |
val sexp_of_file_kind : file_kind -> Ppx_sexp_conv_lib.Sexp.t
val file_kind_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> file_kind
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. The times are float
number of seconds since the epoch; we don't use Time.t
because Time
depends on Unix
, so the fix isn't so trivial. Same for Native_file.stats
below.
val sexp_of_stats : stats -> Ppx_sexp_conv_lib.Sexp.t
val stats_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> stats
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
This sub-module provides the normal OCaml Unix functions that deal with file size using native ints. These are here because, in general, you should be using 64bit file operations so that large files aren't an issue. If you have a real need to use potentially 31bit file operations (and you should be dubious of such a need) you can open this module
Locking
type lock_command = Unix.lock_command =
Commands for lockf
.
val sexp_of_lock_command : lock_command -> Ppx_sexp_conv_lib.Sexp.t
val lock_command_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> lock_command
val lockf : File_descr.t -> mode:lock_command -> len:Core_kernel.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
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.
Mapping files into memory
val map_file : File_descr.t -> ?pos:int64 -> ('a, 'b) Bigarray.kind -> 'c Bigarray.layout -> shared:bool -> int array -> ('a, 'b, 'c) Bigarray.Genarray.t
Memory mapping of a file as a big array. map_file fd kind layout ~shared dims
returns a big array of kind kind
, layout layout
, and dimensions as specified in dims
.
The data contained in this big array are the contents of the file referred to by the file descriptor fd
.
The optional pos
parameter is the byte offset in the file of the data being mapped. It defaults to 0.
If shared
is true
, all modifications performed on the array are reflected in the file. This requires that fd
be opened with write permissions. If shared
is false
, modifications performed on the array are done in memory only, using copy-on-write of the modified pages; the underlying file is not affected.
To adjust automatically the dimensions of the big array to the actual size of the file, the major dimension (that is, the first dimension for an array with C layout, and the last dimension for an array with Fortran layout) can be given as -1
. map_file
then determines the major dimension from the size of the file. The file must contain an integral number of sub-arrays as determined by the non-major dimensions, otherwise Failure
is raised. If all dimensions of the big array are given, the file size is matched against the size of the big array. If the file is larger than the big array, only the initial portion of the file is mapped to the big array. If the file is smaller than the bigarray, the file is automatically grown to the size of the big array. This requires write permissions on fd
.
Array accesses are bounds-checked, but the bounds are determined by the initial call to map_file
. Therefore, you should make sure no other process modifies the mapped file while you're accessing it, or a SIGBUS signal may be raised. This happens, for instance, if the file is shrunk. Invalid_argument
or Failure
may be raised in cases where argument validation fails.
- since
- 4.05.0
Operations on file names
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
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.
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 access : string -> [ `Read | `Write | `Exec | `Exists ] list -> (unit, exn) Core_kernel.Result.t
Check that the process has the given permissions over the named file.
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
.
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_opt : dir_handle -> string option
Return the next entry in a directory. Returns None
when the end of the directory has been reached.
val readdir : dir_handle -> string
Same as readdir_opt
except that it signals the end of the directory by raising End_of_file
.
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
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_search_path:string list -> ?argv0: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. If argv0
is given, it is used (instead of prog
) as the first element of the argv
array passed to execve
.
The exact program to execute is determined using the usual conventions. More precisely, if prog
contains at least one '/' character then it is used as is (relative to working_dir
if prog
is a relative path, absolute otherwise). Note that working_dir
defaults to the working directory of the current process, i.e. getcwd ()
. If prog
contains no '/' character, then it is looked up in prog_search_path
: for the first dir
in prog_search_path
such that Filename.concat dir prog
exists and is executable, Filename.concat dir prog
is the program that will be executed.
prog_search_path
defaults to the list of directories encoded as a ':' separated list in the "PATH" environment variable of the current running process. If no such variable is defined, then
["/bin"; "/usr/bin"]
is used instead. Note that the "PATH" environment variable is looked up in the environment of the current running process, i.e. via getenv "PATH"
. Setting the "PATH" variable in the env
argument of this function has no effect on how prog
is resolved.
In a setuid or setgid program, or one which has inherited such privileges, reading of the PATH variable will return an empty result. If a search path is required then it should be provided explicitly using prog_search_path
in such scenarios; alternatively, perhaps more satisfactorily, an absolute path should be given as prog
.
val open_process_in : string -> Stdio.In_channel.t
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 Caml.flush
at the right times to ensure correct synchronization.
val open_process_out : string -> Stdio.Out_channel.t
val open_process : string -> Stdio.In_channel.t * Stdio.Out_channel.t
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.
val open_process_full : string -> env:string array -> Process_channels.t
val close_process_in : Stdio.In_channel.t -> 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 : Stdio.Out_channel.t -> 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 : (Stdio.In_channel.t * Stdio.Out_channel.t) -> 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
symlink ~target ~link_name
creates the file link_name
as a symbolic link to the file target
. On Windows, this has the semantics using stat
as described at: http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.html
Polling
module Select_fds : sig ... end
val sexp_of_select_timeout : select_timeout -> Ppx_sexp_conv_lib.Sexp.t
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
Wait until some input/output operations become possible on some channels. The three list arguments are a set of descriptors to check for reading, for writing, or for exceptional conditions. ~timeout
is the maximal timeout. The result is composed of three sets of descriptors: those ready for reading, ready for writing, and over which an exceptional condition is pending.
Setting restart to true means that we want select
to restart automatically on EINTR (instead of propagating the exception)...
Time functions
type process_times = Unix.process_times = {
}
The execution times (CPU times) of a process.
val sexp_of_process_times : process_times -> Ppx_sexp_conv_lib.Sexp.t
val process_times_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> process_times
module Clock : sig ... end
type tm = Unix.tm = {
}
The type representing wallclock time and calendar date.
val sexp_of_tm : tm -> Ppx_sexp_conv_lib.Sexp.t
val tm_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> tm
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.
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.
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.
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 =
The three kinds of interval timers.
val sexp_of_interval_timer : interval_timer -> Ppx_sexp_conv_lib.Sexp.t
val interval_timer_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> interval_timer
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 sexp_of_interval_timer_status : interval_timer_status -> Ppx_sexp_conv_lib.Sexp.t
val interval_timer_status_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> interval_timer_status
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
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.
module Passwd : sig ... end
Structure of entries in the passwd
database
module Group : sig ... end
Structure of entries in the groups
database.
module Protocol_family : sig ... end
Internet addresses
module Inet_addr : sig ... end
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. Values are always normalized so the base address is the lowest IP address in the range, so for example to_string (of_string "192.168.1.101/24") = "192.168.1.0/24"
.
Sockets
type socket_domain = Unix.socket_domain =
| PF_UNIX | Unix domain |
| PF_INET | Internet domain |
| PF_INET6 | Internet domain (IPv6) |
The type of socket domains.
val sexp_of_socket_domain : socket_domain -> Ppx_sexp_conv_lib.Sexp.t
val socket_domain_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> socket_domain
val bin_shape_socket_domain : Bin_prot.Shape.t
val bin_size_socket_domain : socket_domain Bin_prot.Size.sizer
val bin_write_socket_domain : socket_domain Bin_prot.Write.writer
val bin_writer_socket_domain : socket_domain Bin_prot.Type_class.writer
val bin_read_socket_domain : socket_domain Bin_prot.Read.reader
val __bin_read_socket_domain__ : (int -> socket_domain) Bin_prot.Read.reader
val bin_reader_socket_domain : socket_domain Bin_prot.Type_class.reader
val bin_socket_domain : socket_domain Bin_prot.Type_class.t
type socket_type = Unix.socket_type =
| SOCK_STREAM | Stream socket |
| SOCK_DGRAM | Datagram socket |
| SOCK_RAW | Raw socket |
| SOCK_SEQPACKET | Sequenced packets socket |
The type of socket kinds, specifying the semantics of communications.
val sexp_of_socket_type : socket_type -> Ppx_sexp_conv_lib.Sexp.t
val socket_type_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> socket_type
val bin_shape_socket_type : Bin_prot.Shape.t
val bin_size_socket_type : socket_type Bin_prot.Size.sizer
val bin_write_socket_type : socket_type Bin_prot.Write.writer
val bin_writer_socket_type : socket_type Bin_prot.Type_class.writer
val bin_read_socket_type : socket_type Bin_prot.Read.reader
val __bin_read_socket_type__ : (int -> socket_type) Bin_prot.Read.reader
val bin_reader_socket_type : socket_type Bin_prot.Type_class.reader
val bin_socket_type : socket_type 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_shape_sockaddr : Bin_prot.Shape.t
val bin_size_sockaddr : sockaddr Bin_prot.Size.sizer
val bin_write_sockaddr : sockaddr Bin_prot.Write.writer
val bin_writer_sockaddr : sockaddr Bin_prot.Type_class.writer
val bin_read_sockaddr : sockaddr Bin_prot.Read.reader
val __bin_read_sockaddr__ : (int -> sockaddr) Bin_prot.Read.reader
val bin_reader_sockaddr : sockaddr Bin_prot.Type_class.reader
val bin_sockaddr : sockaddr Bin_prot.Type_class.t
val sexp_of_sockaddr : sockaddr -> Ppx_sexp_conv_lib.Sexp.t
val sockaddr_of_sexp : Core_kernel.Sexp.t -> sockaddr
type sockaddr_blocking_sexp = sockaddr
sockaddr_blocking_sexp
is like sockaddr
, with of_sexp
that performs DNS lookup to resolve Inet_addr.t
.
val bin_shape_sockaddr_blocking_sexp : Bin_prot.Shape.t
val bin_size_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Size.sizer
val bin_write_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Write.writer
val bin_writer_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.writer
val bin_read_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Read.reader
val __bin_read_sockaddr_blocking_sexp__ : (int -> sockaddr_blocking_sexp) Bin_prot.Read.reader
val bin_reader_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.reader
val bin_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.t
val sexp_of_sockaddr_blocking_sexp : sockaddr_blocking_sexp -> Ppx_sexp_conv_lib.Sexp.t
val sockaddr_blocking_sexp_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> sockaddr_blocking_sexp
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 -> backlog:int -> unit
Set up a socket for receiving connection requests. The integer argument is the number of pending requests that will be established and queued for accept
. Depending on operating system, version, and configuration, subsequent connections may be refused actively (as with RST
), ignored, or effectively established and queued anyway.
Because handling of excess connections varies, it is most robust for applications to accept and close excess connections if they can. To be sure the client receives an RST
rather than an orderly shutdown, you can setsockopt_optint file_descr SO_LINGER
(Some 0)
before closing.
In Linux, for example, the system configuration parameters tcp_max_syn_backlog
, tcp_abort_on_overflow
, and syncookies
can all affect connection queuing behavior.
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 sexp_of_shutdown_command : shutdown_command -> Ppx_sexp_conv_lib.Sexp.t
val shutdown_command_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> shutdown_command
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.
The flags for UnixLabels.recv
, UnixLabels.recvfrom
, UnixLabels.send
and UnixLabels.sendto
.
val sexp_of_msg_flag : msg_flag -> Ppx_sexp_conv_lib.Sexp.t
val msg_flag_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> msg_flag
val recv : File_descr.t -> buf:Core_kernel.Bytes.t -> pos:int -> len:int -> mode:msg_flag list -> int
Receive data from a connected socket.
val recvfrom : File_descr.t -> buf:Core_kernel.Bytes.t -> pos:int -> len:int -> mode:msg_flag list -> int * sockaddr
Receive data from an unconnected socket.
val send : File_descr.t -> buf:Core_kernel.Bytes.t -> pos:int -> len:int -> mode:msg_flag list -> int
Send data over a connected socket.
val send_substring : File_descr.t -> buf:string -> pos:int -> len:int -> mode:msg_flag list -> int
Same as send
but with a string buffer.
val sendto : File_descr.t -> buf:Core_kernel.Bytes.t -> pos:int -> len:int -> mode:msg_flag list -> addr:sockaddr -> int
Send data over an unconnected socket.
val sendto_substring : File_descr.t -> buf:string -> pos:int -> len:int -> mode:msg_flag list -> addr:sockaddr -> int
Same as sendto
but with a string buffer.
Socket options
type 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 -> Ppx_sexp_conv_lib.Sexp.t
val socket_bool_option_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> socket_bool_option
type 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 -> Ppx_sexp_conv_lib.Sexp.t
val socket_int_option_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> socket_int_option
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 sexp_of_socket_float_option : socket_float_option -> Ppx_sexp_conv_lib.Sexp.t
val socket_float_option_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> socket_float_option
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 -> Stdio.In_channel.t * Stdio.Out_channel.t
Connect to a server at the given address. Return a pair of buffered channels connected to the server. Remember to call Caml.flush
on the output channel at the right times to ensure correct synchronization.
val shutdown_connection : Stdio.In_channel.t -> 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 : (Stdio.In_channel.t -> Stdio.Out_channel.t -> 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
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; | Canonical host name |
}
Address information returned by Unix.getaddrinfo
.
val sexp_of_addr_info : addr_info -> Ppx_sexp_conv_lib.Sexp.t
type addr_info_blocking_sexp = addr_info
addr_info_blocking_sexp
is like addr_info
, with of_sexp
that performs DNS lookup to resolve Inet_addr.t
.
val sexp_of_addr_info_blocking_sexp : addr_info_blocking_sexp -> Ppx_sexp_conv_lib.Sexp.t
val addr_info_blocking_sexp_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> addr_info_blocking_sexp
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_PASSIVE | Set address to ``any'' address for use with |
Options to Unix.getaddrinfo
.
val sexp_of_getaddrinfo_option : getaddrinfo_option -> Ppx_sexp_conv_lib.Sexp.t
val getaddrinfo_option_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> getaddrinfo_option
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; | Name of service or port number |
}
Host and service information returned by Unix.getnameinfo
.
val sexp_of_name_info : name_info -> Ppx_sexp_conv_lib.Sexp.t
val name_info_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> name_info
type getnameinfo_option =
Options to Unix.getnameinfo
.
val sexp_of_getnameinfo_option : getnameinfo_option -> Ppx_sexp_conv_lib.Sexp.t
val getnameinfo_option_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> getnameinfo_option
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 Caml.Not_found
or Not_found_s
if an error occurs.
Terminal interface
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 : Stdio.In_channel.t -> float -> unit
Set a timeout for a socket associated with an In_channel.t
val set_out_channel_timeout : Stdio.Out_channel.t -> float -> unit
Set a timeout for a socket associated with an Out_channel.t
exit_immediately exit_code
immediately calls the exit
system call with the given exit code without performing any other actions (unlike Caml.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.
- raises Unix_error
if the system call fails.
- parameter file_kind
default =
S_REG
(= regular file)
- parameter perm
default =
0o600
(= read/write for user only)
- parameter major
default =
0
- parameter 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
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_opt : dir_handle -> (string * nativeint) option
readdir_ino_opt dh
return the next entry in a directory (((filename, inode)
). Returns None
when the end of the directory has been reached.
val readdir_ino : dir_handle -> string * nativeint
Same as readdir_ino_opt
except that it signals the end of the directory by raising End_of_file
.
val read_assume_fd_is_nonblocking : File_descr.t -> ?pos:int -> ?len:int -> Core_kernel.Bytes.t -> 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
.
- returns
the number of bytes actually read.
- raises Invalid_argument
if buffer range out of bounds.
- raises Unix_error
on Unix-errors.
- parameter pos
= 0
- parameter len
=
String.length buf - pos
val write_assume_fd_is_nonblocking : File_descr.t -> ?pos:int -> ?len:int -> Core_kernel.Bytes.t -> 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
.
- returns
the number of bytes actually written.
- raises Invalid_argument
if buffer range out of bounds.
- raises Unix_error
on Unix-errors.
- parameter pos
= 0
- parameter 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
.
- returns
the number of bytes actually written.
- raises Invalid_argument
if the designated ranges are invalid.
- raises Unix_error
on Unix-errors.
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.
- returns
the number of bytes actually written.
- raises Invalid_argument
if the designated ranges are invalid.
- raises Unix_error
on Unix-errors.
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
module Resource_usage : sig ... end
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 |
| CLK_TCK |
System configuration
See 'man sysconf' for documentation.
val sexp_of_sysconf : sysconf -> Ppx_sexp_conv_lib.Sexp.t
val sysconf_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> sysconf
val sysconf : sysconf -> int64 option
Wrapper over sysconf
function in C.
val sysconf_exn : 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 .tmp.
followed by six random characters to make the name unique. Unlike C's mkstemp
, prefix
should not include six X's at the end.
The file descriptor will have close-on-exec flag set if O_CLOEXEC flag is supported.
- raises Unix_error
on errors.
mkdtemp prefix
creates a temporary directory with prefix
, automatically appending a suffix of .tmp.
followed by six random characters to make the name unique.
- raises Unix_error
on errors. k
Signal handling
Causes abnormal program termination unless the signal SIGABRT is caught and the signal handler does not return. If the SIGABRT signal is blocked or ignored, the abort() function will still override it.
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
val fnmatch : ?flags:[ `No_escape | `Pathname | `Period | `File_name | `Leading_dir | `Casefold ] list -> pat:string -> string -> bool
no system calls involved
val wordexp : (?flags:[ `No_cmd | `Show_err | `Undef ] list -> string -> string array) Core_kernel.Or_error.t
See man page for wordexp.
System information
module Utsname : sig ... end
val uname : unit -> Utsname.t
See man page for uname.
Additional IP functionality
if_indextoname ifindex
If ifindex
is an interface index, then the function returns the interface name. Otherwise, it raises Unix_error
.
val mcast_join : ?ifname:string -> ?source:Inet_addr.t -> File_descr.t -> sockaddr -> unit
mcast_join ?ifname ?source sock addr
join a multicast group at addr
with socket sock
, from source at source
if specified, optionally using network interface ifname
.
- parameter ifname
default = any interface
val mcast_leave : ?ifname:string -> ?source:Inet_addr.t -> File_descr.t -> sockaddr -> unit
mcast_leave ?ifname ?source sock addr
leaves a multicast group at addr
with socket sock
, from source at source
if specified, optionally using network interface ifname
.
- parameter 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
For keeping your memory in RAM, i.e. preventing it from being swapped out.
module Ifaddr : sig ... end
A network interface on the local machine. See man getifaddrs
.
val getifaddrs : unit -> Ifaddr.t list
module Stable : sig ... end