module Unix: Core_unix
module File_descr:sig
..end
typeerror =
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 |
(* |
Unknown error
| *) |
Core_unix.Error.t
below.EUNKNOWNERR
.module Error:sig
..end
exception Unix_error of Error.t * string * string
module Syscall_result:module type of Syscall_result
with type 'a t = 'a Syscall_result.t
val unix_error : int -> string -> string -> 'a
Unix_error
with a given errno, function name and argumentval error_message : error -> string
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.
If you're looking for getenv
, that's in the Sys module.
val environment : unit -> string array
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.
module Exit:sig
..end
module Exit_or_signal:sig
..end
module Exit_or_signal_or_stop:sig
..end
typeenv =
[ `Extend of (string * string) list
| `Replace of (string * string) list
| `Replace_raw of string list ]
env
is used to control the environment of a child process, and can take three forms.
`Replace_raw
replaces the entire environment with strings in the Unix style, like
"VARIABLE_NAME=value"
. `Replace
has the same effect as `Replace_raw
, but using
bindings represented as "VARIABLE_NAME", "value"
. `Extend
adds entries to the
existing environment rather than replacing the whole environment.
If env
contains multiple bindings for the same variable, the last takes precedence.
In the case of `Extend
, bindings in env
take precedence over the existing
environment.
val exec : prog:string ->
args:string list ->
?use_path:bool -> ?env:env -> unit -> Core_kernel.Std.never_returns
exec ~prog ~args ?search_path ?env
execs prog
with args
. If use_path = true
(the default) and prog
doesn't contain a slash, then exec
searches the PATH
environment variable for prog
. If env
is supplied, it determines the environment
when prog
is executed.
The first element in args should be the program itself; the correct way to call exec
is:
exec ~prog ~args:[ prog; arg1; arg2; ...] ()
val fork_exec : prog:string ->
args:string list ->
?use_path:bool -> ?env:env -> unit -> Core_kernel.Std.Pid.t
fork_exec ~prog ~args ?use_path ?env ()
forks and execs prog
with args
in the
child process, returning the child PID to the parent.val fork : unit -> [ `In_the_child | `In_the_parent of Core_kernel.Std.Pid.t ]
fork ()
forks a new process. The return value indicates whether we are continuing
in the child or the parent, and if the parent, includes the child's process id.wait{,_nohang,_untraced,_nohang_untraced} ?restart wait_on
is a family of functions
that wait on a process to exit (normally or via a signal) or be stopped by a signal
(if untraced
is used). The wait_on
argument specifies which processes to wait on.
The nohang
variants return None
immediately if no such process exists. If
nohang
is not used, waitpid
will block until one of the desired processes exits.
The non-nohang variants have a restart
flag with (default true) that causes the
system call to be retried upon EAGAIN|EINTR. The nohang variants do not have this
flag because they don't block.
typewait_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
/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
val getppid : unit -> Core_kernel.Std.Pid.t option
val getppid_exn : unit -> Core_kernel.Std.Pid.t
module Thread_id:sig
..end
val gettid : (unit -> Thread_id.t) Core_kernel.Std.Or_error.t
val nice : int -> int
val stdin : File_descr.t
val stdout : File_descr.t
val stderr : File_descr.t
UnixLabels.openfile
.typeopen_flag =
Unix.open_flag
=
| |
O_RDONLY |
(* |
Open for reading
| *) |
| |
O_WRONLY |
(* |
Open for writing
| *) |
| |
O_RDWR |
(* |
Open for reading and writing
| *) |
| |
O_NONBLOCK |
(* |
Open in non-blocking mode
| *) |
| |
O_APPEND |
(* |
Open for append
| *) |
| |
O_CREAT |
(* |
Create if nonexistent
| *) |
| |
O_TRUNC |
(* |
Truncate to 0 length if existing
| *) |
| |
O_EXCL |
(* |
Fail if existing
| *) |
| |
O_NOCTTY |
(* |
Don't make this dev a controlling tty
| *) |
| |
O_DSYNC |
(* |
Writes complete as `Synchronised I/O data integrity completion'
| *) |
| |
O_SYNC |
(* |
Writes complete as `Synchronised I/O file integrity completion'
| *) |
| |
O_RSYNC |
(* |
Reads complete as writes (depending on O_SYNC/O_DSYNC)
| *) |
| |
O_SHARE_DELETE |
(* |
Windows only: allow the file to be deleted while still open
| *) |
| |
O_CLOEXEC |
(* |
Set the close-on-exec flag on the descriptor returned by
Core_unix.openfile | *) |
val open_flag_of_sexp : Core_kernel.Std.Sexp.t -> open_flag
val sexp_of_open_flag : open_flag -> Core_kernel.Std.Sexp.t
typefile_perm =
int
val openfile : ?perm:file_perm ->
mode:open_flag list -> string -> File_descr.t
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
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
write
but ensures that all errors are reported and
that no character has ever been written when an error is reported.val in_channel_of_descr : File_descr.t -> Core_kernel.Std.In_channel.t
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
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
val descr_of_out_channel : Core_kernel.Std.Out_channel.t -> File_descr.t
typeseek_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
| *) |
UnixLabels.lseek
.val lseek : File_descr.t -> int64 -> mode:seek_command -> int64
val truncate : string -> len:int64 -> unit
val ftruncate : File_descr.t -> len:int64 -> unit
typefile_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
| *) |
typestats =
Unix.LargeFile.stats
= {
|
st_dev : |
(* |
Device number
| *) |
|
st_ino : |
(* |
Inode number
| *) |
|
st_kind : |
(* |
Kind of the file
| *) |
|
st_perm : |
(* |
Access rights
| *) |
|
st_nlink : |
(* |
Number of links
| *) |
|
st_uid : |
(* |
User id of the owner
| *) |
|
st_gid : |
(* |
Group ID of the file's group
| *) |
|
st_rdev : |
(* |
Device minor number
| *) |
|
st_size : |
(* |
Size in bytes
| *) |
|
st_atime : |
(* |
Last access time
| *) |
|
st_mtime : |
(* |
Last modification time
| *) |
|
st_ctime : |
(* |
Last status change time
| *) |
val stat : string -> stats
val lstat : string -> stats
UnixLabels.stat
, but in case the file is a symbolic link,
return the information for the link itself.val fstat : File_descr.t -> stats
module Native_file:sig
..end
typelock_command =
Unix.lock_command
=
| |
F_ULOCK |
(* |
Unlock a region
| *) |
| |
F_LOCK |
(* |
Lock a region for writing, and block if already locked
| *) |
| |
F_TLOCK |
(* |
Lock a region for writing, or fail if already locked
| *) |
| |
F_TEST |
(* |
Test a region for other process locks
| *) |
| |
F_RLOCK |
(* |
Lock a region for reading, and block if already locked
| *) |
| |
F_TRLOCK |
(* |
Lock a region for reading, or fail if already locked
| *) |
Core_unix.lockf
.val lockf : File_descr.t ->
mode:lock_command -> len:Core_kernel.Std.Int64.t -> unit
module Flock_command:sig
..end
val flock : File_descr.t -> Flock_command.t -> bool
flock fd cmd
places or releases a lock on the fd as per the flock C call of the same
name.val isatty : File_descr.t -> bool
true
if the given file descriptor refers to a terminal or
console window, false
otherwise.val unlink : string -> unit
val remove : string -> unit
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.val chmod : string -> perm:file_perm -> unit
val fchmod : File_descr.t -> perm:file_perm -> unit
val chown : string -> uid:int -> gid:int -> unit
val fchown : File_descr.t -> uid:int -> gid:int -> unit
val umask : int -> int
val access : string ->
[ `Exec | `Exists | `Read | `Write ] list ->
(unit, exn) Core_kernel.Std.Result.t
val access_exn : string -> [ `Exec | `Exists | `Read | `Write ] list -> unit
val dup : File_descr.t -> File_descr.t
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
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
UnixLabels.set_nonblock
.val set_close_on_exec : File_descr.t -> unit
exec
functions.val clear_close_on_exec : File_descr.t -> unit
UnixLabels.set_close_on_exec
.val mkdir : ?perm:file_perm -> string -> unit
val mkdir_p : ?perm:file_perm -> string -> unit
mkdir ~perm
.val rmdir : string -> unit
val chdir : string -> unit
val getcwd : unit -> string
val chroot : string -> unit
typedir_handle =
Unix.dir_handle
val opendir : ?restart:bool -> string -> dir_handle
val readdir : dir_handle -> string
End_of_file
when the end of the directory has been reached.val rewinddir : dir_handle -> unit
val closedir : dir_handle -> unit
val pipe : unit -> File_descr.t * File_descr.t
val mkfifo : string -> perm:file_perm -> unit
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:string ->
args:string list -> env:env -> unit -> Process_info.t
create_process_env ~prog ~args ~env
as create_process
, but takes an additional
parameter that extends or replaces the current environment. No effort is made to
ensure that the keys passed in as env are unique, so if an environment variable is set
twice the second version will override the first.val open_process_in : string -> Pervasives.in_channel
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
UnixLabels.open_process_in
.val open_process : string -> Pervasives.in_channel * Pervasives.out_channel
UnixLabels.open_process_in
.module Process_channels:sig
..end
UnixLabels.open_process
, but the second argument specifies
the environment passed to the command.
val open_process_full : string -> env:string array -> Process_channels.t
val close_process_in : Pervasives.in_channel -> Exit_or_signal.t
UnixLabels.open_process_in
,
wait for the associated command to terminate,
and return its termination status.val close_process_out : Pervasives.out_channel -> Exit_or_signal.t
UnixLabels.open_process_out
,
wait for the associated command to terminate,
and return its termination status.val close_process : Pervasives.in_channel * Pervasives.out_channel -> Exit_or_signal.t
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
UnixLabels.open_process_full
,
wait for the associated command to terminate,
and return its termination status.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
module Select_fds:sig
..end
typeselect_timeout =
[ `After of Core_kernel.Time_ns.Span.t | `Immediately | `Never ]
val select : ?restart:bool ->
read:File_descr.t list ->
write:File_descr.t list ->
except:File_descr.t list ->
timeout:select_timeout -> unit -> Select_fds.t
val pause : unit -> unit
typeprocess_times =
Unix.process_times
= {
|
tms_utime : |
(* |
User time for the process
| *) |
|
tms_stime : |
(* |
System time for the process
| *) |
|
tms_cutime : |
(* |
User time for the children processes
| *) |
|
tms_cstime : |
(* |
System time for the children processes
| *) |
typetm =
Unix.tm
= {
|
tm_sec : |
(* |
Seconds 0..59
| *) |
|
tm_min : |
(* |
Minutes 0..59
| *) |
|
tm_hour : |
(* |
Hours 0..23
| *) |
|
tm_mday : |
(* |
Day of month 1..31
| *) |
|
tm_mon : |
(* |
Month of year 0..11
| *) |
|
tm_year : |
(* |
Year - 1900
| *) |
|
tm_wday : |
(* |
Day of week (Sunday is 0)
| *) |
|
tm_yday : |
(* |
Day of year 0..365
| *) |
|
tm_isdst : |
(* |
Daylight time savings in effect
| *) |
val time : unit -> float
val gettimeofday : unit -> float
Core_unix.time
above, but with resolution better than 1 second.val gmtime : float -> tm
UnixLabels.time
, into a date and
a time. Assumes UTC.val timegm : tm -> float
val localtime : float -> tm
UnixLabels.time
, into a date and
a time. Assumes the local time zone.val mktime : tm -> float * tm
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
tm
argument, into a formatted string.
See 'man strftime' for format options.val strptime : fmt:string -> string -> Unix.tm
val alarm : int -> int
SIGALRM
signal after the given number of seconds.val sleep : int -> unit
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
val utimes : string -> access:float -> modif:float -> unit
typeinterval_timer =
Unix.interval_timer
=
| |
ITIMER_REAL |
(* |
decrements in real time, and sends the signal
SIGALRM when expired. | *) |
| |
ITIMER_VIRTUAL |
(* |
decrements in process virtual time, and sends
SIGVTALRM when expired. | *) |
| |
ITIMER_PROF |
(* |
(for profiling) decrements both when the process
is running and when the system is running on behalf of the
process; it sends
SIGPROF when expired. | *) |
typeinterval_timer_status =
Unix.interval_timer_status
= {
|
it_interval : |
(* |
Period
| *) |
|
it_value : |
(* |
Current value of the timer
| *) |
val getitimer : interval_timer -> interval_timer_status
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.val getuid : unit -> int
val geteuid : unit -> int
val setuid : int -> unit
val getgid : unit -> int
val getegid : unit -> int
val setgid : int -> unit
module Passwd:sig
..end
passwd
database
module Group:sig
..end
groups
database.
val getlogin : unit -> string
module Protocol_family:sig
..end
module Inet_addr:sig
..end
module Cidr:sig
..end
typesocket_domain =
Unix.socket_domain
=
| |
PF_UNIX |
(* |
Unix domain
| *) |
| |
PF_INET |
(* |
Internet domain
| *) |
| |
PF_INET6 |
typesocket_type =
Unix.socket_type
=
| |
SOCK_STREAM |
(* |
Stream socket
| *) |
| |
SOCK_DGRAM |
(* |
Datagram socket
| *) |
| |
SOCK_RAW |
(* |
Raw socket
| *) |
| |
SOCK_SEQPACKET |
typesockaddr =
Unix.sockaddr
=
| |
ADDR_UNIX of |
| |
ADDR_INET of |
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
val socket : domain:socket_domain ->
kind:socket_type -> protocol:int -> File_descr.t
val socketpair : domain:socket_domain ->
kind:socket_type ->
protocol:int -> File_descr.t * File_descr.t
val accept : File_descr.t -> File_descr.t * sockaddr
val bind : File_descr.t -> addr:sockaddr -> unit
val connect : File_descr.t -> addr:sockaddr -> unit
val listen : File_descr.t -> max:int -> unit
typeshutdown_command =
Unix.shutdown_command
=
| |
SHUTDOWN_RECEIVE |
(* |
Close for receiving
| *) |
| |
SHUTDOWN_SEND |
(* |
Close for sending
| *) |
| |
SHUTDOWN_ALL |
(* |
Close both
| *) |
shutdown
.val shutdown : File_descr.t -> mode:shutdown_command -> unit
val getsockname : File_descr.t -> sockaddr
val getpeername : File_descr.t -> sockaddr
typemsg_flag =
Unix.msg_flag
=
| |
MSG_OOB |
| |
MSG_DONTROUTE |
| |
MSG_PEEK |
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
val recvfrom : File_descr.t ->
buf:string ->
pos:int ->
len:int -> mode:msg_flag list -> int * sockaddr
val send : File_descr.t ->
buf:string -> pos:int -> len:int -> mode:msg_flag list -> int
val sendto : File_descr.t ->
buf:string ->
pos:int ->
len:int -> mode:msg_flag list -> addr:sockaddr -> int
type
socket_bool_option =
| |
SO_DEBUG |
(* |
Record debugging information
| *) |
| |
SO_BROADCAST |
(* |
Permit sending of broadcast messages
| *) |
| |
SO_REUSEADDR |
(* |
Allow reuse of local addresses for bind
| *) |
| |
SO_KEEPALIVE |
(* |
Keep connection active
| *) |
| |
SO_DONTROUTE |
(* |
Bypass the standard routing algorithms
| *) |
| |
SO_OOBINLINE |
(* |
Leave out-of-band data in line
| *) |
| |
SO_ACCEPTCONN |
|||
| |
TCP_NODELAY |
(* |
Control the Nagle algorithm for TCP sockets
| *) |
| |
IPV6_ONLY |
(* |
Forbid binding an IPv6 socket to an IPv4 address
| *) |
UnixLabels.getsockopt
and modified with UnixLabels.setsockopt
. These options have a boolean
(true
/false
) value.type
socket_int_option =
| |
SO_SNDBUF |
(* |
Size of send buffer
| *) |
| |
SO_RCVBUF |
(* |
Size of received buffer
| *) |
| |
SO_ERROR |
(* |
Report the error status and clear it
| *) |
| |
SO_TYPE |
(* |
Report the socket type
| *) |
| |
SO_RCVLOWAT |
(* |
Minimum number of bytes to process for input operations
| *) |
| |
SO_SNDLOWAT |
type
socket_optint_option =
| |
SO_LINGER |
(* |
Whether to linger on closed connections
with sexp that have data present, and for how long
(in seconds)
| *) |
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
| *) |
UnixLabels.getsockopt_float
and modified with UnixLabels.setsockopt_float
. These options have a
floating-point value representing a time in seconds.
The value 0 means infinite timeout.val getsockopt : File_descr.t -> socket_bool_option -> bool
val setsockopt : File_descr.t -> socket_bool_option -> bool -> unit
val getsockopt_int : File_descr.t -> socket_int_option -> int
UnixLabels.getsockopt
for an integer-valued socket option.val setsockopt_int : File_descr.t -> socket_int_option -> int -> unit
UnixLabels.setsockopt
for an integer-valued socket option.val getsockopt_optint : File_descr.t -> socket_optint_option -> int option
UnixLabels.getsockopt
for a socket option whose value is an int option
.val setsockopt_optint : File_descr.t ->
socket_optint_option -> int option -> unit
UnixLabels.setsockopt
for a socket option whose value is an int option
.val getsockopt_float : File_descr.t -> socket_float_option -> float
UnixLabels.getsockopt
for a socket option whose value is a floating-point
number.val setsockopt_float : File_descr.t -> socket_float_option -> float -> unit
UnixLabels.setsockopt
for a socket option whose value is a floating-point
number.val open_connection : sockaddr -> Pervasives.in_channel * Pervasives.out_channel
Pervasives.flush
on the output channel at the right times
to ensure correct synchronization.val shutdown_connection : Pervasives.in_channel -> unit
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
UnixLabels.establish_server
never returns normally.val gethostname : unit -> string
module Host:sig
..end
module Protocol:sig
..end
module Service:sig
..end
type
addr_info = {
|
ai_family : |
(* |
Socket domain
| *) |
|
ai_socktype : |
(* |
Socket type
| *) |
|
ai_protocol : |
(* |
Socket protocol number
| *) |
|
ai_addr : |
(* |
Address
| *) |
|
ai_canonname : |
Unix.getaddrinfo
.type
getaddrinfo_option =
| |
AI_FAMILY of |
(* |
Impose the given socket domain
| *) |
| |
AI_SOCKTYPE of |
(* |
Impose the given socket type
| *) |
| |
AI_PROTOCOL of |
(* |
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 |
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 : |
(* |
Name or IP address of host
| *) |
|
ni_service : |
Unix.getnameinfo
.
Name of service or port number
type
getnameinfo_option =
| |
NI_NOFQDN |
(* |
Do not qualify local host names
| *) |
| |
NI_NUMERICHOST |
(* |
Always return host as IP address
| *) |
| |
NI_NAMEREQD |
(* |
Fail if host name cannot be determined
| *) |
| |
NI_NUMERICSERV |
(* |
Always return service as port number
| *) |
| |
NI_DGRAM |
val getnameinfo : sockaddr ->
getnameinfo_option list -> name_info
getnameinfo addr opts
returns the host name and service name
corresponding to the socket address addr
. opts
is a possibly
empty list of options that governs how these names are obtained.
Raise Not_found
if an error occurs.termios
man page for a complete
description.module Terminal_io:sig
..end
val get_sockaddr : string -> int -> sockaddr
val set_in_channel_timeout : Pervasives.in_channel -> float -> unit
in_channel
val set_out_channel_timeout : Pervasives.out_channel -> float -> unit
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.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.Invalid_argument
if an unsupported file kind is used.Unix_error
if the system call fails.file_kind
: default = S_REG
(= regular file)perm
: default = 0o600
(= read/write for user only)major
: default = 0
minor
: default = 0
module IOVec:sig
..end
val dirfd : dir_handle -> File_descr.t
val sync : unit -> unit
val fsync : File_descr.t -> unit
val fdatasync : File_descr.t -> unit
val readdir_ino : dir_handle -> string * nativeint
readdir_ino dh
return the next entry in a directory (((filename,
inode)
).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
.Invalid_argument
if buffer range out of bounds.Unix_error
on Unix-errors.pos
: = 0len
: = String.length buf - pos
val write_assume_fd_is_nonblocking : File_descr.t -> ?pos:int -> ?len:int -> string -> int
write_assume_fd_is_nonblocking fd ?pos ?len buf
calls the system call
write
ASSUMING THAT IT IS NOT GOING TO BLOCK. Writes at most len
bytes from buffer buf
starting at position pos
.Invalid_argument
if buffer range out of bounds.Unix_error
on Unix-errors.pos
: = 0len
: = 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
.Invalid_argument
if the designated ranges are invalid.Unix_error
on Unix-errors.val writev : File_descr.t -> ?count:int -> string IOVec.t array -> int
writev fd ?count iovecs
like Core_unix.writev_assume_fd_is_nonblocking
, but does
not require the descriptor to not block. If you feel you have to
use this function, you should probably have chosen I/O-vectors that
build on bigstrings, because this function has to internally blit
the I/O-vectors (ordinary OCaml strings) to intermediate buffers on
the C-heap.Invalid_argument
if the designated ranges are invalid.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 |
val sysconf : sysconf -> int64
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.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.Unix_error
on errors.
kval abort : unit -> 'a
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
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
module Utsname:sig
..end
val uname : unit -> Utsname.t
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 interfaceval 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 interfaceval get_mcast_ttl : File_descr.t -> int
get_mcast_ttl sock
reads the time-to-live value of outgoing multicast packets for
socket sock
.val set_mcast_ttl : File_descr.t -> int -> unit
set_mcast_ttl sock ttl
sets the time-to-live value of outgoing multicast packets for
socket sock
to ttl
.val get_mcast_loop : File_descr.t -> bool
get_mcast_loop sock
reads the boolean argument that determines whether sent
multicast packets are looped back to local sockets.val set_mcast_loop : File_descr.t -> bool -> unit
set_mcast_loop sock loop
sets the boolean argument that determines whether sent
multicast packets are looped back to local sockets.val set_mcast_ifname : File_descr.t -> string -> unit
set_mcast_ifname sock "eth0"
sets outgoing multicast traffic on IPv4 UDP socket
sock
to go out through interface eth0
.
This uses setsockopt
with IP_MULTICAST_IF
and applies to multicast traffic. For
non-multicast applications, see Linux_ext.bind_to_interface
.
module Scheduler:sig
..end
module Priority:sig
..end
module Mman:sig
..end
module Syslog: module type of Syslog
val error_of_sexp : Sexplib.Sexp.t -> error
val sexp_of_error : error -> Sexplib.Sexp.t
EUNKNOWNERR
.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.
If you're looking for getenv
, that's in the Sys module.
Return the process environment, as an array of strings
with the format ``variable=value''.
Unix.putenv ~key ~data
sets the value associated to a
variable in the process environment.
key
is the name of the environment variable,
and data
its new associated value.
unsetenv name
deletes the variable name
from the environment.
EINVAL name
contained an ’=’ or an '\000' character.
of_unix
assumes that any signal numbers in the incoming value are O'Caml internal
signal numbers.of_unix
assumes that any signal numbers in the incoming value are O'Caml internal
signal numbers.val env_of_sexp : Sexplib.Sexp.t -> env
env
is used to control the environment of a child process, and can take three forms.
`Replace_raw
replaces the entire environment with strings in the Unix style, like
"VARIABLE_NAME=value"
. `Replace
has the same effect as `Replace_raw
, but using
bindings represented as "VARIABLE_NAME", "value"
. `Extend
adds entries to the
existing environment rather than replacing the whole environment.
If env
contains multiple bindings for the same variable, the last takes precedence.
In the case of `Extend
, bindings in env
take precedence over the existing
environment.
val __env_of_sexp__ : Sexplib.Sexp.t -> env
val sexp_of_env : env -> Sexplib.Sexp.t
exec ~prog ~args ?search_path ?env
execs prog
with args
. If use_path = true
(the default) and prog
doesn't contain a slash, then exec
searches the PATH
environment variable for prog
. If env
is supplied, it determines the environment
when prog
is executed.
The first element in args should be the program itself; the correct way to call exec
is:
exec ~prog ~args:[ prog; arg1; arg2; ...] ()
true
fork_exec ~prog ~args ?use_path ?env ()
forks and execs prog
with args
in the
child process, returning the child PID to the parent.true
fork ()
forks a new process. The return value indicates whether we are continuing
in the child or the parent, and if the parent, includes the child's process id.wait{,_nohang,_untraced,_nohang_untraced} ?restart wait_on
is a family of functions
that wait on a process to exit (normally or via a signal) or be stopped by a signal
(if untraced
is used). The wait_on
argument specifies which processes to wait on.
The nohang
variants return None
immediately if no such process exists. If
nohang
is not used, waitpid
will block until one of the desired processes exits.
The non-nohang variants have a restart
flag with (default true) that causes the
system call to be retried upon EAGAIN|EINTR. The nohang variants do not have this
flag because they don't block.
val wait_on_of_sexp : Sexplib.Sexp.t -> wait_on
val __wait_on_of_sexp__ : Sexplib.Sexp.t -> wait_on
val sexp_of_wait_on : wait_on -> Sexplib.Sexp.t
waitpid pid
waits for child process pid
to terminate, and returns its exit status.
waitpid_exn
is like waitpid
, except it only returns if the child exits with status
zero, and raises if the child terminates in any other way./bin/sh
and therefore can contain redirections, quotes, variables,
etc. The result WEXITED 127
indicates that the shell couldn't
be executed.UnixLabels.openfile
.Core_unix.openfile
val file_perm_of_sexp : Sexplib.Sexp.t -> file_perm
val sexp_of_file_perm : file_perm -> Sexplib.Sexp.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.
These three flags are not individual bits like flags usually are. The access mode
is represented by the lower two bits of the Open_flags.t
. A particular
Open_flags.t
should include exactly one access mode. Combining different
Open_flags.t
's using flags operations (e.g +
) is only sensible if they have the
same access mode.
creation
can_read t
iff t
has rdonly
or rdwr
can_read t
iff t
has wronly
or rdwr
fcntl_getfl fd
gets the current flags for fd
from the open-file-descriptor table
via the system call fcntl(fd, F_GETFL)
. See "man fcntl".
fcntl_setfl fd flags
sets the flags for fd
in the open-file-descriptor table via
the system call fcntl(fd, F_SETFL, flags)
. See "man fcntl". As per the Linux man
page, on Linux this only allows append
and nonblock
to be set.
Close a file descriptor.
with_file file ~mode ~perm ~f
opens file
, and applies f
to the resulting file
descriptor. When f
finishes (or raises), with_file
closes the descriptor and
returns the result of f
(or raises).
read fd buff ofs len
reads len
characters from descriptor
fd
, storing them in string buff
, starting at position ofs
in string buff
. Return the number of characters actually read.
write fd buff ofs len
writes len
characters to descriptor
fd
, taking them from string buff
, starting at position ofs
in string buff
. Return the number of characters actually
written.
When an error is reported some characters might have already been
written. Use single_write
instead to ensure that this is not the
case.
WARNING: write is an interruptible call and has no way to handle
EINTR properly. You should most probably be using single write.
Same as write
but ensures that all errors are reported and
that no character has ever been written when an error is reported.
set_binary_mode_in ic false
if text mode is desired.set_binary_mode_out oc false
if text mode is desired.val seek_command_of_sexp : Sexplib.Sexp.t -> seek_command
UnixLabels.lseek
.val sexp_of_seek_command : seek_command -> Sexplib.Sexp.t
val file_kind_of_sexp : Sexplib.Sexp.t -> file_kind
val sexp_of_file_kind : file_kind -> Sexplib.Sexp.t
val stats_of_sexp : Sexplib.Sexp.t -> stats
UnixLabels.stat
calls.val sexp_of_stats : stats -> Sexplib.Sexp.t
UnixLabels.stat
, but in case the file is a symbolic link,
return the information for the link itself.UnixLabels.stat
calls.UnixLabels.stat
, but in case the file is a symbolic link,
return the information for the link itself.val lock_command_of_sexp : Sexplib.Sexp.t -> lock_command
Core_unix.lockf
.val sexp_of_lock_command : lock_command -> Sexplib.Sexp.t
lockf fd cmd size
place a lock on a file_descr that prevents any other process from
calling lockf successfully on the same file. Due to a limitation in the current
implementation the length will be converted to a native int, potentially throwing an
exception if it is too large.flock fd cmd
places or releases a lock on the fd as per the flock C call of the same
name.true
if the given file descriptor refers to a terminal or
console window, false
otherwise.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.dup2 ~src ~dst
duplicates src
to dst
, closing dst
if already
opened.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
.UnixLabels.set_nonblock
.exec
functions.UnixLabels.set_close_on_exec
.mkdir ~perm
.create_process ~prog ~args
forks a new process that executes the program prog
with
arguments args
. The function returns the pid of the process along with file
descriptors attached to stdin, stdout, and stderr of the new process. The executable
file prog
is searched for in the path. The new process has the same environment as
the current process. Unlike in execve
the program name is automatically passed as
the first argument.create_process_env ~prog ~args ~env
as create_process
, but takes an additional
parameter that extends or replaces the current environment. No effort is made to
ensure that the keys passed in as env are unique, so if an environment variable is set
twice the second version will override the first.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.UnixLabels.open_process_in
.UnixLabels.open_process_in
.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.UnixLabels.open_process_in
,
wait for the associated command to terminate,
and return its termination status.UnixLabels.open_process_out
,
wait for the associated command to terminate,
and return its termination status.UnixLabels.open_process
,
wait for the associated command to terminate,
and return its termination status.UnixLabels.open_process_full
,
wait for the associated command to terminate,
and return its termination status.symlink source dest
creates the file dest
as a symbolic link
to the file source
.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
Core_unix.time
above, but with resolution better than 1 second.UnixLabels.time
, into a date and
a time. Assumes UTC.UnixLabels.time
, into a date and
a time. Assumes the local time zone.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.tm
argument, into a formatted string.
See 'man strftime' for format options.SIGALRM
signal after the given number of seconds.nanosleep f
delays execution of the program for at least f
seconds. The function
can return earlier if a signal has been delivered, in which case the number of
seconds left is returned. Any other failure raises an exception.val interval_timer_of_sexp : Sexplib.Sexp.t -> interval_timer
val sexp_of_interval_timer : interval_timer -> Sexplib.Sexp.t
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
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.passwd
databasegetpwents
is a thread-safe wrapper over the low-level passwd database
functions.groups
database.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.of_string
and if that fails, use Host.getbyname
.of_string
for a description of the printable representation.bind
, representing all the Internet addresses
that the host machine possesses.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.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.base_address 192.168.0.0/24 = 192.168.0.0
bits 192.168.0.0/24 = 24
.does_match 10.0.0.0/8 10.0.0.0
is true.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
ADDR_UNIX name
is a socket
address in the Unix domain; name
is a file name in the file
system. ADDR_INET(addr,port)
is a socket address in the Internet
domain; addr
is the Internet address of the machine, and
port
is the port number.val bin_read_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Read.reader
val __bin_read_sockaddr__ : (int -> sockaddr) Core_kernel.Std.Bin_prot.Read.reader
val bin_reader_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.reader
val bin_size_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Size.sizer
val bin_write_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Write.writer
val bin_writer_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.writer
val sockaddr_of_sexp : Sexplib.Sexp.t -> sockaddr
val sexp_of_sockaddr : sockaddr -> Sexplib.Sexp.t
val shutdown_command_of_sexp : Sexplib.Sexp.t -> shutdown_command
shutdown
.val sexp_of_shutdown_command : shutdown_command -> Sexplib.Sexp.t
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 msg_flag_of_sexp : Sexplib.Sexp.t -> msg_flag
UnixLabels.recv
, UnixLabels.recvfrom
,
UnixLabels.send
and UnixLabels.sendto
.val sexp_of_msg_flag : msg_flag -> Sexplib.Sexp.t
val socket_bool_option_of_sexp : Sexplib.Sexp.t -> socket_bool_option
UnixLabels.getsockopt
and modified with UnixLabels.setsockopt
. These options have a boolean
(true
/false
) value.val sexp_of_socket_bool_option : socket_bool_option -> Sexplib.Sexp.t
val socket_int_option_of_sexp : Sexplib.Sexp.t -> socket_int_option
UnixLabels.getsockopt_int
and modified with UnixLabels.setsockopt_int
. These options have an
integer value.val sexp_of_socket_int_option : socket_int_option -> Sexplib.Sexp.t
UnixLabels.getsockopt_optint
and modified with UnixLabels.setsockopt_optint
. These options have a
value of type int option
, with None
meaning ``disabled''.val socket_float_option_of_sexp : Sexplib.Sexp.t -> socket_float_option
UnixLabels.getsockopt_float
and modified with UnixLabels.setsockopt_float
. These options have a
floating-point value representing a time in seconds.
The value 0 means infinite timeout.val sexp_of_socket_float_option : socket_float_option -> Sexplib.Sexp.t
UnixLabels.getsockopt
for an integer-valued socket option.UnixLabels.setsockopt
for an integer-valued socket option.UnixLabels.getsockopt
for a socket option whose value is an int option
.UnixLabels.setsockopt
for a socket option whose value is an int option
.UnixLabels.getsockopt
for a socket option whose value is a floating-point
number.UnixLabels.setsockopt
for a socket option whose value is a floating-point
number.Pervasives.flush
on the output channel at the right times
to ensure correct synchronization.UnixLabels.open_connection
;
that is, transmit an end-of-file condition to the server reading
on the other side of the connection.UnixLabels.establish_server
never returns normally.hosts
database.hosts
with the given name.
NOTE: This function is not thread safe with certain versions of winbind using "wins"
name resolution.
Find an entry in hosts
with the given address.
Structure of entries in the protocols
database.
Find an entry in protocols
with the given name.
Find an entry in protocols
with the given protocol number.
Structure of entries in the services
database.
Find an entry in services
with the given name.
Find an entry in services
with the given service number.
val addr_info_of_sexp : Sexplib.Sexp.t -> addr_info
Unix.getaddrinfo
.val sexp_of_addr_info : addr_info -> Sexplib.Sexp.t
val getaddrinfo_option_of_sexp : Sexplib.Sexp.t -> getaddrinfo_option
Unix.getaddrinfo
.val sexp_of_getaddrinfo_option : getaddrinfo_option -> Sexplib.Sexp.t
getaddrinfo host service opts
returns a list of Unix.addr_info
records describing socket parameters and addresses suitable for
communicating with the given host and service. The empty list is
returned if the host or service names are unknown, or the constraints
expressed in opts
cannot be satisfied.
host
is either a host name or the string representation of an IP
address. host
can be given as the empty string; in this case,
the ``any'' address or the ``loopback'' address are used,
depending whether opts
contains AI_PASSIVE
.
service
is either a service name or the string representation of
a port number. service
can be given as the empty string;
in this case, the port field of the returned addresses is set to 0.
opts
is a possibly empty list of options that allows the caller
to force a particular socket domain (e.g. IPv6 only, or IPv4 only)
or a particular socket type (e.g. TCP only or UDP only).
val name_info_of_sexp : Sexplib.Sexp.t -> name_info
Unix.getnameinfo
.val sexp_of_name_info : name_info -> Sexplib.Sexp.t
val getnameinfo_option_of_sexp : Sexplib.Sexp.t -> getnameinfo_option
Unix.getnameinfo
.val sexp_of_getnameinfo_option : getnameinfo_option -> Sexplib.Sexp.t
getnameinfo addr opts
returns the host name and service name
corresponding to the socket address addr
. opts
is a possibly
empty list of options that governs how these names are obtained.
Raise Not_found
if an error occurs.termios
man page for a complete
description.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.TCIFLUSH
flushes data received but not read,
TCOFLUSH
flushes data written but not transmitted, and
TCIOFLUSH
flushes both.TCOOFF
suspends output, TCOON
restarts output,
TCIOFF
transmits a STOP character to suspend input,
and TCION
transmits a START character to restart input.in_channel
out_channel
exit_immediately exit_code
immediately calls the exit
system call with the given
exit code without performing any other actions (unlike Pervasives.exit). Does not
return.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.empty
the empty I/O-vector.of_string ?pos ?len str
of_bigstring ?pos ?len bstr
drop iovec n
drops n
characters from iovec
.readdir_ino dh
return the next entry in a directory (((filename,
inode)
).read_assume_fd_is_nonblocking fd ?pos ?len buf
calls the system call
read
ASSUMING THAT IT IS NOT GOING TO BLOCK. Reads at most len
bytes into buffer buf
starting at position pos
.write_assume_fd_is_nonblocking fd ?pos ?len buf
calls the system call
write
ASSUMING THAT IT IS NOT GOING TO BLOCK. Writes at most len
bytes from buffer buf
starting at position pos
.writev_assume_fd_is_nonblocking fd ?count iovecs
calls the system call
writev
ASSUMING THAT IT IS NOT GOING TO BLOCK using count
I/O-vectors iovecs
.writev fd ?count iovecs
like Core_unix.writev_assume_fd_is_nonblocking
, but does
not require the descriptor to not block. If you feel you have to
use this function, you should probably have chosen I/O-vectors that
build on bigstrings, because this function has to internally blit
the I/O-vectors (ordinary OCaml strings) to intermediate buffers on
the C-heap.pselect rfds wfds efds timeout sigmask
like Core_unix.select
but
also allows one to wait for the arrival of signals.add ru1 ru2
adds two rusage structures (e.g. your resource usage
and your children's).val sysconf_of_sexp : Sexplib.Sexp.t -> sysconf
val sexp_of_sysconf : sysconf -> Sexplib.Sexp.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.mkdtemp prefix
creates a temporary directory with prefix
,
automatically appending a suffix of six random characters to make
the name unique.getgrouplist user group
returns the list of groups to which user
belongs.
See 'man getgrouplist'.mcast_join ?ifname sock addr
join a multicast group at addr
with socket sock
,
from source at source
if specified, optionally using network interface ifname
.mcast_leave ?ifname sock addr
leaves a multicast group at addr
with socket sock
,
optionally using network interface ifname
.get_mcast_ttl sock
reads the time-to-live value of outgoing multicast packets for
socket sock
.set_mcast_ttl sock ttl
sets the time-to-live value of outgoing multicast packets for
socket sock
to ttl
.get_mcast_loop sock
reads the boolean argument that determines whether sent
multicast packets are looped back to local sockets.set_mcast_loop sock loop
sets the boolean argument that determines whether sent
multicast packets are looped back to local sockets.set_mcast_ifname sock "eth0"
sets outgoing multicast traffic on IPv4 UDP socket
sock
to go out through interface eth0
.
This uses setsockopt
with IP_MULTICAST_IF
and applies to multicast traffic. For
non-multicast applications, see Linux_ext.bind_to_interface
.