Module Iobuf_intf.Unix

module Unix: Unix

module File_descr: sig .. end

Error report

type error = Unix.error = 

module Error: sig .. end

exception Unix_error of error * string * string

val unix_error : int -> string -> string -> 'a

val error_message : error -> string

val handle_unix_error : (unit -> 'a) -> 'a

val retry_until_no_eintr : (unit -> 'a) -> 'a

Access to the process environment

If you're looking for getenv, that's in the Sys module.

val environment : unit -> string array

val putenv : key:string -> data:string -> unit

val unsetenv : string -> unit

Process handling

module Exit: sig .. end

module Exit_or_signal: sig .. end

module Exit_or_signal_or_stop: sig .. end

val exec : prog:string ->
       args:string list ->
       ?use_path:bool -> ?env:string list -> unit -> Core_kernel.Std.never_returns

val fork_exec : prog:string ->
       args:string list ->
       ?use_path:bool -> ?env:string list -> unit -> Core_kernel.Std.Pid.t

val fork : unit -> [ `In_the_child | `In_the_parent of Core_kernel.Std.Pid.t ]

The non-nohang variants have a restart flag with (default true) that causes the system call to be retried upon EAGAIN|EINTR. The nohang variants do not have this flag because they don't block.

type wait_on = [ `Any
       | `Group of Core_kernel.Std.Pid.t
       | `My_group
       | `Pid of Core_kernel.Std.Pid.t ] 

val wait : ?restart:bool ->
       wait_on -> Core_kernel.Std.Pid.t * Exit_or_signal.t

val wait_nohang : wait_on ->
       (Core_kernel.Std.Pid.t * Exit_or_signal.t) option

val wait_untraced : ?restart:bool ->
       wait_on ->
       Core_kernel.Std.Pid.t * Exit_or_signal_or_stop.t

val wait_nohang_untraced : wait_on ->
       (Core_kernel.Std.Pid.t * Exit_or_signal_or_stop.t) option

val waitpid : Core_kernel.Std.Pid.t -> Exit_or_signal.t

val waitpid_exn : Core_kernel.Std.Pid.t -> unit

val system : string -> Exit_or_signal.t

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

val nice : int -> int

Basic file input/output

val stdin : File_descr.t

val stdout : File_descr.t

val stderr : File_descr.t

type open_flag = Unix.open_flag = 

type file_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

val fcntl_setfl : File_descr.t -> Open_flags.t -> unit

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

val read : ?restart:bool ->
       ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int

val write : ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int

val single_write : ?restart:bool ->
       ?pos:int -> ?len:int -> File_descr.t -> buf:string -> int

Interfacing with the standard input/output library

val in_channel_of_descr : File_descr.t -> Core_kernel.Std.In_channel.t

val out_channel_of_descr : File_descr.t -> Core_kernel.Std.Out_channel.t

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

Seeking and truncating

type seek_command = Unix.seek_command = 

val lseek : File_descr.t -> int64 -> mode:seek_command -> int64

val truncate : string -> len:int64 -> unit

val ftruncate : File_descr.t -> len:int64 -> unit

File statistics

type file_kind = Unix.file_kind = 

type stats = Unix.LargeFile.stats = {

val stat : string -> stats

val lstat : string -> stats

val fstat : File_descr.t -> stats

module Native_file: sig .. end

Locking

type lock_command = Unix.lock_command = 

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

val isatty : File_descr.t -> bool

Operations on file names

val unlink : string -> unit

val remove : string -> unit

val rename : src:string -> dst:string -> unit

val link : ?force:bool -> target:string -> link_name:string -> unit -> unit

File permissions and ownership

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

Operations on file descriptors

val dup : File_descr.t -> File_descr.t

val dup2 : src:File_descr.t -> dst:File_descr.t -> unit

val set_nonblock : File_descr.t -> unit

val clear_nonblock : File_descr.t -> unit

val set_close_on_exec : File_descr.t -> unit

val clear_close_on_exec : File_descr.t -> unit

Directories

val mkdir : ?perm:file_perm -> string -> unit

val mkdir_p : ?perm:file_perm -> string -> unit

val rmdir : string -> unit

val chdir : string -> unit

val getcwd : unit -> string

val chroot : string -> unit

type dir_handle = Unix.dir_handle 

val opendir : ?restart:bool -> string -> dir_handle

val readdir : dir_handle -> string

val rewinddir : dir_handle -> unit

val closedir : dir_handle -> unit

Pipes and redirections

val pipe : unit -> File_descr.t * File_descr.t

val mkfifo : string -> perm:file_perm -> unit

High-level process and redirection management

module Process_info: sig .. end

val create_process : prog:string -> args:string list -> Process_info.t

type env = [ `Extend of (string * string) list | `Replace of (string * string) list ] 

val create_process_env : ?working_dir:string ->
       prog:string ->
       args:string list -> env:env -> unit -> Process_info.t

val open_process_in : string -> Pervasives.in_channel

val open_process_out : string -> Pervasives.out_channel

val open_process : string -> Pervasives.in_channel * Pervasives.out_channel

module Process_channels: sig .. end

val open_process_full : string -> env:string array -> Process_channels.t

val close_process_in : Pervasives.in_channel -> Exit_or_signal.t

val close_process_out : Pervasives.out_channel -> Exit_or_signal.t

val close_process : Pervasives.in_channel * Pervasives.out_channel -> Exit_or_signal.t

val close_process_full : Process_channels.t -> Exit_or_signal.t

Symbolic links

val symlink : src:string -> dst:string -> unit

val readlink : string -> string

Polling

module Select_fds: sig .. end

type select_timeout = [ `After of float | `Immediately | `Never ] 

val select : ?restart:bool ->
       read:File_descr.t list ->
       write:File_descr.t list ->
       except:File_descr.t list ->
       timeout:select_timeout -> unit -> Select_fds.t

val pause : unit -> unit

Time functions

type process_times = Unix.process_times = {

type tm = Unix.tm = {

val time : unit -> float

val gettimeofday : unit -> float

val gmtime : float -> tm

val timegm : tm -> float

val localtime : float -> tm

val mktime : tm -> float * tm

val strftime : tm -> string -> string

val strptime : fmt:string -> string -> Unix.tm

val alarm : int -> int

val sleep : int -> unit

val nanosleep : float -> float

val times : unit -> process_times

val utimes : string -> access:float -> modif:float -> unit

type interval_timer = Unix.interval_timer = 

type interval_timer_status = Unix.interval_timer_status = {

val getitimer : interval_timer -> interval_timer_status

val setitimer : interval_timer ->
       interval_timer_status -> interval_timer_status

User id, group id

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

module Group: sig .. end

val getlogin : unit -> string

module Protocol_family: sig .. end

Internet addresses

module Inet_addr: sig .. end

module Cidr: sig .. end

Sockets

type socket_domain = Unix.socket_domain = 

type socket_type = Unix.socket_type = 

type sockaddr = Unix.sockaddr = 

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

type shutdown_command = Unix.shutdown_command = 

val shutdown : File_descr.t -> mode:shutdown_command -> unit

val getsockname : File_descr.t -> sockaddr

val getpeername : File_descr.t -> sockaddr

type msg_flag = Unix.msg_flag = 

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

Socket options

type socket_bool_option = 

type socket_int_option = 

type socket_optint_option = 

type socket_float_option = 

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

val setsockopt_int : File_descr.t -> socket_int_option -> int -> unit

val getsockopt_optint : File_descr.t -> socket_optint_option -> int option

val setsockopt_optint : File_descr.t ->
       socket_optint_option -> int option -> unit

val getsockopt_float : File_descr.t -> socket_float_option -> float

val setsockopt_float : File_descr.t -> socket_float_option -> float -> unit

High-level network connection functions

val open_connection : sockaddr -> Pervasives.in_channel * Pervasives.out_channel

val shutdown_connection : Pervasives.in_channel -> unit

val establish_server : (Pervasives.in_channel -> Pervasives.out_channel -> unit) ->
       addr:sockaddr -> unit

Host and protocol databases

val gethostname : unit -> string

module Host: sig .. end

module Protocol: sig .. end

module Service: sig .. end

type addr_info = {

type getaddrinfo_option = 

val getaddrinfo : string ->
       string -> getaddrinfo_option list -> addr_info list

type name_info = {

type getnameinfo_option = 

val getnameinfo : sockaddr ->
       getnameinfo_option list -> name_info

Getting terminal size

Terminal interface

module Terminal_io: sig .. end

val get_sockaddr : string -> int -> sockaddr

val set_in_channel_timeout : Pervasives.in_channel -> float -> unit

val set_out_channel_timeout : Pervasives.out_channel -> float -> unit

val exit_immediately : int -> 'a

Filesystem functions

val mknod : ?file_kind:file_kind ->
       ?perm:int -> ?major:int -> ?minor:int -> string -> unit

I/O vectors

module IOVec: sig .. end

I/O functions

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

val read_assume_fd_is_nonblocking : File_descr.t -> ?pos:int -> ?len:int -> string -> int

val write_assume_fd_is_nonblocking : File_descr.t -> ?pos:int -> ?len:int -> string -> int

val writev_assume_fd_is_nonblocking : File_descr.t -> ?count:int -> string IOVec.t array -> int

val writev : File_descr.t -> ?count:int -> string IOVec.t array -> int

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

module RLimit: sig .. end

module Resource_usage: sig .. end

type sysconf = 

val sysconf : sysconf -> int64

Temporary file and directory creation

val mkstemp : string -> string * File_descr.t

val mkdtemp : string -> string

Signal handling

val abort : unit -> 'a

User id, group id

val initgroups : string -> int -> unit

val getgrouplist : string -> int -> int array

val getgroups : unit -> int array

Globbing and shell expansion

val fnmatch : ?flags:[ `Casefold
              | `File_name
              | `Leading_dir
              | `No_escape
              | `Pathname
              | `Period ] list ->
       pat:string -> string -> bool

val wordexp : (?flags:[ `No_cmd | `Show_err | `Undef ] list -> string -> string array)
       Core_kernel.Std.Or_error.t

System information

module Utsname: sig .. end

val uname : unit -> Utsname.t

Additional IP functionality

val if_indextoname : int -> string

val mcast_join : ?ifname:string -> File_descr.t -> sockaddr -> unit

val mcast_leave : ?ifname:string -> File_descr.t -> sockaddr -> unit

val get_mcast_ttl : File_descr.t -> int

val set_mcast_ttl : File_descr.t -> int -> unit

val get_mcast_loop : File_descr.t -> bool

val set_mcast_loop : File_descr.t -> bool -> unit

val set_mcast_ifname : File_descr.t -> string -> unit

module Scheduler: sig .. end

module Priority: sig .. end

module Mman: sig .. end

val error_of_sexp : Sexplib.Sexp.t -> error

val sexp_of_error : error -> Sexplib.Sexp.t

Access to the process environment

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.

Process handling

The first element in args should be the program itself; the correct way to call exec is:

exec ~prog ~args: prog; arg1; arg2; ... ()

fork_exec ~prog ~args ?use_path ?env () forks and execs prog with args in the child process, returning the child pid to the parent.

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

Basic file input/output

val open_flag_of_sexp : Sexplib.Sexp.t -> open_flag

val sexp_of_open_flag : open_flag -> Sexplib.Sexp.t

val open_flag_of_sexp : Sexplib.Sexp.t -> open_flag

val sexp_of_open_flag : open_flag -> Sexplib.Sexp.t

val file_perm_of_sexp : Sexplib.Sexp.t -> file_perm

val sexp_of_file_perm : file_perm -> Sexplib.Sexp.t

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.

Interfacing with the standard input/output library

Seeking and truncating

val seek_command_of_sexp : Sexplib.Sexp.t -> seek_command

val sexp_of_seek_command : seek_command -> Sexplib.Sexp.t

File statistics

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

val sexp_of_stats : stats -> Sexplib.Sexp.t

Locking

val lock_command_of_sexp : Sexplib.Sexp.t -> lock_command

val sexp_of_lock_command : lock_command -> Sexplib.Sexp.t

Operations on file names

File permissions and ownership

Operations on file descriptors

Directories

Pipes and redirections

High-level process and redirection management

val env_of_sexp : Sexplib.Sexp.t -> env

val __env_of_sexp__ : Sexplib.Sexp.t -> env

val sexp_of_env : env -> Sexplib.Sexp.t

Symbolic links

Polling

val sexp_of_select_timeout : select_timeout -> Sexplib.Sexp.t

Time functions

val process_times_of_sexp : Sexplib.Sexp.t -> process_times

val sexp_of_process_times : process_times -> Sexplib.Sexp.t

val tm_of_sexp : Sexplib.Sexp.t -> tm

val sexp_of_tm : tm -> Sexplib.Sexp.t

val interval_timer_of_sexp : Sexplib.Sexp.t -> interval_timer

val sexp_of_interval_timer : interval_timer -> Sexplib.Sexp.t

val interval_timer_status_of_sexp : Sexplib.Sexp.t -> interval_timer_status

val sexp_of_interval_timer_status : interval_timer_status -> Sexplib.Sexp.t

User id, group id

Internet addresses

• base_address 192.168.0.0/24 = 192.168.0.0
• bits 192.168.0.0/24 = 24.

Sockets

val bin_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Type_class.t

val bin_read_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Read.reader

val __bin_read_socket_domain__ : (int -> socket_domain) Core_kernel.Std.Bin_prot.Read.reader

val bin_reader_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Type_class.reader

val bin_size_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Size.sizer

val bin_write_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Write.writer

val bin_writer_socket_domain : socket_domain Core_kernel.Std.Bin_prot.Type_class.writer

val socket_domain_of_sexp : Sexplib.Sexp.t -> socket_domain

val sexp_of_socket_domain : socket_domain -> Sexplib.Sexp.t

val bin_socket_type : socket_type Core_kernel.Std.Bin_prot.Type_class.t

val bin_read_socket_type : socket_type Core_kernel.Std.Bin_prot.Read.reader

val __bin_read_socket_type__ : (int -> socket_type) Core_kernel.Std.Bin_prot.Read.reader

val bin_reader_socket_type : socket_type Core_kernel.Std.Bin_prot.Type_class.reader

val bin_size_socket_type : socket_type Core_kernel.Std.Bin_prot.Size.sizer

val bin_write_socket_type : socket_type Core_kernel.Std.Bin_prot.Write.writer

val bin_writer_socket_type : socket_type Core_kernel.Std.Bin_prot.Type_class.writer

val socket_type_of_sexp : Sexplib.Sexp.t -> socket_type

val sexp_of_socket_type : socket_type -> Sexplib.Sexp.t

val bin_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.t

val bin_read_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Read.reader

val __bin_read_sockaddr__ : (int -> sockaddr) Core_kernel.Std.Bin_prot.Read.reader

val bin_reader_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.reader

val bin_size_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Size.sizer

val bin_write_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Write.writer

val bin_writer_sockaddr : sockaddr Core_kernel.Std.Bin_prot.Type_class.writer

val sockaddr_of_sexp : Sexplib.Sexp.t -> sockaddr

val sexp_of_sockaddr : sockaddr -> Sexplib.Sexp.t

val shutdown_command_of_sexp : Sexplib.Sexp.t -> shutdown_command

val sexp_of_shutdown_command : shutdown_command -> Sexplib.Sexp.t

val msg_flag_of_sexp : Sexplib.Sexp.t -> msg_flag

val sexp_of_msg_flag : msg_flag -> Sexplib.Sexp.t

Socket options

val socket_bool_option_of_sexp : Sexplib.Sexp.t -> socket_bool_option

val sexp_of_socket_bool_option : socket_bool_option -> Sexplib.Sexp.t

val socket_int_option_of_sexp : Sexplib.Sexp.t -> socket_int_option

val sexp_of_socket_int_option : socket_int_option -> Sexplib.Sexp.t

val socket_float_option_of_sexp : Sexplib.Sexp.t -> socket_float_option

val sexp_of_socket_float_option : socket_float_option -> Sexplib.Sexp.t

High-level network connection functions

Host and protocol databases

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

val sexp_of_addr_info : addr_info -> Sexplib.Sexp.t

val getaddrinfo_option_of_sexp : Sexplib.Sexp.t -> getaddrinfo_option

val sexp_of_getaddrinfo_option : getaddrinfo_option -> Sexplib.Sexp.t

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

val sexp_of_name_info : name_info -> Sexplib.Sexp.t

val getnameinfo_option_of_sexp : Sexplib.Sexp.t -> getnameinfo_option

val sexp_of_getnameinfo_option : getnameinfo_option -> Sexplib.Sexp.t

Getting terminal size

Terminal interface

Filesystem functions

I/O vectors

I/O functions

Resource limits

Resource usage

val sysconf_of_sexp : Sexplib.Sexp.t -> sysconf

val sexp_of_sysconf : sysconf -> Sexplib.Sexp.t

Temporary file and directory creation

Signal handling

User id, group id

Globbing and shell expansion

System information

Additional IP functionality