Module Unix

module Unix: sig .. end

---

Error report

type 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 int	(*	Unknown error	*)

exception Unix_error(error, string, string);

let error_message: error => string;

let handle_unix_error: ('a => 'b, 'a) => 'b;

Access to the process environment

let environment: unit => array(string);

let getenv: string => string;

let putenv: (string, string) => unit;

Process handling

type process_status = 

|	WEXITED of int	(*	The process terminated normally by exit; the argument is the return code.	*)
|	WSIGNALED of int	(*	The process was killed by a signal; the argument is the signal number.	*)
|	WSTOPPED of int	(*	The process was stopped by a signal; the argument is the signal number.	*)

type wait_flag = 

|	WNOHANG	(*	do not block if no child has died yet, but immediately return with a pid equal to 0.	*)
|	WUNTRACED	(*	report also the children that receive stop signals.	*)

let execv: (string, array(string)) => 'a;

let execve: (string, array(string), array(string)) => 'a;

let execvp: (string, array(string)) => 'a;

let execvpe: (string, array(string), array(string)) => 'a;

let fork: unit => int;

let wait: unit => (int, process_status);

let waitpid: (list(wait_flag), int) => (int, process_status);

let system: string => process_status;

let getpid: unit => int;

let getppid: unit => int;

let nice: int => int;

Basic file input/output

type file_descr;

let stdin: file_descr;

let stdout: file_descr;

let stderr: file_descr;

type 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 Unix.openfile	*)

type file_perm = int;

let openfile: (string, list(open_flag), file_perm) => file_descr;

let close: file_descr => unit;

let read: (file_descr, bytes, int, int) => int;

let write: (file_descr, bytes, int, int) => int;

let single_write: (file_descr, bytes, int, int) => int;

let write_substring: (file_descr, string, int, int) => int;

let single_write_substring: (file_descr, string, int, int) => int;

Interfacing with the standard input/output library

let in_channel_of_descr: file_descr => Pervasives.in_channel;

let out_channel_of_descr: file_descr => Pervasives.out_channel;

let descr_of_in_channel: Pervasives.in_channel => file_descr;

let descr_of_out_channel: Pervasives.out_channel => file_descr;

Seeking and truncating

type 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	*)

let lseek: (file_descr, int, seek_command) => int;

let truncate: (string, int) => unit;

let ftruncate: (file_descr, int) => unit;

File status

type 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	*)

type stats = {

	st_dev : int;	(*	Device number	*)
	st_ino : int;	(*	Inode number	*)
	st_kind : file_kind;	(*	Kind of the file	*)
	st_perm : file_perm;	(*	Access rights	*)
	st_nlink : int;	(*	Number of links	*)
	st_uid : int;	(*	User id of the owner	*)
	st_gid : int;	(*	Group ID of the file's group	*)
	st_rdev : int;	(*	Device minor number	*)
	st_size : int;	(*	Size in bytes	*)
	st_atime : float;	(*	Last access time	*)
	st_mtime : float;	(*	Last modification time	*)
	st_ctime : float;	(*	Last status change time	*)

}

let stat: string => stats;

let lstat: string => stats;

let fstat: file_descr => stats;

let isatty: file_descr => bool;

File operations on large files

module LargeFile: sig .. end

Operations on file names

let unlink: string => unit;

let rename: (string, string) => unit;

let link: (string, string) => unit;

File permissions and ownership

type access_permission = 

|	R_OK	(*	Read permission	*)
|	W_OK	(*	Write permission	*)
|	X_OK	(*	Execution permission	*)
|	F_OK	(*	File exists	*)

let chmod: (string, file_perm) => unit;

let fchmod: (file_descr, file_perm) => unit;

let chown: (string, int, int) => unit;

let fchown: (file_descr, int, int) => unit;

let umask: int => int;

let access: (string, list(access_permission)) => unit;

Operations on file descriptors

let dup: file_descr => file_descr;

let dup2: (file_descr, file_descr) => unit;

let set_nonblock: file_descr => unit;

let clear_nonblock: file_descr => unit;

let set_close_on_exec: file_descr => unit;

let clear_close_on_exec: file_descr => unit;

Directories

let mkdir: (string, file_perm) => unit;

let rmdir: string => unit;

let chdir: string => unit;

let getcwd: unit => string;

let chroot: string => unit;

type dir_handle;

let opendir: string => dir_handle;

let readdir: dir_handle => string;

let rewinddir: dir_handle => unit;

let closedir: dir_handle => unit;

Pipes and redirections

let pipe: unit => (file_descr, file_descr);

let mkfifo: (string, file_perm) => unit;

High-level process and redirection management

let create_process:
  (string, array(string), file_descr, file_descr, file_descr) => int;

let create_process_env:
  (string, array(string), array(string), file_descr, file_descr, file_descr) =>
  int;

let open_process_in: string => Pervasives.in_channel;

let open_process_out: string => Pervasives.out_channel;

let open_process: string => (Pervasives.in_channel, Pervasives.out_channel);

let open_process_full:
  (string, array(string)) =>
  (Pervasives.in_channel, Pervasives.out_channel, Pervasives.in_channel);

let close_process_in: Pervasives.in_channel => process_status;

let close_process_out: Pervasives.out_channel => process_status;

let close_process:
  ((Pervasives.in_channel, Pervasives.out_channel)) => process_status;

let close_process_full:
  ((Pervasives.in_channel, Pervasives.out_channel, Pervasives.in_channel)) =>
  process_status;

Symbolic links

let symlink: (string, string) => unit;

let readlink: string => string;

Polling

let select:
  (list(file_descr), list(file_descr), list(file_descr), float) =>
  (list(file_descr), list(file_descr), list(file_descr));

Locking

type 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	*)

