Up

module Extended_unix

: sig

Extensions to Core.Unix.

#
val fork_exec : ?stdin:Core.Std.Unix.File_descr.t -> ?stdout:Core.Std.Unix.File_descr.t -> ?stderr:Core.Std.Unix.File_descr.t -> ?path_lookup:bool -> ?env:[
| `Extend of (string * string) list
| `Replace of (string * string) list
] -> ?working_dir:string -> ?setuid:int -> ?setgid:int -> string -> string list -> Core.Std.Pid.t

fork_exec prog args ~stdin ~stdout ~stderr ~setuid ~setgid forks a new process that executes the program in file prog, with arguments args. The pid of the new process is returned immediately; the new process executes concurrently with the current process.

The function raises EPERM if when using set{gid,uid} and the user id is not 0.

The standard input and outputs of the new process are connected to the descriptors stdin, stdout and stderr.

The close_on_exec flag is cleared from stderr stdout and stdin so it's safe to pass in fds with close_on_exec set.

path_lookup if true than we use PATH to find the process to exec.
Env specifies the environment the process runs in
ERRORS: Unix.unix_error. This function should not raise EINTR; it will restart itself automatically.
RATIONAL: setuid and setgid do not do a full id drop (e.g.: they save the id in saved id) when the user does not have the privileges required to setuid to anyone.
By default all file descriptors should be set_closexec ASAP after being open to avoid being captured in parallel execution of fork_exec; resetting the closexec flag on the forked flag is a cleaner and more thread safe approach.
BUGS: The capabilities for setuid in linux are not tied to the uid 0 (man 7 capabilities). It is still fair to assume that under most system this capability is there IFF uid == 0. A more fine grain permissionning approach would make this function non-portable and be hard to implement in an async-signal-way.
Because this function keeps the lock for most of its lifespan and restarts automatically on EINTR it might prevent the OCaml signal handlers to run in that thread.
#
val seteuid : int -> unit
#
val setreuid : uid:int -> euid:int -> unit
#
external ntohl : Core.Std.Int32.t -> Core.Std.Int32.t = "extended_ml_ntohl"

Network to host order long, like C.

#
external htonl : Core.Std.Int32.t -> Core.Std.Int32.t = "extended_ml_htonl"

Host to network order long, like C.

#
type statvfs = {
# bsize
: int;(*file system block size*)
# frsize
: int;(*fragment size*)
# blocks
: int;(*size of fs in frsize units*)
# bfree
: int;(*# free blocks*)
# bavail
: int;(*# free blocks for non-root*)
# files
: int;(*# inodes*)
# ffree
: int;(*# free inodes*)
# favail
: int;(*# free inodes for non-root*)
# fsid
: int;(*file system ID*)
# flag
: int;(*mount flags*)
# namemax
: int;(*maximum filename length*)
}
#
external statvfs : string -> statvfs = "statvfs_stub"

get file system statistics

#
external getloadavg : unit -> float * float * float = "getloadavg_stub"

get load averages

#
module Extended_passwd : sig
#
val of_passwd_line : string -> Core.Std.Unix.Passwd.t option

of_passwd_line parse a passwd-like line

#
val of_passwd_line_exn : string -> Core.Std.Unix.Passwd.t

of_passwd_line_exn parse a passwd-like line

#
val of_passwd_file : string -> Core.Std.Unix.Passwd.t list option

of_passwd_file parse a passwd-like file

#
val of_passwd_file_exn : string -> Core.Std.Unix.Passwd.t list

of_passwd_file_exn parse a passwd-like file

end
#
external strptime : fmt:string -> string -> Core.Std.Unix.tm = "unix_strptime"

The CIDR module moved into Core.Unix

#
module Inet_port : sig

Simple int wrapper to be explicit about ports.

#
type t
#
val of_int : int -> t option
#
val of_int_exn : int -> t
#
val of_string : string -> t option
#
val of_string_exn : string -> t
#
val to_int : t -> int
#
val to_string : t -> string
#
val t_of_sexp : Sexplib.Sexp.t -> t
#
val sexp_of_t : t -> Sexplib.Sexp.t
end
#
module Mac_address : sig
#
type t
#
val equal : t -> t -> bool
#
val of_string : string -> t
#
val to_string : t -> string
#
val to_string_cisco : t -> string
include Core.Std.Hashable.S with type t := t
#
val bin_t : t Core.Std.Bin_prot.Type_class.t
#
val bin_read_t : t Core.Std.Bin_prot.Read.reader
#
val __bin_read_t__ : (int -> t) Core.Std.Bin_prot.Read.reader
#
val bin_reader_t : t Core.Std.Bin_prot.Type_class.reader
#
val bin_size_t : t Core.Std.Bin_prot.Size.sizer
#
val bin_write_t : t Core.Std.Bin_prot.Write.writer
#
val bin_writer_t : t Core.Std.Bin_prot.Type_class.writer
#
val t_of_sexp : Sexplib.Sexp.t -> t
#
val sexp_of_t : t -> Sexplib.Sexp.t
end
#
module Quota : sig
#
type bytes = private Core.Std.Int63.t
#
type inodes = private Core.Std.Int63.t
#
val bytes : Core.Std.Int63.t -> bytes
#
val inodes : Core.Std.Int63.t -> inodes
#
type 'units limit = {
# soft
: 'units option;
# hard
: 'units option;
# grace
: Core.Std.Time.t option;
}
#
type 'units usage = private 'units
#
val query : [
| `User
| `Group
] -> id:int -> path:string -> (bytes limit * bytes usage * inodes limit * inodes usage) Core.Std.Or_error.t
#
val set : [
| `User
| `Group
] -> id:int -> path:string -> bytes limit -> inodes limit -> unit Core.Std.Or_error.t
#
val bytes_of_sexp : Sexplib.Sexp.t -> bytes
#
val sexp_of_bytes : bytes -> Sexplib.Sexp.t
#
val inodes_of_sexp : Sexplib.Sexp.t -> inodes
#
val sexp_of_inodes : inodes -> Sexplib.Sexp.t
#
val limit_of_sexp : (Sexplib.Sexp.t -> 'units) -> Sexplib.Sexp.t -> 'units limit
#
val sexp_of_limit : ('units -> Sexplib.Sexp.t) -> 'units limit -> Sexplib.Sexp.t
end
#
module Mount_entry : sig
#
type t
#
val parse_line : string -> t option Core.Std.Or_error.t
#
val fsname : t -> string
#
val directory : t -> string
#
val fstype : t -> string
#
val options : t -> string
#
val dump_freq : t -> int option
#
val fsck_pass : t -> int option
#
val visible_filesystem : t list -> t Core.Std.String.Map.t
#
val t_of_sexp : Sexplib.Sexp.t -> t
#
val sexp_of_t : t -> Sexplib.Sexp.t
end
#
val bin_statvfs : statvfs Core.Std.Bin_prot.Type_class.t
#
val bin_read_statvfs : statvfs Core.Std.Bin_prot.Read.reader
#
val __bin_read_statvfs__ : (int -> statvfs) Core.Std.Bin_prot.Read.reader
#
val bin_reader_statvfs : statvfs Core.Std.Bin_prot.Type_class.reader
#
val bin_size_statvfs : statvfs Core.Std.Bin_prot.Size.sizer
#
val bin_write_statvfs : statvfs Core.Std.Bin_prot.Write.writer
#
val bin_writer_statvfs : statvfs Core.Std.Bin_prot.Type_class.writer
#
val statvfs_of_sexp : Sexplib.Sexp.t -> statvfs
#
val sexp_of_statvfs : statvfs -> Sexplib.Sexp.t
end