module Core_unix: sig
.. end
Interface to the Unix system.
To use as replacement to default Unix
module,
add module Unix = UnixLabels
in your implementation.
module File_descr: sig
.. end
File descriptor.
Error report
type
error = Unix.error
=
| |
E2BIG |
| |
EACCES |
| |
EAGAIN |
| |
EBADF |
| |
EBUSY |
| |
ECHILD |
| |
EDEADLK |
| |
EDOM |
| |
EEXIST |
| |
EFAULT |
| |
EFBIG |
| |
EINTR |
| |
EINVAL |
| |
EIO |
| |
EISDIR |
| |
EMFILE |
| |
EMLINK |
| |
ENAMETOOLONG |
| |
ENFILE |
| |
ENODEV |
| |
ENOENT |
| |
ENOEXEC |
| |
ENOLCK |
| |
ENOMEM |
| |
ENOSPC |
| |
ENOSYS |
| |
ENOTDIR |
| |
ENOTEMPTY |
| |
ENOTTY |
| |
ENXIO |
| |
EPERM |
| |
EPIPE |
| |
ERANGE |
| |
EROFS |
| |
ESPIPE |
| |
ESRCH |
| |
EXDEV |
| |
EWOULDBLOCK |
| |
EINPROGRESS |
| |
EALREADY |
| |
ENOTSOCK |
| |
EDESTADDRREQ |
| |
EMSGSIZE |
| |
EPROTOTYPE |
| |
ENOPROTOOPT |
| |
EPROTONOSUPPORT |
| |
ESOCKTNOSUPPORT |
| |
EOPNOTSUPP |
| |
EPFNOSUPPORT |
| |
EAFNOSUPPORT |
| |
EADDRINUSE |
| |
EADDRNOTAVAIL |
| |
ENETDOWN |
| |
ENETUNREACH |
| |
ENETRESET |
| |
ECONNABORTED |
| |
ECONNRESET |
| |
ENOBUFS |
| |
EISCONN |
| |
ENOTCONN |
| |
ESHUTDOWN |
| |
ETOOMANYREFS |
| |
ETIMEDOUT |
| |
ECONNREFUSED |
| |
EHOSTDOWN |
| |
EHOSTUNREACH |
| |
ELOOP |
| |
EOVERFLOW |
| |
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.
val sexp_of_error : error -> Sexplib.Sexp.t
val error_of_sexp : Sexplib.Sexp.t -> error
Unknown error
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 : ('a -> 'b) -> 'a -> 'b
handle_unix_error f x
applies f
to x
and returns the result.
If the exception Unix_error
is raised, it prints a message
describing the error and exits with code 2.
Access to the process environment
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 Process_status: sig
.. end
The termination status of a process.
Flags for UnixLabels.waitpid
.
type
wait_flag = Unix.wait_flag
=
execv prog args
execute the program in file prog
, with
the arguments args
, and the current process environment.
These execv*
functions never return: on success, the current
program is replaced by the new one;
on failure, a UnixLabels.Unix_error
exception is raised.
val execv : prog:string -> args:string array -> 'a
val execve : prog:string -> args:string array -> env:string array -> 'a
Same as UnixLabels.execv
, except that the third argument provides the
environment to the program executed.
val execvp : prog:string -> args:string array -> 'a
Same as UnixLabels.execv
respectively, except that
the program is searched in the path.
val execvpe : prog:string -> args:string array -> env:string array -> 'a
Same as UnixLabels.execve
respectively, except that
the program is searched in the path.
val fork : unit -> int
Fork a new process. The returned integer is 0 for the child
process, the pid of the child process for the parent process.
val wait : ?restart:bool -> unit -> int * Process_status.t
Wait until one of the children processes die, and return its pid
and termination status.
Same as UnixLabels.wait
, but waits for the process whose pid is given.
A pid of -1
means wait for any child.
A pid of 0
means wait for any child in the same process group
as the current process.
Negative pid arguments represent process groups.
The list of options indicates whether waitpid
should return
immediately without waiting, or also report stopped children.
restart
(default false) causes the system call to be retried
upon EINTR.
val waitpid : ?restart:bool ->
mode:wait_flag list -> int -> int * Process_status.t
val system : string -> Process_status.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 -> int
Return the pid of the process.
val getppid : unit -> int
Return the pid of the parent 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
type
file_descr = Unix.file_descr
The abstract type of file descriptors.
val stdin : file_descr
File descriptor for standard input.
val stdout : file_descr
File descriptor for standard output.
val stderr : file_descr
File descriptor for standard standard error.
type
open_flag = Unix.open_flag
=
| |
O_RDONLY |
| |
O_WRONLY |
| |
O_RDWR |
| |
O_NONBLOCK |
| |
O_APPEND |
| |
O_CREAT |
| |
O_TRUNC |
| |
O_EXCL |
| |
O_NOCTTY |
| |
O_DSYNC |
| |
O_SYNC |
| |
O_RSYNC |
The flags to UnixLabels.openfile
.
type
file_perm = int
The type of file access rights.
val sexp_of_file_perm : file_perm -> Sexplib.Sexp.t
val file_perm_of_sexp : Sexplib.Sexp.t -> file_perm
val openfile : string ->
mode:open_flag list ->
perm:file_perm -> file_descr
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.
val close : file_descr -> unit
Close a file descriptor.
val read : file_descr -> buf:string -> pos:int -> len:int -> 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 : file_descr -> buf:string -> pos:int -> len:int -> 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.
val single_write : file_descr -> buf:string -> pos:int -> len:int -> 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 -> Pervasives.in_channel
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 -> Pervasives.out_channel
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 : Pervasives.in_channel -> file_descr
Return the descriptor corresponding to an input channel.
val descr_of_out_channel : Pervasives.out_channel -> file_descr
Return the descriptor corresponding to an output channel.
Seeking and truncating
type
seek_command = Unix.seek_command
=
| |
SEEK_SET |
| |
SEEK_CUR |
| |
SEEK_END |
Positioning modes for UnixLabels.lseek
.
val lseek : file_descr -> 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 -> 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 |
| |
S_DIR |
| |
S_CHR |
| |
S_BLK |
| |
S_LNK |
| |
S_FIFO |
| |
S_SOCK |
val sexp_of_file_kind : file_kind -> Sexplib.Sexp.t
val file_kind_of_sexp : Sexplib.Sexp.t -> file_kind
Socket
type
stats = Unix.LargeFile.stats
= {
|
st_dev : int ; |
|
st_ino : int ; |
|
st_kind : file_kind ; |
|
st_perm : file_perm ; |
|
st_nlink : int ; |
|
st_uid : int ; |
|
st_gid : int ; |
|
st_rdev : int ; |
|
st_size : int64 ; |
|
st_atime : float ; |
|
st_mtime : float ; |
|
st_ctime : float ; |
}
The informations returned by the UnixLabels.stat
calls.
val sexp_of_stats : stats -> Sexplib.Sexp.t
val stats_of_sexp : Sexplib.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 -> stats
Return the information for the file associated with the given
descriptor.
module Native_file: sig
.. end
Locking
type
lock_command = Unix.lock_command
=
| |
F_ULOCK |
| |
F_LOCK |
| |
F_TLOCK |
| |
F_TEST |
| |
F_RLOCK |
| |
F_TRLOCK |
val lockf : file_descr ->
mode:lock_command -> len:Core_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 -> 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 -> 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 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.
force
: default = false
File permissions and ownership
val chmod : string -> perm:file_perm -> unit
Change the permissions of the named file.
val fchmod : file_descr -> 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 -> 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.
type
access_permission = Unix.access_permission
=
| |
R_OK |
| |
W_OK |
| |
X_OK |
| |
F_OK |
Flags for the UnixLabels.access
call.
val access : string -> perm:access_permission list -> unit
Check that the process has the given permissions over the named
file. Raise Unix_error
otherwise.
Operations on file descriptors
val dup : file_descr -> file_descr
Return a new file descriptor referencing the same file as
the given descriptor.
val dup2 : src:file_descr -> dst:file_descr -> unit
dup2 fd1 fd2
duplicates fd1
to fd2
, closing fd2
if already
opened.
val set_nonblock : file_descr -> 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 -> unit
Clear the ``non-blocking'' flag on the given descriptor.
See UnixLabels.set_nonblock
.
val set_close_on_exec : file_descr -> 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 -> unit
Clear the ``close-on-exec'' flag on the given descriptor.
See UnixLabels.set_close_on_exec
.
Directories
val mkdir : string -> perm:file_perm -> unit
Create a directory. The permissions of the created directory are
(perm & ~umask & 0777)
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 : string -> dir_handle
Open a descriptor on a directory
Return the next entry in a directory.
val readdir : dir_handle -> string
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 * file_descr
Create a pipe. The first component of the result is opened
for reading, that's the exit to the pipe. The second component is
opened for writing, that's the entrance to the pipe.
val mkfifo : string -> perm:file_perm -> unit
Create a named pipe with the given permissions.
High-level process and redirection management
module Process_info: sig
.. end
Low-level process
val create_process : prog:string -> args:string list -> Process_info.t
create_process ~prog ~args
forks a new process that
executes the program prog
with arguments args
. The function
returns the pid of the process along with file descriptors attached to
stdin, stdout, and stderr of the new process. The executable file
prog
is searched for in the path. The new process has the same
environment as the current process. Unlike in execve
the program
name is automatically passed as the first argument.
val create_process_env : prog:string ->
args:string list ->
env:[ `Extend of (string * string) list | `Replace of (string * string) list ] ->
Process_info.t
create_process_env ~prog ~args ~env
as create process, but takes an
* additional parameter that extends, or replaces the current environment.
val open_process_in : string -> Pervasives.in_channel
High-level pipe and process management. These functions
(with UnixLabels.open_process_out
and UnixLabels.open_process
)
run the given command in parallel with the program,
and return channels connected to the standard input and/or
the standard output of the command. The command is interpreted
by the shell /bin/sh
(cf. system
). Warning: writes on channels
are buffered, hence be careful to call Pervasives.flush
at the right times
to ensure correct synchronization.
val open_process_out : string -> Pervasives.out_channel
See UnixLabels.open_process_in
.
val open_process : string -> Pervasives.in_channel * Pervasives.out_channel
See UnixLabels.open_process_in
.
module Process_channels: sig
.. end
Similar to UnixLabels.open_process
, but the second argument specifies
the environment passed to the command.
val open_process_full : string -> env:string array -> Process_channels.t
val close_process_in : Pervasives.in_channel -> Process_status.t
Close channels opened by UnixLabels.open_process_in
,
wait for the associated command to terminate,
and return its termination status.
val close_process_out : Pervasives.out_channel -> Process_status.t
Close channels opened by UnixLabels.open_process_out
,
wait for the associated command to terminate,
and return its termination status.
val close_process : Pervasives.in_channel * Pervasives.out_channel -> Process_status.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 -> Process_status.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.
val select : ?restart:bool ->
read:file_descr list ->
write:file_descr list ->
except:file_descr list ->
timeout:float -> 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 ; |
|
tms_stime : float ; |
|
tms_cutime : float ; |
|
tms_cstime : float ; |
}
The execution times (CPU times) of a process.
type
tm = Unix.tm
= {
|
tm_sec : int ; |
|
tm_min : int ; |
|
tm_hour : int ; |
|
tm_mday : int ; |
|
tm_mon : int ; |
|
tm_year : int ; |
|
tm_wday : int ; |
|
tm_yday : int ; |
|
tm_isdst : bool ; |
}
The type representing wallclock time and calendar date.
val sexp_of_tm : tm -> Sexplib.Sexp.t
val tm_of_sexp : Sexplib.Sexp.t -> tm
val time : unit -> float
Return the current time since 00:00:00 GMT, Jan. 1, 1970,
in seconds.
val gettimeofday : unit -> float
Same as UnixLabels.time
, 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 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 |
| |
ITIMER_VIRTUAL |
| |
ITIMER_PROF |
The three kinds of interval timers.
type
interval_timer_status = Unix.interval_timer_status
= {
|
it_interval : float ; |
|
it_value : float ; |
}
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.
val getgroups : unit -> int array
Return the list of groups to which the user executing the process
belongs.
module Passwd: sig
.. end
Structure of entries in the passwd
database
module Group: sig
.. end
Structure of entries in the groups
database.
val getlogin : unit -> string
Return the login name of the user executing the process.
Internet addresses
type
inet_addr = Unix.inet_addr
The abstract type of Internet addresses.
val bin_size_inet_addr : inet_addr Bin_prot.Size.sizer
val bin_write_inet_addr : inet_addr Bin_prot.Write_ml.writer
val bin_write_inet_addr_ : inet_addr Bin_prot.Unsafe_write_c.writer
val bin_writer_inet_addr : inet_addr Bin_prot.Type_class.writer
val bin_read_inet_addr : inet_addr Bin_prot.Read_ml.reader
val bin_read_inet_addr_ : inet_addr Bin_prot.Unsafe_read_c.reader
val bin_read_inet_addr__ : (int -> inet_addr) Bin_prot.Unsafe_read_c.reader
val bin_reader_inet_addr : inet_addr Bin_prot.Type_class.reader
val bin_inet_addr : inet_addr Bin_prot.Type_class.t
val sexp_of_inet_addr : inet_addr -> Sexplib.Sexp.t
val inet_addr_of_sexp : Sexplib.Sexp.t -> inet_addr
val inet_addr_of_string : string -> inet_addr
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 string_of_inet_addr : inet_addr -> string
Return the printable representation of the given Internet address.
See Unix.inet_addr_of_string
for a description of the
printable representation.
val inet_addr_any : inet_addr
A special IPv4 address, for use only with bind
, representing
all the Internet addresses that the host machine possesses.
val inet_addr_loopback : inet_addr
A special IPv4 address representing the host machine (127.0.0.1
).
val inet6_addr_any : inet_addr
A special IPv6 address, for use only with bind
, representing
all the Internet addresses that the host machine possesses.
val inet6_addr_loopback : inet_addr
A special IPv6 address representing the host machine (::1
).
Sockets
type
socket_domain = Unix.socket_domain
=
| |
PF_UNIX |
| |
PF_INET |
| |
PF_INET6 |
The type of socket domains.
val bin_size_socket_domain : socket_domain Bin_prot.Size.sizer
val bin_write_socket_domain : socket_domain Bin_prot.Write_ml.writer
val bin_write_socket_domain_ : socket_domain Bin_prot.Unsafe_write_c.writer
val bin_writer_socket_domain : socket_domain Bin_prot.Type_class.writer
val bin_read_socket_domain : socket_domain Bin_prot.Read_ml.reader
val bin_read_socket_domain_ : socket_domain Bin_prot.Unsafe_read_c.reader
val bin_read_socket_domain__ : (int -> socket_domain) Bin_prot.Unsafe_read_c.reader
val bin_reader_socket_domain : socket_domain Bin_prot.Type_class.reader
val bin_socket_domain : socket_domain Bin_prot.Type_class.t
val sexp_of_socket_domain : socket_domain -> Sexplib.Sexp.t
val socket_domain_of_sexp : Sexplib.Sexp.t -> socket_domain
type
socket_type = Unix.socket_type
=
| |
SOCK_STREAM |
| |
SOCK_DGRAM |
| |
SOCK_RAW |
| |
SOCK_SEQPACKET |
The type of socket kinds, specifying the semantics of
communications.
val bin_size_socket_type : socket_type Bin_prot.Size.sizer
val bin_write_socket_type : socket_type Bin_prot.Write_ml.writer
val bin_write_socket_type_ : socket_type Bin_prot.Unsafe_write_c.writer
val bin_writer_socket_type : socket_type Bin_prot.Type_class.writer
val bin_read_socket_type : socket_type Bin_prot.Read_ml.reader
val bin_read_socket_type_ : socket_type Bin_prot.Unsafe_read_c.reader
val bin_read_socket_type__ : (int -> socket_type) Bin_prot.Unsafe_read_c.reader
val bin_reader_socket_type : socket_type Bin_prot.Type_class.reader
val bin_socket_type : socket_type Bin_prot.Type_class.t
val sexp_of_socket_type : socket_type -> Sexplib.Sexp.t
val socket_type_of_sexp : Sexplib.Sexp.t -> socket_type
type
sockaddr = Unix.sockaddr
=
| |
ADDR_UNIX of string |
| |
ADDR_INET of inet_addr * 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 bin_size_sockaddr : sockaddr Bin_prot.Size.sizer
val bin_write_sockaddr : sockaddr Bin_prot.Write_ml.writer
val bin_write_sockaddr_ : sockaddr Bin_prot.Unsafe_write_c.writer
val bin_writer_sockaddr : sockaddr Bin_prot.Type_class.writer
val bin_read_sockaddr : sockaddr Bin_prot.Read_ml.reader
val bin_read_sockaddr_ : sockaddr Bin_prot.Unsafe_read_c.reader
val bin_read_sockaddr__ : (int -> sockaddr) Bin_prot.Unsafe_read_c.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 -> Sexplib.Sexp.t
val sockaddr_of_sexp : Sexplib.Sexp.t -> sockaddr
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
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 * file_descr
Create a pair of unnamed sockets, connected together.
val accept : file_descr -> file_descr * 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 -> addr:sockaddr -> unit
Bind a socket to an address.
val connect : file_descr -> addr:sockaddr -> unit
Connect a socket to an address.
val listen : file_descr -> 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 |
| |
SHUTDOWN_SEND |
| |
SHUTDOWN_ALL |
The type of commands for shutdown
.
val shutdown : file_descr -> 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 -> sockaddr
Return the address of the given socket.
val getpeername : file_descr -> 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 ->
buf:string -> pos:int -> len:int -> mode:msg_flag list -> int
Receive data from an unconnected socket.
val recvfrom : file_descr ->
buf:string ->
pos:int ->
len:int -> mode:msg_flag list -> int * sockaddr
Receive data from an unconnected socket.
val send : file_descr ->
buf:string -> pos:int -> len:int -> mode:msg_flag list -> int
Send data over an unconnected socket.
val sendto : file_descr ->
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 |
| |
SO_BROADCAST |
| |
SO_REUSEADDR |
| |
SO_KEEPALIVE |
| |
SO_DONTROUTE |
| |
SO_OOBINLINE |
| |
SO_ACCEPTCONN |
| |
TCP_NODELAY |
| |
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 |
| |
SO_RCVBUF |
| |
SO_ERROR |
| |
SO_TYPE |
| |
SO_RCVLOWAT |
| |
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 =
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 |
| |
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 -> socket_bool_option -> bool
Return the current status of a boolean-valued option
in the given socket.
val setsockopt : file_descr -> socket_bool_option -> bool -> unit
Set or clear a boolean-valued option in the given socket.
val getsockopt_int : file_descr -> socket_int_option -> int
Same as UnixLabels.getsockopt
for an integer-valued socket option.
val setsockopt_int : file_descr -> socket_int_option -> int -> unit
Same as UnixLabels.setsockopt
for an integer-valued socket option.
val getsockopt_optint : file_descr -> socket_optint_option -> int option
Same as UnixLabels.getsockopt
for a socket option whose value is an int option
.
val setsockopt_optint : file_descr -> 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 -> socket_float_option -> float
Same as UnixLabels.getsockopt
for a socket option whose value is a floating-point
number.
val setsockopt_float : file_descr -> socket_float_option -> float -> unit
Same as UnixLabels.setsockopt
for a socket option whose value is a floating-point
number.
High-level network connection functions
val open_connection : sockaddr -> Pervasives.in_channel * Pervasives.out_channel
Connect to a server at the given address.
Return a pair of buffered channels connected to the server.
Remember to call Pervasives.flush
on the output channel at the right times
to ensure correct synchronization.
val shutdown_connection : Pervasives.in_channel -> unit
``Shut down'' a connection established with UnixLabels.open_connection
;
that is, transmit an end-of-file condition to the server reading
on the other side of the connection.
val establish_server : (Pervasives.in_channel -> Pervasives.out_channel -> unit) ->
addr:sockaddr -> unit
Establish a server on the given address.
The function given as first argument is called for each connection
with two buffered channels connected to the client. A new process
is created for each connection. The function UnixLabels.establish_server
never returns normally.
Host and protocol databases
val gethostname : unit -> string
Return the name of the local host.
module Host: sig
.. end
module Protocol: sig
.. end
module Service: sig
.. end
type
addr_info = {
}
Address information returned by Unix.getaddrinfo
.
type
getaddrinfo_option =
| |
AI_FAMILY of socket_domain |
| |
AI_SOCKTYPE of socket_type |
| |
AI_PROTOCOL of int |
| |
AI_NUMERICHOST |
| |
AI_CANONNAME |
| |
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 ; |
|
ni_service : string ; |
}
Host and service information returned by
Unix.getnameinfo
.
Name of service or port number
type
getnameinfo_option =
| |
NI_NOFQDN |
| |
NI_NUMERICHOST |
| |
NI_NAMEREQD |
| |
NI_NUMERICSERV |
| |
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
val get_terminal_size : unit -> int * int
get_terminal_size ()
Returns (rows, cols)
, the number of rows and
columns of the terminal.
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
Jane Street extensions
val get_inet_addr : string -> inet_addr
Get inet_addr of a hostname or IP
val get_sockaddr : string -> int -> sockaddr
Get a sockaddr from a hostname or IP, and a port
val set_in_channel_timeout : Pervasives.in_channel -> float -> unit
Set a timeout for a socket associated with an in_channel
val set_out_channel_timeout : Pervasives.out_channel -> float -> unit
Set a timeout for a socket associated with an out_channel
Utility functions
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.
RaisesInvalid_argument
if an unsupported file kind is used.
Unix_error
if the system call fails.
file_kind
: default = S_REG
(= regular file)
perm
: default = 0o600
(= read/write for user only)
major
: default = 0
minor
: default = 0
I/O vectors
module IOVec: sig
.. end
I/O-vectors for scatter/gather-operations
I/O functions
val int_of_file_descr : file_descr -> int
int_of_file_descr fd
converts file descriptor fd
to the internal
integer value.
val file_descr_of_int : int -> file_descr
file_descr_of_int n
converts an integer to a file descriptor.
val dirfd : dir_handle -> file_descr
Extract a file descriptor from a directory handle.
val sync : unit -> unit
Synchronize all filesystem buffers with disk.
val fsync : file_descr -> unit
Synchronize the kernel buffers of a given file descriptor with disk.
val fdatasync : file_descr -> 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 -> ?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
.
RaisesInvalid_argument
if buffer range out of bounds.
Unix_error
on Unix-errors.
Returns the
number of bytes actually read.
pos
: = 0
len
: = String.length buf - pos
val write_assume_fd_is_nonblocking : file_descr -> ?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
.
RaisesInvalid_argument
if buffer range out of bounds.
Unix_error
on Unix-errors.
Returns the
number of bytes actually written.
pos
: = 0
len
: = String.length buf - pos
val writev_assume_fd_is_nonblocking : file_descr -> ?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
.
RaisesInvalid_argument
if the designated ranges are invalid.
Unix_error
on Unix-errors.
Returns the number of bytes actually written.
val writev : file_descr -> ?count:int -> string IOVec.t array -> int
writev fd ?count iovecs
like
Core_unix.writev_assume_fd_is_nonblocking
, but does
not require the descriptor to not block. If you feel you have to
use this function, you should probably have chosen I/O-vectors that
build on bigstrings, because this function has to internally blit
the I/O-vectors (ordinary OCaml strings) to intermediate buffers on
the C-heap.
RaisesInvalid_argument
if the designated ranges are invalid.
Unix_error
on Unix-errors.
Returns the number of bytes actually written.
val pselect : file_descr list ->
file_descr list ->
file_descr list ->
float ->
int list ->
file_descr list * file_descr list *
file_descr list
pselect rfds wfds efds timeout sigmask
like
Core_unix.select
but
also allows one to wait for the arrival of signals.
module RLimit: sig
.. end
Resource limits
module Resource_usage: sig
.. end
Resource usage -- For details, "man getrusage"
System configuration
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 |
val sysconf : sysconf -> int64
Temporary file and directory creation
val mkstemp : string -> string * Unix.file_descr
mkstemp prefix
creates and opens a unique temporary file with
prefix
, automatically appending a suffix of six random characters
to make the name unique.
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
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
System information
module Utsname: sig
.. end
val uname : unit -> Utsname.t
Additional IP functionality
val if_indextoname : int -> string
val mcast_join : ?ifname:string -> file_descr -> sockaddr -> unit
mcast_join ?ifname sock addr
join a multicast group at addr
with socket sock
, optionally using network interface ifname
.
ifname
: default = any interface
val mcast_leave : ?ifname:string -> file_descr -> 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
module Scheduler: sig
.. end
module Priority: sig
.. end
val get_num_open_fds : unit -> int
get_num_open_fds ()
Returns number of open file descriptors. It walks
through every possible file descriptor and calls fcntl() to see if it
is valid, which may be slow. This function can be useful for detecting
descriptor leaks.
module Mman: sig
.. end