let lockf: (file_descr, lock_command, int) => unit;

Signals

Note: installation of signal handlers is performed via the functions Sys.signal and Sys.set_signal.

let kill: (int, int) => unit;

type sigprocmask_command = 

|	SIG_SETMASK
|	SIG_BLOCK
|	SIG_UNBLOCK

let sigprocmask: (sigprocmask_command, list(int)) => list(int);

let sigpending: unit => list(int);

let sigsuspend: list(int) => unit;

let pause: unit => unit;

Time functions

type 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	*)

}

type tm = {

	tm_sec : int;	(*	Seconds 0..60	*)
	tm_min : int;	(*	Minutes 0..59	*)
	tm_hour : int;	(*	Hours 0..23	*)
	tm_mday : int;	(*	Day of month 1..31	*)
	tm_mon : int;	(*	Month of year 0..11	*)
	tm_year : int;	(*	Year - 1900	*)
	tm_wday : int;	(*	Day of week (Sunday is 0)	*)
	tm_yday : int;	(*	Day of year 0..365	*)
	tm_isdst : bool;	(*	Daylight time savings in effect	*)

}

let time: unit => float;

let gettimeofday: unit => float;

let gmtime: float => tm;

let localtime: float => tm;

let mktime: tm => (float, tm);

let alarm: int => int;

let sleep: int => unit;

let times: unit => process_times;

let utimes: (string, float, float) => unit;

type 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.	*)

type interval_timer_status = {

	it_interval : float;	(*	Period	*)
	it_value : float;	(*	Current value of the timer	*)

}

let getitimer: interval_timer => interval_timer_status;

let setitimer:
  (interval_timer, interval_timer_status) => interval_timer_status;

User id, group id

let getuid: unit => int;

let geteuid: unit => int;

let setuid: int => unit;

let getgid: unit => int;

let getegid: unit => int;

let setgid: int => unit;

let getgroups: unit => array(int);

let setgroups: array(int) => unit;

let initgroups: (string, int) => unit;

type passwd_entry = {

	pw_name : string;
	pw_passwd : string;
	pw_uid : int;
	pw_gid : int;
	pw_gecos : string;
	pw_dir : string;
	pw_shell : string;

}

type group_entry = {

	gr_name : string;
	gr_passwd : string;
	gr_gid : int;
	gr_mem : string array;

}

let getlogin: unit => string;

let getpwnam: string => passwd_entry;

let getgrnam: string => group_entry;

let getpwuid: int => passwd_entry;

let getgrgid: int => group_entry;

Internet addresses

type inet_addr;

let inet_addr_of_string: string => inet_addr;

let string_of_inet_addr: inet_addr => string;

let inet_addr_any: inet_addr;

let inet_addr_loopback: inet_addr;

let inet6_addr_any: inet_addr;

let inet6_addr_loopback: inet_addr;

Sockets

type socket_domain = 

|	PF_UNIX	(*	Unix domain	*)
|	PF_INET	(*	Internet domain (IPv4)	*)
|	PF_INET6	(*	Internet domain (IPv6)	*)

type socket_type = 

|	SOCK_STREAM	(*	Stream socket	*)
|	SOCK_DGRAM	(*	Datagram socket	*)
|	SOCK_RAW	(*	Raw socket	*)
|	SOCK_SEQPACKET	(*	Sequenced packets socket	*)

type sockaddr = 

