Raised by the system calls below when an error is encountered. The first component is the error code; the second component is the function name; the third component is the string parameter to the function, if it has one, or the empty string otherwise.
deprecated [since 2016-10] use [Unix.Error.message] instead
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.
Access to the process environment
If you're looking for getenv, that's in the Sys module.
val environment : unit ->string array
Return the process environment, as an array of strings with the format ``variable=value''.
val putenv : key:string ->data:string -> unit
Unix.putenv ~key ~data sets the value associated to a variable in the process environment. key is the name of the environment variable, and data its new associated value.
val unsetenv : string -> unit
unsetenv name deletes the variable name from the environment.
EINVAL name contained an ’=’ or an '\000' character.
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 ->argv:string list->?use_path:bool ->?env:env->unit ->Core_kernel.Nothing.t
exec ~prog ~argv ?search_path ?env execs prog with argv. If use_path = true (the default) and prog doesn't contain a slash, then exec searches the PATH environment variable for prog. If env is supplied, it determines the environment when prog is executed.
The first element in argv should be the program itself; the correct way to call exec is:
exec ~prog ~argv:[ prog; arg1; arg2; ...] ()
val fork_exec :
prog:string ->argv:string list->?use_path:bool ->?env:env->unit ->Core_kernel.Pid.t
fork_exec ~prog ~argv ?use_path ?env () forks and execs prog with argv in the child process, returning the child PID to the parent. As in exec, the first element in argv should be the program itself.
val fork : unit ->[ `In_the_child | `In_the_parent of Core_kernel.Pid.t ]
fork () forks a new process. The return value indicates whether we are continuing in the child or the parent, and if the parent, includes the child's process id.
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.
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.
Execute the given command, wait until it terminates, and return its termination status. The string is interpreted by the shell /bin/sh and therefore can contain redirections, quotes, variables, etc. The result WEXITED 127 indicates that the shell couldn't be executed.
Get the numeric ID of the current thread, e.g. for identifying it in top(1).
val nice : int -> int
Change the process priority. The integer argument is added to the ``nice'' value. (Higher values of the ``nice'' value mean lower priorities.) Return the new nice value.
Open the named file with the given flags. Third argument is the permissions to give to the file if it is created. Return a file descriptor on the named file. Default permissions 0o644.
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.
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 bytes buff, starting at position ofs in bytes buff. Return the number of characters actually written.
When an error is reported some characters might have already been written. Use single_write instead to ensure that this is not the case.
WARNING: write is an interruptible call and has no way to handle EINTR properly. You should most probably be using single write.
val write_substring : ?pos:int ->?len:int ->File_descr.t->buf:string -> int
Same as write but ensures that all errors are reported and that no character has ever been written when an error is reported.
val single_write_substring :
?restart:bool ->?pos:int ->?len:int ->File_descr.t->buf:string ->
int
Same as single_write but with a string buffer.
Interfacing with the standard input/output library
val in_channel_of_descr : File_descr.t->Core__.Import.In_channel.t
Create an input channel reading from the given descriptor. The channel is initially in binary mode; use set_binary_mode_in ic false if text mode is desired.
val out_channel_of_descr : File_descr.t->Core__.Import.Out_channel.t
Create an output channel writing on the given descriptor. The channel is initially in binary mode; use set_binary_mode_out oc false if text mode is desired.
val descr_of_in_channel : Core__.Import.In_channel.t ->File_descr.t
Return the descriptor corresponding to an input channel.
val descr_of_out_channel : Core__.Import.Out_channel.t ->File_descr.t
Return the descriptor corresponding to an output channel.
Seeking and truncating
type seek_command = Unix.seek_command =
| SEEK_SET
(*
indicates positions relative to the beginning of the file
*)
| SEEK_CUR
(*
indicates positions relative to the current position
*)
| SEEK_END
(*
indicates positions relative to the end of the file
*)
POSITIONING modes for UnixLabels.lseek.
includesig ... end
val seek_command_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->seek_command
val sexp_of_seek_command : seek_command->Ppx_sexp_conv_lib.Sexp.t
The informations returned by the UnixLabels.stat calls. The times are float number of seconds since the epoch; we don't use Time.t because Time depends on Unix, so the fix isn't so trivial. Same for Native_file.stats below.
includesig ... end
val stats_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->stats
val sexp_of_stats : stats->Ppx_sexp_conv_lib.Sexp.t
This sub-module provides the normal OCaml Unix functions that deal with file size using native ints. These are here because, in general, you should be using 64bit file operations so that large files aren't an issue. If you have a real need to use potentially 31bit file operations (and you should be dubious of such a need) you can open this module
Locking
type lock_command = Unix.lock_command =
| 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
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.
Return true if the given file descriptor refers to a terminal or console window, false otherwise.
Operations on file names
val unlink : string -> unit
Removes the named file
val remove : string -> unit
Removes the named file or directory
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.
Set the ``non-blocking'' flag on the given descriptor. When the non-blocking flag is set, reading on a descriptor on which there is temporarily no data available raises the EAGAIN or EWOULDBLOCK error instead of blocking; writing on a descriptor on which there is temporarily no room for writing also raises EAGAIN or EWOULDBLOCK.
Set the ``close-on-exec'' flag on the given descriptor. A descriptor with the close-on-exec flag is automatically closed when the current process starts another program with one of the exec functions.
Create a pipe. The first component of the result is opened for reading, that's the exit to the pipe. The second component is opened for writing, that's the entrance to the pipe.
val 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 ->Core__.Import.In_channel.t
High-level pipe and process management. These functions (with UnixLabels.open_process_out and UnixLabels.open_process) run the given command in parallel with the program, and return channels connected to the standard input and/or the standard output of the command. The command is interpreted by the shell /bin/sh (cf. system). Warning: writes on channels are buffered, hence be careful to call Pervasives.flush at the right times to ensure correct synchronization.
val open_process_out : string ->Core__.Import.Out_channel.t
See UnixLabels.open_process_in.
val open_process :
string ->Core__.Import.In_channel.t * Core__.Import.Out_channel.t
Similar to UnixLabels.open_process, but the second argument specifies the environment passed to the command. The result is a triple of channels connected to the standard output, standard input, and standard error of the command.
Close channels opened by UnixLabels.open_process_full, wait for the associated command to terminate, and return its termination status.
Symbolic links
val symlink : src:string ->dst:string -> unit
symlink source dest creates the file dest as a symbolic link to the file source. On Windows, this has the semantics using stat as described at: http://caml.inria.fr/pub/docs/manual-ocaml/libref/Unix.html
Wait until some input/output operations become possible on some channels. The three list arguments are a set of descriptors to check for reading, for writing, or for exceptional conditions. ~timeout is the maximal timeout. The result is composed of three sets of descriptors: those ready for reading, ready for writing, and over which an exceptional condition is pending.
Setting restart to true means that we want select to restart automatically on EINTR (instead of propagating the exception)...
val pause : unit -> unit
Wait until a non-ignored, non-blocked signal is delivered.
Time functions
type process_times = Unix.process_times = {
tms_utime : float;
(*
User time for the process
*)
tms_stime : float;
(*
System time for the process
*)
tms_cutime : float;
(*
User time for the children processes
*)
tms_cstime : float;
(*
System time for the children processes
*)
}
The execution times (CPU times) of a process.
includesig ... end
val process_times_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->process_times
val sexp_of_process_times : process_times->Ppx_sexp_conv_lib.Sexp.t
Convert a date and time, specified by the tm argument, into a time in seconds, as returned by UnixLabels.time. Also return a normalized copy of the given tm record, with the tm_wday, tm_yday, and tm_isdst fields recomputed from the other fields. The tm argument is interpreted in the local time zone.
Convert a date and time, specified by the tm argument, into a formatted string. See 'man strftime' for format options.
val strptime : fmt:string ->string ->Unix.tm
Given a format string, convert a corresponding string to a date and time See 'man strptime' for format options.
val alarm : int -> int
Schedule a SIGALRM signal after the given number of seconds.
val sleep : int -> unit
Stop execution for the given number of seconds.
val nanosleep : float -> float
nanosleep f delays execution of the program for at least f seconds. The function can return earlier if a signal has been delivered, in which case the number of seconds left is returned. Any other failure raises an exception.
val utimes : string ->access:float ->modif:float -> unit
Set the last access time (second arg) and last modification time (third arg) for a file. Times are expressed in seconds from 00:00:00 GMT, Jan. 1, 1970.
type interval_timer = Unix.interval_timer =
| ITIMER_REAL
(*
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.
*)
The three kinds of interval timers.
includesig ... end
val interval_timer_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->interval_timer
val sexp_of_interval_timer : interval_timer->Ppx_sexp_conv_lib.Sexp.t
type interval_timer_status = Unix.interval_timer_status = {
it_interval : float;
(*
Period
*)
it_value : float;
(*
Current value of the timer
*)
}
The type describing the status of an interval timer
includesig ... end
val interval_timer_status_of_sexp :
Ppx_sexp_conv_lib.Sexp.t ->interval_timer_status
setitimer t s sets the interval timer t and returns its previous status. The s argument is interpreted as follows: s.it_value, if nonzero, is the time to the next timer expiration; s.it_interval, if nonzero, specifies a value to be used in reloading it_value when the timer expires. Setting s.it_value to zero disable the timer. Setting s.it_interval to zero causes the timer to be disabled after its next expiration.
User id, group id
It's highly recommended to read the straight unix docs on these functions for more color. You can get that info from man pages or http://www.opengroup.org/onlinepubs/000095399/functions/setuid.html
val getuid : unit -> int
Return the user id of the user executing the process.
val geteuid : unit -> int
Return the effective user id under which the process runs.
val setuid : int -> unit
Sets the real user id and effective user id for the process. Only use this when superuser. To setuid as an ordinary user, see Core_extended.Unix.seteuid.
val getgid : unit -> int
Return the group id of the user executing the process.
val getegid : unit -> int
Return the effective group id under which the process runs.
val setgid : int -> unit
Set the real group id and effective group id for the process.
A representation of CIDR netmasks (e.g. "192.168.0.0/24") and functions to match if a given address is inside the range or not. Only IPv4 addresses are supported. Values are always normalized so the base address is the lowest IP address in the range, so for example to_string (of_string "192.168.1.101/24") = "192.168.1.0/24".
Sockets
type socket_domain = Unix.socket_domain =
| PF_UNIX
(*
Unix domain
*)
| PF_INET
(*
Internet domain
*)
| PF_INET6
(*
Internet domain (IPv6)
*)
The type of socket domains.
includesig ... end
val socket_domain_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->socket_domain
val sexp_of_socket_domain : socket_domain->Ppx_sexp_conv_lib.Sexp.t
val bin_socket_domain : socket_domainCore__.Import.Bin_prot.Type_class.t
val bin_read_socket_domain : socket_domainCore__.Import.Bin_prot.Read.reader
val __bin_read_socket_domain__ :
(int ->socket_domain)Core__.Import.Bin_prot.Read.reader
val bin_reader_socket_domain :
socket_domainCore__.Import.Bin_prot.Type_class.reader
val bin_size_socket_domain : socket_domainCore__.Import.Bin_prot.Size.sizer
val bin_write_socket_domain : socket_domainCore__.Import.Bin_prot.Write.writer
val bin_writer_socket_domain :
socket_domainCore__.Import.Bin_prot.Type_class.writer
val bin_shape_socket_domain : Core__.Import.Bin_prot.Shape.t
type socket_type = Unix.socket_type =
| SOCK_STREAM
(*
Stream socket
*)
| SOCK_DGRAM
(*
Datagram socket
*)
| SOCK_RAW
(*
Raw socket
*)
| SOCK_SEQPACKET
(*
Sequenced packets socket
*)
The type of socket kinds, specifying the semantics of communications.
includesig ... end
val socket_type_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->socket_type
val sexp_of_socket_type : socket_type->Ppx_sexp_conv_lib.Sexp.t
val bin_socket_type : socket_typeCore__.Import.Bin_prot.Type_class.t
val bin_read_socket_type : socket_typeCore__.Import.Bin_prot.Read.reader
val __bin_read_socket_type__ :
(int ->socket_type)Core__.Import.Bin_prot.Read.reader
val bin_reader_socket_type :
socket_typeCore__.Import.Bin_prot.Type_class.reader
val bin_size_socket_type : socket_typeCore__.Import.Bin_prot.Size.sizer
val bin_write_socket_type : socket_typeCore__.Import.Bin_prot.Write.writer
val bin_writer_socket_type :
socket_typeCore__.Import.Bin_prot.Type_class.writer
val bin_shape_socket_type : Core__.Import.Bin_prot.Shape.t
The type of socket addresses. ADDR_UNIX name is a socket address in the Unix domain; name is a file name in the file system. ADDR_INET(addr,port) is a socket address in the Internet domain; addr is the Internet address of the machine, and port is the port number.
includesig ... end
val bin_sockaddr : sockaddrCore__.Import.Bin_prot.Type_class.t
val bin_read_sockaddr : sockaddrCore__.Import.Bin_prot.Read.reader
val __bin_read_sockaddr__ :
(int ->sockaddr)Core__.Import.Bin_prot.Read.reader
val bin_reader_sockaddr : sockaddrCore__.Import.Bin_prot.Type_class.reader
val bin_size_sockaddr : sockaddrCore__.Import.Bin_prot.Size.sizer
val bin_write_sockaddr : sockaddrCore__.Import.Bin_prot.Write.writer
val bin_writer_sockaddr : sockaddrCore__.Import.Bin_prot.Type_class.writer
val bin_shape_sockaddr : Core__.Import.Bin_prot.Shape.t
val sexp_of_sockaddr : sockaddr->Ppx_sexp_conv_lib.Sexp.t
Create a new socket in the given domain, and with the given kind. The third argument is the protocol type; 0 selects the default protocol for that kind of sockets.
Accept connections on the given socket. The returned descriptor is a socket connected to the client; the returned address is the address of the connecting client.
Set up a socket for receiving connection requests. The integer argument is the number of pending requests that will be established and queued for accept. Depending on operating system, version, and configuration, subsequent connections may be refused actively (as with RST), ignored, or effectively established and queued anyway.
Because handling of excess connections varies, it is most robust for applications to accept and close excess connections if they can. To be sure the client receives an RST rather than an orderly shutdown, you can setsockopt_optint file_descr SO_LINGER
(Some 0) before closing.
In Linux, for example, the system configuration parameters tcp_max_syn_backlog, tcp_abort_on_overflow, and syncookies can all affect connection queuing behavior.
type shutdown_command = Unix.shutdown_command =
| SHUTDOWN_RECEIVE
(*
Close for receiving
*)
| SHUTDOWN_SEND
(*
Close for sending
*)
| SHUTDOWN_ALL
(*
Close both
*)
The type of commands for shutdown.
includesig ... end
val shutdown_command_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->shutdown_command
val sexp_of_shutdown_command : shutdown_command->Ppx_sexp_conv_lib.Sexp.t
Shutdown a socket connection. SHUTDOWN_SEND as second argument causes reads on the other end of the connection to return an end-of-file condition. SHUTDOWN_RECEIVE causes writes on the other end of the connection to return a closed pipe condition (SIGPIPE signal).
The socket options that can be consulted with UnixLabels.getsockopt and modified with UnixLabels.setsockopt. These options have a boolean (true/false) value.
includesig ... end
val socket_bool_option_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->socket_bool_option
val sexp_of_socket_bool_option : socket_bool_option->Ppx_sexp_conv_lib.Sexp.t
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
(*
Minimum number of bytes to process for output operations
*)
The socket options that can be consulted with UnixLabels.getsockopt_int and modified with UnixLabels.setsockopt_int. These options have an integer value.
includesig ... end
val socket_int_option_of_sexp : Ppx_sexp_conv_lib.Sexp.t ->socket_int_option
val sexp_of_socket_int_option : socket_int_option->Ppx_sexp_conv_lib.Sexp.t
type socket_optint_option =
| SO_LINGER
(*
Whether to linger on closed connections with sexp that have data present, and for how long (in seconds)
*)
The socket options that can be consulted with UnixLabels.getsockopt_optint and modified with UnixLabels.setsockopt_optint. These options have a value of type int option, with None meaning ``disabled''.
type socket_float_option =
| SO_RCVTIMEO
(*
Timeout for input operations
*)
| SO_SNDTIMEO
(*
Timeout for output operations
*)
The socket options that can be consulted with UnixLabels.getsockopt_float and modified with UnixLabels.setsockopt_float. These options have a floating-point value representing a time in seconds. The value 0 means infinite timeout.
includesig ... end
val socket_float_option_of_sexp :
Ppx_sexp_conv_lib.Sexp.t ->socket_float_option
val sexp_of_socket_float_option :
socket_float_option->Ppx_sexp_conv_lib.Sexp.t
Same as UnixLabels.setsockopt for a socket option whose value is a floating-point number.
High-level network connection functions
val open_connection :
sockaddr->Core__.Import.In_channel.t * Core__.Import.Out_channel.t
Connect to a server at the given address. Return a pair of buffered channels connected to the server. Remember to call Pervasives.flush on the output channel at the right times to ensure correct synchronization.
val shutdown_connection : Core__.Import.In_channel.t -> unit
``Shut down'' a connection established with UnixLabels.open_connection; that is, transmit an end-of-file condition to the server reading on the other side of the connection.
val establish_server :
(Core__.Import.In_channel.t ->Core__.Import.Out_channel.t -> unit)->addr:sockaddr->
unit
Establish a server on the given address. The function given as first argument is called for each connection with two buffered channels connected to the client. A new process is created for each connection. The function UnixLabels.establish_server never returns normally.
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).
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.
Terminal interface
The following functions implement the POSIX standard terminal interface. They provide control over asynchronous communication ports and pseudo-terminals. Refer to the termios man page for a complete description.
val set_in_channel_timeout : Core__.Import.In_channel.t ->float -> unit
Set a timeout for a socket associated with an In_channel.t
val set_out_channel_timeout : Core__.Import.Out_channel.t ->float -> unit
Set a timeout for a socket associated with an Out_channel.t
val exit_immediately : int ->_
exit_immediately exit_code immediately calls the exit system call with the given exit code without performing any other actions (unlike Pervasives.exit). Does not return.
Filesystem functions
val mknod :
?file_kind:file_kind->?perm:int ->?major:int ->?minor:int ->string ->
unit
mknod ?file_kind ?perm ?major ?minor path creates a filesystem entry. Note that only FIFO-entries are guaranteed to be supported across all platforms as required by the POSIX-standard. On Linux directories and symbolic links cannot be created with this function. Use Unix.mkdir and Unix.symlink instead there respectively.
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 fd ?count iovecs like writev_assume_fd_is_nonblocking, but does not require the descriptor to not block. If you feel you have to use this function, you should probably have chosen I/O-vectors that build on bigstrings, because this function has to internally blit the I/O-vectors (ordinary OCaml strings) to intermediate buffers on the C-heap.
mkstemp prefix creates and opens a unique temporary file with prefix, automatically appending a suffix of .tmp. followed by six random characters to make the name unique. Unlike C's mkstemp, prefix should not include six X's at the end.
The file descriptor will have close-on-exec flag set if O_CLOEXEC flag is supported.
mkdtemp prefix creates a temporary directory with prefix, automatically appending a suffix of .tmp. followed by six random characters to make the name unique.
Causes abnormal program termination unless the signal SIGABRT is caught and the signal handler does not return. If the SIGABRT signal is blocked or ignored, the abort() function will still override it.
User id, group id
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
Return the list of groups to which the user executing the process belongs.
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.