module Fd = Fd
include Async_unix.Unix_syscalls
Unix_syscalls
provides an interface to many of the functions in OCaml's standard
Unix module. It uses a deferred in the return type of functions that would block.
The idea is that in an Async program one does not use the standard Unix module, since
in doing so one could accidentally block the whole program.
There are also a number of cosmetic changes (e.g. polymorphic variants) and other improvements (e.g. phantom types on sockets) over the standard Unix module.
module Syscall_result = Core.Unix.Syscall_result
module Exit = Async_unix.Unix_syscalls.Exit
module Exit_or_signal = Async_unix.Unix_syscalls.Exit_or_signal
module Exit_or_signal_or_stop = Async_unix.Unix_syscalls.Exit_or_signal_or_stop
val system : string ‑> Exit_or_signal.t Async_unix.Import.Deferred.t
val system_exn : string ‑> unit Async_unix.Import.Deferred.t
val getpid : unit ‑> Core.Pid.t
val getppid : unit ‑> Core.Pid.t option
val getppid_exn : unit ‑> Core.Pid.t
val this_process_became_child_of_init : ?poll_delay:Core.Time.Span.t ‑> unit ‑> unit Async_unix.Import.Deferred.t
this_process_became_child_of_init
returns a deferred that becomes determined when
the current process becomes a child of init(8). This is useful to determine if one's
parent has died, because in that case init will becomes one's parent.
See Linux_ext.pr_set_pdeathsig : Signal.t -> unit
for related way to get information
about parent death.
val cores : (unit ‑> int Async_unix.Import.Deferred.t) Core.Or_error.t
cores ()
Returns the number of cores
val openfile : ?perm:file_perm ‑> string ‑> mode:open_flag list ‑> Async_unix.Fd.t Async_unix.Import.Deferred.t
val with_file : ?exclusive:[ `Read | `Write ] ‑> ?perm:file_perm ‑> string ‑> mode:open_flag list ‑> f:(Async_unix.Fd.t ‑> 'a Async_unix.Import.Deferred.t) ‑> 'a Async_unix.Import.Deferred.t
with_file file ~mode ~perm ~f ?exclusive
opens file
, and applies f
to the
resulting file descriptor. When the result of f
becomes determined, it closes the
descriptor and returns the result of f
. If exclusive
is supplied, then the file
descriptor is locked before calling f
and unlocked after calling f
.
module Open_flags = Async_unix.Unix_syscalls.Open_flags
val fcntl_getfl : Async_unix.Fd.t ‑> Open_flags.t Async_unix.Import.Deferred.t
fcntl_getfl
and fcntl_setf
are deferred wrappers around the corresponding
functions in Core.Unix
for accessing the open-file-descriptor table.
val fcntl_setfl : Async_unix.Fd.t ‑> Open_flags.t ‑> unit Async_unix.Import.Deferred.t
include module type of Async_unix.Fd.Close
The Close
module exists to collect close
and its associated types, so they
can be easily reused elsewhere, e.g. Unix_syscalls
.
type file_descriptor_handling
=
| Close_file_descriptor of socket_handling |
| Do_not_close_file_descriptor |
val close : ?file_descriptor_handling:file_descriptor_handling ‑> Async_unix.Fd.t ‑> unit Async_unix.Import.Deferred.t
close t
prevents further use of t
, and makes shutdown()
and close()
system
calls on t
's underlying file descriptor according to the
file_descriptor_handling
argument and whether or not t
is a socket, i.e. kind t
= Socket `Active
:
| file_descriptor_handling | shutdown() | close() | |----------------------------------------------+------------+---------| | Do_not_close_file_descriptor | no | no | | Close_file_descriptor Shutdown_socket | if socket | yes | | Close_file_descriptor Do_not_shutdown_socket | no | yes |
The result of close
becomes determined once the system calls complete. It is OK
to call close
multiple times on the same t
; calls subsequent to the initial call
will have no effect, but will return the same deferred as the original call.
val lseek : Async_unix.Fd.t ‑> int64 ‑> mode:[< `Set | `Cur | `End ] ‑> int64 Async_unix.Import.Deferred.t
val truncate : string ‑> len:int64 ‑> unit Async_unix.Import.Deferred.t
val ftruncate : Async_unix.Fd.t ‑> len:int64 ‑> unit Async_unix.Import.Deferred.t
val fsync : Async_unix.Fd.t ‑> unit Async_unix.Import.Deferred.t
val fdatasync : Async_unix.Fd.t ‑> unit Async_unix.Import.Deferred.t
val sync : unit ‑> unit Async_unix.Import.Deferred.t
val lockf : ?len:Core.Int64.t ‑> Async_unix.Fd.t ‑> [ `Read | `Write ] ‑> unit Async_unix.Import.Deferred.t
lockf fd read_or_write ?len
exclusively locks for reading/writing the section of the
open file fd
specified by the current file position and len
(see man lockf). It
returns when the lock has been acquired. It raises if fd
is closed.
val try_lockf : ?len:Core.Int64.t ‑> Async_unix.Fd.t ‑> [ `Read | `Write ] ‑> bool
try_lockf fd read_or_write ?len
attempts to exclusively lock for reading/writing the
section of the open file fd
specified by the current file position and len
(see
man lockf). It returns true
if it acquired the lock. It raises if fd
is
closed.
val test_lockf : ?len:Core.Int64.t ‑> Async_unix.Fd.t ‑> bool
lockf_is_locked fd ?len
checks the lock on section of the open file fd
specified
by the current file position and len
(see man lockf). If the section is unlocked or
locked by this process, it returns true, else it returns false. It raises if fd
is
closed.
val unlockf : ?len:Core.Int64.t ‑> Async_unix.Fd.t ‑> unit
unlockf fd ?len
unlocks the section of the open file fd
specified by the current
file position and len
(see man lockf). It raises if fd
is closed.
module File_kind = Async_unix.Unix_syscalls.File_kind
module Stats = Async_unix.Unix_syscalls.Stats
val fstat : Async_unix.Fd.t ‑> Stats.t Async_unix.Import.Deferred.t
val stat : string ‑> Stats.t Async_unix.Import.Deferred.t
val lstat : string ‑> Stats.t Async_unix.Import.Deferred.t
val isatty : Async_unix.Fd.t ‑> bool Async_unix.Import.Deferred.t
val unlink : string ‑> unit Async_unix.Import.Deferred.t
val remove : string ‑> unit Async_unix.Import.Deferred.t
val rename : src:string ‑> dst:string ‑> unit Async_unix.Import.Deferred.t
val link : ?force:bool ‑> target:string ‑> link_name:string ‑> unit ‑> unit Async_unix.Import.Deferred.t
val chmod : string ‑> perm:file_perm ‑> unit Async_unix.Import.Deferred.t
val fchmod : Async_unix.Fd.t ‑> perm:file_perm ‑> unit Async_unix.Import.Deferred.t
val chown : string ‑> uid:int ‑> gid:int ‑> unit Async_unix.Import.Deferred.t
val fchown : Async_unix.Fd.t ‑> uid:int ‑> gid:int ‑> unit Async_unix.Import.Deferred.t
val access : string ‑> [ `Read | `Write | `Exec | `Exists ] list ‑> (unit, exn) Core.Result.t Async_unix.Import.Deferred.t
val access_exn : string ‑> [ `Read | `Write | `Exec | `Exists ] list ‑> unit Async_unix.Import.Deferred.t
val set_close_on_exec : Async_unix.Fd.t ‑> unit
val clear_close_on_exec : Async_unix.Fd.t ‑> unit
val mkdir : ?p:unit ‑> ?perm:file_perm ‑> string ‑> unit Async_unix.Import.Deferred.t
val rmdir : string ‑> unit Async_unix.Import.Deferred.t
val chdir : string ‑> unit Async_unix.Import.Deferred.t
val getcwd : unit ‑> string Async_unix.Import.Deferred.t
val chroot : string ‑> unit Async_unix.Import.Deferred.t
val opendir : string ‑> dir_handle Async_unix.Import.Deferred.t
val readdir_opt : dir_handle ‑> string option Async_unix.Import.Deferred.t
readdir_opt dir_handle
returns the next directory member, or None
when there are
no more directory members to return.
val readdir : dir_handle ‑> string Async_unix.Import.Deferred.t
val rewinddir : dir_handle ‑> unit Async_unix.Import.Deferred.t
val closedir : dir_handle ‑> unit Async_unix.Import.Deferred.t
val pipe : Core.Info.t ‑> ([ `Reader of Async_unix.Fd.t ] * [ `Writer of Async_unix.Fd.t ]) Async_unix.Import.Deferred.t
The info
supplied to pipe is debugging information that will be included in the
returned Fd
s.
val mkfifo : ?perm:file_perm ‑> string ‑> unit Async_unix.Import.Deferred.t
Create a named pipe with the given permissions.
val symlink : src:string ‑> dst:string ‑> unit Async_unix.Import.Deferred.t
val readlink : string ‑> string Async_unix.Import.Deferred.t
val mkstemp : string ‑> (string * Async_unix.Fd.t) Async_unix.Import.Deferred.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.
val mkdtemp : string ‑> string Async_unix.Import.Deferred.t
val getgrouplist : string ‑> int ‑> int array Async_unix.Import.Deferred.t
type process_times
= Core.Unix.process_times
=
{
}
Time functions.
val times : unit ‑> process_times
type tm
= Core.Unix.tm
=
{
}
val gmtime : float ‑> tm
val localtime : float ‑> tm
val utimes : string ‑> access:float ‑> modif:float ‑> unit Async_unix.Import.Deferred.t
val fork_exec : prog:string ‑> argv:string list ‑> ?use_path:bool ‑> ?env:[ env | `Replace_raw of string list ] ‑> unit ‑> Core.Pid.t Async_unix.Import.Deferred.t
fork_exec ~prog ~argv ?path ?env
forks and execs prog
with argv
, and returns the
child pid. If use_path = true
(the default) and prog
doesn't contain a slash,
then fork_exec
searches the PATH environment variable for prog
. If env
is
supplied, it specifies the environment when prog
is executed.
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. See Unix.exec.
include sig ... end
val wait_on_of_sexp : Sexplib.Sexp.t ‑> wait_on
val __wait_on_of_sexp__ : Sexplib.Sexp.t ‑> wait_on
val sexp_of_wait_on : wait_on ‑> Sexplib.Sexp.t
val wait : wait_on ‑> (Core.Pid.t * Exit_or_signal.t) Async_unix.Import.Deferred.t
val wait_nohang : wait_on ‑> (Core.Pid.t * Exit_or_signal.t) option
val wait_untraced : wait_on ‑> (Core.Pid.t * Exit_or_signal_or_stop.t) Async_unix.Import.Deferred.t
val wait_nohang_untraced : wait_on ‑> (Core.Pid.t * Exit_or_signal_or_stop.t) option
val waitpid : Core.Pid.t ‑> Exit_or_signal.t Async_unix.Import.Deferred.t
waitpid pid
returns a deferred that becomes determined with the child's exit
status, when the child process with process id pid
exits. waitpid_exn
is like
waitpid
, except the result only becomes determined if the child exits with status
zero; it raises if the child terminates in any other way.
val waitpid_exn : Core.Pid.t ‑> unit Async_unix.Import.Deferred.t
module Inet_addr = Async_unix.Unix_syscalls.Inet_addr
module Cidr = Async_unix.Unix_syscalls.Cidr
module Protocol_family = Async_unix.Unix_syscalls.Protocol_family
val socketpair : unit ‑> Async_unix.Fd.t * Async_unix.Fd.t
module Socket = Async_unix.Unix_syscalls.Socket
val bind_to_interface_exn : (Async_unix.Fd.t ‑> [ `Any | `Interface_name of string ] ‑> unit) Core.Or_error.t
module Host = Async_unix.Unix_syscalls.Host
include sig ... end
val socket_domain_of_sexp : Sexplib.Sexp.t ‑> socket_domain
val sexp_of_socket_domain : socket_domain ‑> Sexplib.Sexp.t
val bin_socket_domain : socket_domain Bin_prot.Type_class.t
val bin_read_socket_domain : socket_domain Bin_prot.Read.reader
val __bin_read_socket_domain__ : (int ‑> socket_domain) Bin_prot.Read.reader
val bin_reader_socket_domain : socket_domain Bin_prot.Type_class.reader
val bin_size_socket_domain : socket_domain Bin_prot.Size.sizer
val bin_write_socket_domain : socket_domain Bin_prot.Write.writer
val bin_writer_socket_domain : socket_domain Bin_prot.Type_class.writer
val bin_shape_socket_domain : Bin_prot.Shape.t
include sig ... end
val socket_type_of_sexp : Sexplib.Sexp.t ‑> socket_type
val sexp_of_socket_type : socket_type ‑> Sexplib.Sexp.t
val bin_socket_type : socket_type Bin_prot.Type_class.t
val bin_read_socket_type : socket_type Bin_prot.Read.reader
val __bin_read_socket_type__ : (int ‑> socket_type) Bin_prot.Read.reader
val bin_reader_socket_type : socket_type Bin_prot.Type_class.reader
val bin_size_socket_type : socket_type Bin_prot.Size.sizer
val bin_write_socket_type : socket_type Bin_prot.Write.writer
val bin_writer_socket_type : socket_type Bin_prot.Type_class.writer
val bin_shape_socket_type : Bin_prot.Shape.t
include sig ... end
val sexp_of_sockaddr : sockaddr ‑> Sexplib.Sexp.t
val bin_sockaddr : sockaddr Bin_prot.Type_class.t
val bin_read_sockaddr : sockaddr Bin_prot.Read.reader
val __bin_read_sockaddr__ : (int ‑> sockaddr) Bin_prot.Read.reader
val bin_reader_sockaddr : sockaddr Bin_prot.Type_class.reader
val bin_size_sockaddr : sockaddr Bin_prot.Size.sizer
val bin_write_sockaddr : sockaddr Bin_prot.Write.writer
val bin_writer_sockaddr : sockaddr Bin_prot.Type_class.writer
val bin_shape_sockaddr : Bin_prot.Shape.t
val sockaddr_of_sexp : Core.Sexp.t ‑> sockaddr
sockaddr_blocking_sexp
is like sockaddr
, with of_sexp
that performs DNS lookup
to resolve Inet_addr.t
.
include sig ... end
val sockaddr_blocking_sexp_of_sexp : Sexplib.Sexp.t ‑> sockaddr_blocking_sexp
val sexp_of_sockaddr_blocking_sexp : sockaddr_blocking_sexp ‑> Sexplib.Sexp.t
val bin_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.t
val bin_read_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Read.reader
val __bin_read_sockaddr_blocking_sexp__ : (int ‑> sockaddr_blocking_sexp) Bin_prot.Read.reader
val bin_reader_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.reader
val bin_size_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Size.sizer
val bin_write_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Write.writer
val bin_writer_sockaddr_blocking_sexp : sockaddr_blocking_sexp Bin_prot.Type_class.writer
val bin_shape_sockaddr_blocking_sexp : Bin_prot.Shape.t
module Addr_info = Async_unix.Unix_syscalls.Addr_info
module Name_info = Async_unix.Unix_syscalls.Name_info
module Error = Core.Unix.Error
type error
= Core.Unix.Error.t
=
val sexp_of_error : Error.t ‑> Core.Sexp.t
val error_of_sexp : Core.Sexp.t ‑> Error.t
exception
Unix_error of Error.t * string * string
module Terminal_io = Async_unix.Unix_syscalls.Terminal_io
module Ifaddr = Core.Unix.Ifaddr
val getifaddrs : unit ‑> Ifaddr.t list Async_unix.Import.Deferred.t
getifaddrs
gets the information using the socket-based netlink interface, which
can block, see: https://www.infradead.org/~tgr/libnl/doc/core.html.
val getlogin : unit ‑> string Async_unix.Import.Deferred.t
Return the login name of the user executing the process.
This returns a deferred because the username may need to be looked up in what is essentially a database elsewhere on the network (winbound user, or NIS).
val wordexp : (?flags:[ `No_cmd | `Show_err | `Undef ] list ‑> string ‑> string array Async_unix.Import.Deferred.t) Core.Or_error.t