|	ADDR_UNIX of string
|	ADDR_INET of inet_addr * int	(*	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.	*)

let socket: (socket_domain, socket_type, int) => file_descr;

let domain_of_sockaddr: sockaddr => socket_domain;

let socketpair: (socket_domain, socket_type, int) => (file_descr, file_descr);

let accept: file_descr => (file_descr, sockaddr);

let bind: (file_descr, sockaddr) => unit;

let connect: (file_descr, sockaddr) => unit;

let listen: (file_descr, int) => unit;

type shutdown_command = 

|	SHUTDOWN_RECEIVE	(*	Close for receiving	*)
|	SHUTDOWN_SEND	(*	Close for sending	*)
|	SHUTDOWN_ALL	(*	Close both	*)

let shutdown: (file_descr, shutdown_command) => unit;

let getsockname: file_descr => sockaddr;

let getpeername: file_descr => sockaddr;

type msg_flag = 

|	MSG_OOB
|	MSG_DONTROUTE
|	MSG_PEEK	(*	The flags for Unix.recv, Unix.recvfrom, Unix.send and Unix.sendto.	*)

let recv: (file_descr, bytes, int, int, list(msg_flag)) => int;

let recvfrom: (file_descr, bytes, int, int, list(msg_flag)) => (int, sockaddr);

let send: (file_descr, bytes, int, int, list(msg_flag)) => int;

let send_substring: (file_descr, string, int, int, list(msg_flag)) => int;

let sendto: (file_descr, bytes, int, int, list(msg_flag), sockaddr) => int;

let sendto_substring:
  (file_descr, string, int, int, list(msg_flag), sockaddr) => int;

Socket options

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	(*	Report whether socket listening is enabled	*)
|	TCP_NODELAY	(*	Control the Nagle algorithm for TCP sockets	*)
|	IPV6_ONLY	(*	Forbid binding an IPv6 socket to an IPv4 address	*)

type socket_int_option = 

|	SO_SNDBUF	(*	Size of send buffer	*)
|	SO_RCVBUF	(*	Size of received buffer	*)
|	SO_ERROR	(*	Deprecated. Use Unix.getsockopt_error instead.	*)
|	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	*)

type socket_optint_option = 

|

SO_LINGER

(*

Whether to linger on closed connections that have data present, and for how long (in seconds)

*)

type socket_float_option = 

|	SO_RCVTIMEO	(*	Timeout for input operations	*)
|	SO_SNDTIMEO	(*	Timeout for output operations	*)

let getsockopt: (file_descr, socket_bool_option) => bool;

let setsockopt: (file_descr, socket_bool_option, bool) => unit;

let getsockopt_int: (file_descr, socket_int_option) => int;

let setsockopt_int: (file_descr, socket_int_option, int) => unit;

let getsockopt_optint: (file_descr, socket_optint_option) => option(int);

let setsockopt_optint: (file_descr, socket_optint_option, option(int)) => unit;

let getsockopt_float: (file_descr, socket_float_option) => float;

let setsockopt_float: (file_descr, socket_float_option, float) => unit;

let getsockopt_error: file_descr => option(error);

High-level network connection functions

let open_connection:
  sockaddr => (Pervasives.in_channel, Pervasives.out_channel);

let shutdown_connection: Pervasives.in_channel => unit;

let establish_server:
  ((Pervasives.in_channel, Pervasives.out_channel) => unit, sockaddr) => unit;

Host and protocol databases

type host_entry = {

	h_name : string;
	h_aliases : string array;
	h_addrtype : socket_domain;
	h_addr_list : inet_addr array;

}

type protocol_entry = {

	p_name : string;
	p_aliases : string array;
	p_proto : int;

}

type service_entry = {

	s_name : string;
	s_aliases : string array;
	s_port : int;
	s_proto : string;

}

let gethostname: unit => string;

let gethostbyname: string => host_entry;

let gethostbyaddr: inet_addr => host_entry;

let getprotobyname: string => protocol_entry;

let getprotobynumber: int => protocol_entry;

let getservbyname: (string, string) => service_entry;

let getservbyport: (int, string) => service_entry;

type addr_info = {

	ai_family : socket_domain;	(*	Socket domain	*)
	ai_socktype : socket_type;	(*	Socket type	*)
	ai_protocol : int;	(*	Socket protocol number	*)
	ai_addr : sockaddr;	(*	Address	*)
	ai_canonname : string;	(*	Canonical host name	*)

}

type getaddrinfo_option = 

|	AI_FAMILY of socket_domain	(*	Impose the given socket domain	*)
|	AI_SOCKTYPE of socket_type	(*	Impose the given socket type	*)
|	AI_PROTOCOL of int	(*	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	(*	Set address to ``any'' address for use with Unix.bind	*)

let getaddrinfo: (string, string, list(getaddrinfo_option)) => list(addr_info);

type name_info = {

	ni_hostname : string;	(*	Name or IP address of host	*)
	ni_service : string;

}
Host and service information returned by Unix.getnameinfo.

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	(*	Consider the service as UDP-based instead of the default TCP	*)

let getnameinfo: (sockaddr, list(getnameinfo_option)) => name_info;

Terminal interface

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.

type terminal_io = {

	mutable c_ignbrk : bool;	(*	Ignore the break condition.	*)
	mutable c_brkint : bool;	(*	Signal interrupt on break condition.	*)
	mutable c_ignpar : bool;	(*	Ignore characters with parity errors.	*)
	mutable c_parmrk : bool;	(*	Mark parity errors.	*)
	mutable c_inpck : bool;	(*	Enable parity check on input.	*)
	mutable c_istrip : bool;	(*	Strip 8th bit on input characters.	*)
	mutable c_inlcr : bool;	(*	Map NL to CR on input.	*)
	mutable c_igncr : bool;	(*	Ignore CR on input.	*)
	mutable c_icrnl : bool;	(*	Map CR to NL on input.	*)
	mutable c_ixon : bool;	(*	Recognize XON/XOFF characters on input.	*)
	mutable c_ixoff : bool;	(*	Emit XON/XOFF chars to control input flow.	*)
	mutable c_opost : bool;	(*	Enable output processing.	*)
	mutable c_obaud : int;	(*	Output baud rate (0 means close connection).	*)
	mutable c_ibaud : int;	(*	Input baud rate.	*)
	mutable c_csize : int;	(*	Number of bits per character (5-8).	*)
	mutable c_cstopb : int;	(*	Number of stop bits (1-2).	*)
	mutable c_cread : bool;	(*	Reception is enabled.	*)
	mutable c_parenb : bool;	(*	Enable parity generation and detection.	*)
	mutable c_parodd : bool;	(*	Specify odd parity instead of even.	*)
	mutable c_hupcl : bool;	(*	Hang up on last close.	*)
	mutable c_clocal : bool;	(*	Ignore modem status lines.	*)
	mutable c_isig : bool;	(*	Generate signal on INTR, QUIT, SUSP.	*)
	mutable c_icanon : bool;	(*	Enable canonical processing (line buffering and editing)	*)
	mutable c_noflsh : bool;	(*	Disable flush after INTR, QUIT, SUSP.	*)
	mutable c_echo : bool;	(*	Echo input characters.	*)
	mutable c_echoe : bool;	(*	Echo ERASE (to erase previous character).	*)
	mutable c_echok : bool;	(*	Echo KILL (to erase the current line).	*)
	mutable c_echonl : bool;	(*	Echo NL even if c_echo is not set.	*)
	mutable c_vintr : char;	(*	Interrupt character (usually ctrl-C).	*)
	mutable c_vquit : char;	(*	Quit character (usually ctrl-\).	*)
	mutable c_verase : char;	(*	Erase character (usually DEL or ctrl-H).	*)
	mutable c_vkill : char;	(*	Kill line character (usually ctrl-U).	*)
	mutable c_veof : char;	(*	End-of-file character (usually ctrl-D).	*)
	mutable c_veol : char;	(*	Alternate end-of-line char. (usually none).	*)
	mutable c_vmin : int;	(*	Minimum number of characters to read before the read request is satisfied.	*)
	mutable c_vtime : int;	(*	Maximum read wait (in 0.1s units).	*)
	mutable c_vstart : char;	(*	Start character (usually ctrl-Q).	*)
	mutable c_vstop : char;	(*	Stop character (usually ctrl-S).	*)

}

let tcgetattr: file_descr => terminal_io;

type setattr_when = 

|	TCSANOW
|	TCSADRAIN
|	TCSAFLUSH

let tcsetattr: (file_descr, setattr_when, terminal_io) => unit;

let tcsendbreak: (file_descr, int) => unit;

let tcdrain: file_descr => unit;

type flush_queue = 

|	TCIFLUSH
|	TCOFLUSH
|	TCIOFLUSH

let tcflush: (file_descr, flush_queue) => unit;

type flow_action = 

|	TCOOFF
|	TCOON
|	TCIOFF
|	TCION

let tcflow: (file_descr, flow_action) => unit;

let setsid: unit => int;