Модуль UnixLabels

module UnixLabels: sig .. end

Интерфейс к Unix системе.

Для использования помеченной версии этого модуля, добавьте module Unix = UnixLabels в вашей реализации.

Примечание: все функции этого модуля (кроме UnixLabels.error_message и UnixLabels.handle_unix_error) могут вызывать исключение UnixLabels.Unix_error, когда системный вызов указывает на ошибку.

Отчёт об ошибках

type error = Unix.error =

`\|`	`E2BIG`	`(*`	Список аргументов слишком длинный	`*)`
`\|`	`EACCES`	`(*`	Доступ запрещён	`*)`
`\|`	`EAGAIN`	`(*`	Ресурс временно недоступен; попробуйте снова	`*)`
`\|`	`EBADF`	`(*`	Неверный дескриптор файла	`*)`
`\|`	`EBUSY`	`(*`	Ресурс недоступен	`*)`
`\|`	`ECHILD`	`(*`	Нет дочернего процесса	`*)`
`\|`	`EDEADLK`	`(*`	Возникла тупиковая ситуация ресурса	`*)`
`\|`	`EDOM`	`(*`	Ошибка области для математических функций и т. п.	`*)`
`\|`	`EEXIST`	`(*`	Файл существует	`*)`
`\|`	`EFAULT`	`(*`	Неверный адрес	`*)`
`\|`	`EFBIG`	`(*`	Файл слишком большой	`*)`
`\|`	`EINTR`	`(*`	Функция прервана сигналом	`*)`
`\|`	`EINVAL`	`(*`	Неверный аргумент	`*)`
`\|`	`EIO`	`(*`	Ошибка ввода-вывода оборудования	`*)`
`\|`	`EISDIR`	`(*`	Это директория	`*)`
`\|`	`EMFILE`	`(*`	Превышен лимит открытых файлов процессом	`*)`
`\|`	`EMLINK`	`(*`	Слишком много ссылок	`*)`
`\|`	`ENAMETOOLONG`	`(*`	Слишком длинное имя файла	`*)`
`\|`	`ENFILE`	`(*`	Слишком много открытых файлов в системе	`*)`
`\|`	`ENODEV`	`(*`	Устройства не существует	`*)`
`\|`	`ENOENT`	`(*`	Файл или директория не найдены	`*)`
`\|`	`ENOEXEC`	`(*`	Не является исполняемым файлом	`*)`
`\|`	`ENOLCK`	`(*`	Нет доступных блокировок	`*)`
`\|`	`ENOMEM`	`(*`	Недостаточно памяти	`*)`
`\|`	`ENOSPC`	`(*`	На устройстве закончилось место	`*)`

`\|`	`ENOSYS`	`(*`	Функция не поддерживается	`*)`
`\|`	`ENOTDIR`	`(*`	Это не каталог	`*)`
`\|`	`ENOTEMPTY`	`(*`	Каталог не пустой	`*)`
`\|`	`ENOTTY`	`(*`	Неподходящая операция управления вводом-выводом	`*)`
`\|`	`ENXIO`	`(*`	Такого устройства или адреса нет	`*)`
`\|`	`EPERM`	`(*`	Операция запрещена	`*)`
`\|`	`EPIPE`	`(*`	Разрыв канала	`*)`
`\|`	`ERANGE`	`(*`	Результат слишком большой	`*)`
`\|`	`EROFS`	`(*`	Файловая система только для чтения	`*)`
`\|`	`ESPIPE`	`(*`	Неверный сдвиг, например, в случае с каналом	`*)`
`\|`	`ESRCH`	`(*`	Процесс не найден	`*)`
`\|`	`EXDEV`	`(*`	Неверная ссылка	`*)`
`\|`	`EWOULDBLOCK`	`(*`	Операция заблокирует выполнение	`*)`
`\|`	`EINPROGRESS`	`(*`	Операция уже выполняется	`*)`
`\|`	`EALREADY`	`(*`	Операция уже в процессе	`*)`
`\|`	`ENOTSOCK`	`(*`	Операция сокета на несуществующем сокете	`*)`
`\|`	`EDESTADDRREQ`	`(*`	Требуется адрес назначения	`*)`
`\|`	`EMSGSIZE`	`(*`	Сообщение слишком длинное	`*)`
`\|`	`EPROTOTYPE`	`(*`	Неправильный тип протокола для сокета	`*)`
`\|`	`ENOPROTOOPT`	`(*`	Протокол недоступен	`*)`
`\|`	`EPROTONOSUPPORT`	`(*`	Протокол не поддерживается	`*)`
`\|`	`ESOCKTNOSUPPORT`	`(*`	Тип сокета не поддерживается	`*)`
`\|`	`EOPNOTSUPP`	`(*`	Операция не поддерживается для сокета	`*)`
`\|`	`EPFNOSUPPORT`	`(*`	Семейство протоколов не поддерживается	`*)`
`\|`	`EAFNOSUPPORT`	`(*`	Семейство адресов не поддерживается семейством протоколов	`*)`

`\|`	`EADDRINUSE`	`(*`	Адрес уже используется	`*)`
`\|`	`EADDRNOTAVAIL`	`(*`	Не удаётся назначить запрашиваемый адрес	`*)`
`\|`	`ENETDOWN`	`(*`	Сеть отключена	`*)`
`\|`	`ENETUNREACH`	`(*`	Сеть недоступна	`*)`
`\|`	`ENETRESET`	`(*`	Сеть разорвала соединение при сбросе	`*)`
`\|`	`ECONNABORTED`	`(*`	Программное обеспечение вызвало прерывание соединения	`*)`
`\|`	`ECONNRESET`	`(*`	Соединение прервано удалённой стороной	`*)`
`\|`	`ENOBUFS`	`(*`	Нет доступного буферного пространства	`*)`
`\|`	`EISCONN`	`(*`	Сокет уже подключён	`*)`
`\|`	`ENOTCONN`	`(*`	Сокет не подключён	`*)`
`\|`	`ESHUTDOWN`	`(*`	Отправка невозможна после закрытия сокета	`*)`
`\|`	`ETOOMANYREFS`	`(*`	Слишком много ссылок: нельзя выполнить вставку	`*)`
`\|`	`ETIMEDOUT`	`(*`	Таймаут соединения	`*)`
`\|`	`ECONNREFUSED`	`(*`	Соединение отклонено	`*)`
`\|`	`EHOSTDOWN`	`(*`	Хост выключен	`*)`
`\|`	`EHOSTUNREACH`	`(*`	Маршрут до хоста недоступен	`*)`
`\|`	`ELOOP`	`(*`	Слишком много уровней символических ссылок	`*)`
`\|`	`EOVERFLOW`	`(*`	Размер или позиция файла не представимы	`*)`
`\|`	`EUNKNOWNERR of int`	`(*`	Неизвестная ошибка	`*)`

Тип кодов ошибок. Ошибки, определённые в стандарте POSIX, и дополнительные ошибки из UNIX98 и BSD. Все остальные ошибки отображаются как EUNKNOWNERR.

exception Unix_error of error * string * string

Возвращаются системными вызовами ниже, когда возникает ошибка. Первый компонент — код ошибки; второй компонент — имя функции; третий компонент — строковый параметр функции, если он есть, или пустая строка в противном случае.

UnixLabels.Unix_error и Unix.Unix_error одинаковы, и перехват одной из них будет перехватывать другую.

val error_message : error -> string

Возвращает строку, описывающую данный код ошибки.

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

handle_unix_error f x применяет f к x и возвращает результат. Если возникает исключение UnixLabels.Unix_error, выводится сообщение об ошибке и выполняется выход с кодом 2.

Доступ к среде процесса

val environment : unit -> string array

Возвращает среду процесса в виде массива строк формата «переменная=значение». Возвращаемый массив пустой, если у процесса есть особые привилегии.

val unsafe_environment : unit -> string array

Возвращает среду процесса в виде массива строк формата «переменная=значение». В отличие от UnixLabels.environment, эта функция возвращает заполненный массив даже если у процесса есть особые привилегии. Дополнительные сведения см. в документации для UnixLabels.unsafe_getenv.

Since 4.12.0

val getenv : string -> string

Возвращает значение, связанное с переменной в среде процесса, если у процесса нет особых привилегий.

Raises Not_found, если переменная не определена или у процесса есть особые привилегии. Эта функция идентична Sys.getenv.

val unsafe_getenv : string -> string

Возвращает значение, связанное с переменной в среде процесса.

В отличие от UnixLabels.getenv, эта функция возвращает значение даже если у процесса есть особые привилегии. Она считается небезопасной, так как программисту программы с правами setuid или setgid нужно быть внимательным, чтобы избежать использования злонамеренно составленных переменных среды в пути поиска исполняемых файлов, местах для временных файлов или логов, и т.п.

Since 4.06.0
Raises Not_found, если переменная не определена.

val putenv : string -> string -> unit

putenv name value устанавливает значение, связанное с переменной в среде процесса. name — имя переменной среды, а value — её новое значение.

Обработка процессов

type process_status = Unix.process_status =

`\|`	`WEXITED of int`	`(*`	Процесс завершился нормально, `exit`; аргумент — код возврата.	`*)`
`\|`	`WSIGNALED of int`	`(*`	Процесс был завершен сигналом; аргумент — номер сигнала.	`*)`
`\|`	`WSTOPPED of int`	`(*`	Процесс был остановлен сигналом; аргумент — номер сигнала.	`*)`

Код завершения процесса. См. модуль Sys для определений стандартных номеров сигналов. Обратите внимание, что они не являются номерами, используемыми ОС.

type wait_flag = Unix.wait_flag =

`\|`	`WNOHANG`	`(*`	Не блокироваться, если ни один дочерний процесс ещё не завершился, а сразу вернуть значение pid, равное 0.	`*)`
`\|`	`WUNTRACED`	`(*`	Также сообщать о дочерних процессах, получивших сигналы остановки.	`*)`

Флаги для UnixLabels.waitpid.

val execv : prog:string -> args:string array -> 'a

execv ~prog ~args выполняет программу из файла prog с аргументами args и текущей средой процесса. Эти execv* функции никогда не возвращаются: при успехе текущая программа заменяется новой.

Raises Unix_error при ошибке

val execve : prog:string -> args:string array -> env:string array -> 'a

Аналогично UnixLabels.execv, за исключением того, что третий аргумент предоставляет среду исполняемой программе.

val execvp : prog:string -> args:string array -> 'a

Аналогично UnixLabels.execv, за исключением того, что программа ищется в пути.

val execvpe : prog:string -> args:string array -> env:string array -> 'a

Аналогично UnixLabels.execve, за исключением того, что программа ищется в пути.

val fork : unit -> int

Создать новый процесс. Возвращаемое целое число — 0 для дочернего процесса, pid дочернего процесса для родительского процесса.

Raises Invalid_argument в Windows. Используйте UnixLabels.create_process или потоки вместо этого.

val wait : unit -> int * process_status

Ожидать завершения одного из дочерних процессов и вернуть его pid и код завершения.

Raises Invalid_argument в Windows. Используйте UnixLabels.waitpid вместо этого.

val waitpid : mode:wait_flag list -> int -> int * process_status

Аналогично UnixLabels.wait, но ожидает дочерний процесс с заданным pid. Значение pid, равное -1, означает ожидание любого дочернего процесса. Значение pid, равное 0, означает ожидание любого дочернего процесса в той же группе процессов, что и текущий процесс. Отрицательные аргументы pid представляют группы процессов. Список опций указывает, должно ли waitpid возвращаться немедленно без ожидания и сообщать ли об остановленных дочерних процессах.

В Windows: можно ожидать только процесса с заданным PID, а не любого дочернего процесса.

val system : string -> process_status

Выполнить заданную команду, дождаться её завершения и вернуть код завершения. Строка интерпретируется оболочкой /bin/sh (или интерпретатором команд cmd.exe в Windows) и поэтому может содержать перенаправления, кавычки, переменные и т.д. Для правильной обработки пробелов и специальных символов оболочки, встречающихся в именах файлов или аргументах команд, рекомендуется использовать Filename.quote_command. Результат WEXITED 127 указывает, что оболочка не могла быть выполнена.

val _exit : int -> 'a

Немедленно завершить вызывающий процесс, вернув заданный код состояния операционной системе: обычно 0 для указания отсутствия ошибок и небольшое положительное целое число для указания ошибки. В отличие от exit, Unix._exit не выполняет никакой финализации: функции, зарегистрированные с помощью at_exit, не вызываются, каналы ввода/вывода не сбрасываются, и система C run-time также не завершается.

Типичное использование Unix._exit — после операции Unix.fork, когда дочерний процесс сталкивается с критическими ошибками и должен завершиться. В этом случае предпочтительно не выполнять никаких действий финализации в дочернем процессе, так как эти действия могут повлиять на аналогичные действия, выполняемые родительским процессом. Например, каналы вывода не должны сбрасываться дочерним процессом, так как родительский процесс может сбросить их позже, что приведёт к дублированию вывода.

Since 4.12.0

val getpid : unit -> int

Возвращает pid процесса.

val getppid : unit -> int

Возвращает pid родительского процесса.

Raises Invalid_argument в Windows (потому что это бессмысленно)

val nice : int -> int

Изменить приоритет процесса. Целочисленный аргумент добавляется к значению «nice» (более высокие значения «nice» означают более низкий приоритет). Возвращает новое значение nice.

Raises Invalid_argument в Windows

Основные операции ввода/вывода файлов

type file_descr = Unix.file_descr

Абстрактный тип дескрипторов файлов.

val stdin : file_descr

Дескриптор файла для стандартного ввода.

val stdout : file_descr

Дескриптор файла для стандартного вывода.

val stderr : file_descr

Дескриптор файла для стандартной ошибки.

type open_flag = Unix.open_flag =

`\|`	`O_RDONLY`	`(*`	Открыто для чтения	`*)`
`\|`	`O_WRONLY`	`(*`	Открыто для записи	`*)`
`\|`	`O_RDWR`	`(*`	Открыто для чтения и записи	`*)`
`\|`	`O_NONBLOCK`	`(*`	Открыто в режиме без блокировки	`*)`
`\|`	`O_APPEND`	`(*`	Открыто для добавления	`*)`
`\|`	`O_CREAT`	`(*`	Создать, если не существует	`*)`
`\|`	`O_TRUNC`	`(*`	Усечь до длины 0, если существует	`*)`
`\|`	`O_EXCL`	`(*`	Ошибка, если существует	`*)`
`\|`	`O_NOCTTY`	`(*`	Не делать этого разработчика управляющей pty	`*)`
`\|`	`O_DSYNC`	`(*`	Запись завершена как `Завершение целостности синхронизированных данных ввода-вывода`	`*)`
`\|`	`O_SYNC`	`(*`	Запись завершена как `Завершение целостности синхронизированного файла ввода-вывода`	`*)`
`\|`	`O_RSYNC`	`(*`	Чтение завершено, как запись (в зависимости от O_SYNC/O_DSYNC)	`*)`
`\|`	`O_SHARE_DELETE`	`(*`	Только Windows: разрешить удаление файла, пока он открыт	`*)`
`\|`	`O_CLOEXEC`	`(*`	Установить флаг закрытия при выполнении на дескрипторе, возвращённом `UnixLabels.openfile`. Дополнительную информацию см. в `UnixLabels.set_close_on_exec`.	`*)`
`\|`	`O_KEEPEXEC`	`(*`	Сбросить флаг закрытия при выполнении. В настоящее время это значение по умолчанию.	`*)`

Флаги для UnixLabels.openfile.

type file_perm = int

Тип прав доступа к файлу, например, 0o640 — чтение и запись для пользователя, чтение для группы, ничего для других

val openfile : string ->       mode:open_flag list ->       perm:file_perm -> file_descr

Открыть именованный файл с заданными флагами. Третий аргумент — права, которые нужно предоставить файлу, если он создаётся (см. UnixLabels.umask). Вернуть дескриптор файла с именем.

val close : file_descr -> unit

Закрыть дескриптор файла.

val fsync : file_descr -> unit

Очистить буферы файла в диск.

Since 4.12.0

val read : file_descr -> buf:bytes -> pos:int -> len:int -> int

read fd ~buf ~pos ~len считывает len байтов из дескриптора fd, сохраняя их в последовательности байтов buf, начиная с позиции pos в buf. Вернуть количество фактически прочитанных байтов.

val write : file_descr -> buf:bytes -> pos:int -> len:int -> int

write fd ~buf ~pos ~len записывает len байтов в дескриптор fd, взяв их из последовательности байтов buf, начиная с позиции pos в buff. Вернуть количество фактически записанных байтов. write повторяет операцию записи, пока все байты не будут записаны или не произойдёт ошибка.

val single_write : file_descr -> buf:bytes -> pos:int -> len:int -> int

Аналогично UnixLabels.write, но пытается записать только один раз. Таким образом, если произошла ошибка, single_write гарантирует, что никакие данные не были записаны.

val write_substring : file_descr -> buf:string -> pos:int -> len:int -> int

Аналогично UnixLabels.write, но берёт данные из строки вместо последовательности байтов.

Since 4.02.0

val single_write_substring : file_descr -> buf:string -> pos:int -> len:int -> int

Аналогично UnixLabels.single_write, но берёт данные из строки вместо последовательности байтов.

Since 4.02.0

Взаимодействие с стандартной библиотекой ввода/вывода

val in_channel_of_descr : file_descr -> in_channel

Создать канал ввода, читающий из данного дескриптора. Канал изначально в двоичном режиме; используйте set_binary_mode_in ic false, если нужен текстовый режим. Текстовый режим поддерживается только если дескриптор относится к файлу или конвейеру, но не поддерживается, если он относится к сокету.

В Windows: set_binary_mode_in всегда завершается ошибкой для каналов, созданных с помощью этой функции.

Обратите внимание, что каналы ввода буферизованы, поэтому может быть прочитано больше символов из дескриптора, чем доступно с помощью функций канала. Каналы также сохраняют копию текущей позиции в файле.

Закрытие канала ic, возвращённого in_channel_of_descr fd с помощью close_in ic, также закрывает лежащий в основе дескриптор fd. Неправильно закрывать как канал ic, так и дескриптор fd.

Если несколько каналов созданы на одном дескрипторе, один из каналов должен быть закрыт, но не другие. Например, рассмотрите дескриптор s, подключённый к сокету, и два канала ic = in_channel_of_descr s и oc = out_channel_of_descr s. Рекомендуемый протокол закрытия — выполнить close_out oc, что сбросит буферизованный вывод в сокет, затем закроет сокет. Канал ic не должен закрываться и будет собран сборщиком мусора в конечном итоге.

val out_channel_of_descr : file_descr -> out_channel

Создайте канал вывода, записывая в указанный дескриптор. Канал изначально в двоичном режиме; используйте set_binary_mode_out oc false, если требуется текстовый режим. Текстовый режим поддерживается только если дескриптор относится к файлу или конвейпу, но не поддерживается, если он относится к сокету.

В Windows: set_binary_mode_out всегда завершается неудачей для каналов, созданных с помощью этой функции.

Обратите внимание, что каналы вывода буферизованы, поэтому вам может потребоваться вызвать flush, чтобы убедиться, что все данные были отправлены в дескриптор. Каналы также хранят копию текущей позиции в файле.

Закрытие канала oc, возвращаемого out_channel_of_descr fd с помощью close_out oc, также закрывает базовый дескриптор fd. Неправильно закрывать и канал ic, и дескриптор fd.

См. Unix.in_channel_of_descr для обсуждения протокола закрытия, когда несколько каналов созданы на одном дескрипторе.

val descr_of_in_channel : in_channel -> file_descr

Возвращает дескриптор, соответствующий каналу ввода.

val descr_of_out_channel : out_channel -> file_descr

Возвращает дескриптор, соответствующий каналу вывода.

Поиск и обрезка

type seek_command = Unix.seek_command =

`\|`	`SEEK_SET`	`(*`	указывает позиции относительно начала файла	`*)`
`\|`	`SEEK_CUR`	`(*`	указывает позиции относительно текущей позиции	`*)`
`\|`	`SEEK_END`	`(*`	указывает позиции относительно конца файла	`*)`

Режимы позиционирования для UnixLabels.lseek.

val lseek : file_descr -> int -> mode:seek_command -> int

Устанавливает текущую позицию для дескриптора файла и возвращает результирующее смещение (от начала файла).

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

Обрезает именованный файл до указанного размера.

val ftruncate : file_descr -> len:int -> unit

Обрезает файл, соответствующий данному дескриптору, до указанного размера.

Статус файла

type file_kind = Unix.file_kind =

`\|`	`S_REG`	`(*`	Обычный файл	`*)`
`\|`	`S_DIR`	`(*`	Директория	`*)`
`\|`	`S_CHR`	`(*`	Символьное устройство	`*)`
`\|`	`S_BLK`	`(*`	Блочное устройство	`*)`
`\|`	`S_LNK`	`(*`	Символическая ссылка	`*)`
`\|`	`S_FIFO`	`(*`	Именованная труба	`*)`
`\|`	`S_SOCK`	`(*`	Сокет	`*)`

type stats = Unix.stats = {

`st_dev : int;`	`(*`	Номер устройства	`*)`
`st_ino : int;`	`(*`	Номер узла	`*)`
`st_kind : file_kind;`	`(*`	Тип файла	`*)`
`st_perm : file_perm;`	`(*`	Права доступа	`*)`
`st_nlink : int;`	`(*`	Количество ссылок	`*)`
`st_uid : int;`	`(*`	Идентификатор пользователя владельца	`*)`
`st_gid : int;`	`(*`	Идентификатор группы файла	`*)`
`st_rdev : int;`	`(*`	Идентификатор устройства (если это специальный файл)	`*)`
`st_size : int;`	`(*`	Размер в байтах	`*)`
`st_atime : float;`	`(*`	Время последнего доступа	`*)`
`st_mtime : float;`	`(*`	Время последнего изменения	`*)`
`st_ctime : float;`	`(*`	Время последнего изменения статуса	`*)`

}

Информация, возвращаемая вызовами UnixLabels.stat.

val stat : string -> stats

Возвращает информацию о файле с заданным именем.

val lstat : string -> stats

То же, что и UnixLabels.stat, но в случае, если файл является символической ссылкой, возвращает информацию о самой ссылке.

val fstat : file_descr -> stats

Возвращает информацию о файле, связанном с заданным дескриптором.

val isatty : file_descr -> bool

Возвращает true, если заданный дескриптор файла относится к терминалу или консольному окну, false в противном случае.

Операции с большими файлами

module LargeFile: sig .. end

Операции с большими файлами.

Мапирование файлов в память

val map_file : file_descr ->       ?pos:int64 ->       kind:('a, 'b) Bigarray.kind ->       layout:'c Bigarray.layout ->       shared:bool -> dims:int array -> ('a, 'b, 'c) Bigarray.Genarray.t

Мапирование файла в память как Bigarray. map_file fd ~kind ~layout ~shared ~dims возвращает Bigarray типа kind, расположения layout и размеров, как указано в dims. Данные в этом Bigarray — содержимое файла, на который указывает дескриптор файла fd (открытый ранее, например, с помощью UnixLabels.openfile). Необязательный параметр pos — смещение в файле в байтах данных, которые будут отображаться; по умолчанию 0 (отображение с начала файла).

Если shared равно true, все изменения, внесенные в массив, отражаются в файле. Для этого требуется, чтобы файл fd был открыт с правами записи. Если shared равно false, изменения, внесенные в массив, производятся только в памяти, используя копирование при записи изменённых страниц; базовый файл не затрагивается.

UnixLabels.map_file намного эффективнее, чем чтение всего файла в Bigarray, изменение этого Bigarray и последующая запись.

Для автоматической настройки размеров Bigarray до фактического размера файла, главная размерность (первая размерность для массива с C-расположением и последняя размерность для массива с Fortran-расположением) может быть задана как -1. UnixLabels.map_file затем определяет главную размерность по размеру файла. Файл должен содержать целое число подмассивов, как определено неглавными размерностями, в противном случае возникает исключение Failure.

Если все размерности Bigarray заданы, размер файла сопоставляется с размером Bigarray. Если файл больше, чем Bigarray, только начальная часть файла отображается в Bigarray. Если файл меньше, файл автоматически увеличивается до размера Bigarray. Для этого требуются права записи на fd.

Доступы к массиву проверяются на границы, но границы определяются исходным вызовом map_file. Поэтому необходимо убедиться, что ни один другой процесс не изменяет отображенный файл во время доступа, иначе может быть вызван сигнал SIGBUS. Это происходит, например, если размер файла уменьшается.

Invalid_argument или Failure могут быть вызваны в случаях, когда проверка аргументов завершится неудачно.

Since 4.06.0

Операции с именами файлов

val unlink : string -> unit

Удаляет файл с указанным именем.

Если удаляемый файл является каталогом, возникает:

EPERM на POSIX-совместимой системе
EISDIR на Linux >= 2.1.132
EACCESS на Windows

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

rename ~src ~dst изменяет имя файла с src на dst, перемещая его между каталогами при необходимости. Если dst уже существует, его содержимое будет заменено содержимым src. В зависимости от операционной системы, метаданные (разрешения, владелец и т.д.) dst могут быть сохранены или заменены метаданными src.

val link : ?follow:bool -> src:string -> dst:string -> unit

link ?follow ~src ~dst создаёт жёсткую ссылку с именем dst на файл с именем src.

Raises
- ENOSYS На Unix, если требуется ~follow:_, но linkat недоступен.
- ENOSYS На Windows, если требуется ~follow:false.

follow : указывает, следует ли следовать символической ссылке src или создать жёсткую ссылку на сам src. На Unix системах это выполняется с помощью функции linkat(2). Если ?follow не указан, используется функция link(2), поведение которой зависит от ОС, но которая более широко доступна.

val realpath : string -> string

realpath p — абсолютный путь к p, полученный путём разрешения всех дополнительных символов /, относительных частей пути и символических ссылок.

Since 4.13.0

Права доступа и владение файлами

type access_permission = Unix.access_permission =

`\|`	`R_OK`	`(*`	Право на чтение	`*)`
`\|`	`W_OK`	`(*`	Право на запись	`*)`
`\|`	`X_OK`	`(*`	Право на выполнение	`*)`
`\|`	`F_OK`	`(*`	Файл существует	`*)`

Флаги для вызова UnixLabels.access.

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

Изменить права указанного файла.

val fchmod : file_descr -> perm:file_perm -> unit

Изменить права открытого файла.

Raises Invalid_argument на Windows

val chown : string -> uid:int -> gid:int -> unit

Изменить владельца (uid) и группу (gid) указанного файла.

Raises Invalid_argument на Windows

val fchown : file_descr -> uid:int -> gid:int -> unit

Изменить владельца (uid) и группу (gid) открытого файла.

Raises Invalid_argument на Windows

val umask : int -> int

Установить маску создания режима файла процесса и вернуть предыдущую маску.

Raises Invalid_argument на Windows

val access : string -> perm:access_permission list -> unit

Проверить, обладает ли процесс заданными правами над указанным файлом.

На Windows: право на выполнение X_OK проверить нельзя, вместо этого проверяется только право на чтение.

Raises Unix_error в противном случае.

Операции с дескрипторами файлов

val dup : ?cloexec:bool -> file_descr -> file_descr

Возвращает новый дескриптор файла, ссылающийся на тот же файл, что и заданный дескриптор. См. UnixLabels.set_close_on_exec для документации по необязательному аргументу cloexec.

val dup2 : ?cloexec:bool ->       src:file_descr -> dst:file_descr -> unit

dup2 ~src ~dst дублирует src в dst, закрывая dst, если он уже открыт. См. UnixLabels.set_close_on_exec для документации по необязательному аргументу cloexec.

val set_nonblock : file_descr -> unit

Устанавливает флаг «неблокирующий» для заданного дескриптора. При установленном флаге «неблокирующий», чтение из дескриптора, при котором временно нет доступных данных, вызывает ошибку EAGAIN или EWOULDBLOCK вместо блокировки; запись в дескриптор, при котором временно нет места для записи, также вызывает ошибку EAGAIN или EWOULDBLOCK.

val clear_nonblock : file_descr -> unit

Сбрасывает флаг «неблокирующий» для заданного дескриптора. См. UnixLabels.set_nonblock.

val set_close_on_exec : file_descr -> unit

Устанавливает флаг «закрывать при выполнении» для заданного дескриптора. Дескриптор с флагом «закрывать при выполнении» автоматически закрывается, когда текущий процесс запускает другую программу с помощью одной из функций exec, create_process и open_process.

Часто утечка дескрипторов файлов, открытых для, скажем, личного файла, в стороннюю программу является уязвимостью: программа затем получает доступ к личному файлу и может совершить вредные действия с ним. Поэтому настоятельно рекомендуется устанавливать всем дескрипторам файлов флаг «закрывать при выполнении», за исключением тех редких случаев, когда дескриптор файла действительно нужно передавать другой программе.

Лучший способ установить флаг «закрывать при выполнении» для дескриптора файла – создать его в этом состоянии. Для этого функция openfile имеет флаги O_CLOEXEC и O_KEEPEXEC для принудительного режима «закрывать при выполнении» или «сохранять при выполнении» соответственно. Все остальные операции в модуле Unix, создающие дескрипторы файлов, имеют необязательный аргумент ?cloexec:bool, чтобы указать, должен ли дескриптор файла создаваться в режиме «закрывать при выполнении» (записью ~cloexec:true) или в режиме «сохранять при выполнении» (записью ~cloexec:false). По историческим причинам, режим создания дескриптора файла по умолчанию – «сохранять при выполнении», если необязательный аргумент cloexec не задан. Это небезопасный стандарт, поэтому настоятельно рекомендуется передавать явные аргументы cloexec в операции, создающие дескрипторы файлов.

Необязательные аргументы cloexec и флаг O_KEEPEXEC были введены в OCaml 4.05. Раньше распространённой практикой было создание дескрипторов файлов в режиме по умолчанию «сохранять при выполнении», а затем вызов set_close_on_exec для этих только что созданных дескрипторов файлов. Это не так безопасно, как создание дескриптора файла в режиме «закрывать при выполнении», так как в многопоточных программах существует окно уязвимости между моментом создания дескриптора файла и завершением set_close_on_exec. Если другой поток запускает другую программу в течение этого окна, дескриптор будет утечка, так как он по-прежнему находится в режиме «сохранять при выполнении».

Что касается гарантий атомарности, предоставляемых ~cloexec:true или использованием флага O_CLOEXEC: на всех платформах гарантируется, что одновременно выполняющийся поток Caml не может утечь дескриптор, запустив новый процесс. В Linux эта гарантия распространяется на одновременно выполняющиеся потоки C. По состоянию на февраль 2017 года, другие операционные системы лишены необходимых системных вызовов и по-прежнему предоставляют окно уязвимости, в течение которого поток C может увидеть только что созданный дескриптор файла в режиме «сохранять при выполнении».

val clear_close_on_exec : file_descr -> unit

Сбросить флаг «закрывать при выполнении» для заданного дескриптора. См. UnixLabels.set_close_on_exec.

Каталоги

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

Создать каталог с указанными правами (см. UnixLabels.umask).

val rmdir : string -> unit

Удалить пустой каталог.

val chdir : string -> unit

Изменить текущий рабочий каталог процесса.

val getcwd : unit -> string

Вернуть имя текущего рабочего каталога.

val chroot : string -> unit

Изменить корневой каталог процесса.

Raises Invalid_argument на Windows

type dir_handle = Unix.dir_handle

Тип дескрипторов открытых каталогов.

val opendir : string -> dir_handle

Открыть дескриптор каталога

val readdir : dir_handle -> string

Вернуть следующую запись в каталоге.

Raises End_of_file при достижении конца каталога.

val rewinddir : dir_handle -> unit

Переместить дескриптор к началу каталога

val closedir : dir_handle -> unit

Закрыть дескриптор каталога.

Каналы и перенаправления

val pipe : ?cloexec:bool -> unit -> file_descr * file_descr

Создать канал. Первый компонент результата открывается для чтения, это выход из канала. Второй компонент открывается для записи, это вход в канал. См. UnixLabels.set_close_on_exec для документации по необязательному аргументу cloexec.

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

Создать именованный канал с указанными правами (см. UnixLabels.umask).

Raises Invalid_argument на Windows

Управление процессами и перенаправлениями высокого уровня

val create_process : prog:string ->       args:string array ->       stdin:file_descr ->       stdout:file_descr -> stderr:file_descr -> int

create_process ~prog ~args ~stdin ~stdout ~stderr запускает новый процесс, который выполняет программу в файле prog с аргументами args. Идентификатор нового процесса возвращается немедленно; новый процесс выполняется параллельно с текущим процессом. Стандартный ввод и вывод нового процесса подключаются к дескрипторам stdin, stdout и stderr. Передача, например, Unix.stdout для stdout предотвращает перенаправление и заставляет новый процесс иметь тот же стандартный вывод, что и текущий процесс. Файл исполняемой программы prog ищется в пути. Новый процесс имеет ту же среду, что и текущий процесс.

val create_process_env : prog:string ->       args:string array ->       env:string array ->       stdin:file_descr ->       stdout:file_descr -> stderr:file_descr -> int

create_process_env ~prog ~args ~env ~stdin ~stdout ~stderr работает так же, как UnixLabels.create_process, за исключением того, что дополнительный аргумент env указывает среду, передаваемую программе.

val open_process_in : string -> in_channel

Управление каналами и процессами высокого уровня. Эта функция выполняет заданную команду параллельно с программой. Стандартный вывод команды перенаправляется в канал, который можно читать через возвращаемый входной канал. Команда интерпретируется оболочкой /bin/sh (или cmd.exe в Windows), см. UnixLabels.system. Функцию Filename.quote_command можно использовать для цитирования команды и ее аргументов соответствующим образом для используемой оболочки. Если команда не требует выполнения через оболочку, можно использовать UnixLabels.open_process_args_in в качестве более надежной и эффективной альтернативы UnixLabels.open_process_in.

val open_process_out : string -> out_channel

То же, что и UnixLabels.open_process_in, но перенаправляет стандартный ввод команды в канал. Данные, записанные в возвращаемый выходной канал, отправляются в стандартный ввод команды. Предупреждение: записи в выходные каналы буферизуются, поэтому будьте внимательны и вызывайте flush в нужные моменты, чтобы гарантировать правильную синхронизацию. Если команда не требует выполнения через оболочку, вместо UnixLabels.open_process_out можно использовать UnixLabels.open_process_args_out.

val open_process : string -> in_channel * out_channel

То же, что и UnixLabels.open_process_out, но перенаправляет как стандартный ввод, так и стандартный вывод команды в каналы, подключенные к двум возвращаемым каналам. Входной канал подключен к выводу команды, а выходной канал — к вводу команды. Если команда не требует выполнения через оболочку, вместо UnixLabels.open_process можно использовать UnixLabels.open_process_args.

val open_process_full : string ->       env:string array ->       in_channel * out_channel * in_channel

Аналогично UnixLabels.open_process, но второй аргумент задаёт среду, передаваемую команде. Результатом является тройка каналов, подключённых соответственно к стандартному выводу, стандартному вводу и стандартной ошибке команды. Если команда не требует выполнения через оболочку, вместо UnixLabels.open_process_full можно использовать UnixLabels.open_process_args_full.

val open_process_args_in : string -> string array -> in_channel

open_process_args_in prog args запускает программу prog с аргументами args. Новый процесс выполняется параллельно с текущим процессом. Стандартный вывод нового процесса перенаправляется в канал, который можно читать через возвращаемый входной канал.

Исполняемый файл prog ищется в переменной среды PATH. Это поведение изменилось в версии 4.12; ранее prog искался только в текущем каталоге.

Новый процесс имеет ту же среду, что и текущий процесс.

Since 4.08.0

val open_process_args_out : string -> string array -> out_channel

То же, что и UnixLabels.open_process_args_in, но перенаправляет стандартный ввод нового процесса в канал. Данные, записанные в возвращаемый выходной канал, отправляются в стандартный ввод программы. Предупреждение: записи в выходные каналы буферизуются, поэтому будьте внимательны и вызывайте flush в нужные моменты, чтобы гарантировать правильную синхронизацию.

Since 4.08.0

val open_process_args : string -> string array -> in_channel * out_channel

То же, что и UnixLabels.open_process_args_out, но перенаправляет как стандартный ввод, так и стандартный вывод нового процесса в каналы, подключённые к двум возвращаемым каналам. Входной канал подключен к выводу программы, а выходной канал — к вводу программы.

Since 4.08.0

val open_process_args_full : string ->       string array ->       string array -> in_channel * out_channel * in_channel

Аналогично UnixLabels.open_process_args, но третий аргумент задаёт среду, передаваемую новому процессу. Результатом является тройка каналов, подключённых соответственно к стандартному выводу, стандартному вводу и стандартной ошибке программы.

Since 4.08.0

val process_in_pid : in_channel -> int

Возвращает идентификатор процесса (PID), открытого с помощью UnixLabels.open_process_in или UnixLabels.open_process_args_in.

Since 4.12.0

val process_out_pid : out_channel -> int

Возвращает идентификатор процесса (PID), открытого с помощью UnixLabels.open_process_out или UnixLabels.open_process_args_out.

Since 4.12.0

val process_pid : in_channel * out_channel -> int

Возвращает идентификатор процесса (PID), открытого с помощью UnixLabels.open_process или UnixLabels.open_process_args.

Since 4.12.0

val process_full_pid : in_channel * out_channel * in_channel -> int

Возвращает идентификатор процесса (PID), открытого с помощью UnixLabels.open_process_full или UnixLabels.open_process_args_full.

Since 4.12.0

val close_process_in : in_channel -> process_status

Закрывает каналы, открытые с помощью UnixLabels.open_process_in, ждёт завершения связанной команды и возвращает её код завершения.

val close_process_out : out_channel -> process_status

Закрывает каналы, открытые с помощью UnixLabels.open_process_out, ждёт завершения связанной команды и возвращает её код завершения.

val close_process : in_channel * out_channel -> process_status

Закрывает каналы, открытые с помощью UnixLabels.open_process, ждёт завершения связанной команды и возвращает её код завершения.

val close_process_full : in_channel * out_channel * in_channel ->       process_status

Закрывает каналы, открытые с помощью UnixLabels.open_process_full, ждёт завершения связанной команды и возвращает её код завершения.

Символические ссылки

val symlink : ?to_dir:bool -> src:string -> dst:string -> unit

symlink ?to_dir ~src ~dst создаёт файл dst как символическую ссылку на файл src. В Windows, ~to_dir указывает, ссылается ли символическая ссылка на каталог или файл; если опущено, symlink проверяет src с помощью stat и выбирает соответствующим образом, если src не существует, то предполагается false (по этой причине рекомендуется указывать параметр ~to_dir в новом коде). В Unix, ~to_dir игнорируется.

Символические ссылки Windows доступны начиная с Windows Vista. Существуют некоторые важные различия между символическими ссылками Windows и их POSIX аналогами.

Символические ссылки Windows бывают двух типов: каталог и обычный файл, определяющие, ссылается ли символическая ссылка на каталог или файл. Тип должен быть корректным — символическая ссылка на каталог, фактически ссылающаяся на файл, не может быть выбрана с помощью chdir, а символическая ссылка на файл, фактически ссылающаяся на каталог, не может быть прочитана или записана (обратите внимание, что эмуляционный слой Cygwin игнорирует это различие).

Когда символические ссылки создаются на существующие цели, это различие не имеет значения и symlink автоматически создаст правильный тип символической ссылки. Различие имеет значение, когда символическая ссылка создаётся на несуществующую цель.

Другой момент заключается в том, что по умолчанию создание символических ссылок — привилегированная операция. Администраторы всегда должны работать с повышенными привилегиями (или с отключенным UAC), а обычные пользовательские учётные записи по умолчанию должны получить привилегию SeCreateSymbolicLinkPrivilege через Политику локальной безопасности (secpol.msc) или через Active Directory.

UnixLabels.has_symlink можно использовать для проверки возможности создания символических ссылок процессом.

val has_symlink : unit -> bool

Возвращает true, если пользователь может создавать символические ссылки. В Windows это указывает на то, что у пользователя есть не только привилегия SeCreateSymbolicLinkPrivilege, но и он работает с повышенными привилегиями, если необходимо. На других платформах это просто указывает на доступность системного вызова symlink.

Since 4.03.0

val readlink : string -> string

Чтение содержимого символической ссылки.

Опрос

val select : read:file_descr list ->       write:file_descr list ->       except:file_descr list ->       timeout:float ->       file_descr list * file_descr list *       file_descr list

Ожидание, пока некоторые операции ввода/вывода станут возможными для некоторых каналов. Три списка аргументов представляют собой соответственно набор дескрипторов для проверки на чтение (первый аргумент), запись (второй аргумент) или исключительные условия (третий аргумент). Четвёртый аргумент — максимальный интервал ожидания в секундах; отрицательный четвёртый аргумент означает отсутствие таймаута (неограниченное ожидание). Результат состоит из трёх наборов дескрипторов: тех, которые готовы к чтению (первый компонент), записи (второй компонент) и по которым ожидается исключительное условие (третий компонент).

Блокировка

type lock_command = Unix.lock_command =

`\|`	`F_ULOCK`	`(*`	Разблокировать область	`*)`
`\|`	`F_LOCK`	`(*`	Заблокировать область для записи и заблокировать, если она уже заблокирована	`*)`
`\|`	`F_TLOCK`	`(*`	Заблокировать область для записи или вернуть ошибку, если она уже заблокирована	`*)`
`\|`	`F_TEST`	`(*`	Проверить область на наличие блокировок других процессов	`*)`
`\|`	`F_RLOCK`	`(*`	Заблокировать область для чтения и заблокировать, если она уже заблокирована	`*)`
`\|`	`F_TRLOCK`	`(*`	Заблокировать область для чтения или вернуть ошибку, если она уже заблокирована	`*)`

Команды для UnixLabels.lockf.

val lockf : file_descr -> mode:lock_command -> len:int -> unit

lockf fd ~mode ~len устанавливает блокировку на области файла, открытого как fd. Область начинается с текущей позиции чтения/записи для fd (как установлено UnixLabels.lseek), и расширяется на len байтов вперёд, если len положительно, на len байтов назад, если len отрицательно, или до конца файла, если len равно нулю. Блокировка на запись предотвращает получение блокировки на чтение или запись другим процессом в данной области. Блокировка на чтение предотвращает получение блокировки на запись другим процессом в данной области, но позволяет другим процессам получать блокировки на чтение.

Команды F_LOCK и F_RLOCK пытаются установить блокировку на запись в указанной области. Команды F_TLOCK и F_TRLOCK пытаются установить блокировку на чтение в указанной области. Если одна или несколько блокировок, установленных другим процессом, препятствуют получению блокировки текущим процессом, F_LOCK и F_RLOCK блокируются, пока эти блокировки не будут сняты, а F_TLOCK и F_TRLOCK немедленно завершаются с исключением. Команда F_ULOCK удаляет все блокировки, установленные текущим процессом в указанной области. Наконец, команда F_TEST проверяет, может ли быть получена блокировка на запись в указанной области, без фактического её установления. Она возвращает результат немедленно, если успешно, или завершается ошибкой в противном случае.

Что произойдёт, когда процесс попытается заблокировать область файла, которая уже заблокирована тем же процессом, зависит от ОС. В POSIX-совместимых системах вторая операция блокировки выполняется успешно и может "повысить" более старую блокировку с чтения до записи. В Windows вторая операция блокировки будет блокироваться или завершится ошибкой.

Сигналы

Примечание: установка обработчиков сигналов выполняется с помощью функций Sys.signal и Sys.set_signal.

val kill : pid:int -> signal:int -> unit

kill ~pid ~signal отправляет сигнал с номером signal процессу с id pid.

В Windows: эмулируется только сигнал Sys.sigkill.

type sigprocmask_command = Unix.sigprocmask_command =

`\|`	`SIG_SETMASK`
`\|`	`SIG_BLOCK`
`\|`	`SIG_UNBLOCK`

val sigprocmask : mode:sigprocmask_command -> int list -> int list

sigprocmask ~mode sigs изменяет набор заблокированных сигналов. Если mode равно SIG_SETMASK, заблокированные сигналы устанавливаются в список sigs. Если mode равно SIG_BLOCK, сигналы в sigs добавляются к набору заблокированных сигналов. Если mode равно SIG_UNBLOCK, сигналы в sigs удаляются из набора заблокированных сигналов. sigprocmask возвращает набор ранее заблокированных сигналов.

При загрузке модуля Thread версии systhreads эта функция перенаправляется на Thread.sigmask. То есть, sigprocmask изменяет только маску текущей нити.

Raises Invalid_argument в Windows (нет межпроцессных сигналов в Windows)

val sigpending : unit -> int list

Возвращает набор заблокированных сигналов, которые в данный момент ожидают обработки.

Raises Invalid_argument в Windows (нет межпроцессных сигналов в Windows)

val sigsuspend : int list -> unit

sigsuspend sigs атомарно устанавливает заблокированные сигналы на sigs и ожидает, пока не будет доставлен не игнорируемый и не заблокированный сигнал. По возвращении заблокированные сигналы сбрасываются до своего первоначального значения.

Raises Invalid_argument в Windows (нет межпроцессных сигналов в Windows)

val pause : unit -> unit

Ожидает, пока не будет доставлен не игнорируемый и не заблокированный сигнал.

Raises Invalid_argument в Windows (нет межпроцессных сигналов в Windows)

Функции времени

type process_times = Unix.process_times = {

`tms_utime : float;`	`(*`	Время пользователя для процесса	`*)`
`tms_stime : float;`	`(*`	Время системы для процесса	`*)`
`tms_cutime : float;`	`(*`	Время пользователя для дочерних процессов	`*)`
`tms_cstime : float;`	`(*`	Время системы для дочерних процессов	`*)`

}

Время выполнения (времена процессора) процесса.

type tm = Unix.tm = {

`tm_sec : int;`	`(*`	Секунды 0..60	`*)`
`tm_min : int;`	`(*`	Минуты 0..59	`*)`
`tm_hour : int;`	`(*`	Часы 0..23	`*)`
`tm_mday : int;`	`(*`	День месяца 1..31	`*)`
`tm_mon : int;`	`(*`	Месяц года 0..11	`*)`
`tm_year : int;`	`(*`	Год - 1900	`*)`
`tm_wday : int;`	`(*`	День недели (воскресенье - 0)	`*)`
`tm_yday : int;`	`(*`	День года 0..365	`*)`
`tm_isdst : bool;`	`(*`	Действует летнее время	`*)`

}

Тип, представляющий время часов и календарную дату.

val time : unit -> float

Возвращает текущее время с 00:00:00 по Гринвичу, 1 января 1970 года, в секундах.

val gettimeofday : unit -> float

То же, что и UnixLabels.time, но с разрешением лучше, чем 1 секунда.

val gmtime : float -> tm

Преобразует время в секундах, возвращаемое UnixLabels.time, в дату и время. Предполагается UTC (Координированное универсальное время), также известное как GMT. Для выполнения обратного преобразования установите переменную среды TZ в «UTC», используйте UnixLabels.mktime, а затем восстановите исходное значение TZ.

val localtime : float -> tm

Преобразует время в секундах, возвращаемое UnixLabels.time, в дату и время. Предполагается местное часовое поясное время. Функцией, выполняющей обратное преобразование, является UnixLabels.mktime.

val mktime : tm -> float * tm

Преобразует дату и время, указанные аргументом tm, во время в секундах, как возвращает UnixLabels.time. Поля tm_isdst, tm_wday и tm_yday записи tm игнорируются. Также возвращает нормализованную копию переданной записи tm, с пересчитанными полями tm_wday, tm_yday и tm_isdst из других полей, и нормализованными другими полями (например, 40 октября изменяется на 9 ноября). Аргумент tm интерпретируется в местном часовом поясе.

val alarm : int -> int

Планирует сигнал SIGALRM после указанного количества секунд.

Raises Invalid_argument в Windows

val sleep : int -> unit

Останавливает выполнение на заданное количество секунд.

val sleepf : float -> unit

Останавливает выполнение на заданное количество секунд. Подобно sleep, но поддерживаются доли секунд.

Since 4.12.0

val times : unit -> process_times

Возвращает время выполнения процесса.

В Windows: частично реализовано, не будет отображать временные характеристики дочерних процессов.

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

Устанавливает время последнего доступа (второй аргумент) и время последней модификации (третий аргумент) для файла. Время выражено в секундах с момента 00:00:00 по Гринвичу, 1 января 1970 года. Если оба времени 0.0, то время доступа и последней модификации устанавливаются на текущее время.

type interval_timer = Unix.interval_timer =

`\|`	`ITIMER_REAL`	`(*`	уменьшается в реальном времени и отправляет сигнал `SIGALRM` при истечении.	`*)`
`\|`	`ITIMER_VIRTUAL`	`(*`	уменьшается в виртуальном времени процесса и отправляет `SIGVTALRM` при истечении.	`*)`
`\|`	`ITIMER_PROF`	`(*`	(для профилирования) уменьшается как при работе процесса, так и при работе системы от имени процесса; отправляет `SIGPROF` при истечении.	`*)`

Три типа таймеров интервалов.

type interval_timer_status = Unix.interval_timer_status = {

	`it_interval : float;`	`(*`	Период	`*)`
	`it_value : float;`	`(*`	Текущее значение таймера	`*)`

}

Тип, описывающий состояние таймера интервала

val getitimer : interval_timer -> interval_timer_status

Возвращает текущее состояние заданного таймера интервала.

Raises Invalid_argument в Windows

val setitimer : interval_timer ->       interval_timer_status -> interval_timer_status

setitimer t s устанавливает таймер интервала t и возвращает его предыдущее состояние. Аргумент s интерпретируется следующим образом: s.it_value, если не равно нулю, - время до следующего истечения таймера; s.it_interval, если не равно нулю, - значение, используемое для перезагрузки it_value при истечении таймера. Установка s.it_value в ноль отключает таймер. Установка s.it_interval в ноль приводит к отключению таймера после его следующего истечения.

Raises Invalid_argument в Windows

Идентификатор пользователя, идентификатор группы

val getuid : unit -> int

Возвращает идентификатор пользователя, выполняющего процесс.

В Windows: всегда возвращает 1.

val geteuid : unit -> int

Возвращает эффективный идентификатор пользователя, под которым работает процесс.

В Windows: всегда возвращает 1.

val setuid : int -> unit

Устанавливает действительный идентификатор пользователя и эффективный идентификатор пользователя для процесса.

Raises Invalid_argument в Windows

val getgid : unit -> int

Возвращает идентификатор группы пользователя, выполняющего процесс.

В Windows: всегда возвращает 1.

val getegid : unit -> int

Возвращает эффективную группу, под которой выполняется процесс.

В Windows: всегда возвращает 1.

val setgid : int -> unit

Устанавливает реальную и эффективную группу для процесса.

Возбуждает Invalid_argument в Windows

val getgroups : unit -> int array

Возвращает список групп, к которым принадлежит пользователь, выполняющий процесс.

В Windows: всегда возвращает [|1|].

val setgroups : int array -> unit

setgroups groups устанавливает дополнительные идентификаторы групп для вызывающего процесса. Требуются соответствующие привилегии.

Возбуждает Invalid_argument в Windows

val initgroups : string -> int -> unit

initgroups user group инициализирует список доступа к группам, читая базу данных групп /etc/group и используя все группы, членами которых является user. Дополнительная группа group также добавляется в список.

Возбуждает Invalid_argument в Windows

type passwd_entry = Unix.passwd_entry = {

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

}

Структура записей в базе данных passwd.

type group_entry = Unix.group_entry = {

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

}

Структура записей в базе данных groups.

val getlogin : unit -> string

Возвращает имя пользователя, выполняющего процесс.

val getpwnam : string -> passwd_entry

Находит запись в passwd с заданным именем.

Возбуждает Not_found, если такая запись не существует, или всегда в Windows.

val getgrnam : string -> group_entry

Находит запись в group с заданным именем.

Возбуждает Not_found, если такая запись не существует, или всегда в Windows.

val getpwuid : int -> passwd_entry

Находит запись в passwd с заданным идентификатором пользователя.

Возбуждает Not_found, если такая запись не существует, или всегда в Windows.

val getgrgid : int -> group_entry

Находит запись в group с заданным идентификатором группы.

Возбуждает Not_found, если такая запись не существует, или всегда в Windows.

Интернет-адреса

type inet_addr = Unix.inet_addr

Абстрактный тип интернет-адресов.

val inet_addr_of_string : string -> inet_addr

Преобразование из печатного представления интернет-адреса во внутреннее представление. Строка аргумента состоит из 4 чисел, разделенных точками (XXX.YYY.ZZZ.TTT) для адресов IPv4 и до 8 чисел, разделенных двоеточиями, для адресов IPv6.

Возбуждает Failure при вводе строки, которая не соответствует этим форматам.

val string_of_inet_addr : inet_addr -> string

Возвращает печатное представление данного интернет-адреса. См. UnixLabels.inet_addr_of_string для описания печатного представления.

val inet_addr_any : inet_addr

Специальный IPv4-адрес, используемый только с bind, представляющий все интернет-адреса, которыми обладает хост-машина.

val inet_addr_loopback : inet_addr

Специальный IPv4-адрес, представляющий хост-машину (127.0.0.1).

val inet6_addr_any : inet_addr

Специальный IPv6-адрес, используемый только с bind, представляющий все интернет-адреса, которыми обладает хост-машина.

val inet6_addr_loopback : inet_addr

Является ли данный inet_addr IPv6-адресом.

С 4.12.0

Сокеты

type socket_domain = Unix.socket_domain =

`\|`	`PF_UNIX`	`(*`	Домен Unix	`*)`
`\|`	`PF_INET`	`(*`	Домен Интернета (IPv4)	`*)`
`\|`	`PF_INET6`	`(*`	Домен Интернета (IPv6)	`*)`

Тип доменов сокетов. Не все платформы поддерживают сокеты IPv6 (тип PF_INET6).

В Windows: PF_UNIX поддерживается с 4.14.0 в Windows 10 1803 и более поздних версиях.

type socket_type = Unix.socket_type =

`\|`	`SOCK_STREAM`	`(*`	Потоковый сокет	`*)`
`\|`	`SOCK_DGRAM`	`(*`	Сокет дейтаграммы	`*)`
`\|`	`SOCK_RAW`	`(*`	Сокет «сырого» уровня	`*)`
`\|`	`SOCK_SEQPACKET`	`(*`	Сокет для пакетов с упорядоченными последовательностями	`*)`

Тип сокетных видов, определяющий семантику связи. SOCK_SEQPACKET включен для полноты, но редко поддерживается ОС и требует системных вызовов, недоступных в этой библиотеке.

type sockaddr = Unix.sockaddr =

`\|`	`ADDR_UNIX of string`
`\|`	`ADDR_INET of inet_addr * int`

Тип сокетных адресов. ADDR_UNIX name — сокетный адрес в домене Unix; name — имя файла в файловой системе. ADDR_INET(addr,port) — сокетный адрес в интернет-домене; addr — интернет-адрес машины, и port — номер порта.

val socket : ?cloexec:bool ->       domain:socket_domain ->       kind:socket_type -> protocol:int -> file_descr

Создает новый сокет в заданном домене и с заданным видом. Третий аргумент — тип протокола; 0 выбирает протокол по умолчанию для этого вида сокетов. См. UnixLabels.set_close_on_exec для документации по необязательному аргументу cloexec.

val domain_of_sockaddr : sockaddr -> socket_domain

Возвращает домен сокета, соответствующий заданному адресу сокета.

val socketpair : ?cloexec:bool ->       domain:socket_domain ->       kind:socket_type ->       protocol:int -> file_descr * file_descr

Создайте пару сокетов без имен, соединенных вместе. Смотрите UnixLabels.set_close_on_exec для документации по необязательному аргументу cloexec.

val accept : ?cloexec:bool ->       file_descr -> file_descr * sockaddr

Принимайте подключения на заданном сокете. Возвращаемый дескриптор — это сокет, соединённый с клиентом; возвращаемый адрес — это адрес подключающегося клиента. Смотрите UnixLabels.set_close_on_exec для документации по необязательному аргументу cloexec.

val bind : file_descr -> addr:sockaddr -> unit

Привяжите сокет к адресу.

val connect : file_descr -> addr:sockaddr -> unit

Подключите сокет к адресу.

val listen : file_descr -> max:int -> unit

Настройте сокет для приема запросов на подключение. Целочисленный аргумент — максимальное количество ожидающих запросов.

type shutdown_command = Unix.shutdown_command =

`\|`	`SHUTDOWN_RECEIVE`	`(*`	Закрыть для приема	`*)`
`\|`	`SHUTDOWN_SEND`	`(*`	Закрыть для отправки	`*)`
`\|`	`SHUTDOWN_ALL`	`(*`	Закрыть оба	`*)`

Тип команд для shutdown.

val shutdown : file_descr -> mode:shutdown_command -> unit

Закрыть соединение сокета. SHUTDOWN_SEND в качестве второго аргумента приводит к тому, что чтение на другом конце соединения возвращает состояние конца файла. SHUTDOWN_RECEIVE приводит к тому, что записи на другом конце соединения возвращают состояние закрытой трубы (SIGPIPE сигнал).

val getsockname : file_descr -> sockaddr

Возвращает адрес заданного сокета.

val getpeername : file_descr -> sockaddr

Возвращает адрес хоста, подключенного к заданному сокету.

type msg_flag = Unix.msg_flag =

`\|`	`MSG_OOB`
`\|`	`MSG_DONTROUTE`
`\|`	`MSG_PEEK`

Флаги для UnixLabels.recv, UnixLabels.recvfrom, UnixLabels.send и UnixLabels.sendto.

val recv : file_descr ->       buf:bytes -> pos:int -> len:int -> mode:msg_flag list -> int

Получение данных из сокета с установленным соединением.

val recvfrom : file_descr ->       buf:bytes ->       pos:int ->       len:int -> mode:msg_flag list -> int * sockaddr

Получение данных из неустановленного сокета.

val send : file_descr ->       buf:bytes -> pos:int -> len:int -> mode:msg_flag list -> int

Отправка данных по сокету с установленным соединением.

val send_substring : file_descr ->       buf:string -> pos:int -> len:int -> mode:msg_flag list -> int

То же, что и send, но данные берутся из строки вместо последовательности байтов.

Since 4.02.0

val sendto : file_descr ->       buf:bytes ->       pos:int ->       len:int -> mode:msg_flag list -> addr:sockaddr -> int

Отправка данных по неустановленному сокету.

val sendto_substring : file_descr ->       buf:string ->       pos:int ->       len:int -> mode:msg_flag list -> sockaddr -> int

То же, что и sendto, но данные берутся из строки вместо последовательности байтов.

Since 4.02.0

Параметры сокета

type socket_bool_option = Unix.socket_bool_option =

`\|`	`SO_DEBUG`	`(*`	Запись отладочной информации	`*)`
`\|`	`SO_BROADCAST`	`(*`	Разрешить отправку широковещательных сообщений	`*)`
`\|`	`SO_REUSEADDR`	`(*`	Разрешить повторное использование локальных адресов для привязки	`*)`
`\|`	`SO_KEEPALIVE`	`(*`	Сохранять соединение активным	`*)`
`\|`	`SO_DONTROUTE`	`(*`	Обойти стандартные алгоритмы маршрутизации	`*)`
`\|`	`SO_OOBINLINE`	`(*`	Оставить данные вне очереди в очереди	`*)`
`\|`	`SO_ACCEPTCONN`	`(*`	Сообщать, включено ли прослушивание сокета	`*)`
`\|`	`TCP_NODELAY`	`(*`	Управление алгоритмом Nagle для сокетов TCP	`*)`
`\|`	`IPV6_ONLY`	`(*`	Запретить привязку сокета IPv6 к адресу IPv4	`*)`
`\|`	`SO_REUSEPORT`	`(*`	Разрешить повторное использование адресов и портов привязки	`*)`

Параметры сокета, которые можно просмотреть с помощью UnixLabels.getsockopt и изменить с помощью UnixLabels.setsockopt. Эти параметры имеют логическое (true/false) значение.

type socket_int_option = Unix.socket_int_option =

`\|`	`SO_SNDBUF`	`(*`	Размер буфера отправки	`*)`
`\|`	`SO_RCVBUF`	`(*`	Размер буфера приема	`*)`
`\|`	`SO_ERROR`	`(*`	Устарело. Используйте Unix.getsockopt_error вместо этого. Устарело. Используйте `UnixLabels.getsockopt_error` вместо этого.	`*)`
`\|`	`SO_TYPE`	`(*`	Сообщите тип сокета	`*)`
`\|`	`SO_RCVLOWAT`	`(*`	Минимальное количество байт для обработки операций ввода	`*)`
`\|`	`SO_SNDLOWAT`	`(*`	Минимальное количество байт для обработки операций вывода	`*)`

Параметры сокета, которые можно проконсультироваться с UnixLabels.getsockopt_int и изменить с помощью UnixLabels.setsockopt_int. Эти параметры имеют целое значение.

type socket_optint_option = Unix.socket_optint_option =

|

SO_LINGER

(*

Оставаться ли при закрытии подключений, имеющих данные, и на какое время (в секундах)

*)

Параметры сокета, которые можно проконсультироваться с UnixLabels.getsockopt_optint и изменить с помощью UnixLabels.setsockopt_optint. Эти параметры имеют значение типа int option, где None означает «отключено».

type socket_float_option = Unix.socket_float_option =

`\|`	`SO_RCVTIMEO`	`(*`	Тайм-аут для операций ввода	`*)`
`\|`	`SO_SNDTIMEO`	`(*`	Тайм-аут для операций вывода	`*)`

Параметры сокета, которые можно проконсультироваться с UnixLabels.getsockopt_float и изменить с помощью UnixLabels.setsockopt_float. Эти параметры имеют значение с плавающей точкой, представляющее время в секундах. Значение 0 означает бесконечный тайм-аут.

val getsockopt : file_descr -> socket_bool_option -> bool

Возвращает текущее состояние параметра булевого типа в заданном сокете.

val setsockopt : file_descr -> socket_bool_option -> bool -> unit

Установить или сбросить параметр булевого типа в заданном сокете.

val getsockopt_int : file_descr -> socket_int_option -> int

То же, что UnixLabels.getsockopt для параметра сокета с целочисленным значением.

val setsockopt_int : file_descr -> socket_int_option -> int -> unit

То же, что UnixLabels.setsockopt для параметра сокета с целочисленным значением.

val getsockopt_optint : file_descr -> socket_optint_option -> int option

То же, что UnixLabels.getsockopt для параметра сокета, значение которого является int option.

val setsockopt_optint : file_descr ->       socket_optint_option -> int option -> unit

То же, что UnixLabels.setsockopt для параметра сокета, значение которого является int option.

val getsockopt_float : file_descr -> socket_float_option -> float

То же, что UnixLabels.getsockopt для параметра сокета, значение которого является числом с плавающей точкой.

val setsockopt_float : file_descr -> socket_float_option -> float -> unit

То же, что UnixLabels.setsockopt для параметра сокета, значение которого является числом с плавающей точкой.

val getsockopt_error : file_descr -> error option

Возвращает состояние ошибки, связанное с данным сокетом, и очищает его.

Функции высокоуровневого подключения к сети

val open_connection : sockaddr -> in_channel * out_channel

Подключение к серверу по указанному адресу. Возвращает пару буферизованных каналов, подключенных к серверу. Не забудьте вызвать flush на канале вывода в нужные моменты, чтобы обеспечить правильную синхронизацию.

Два канала, возвращенные open_connection, используют один дескриптор сокета. Поэтому, когда подключение завершено, вы должны вызвать close_out на канале вывода, что также закроет базовый сокет. Не вызывайте close_in на канале ввода; его соберёт сборщик мусора.

val shutdown_connection : in_channel -> unit

«Закрытие» соединения, установленного с помощью UnixLabels.open_connection; то есть, передача условия конца файла серверу, читающему на другом конце подключения. Это не закрывает сокет и каналы, используемые соединением. См. Unix.open_connection о том, как их закрыть, когда подключение закончится.

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

Установка сервера по указанному адресу. Переданная в качестве первого аргумента функция вызывается для каждого подключения с двумя буферизованными каналами, подключенными к клиенту. Для каждого подключения создаётся новый процесс. Функция UnixLabels.establish_server никогда не возвращается нормально.

Два канала, переданные функции, используют один дескриптор сокета. Функции не нужно закрывать каналы, так как это происходит автоматически при возврате функции. Если функция предпочитает явное закрытие, она должна закрыть канал вывода с помощью close_out и оставить канал ввода открытым без закрытия, по причинам, объясненным в Unix.in_channel_of_descr.

Возбуждает Invalid_argument в Windows. Используйте потоки вместо этого.

Базы данных хостов и протоколов

type host_entry = Unix.host_entry = {

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

}

Структура записей в базе данных hosts.

type protocol_entry = Unix.protocol_entry = {

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

}

Структура записей в базе данных protocols.

type service_entry = Unix.service_entry = {

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

}

Структура записей в базе данных services.

val gethostname : unit -> string

END_OF_DOCUMENT_MARKER ```

Возвращает имя локального хоста.

val gethostbyname : string -> host_entry

Находит запись в hosts с заданным именем.

Возбуждает Not_found, если такая запись не существует.

val gethostbyaddr : inet_addr -> host_entry

Находит запись в hosts с заданным адресом.

Возбуждает Not_found, если такая запись не существует.

val getprotobyname : string -> protocol_entry

Находит запись в protocols с заданным именем.

Возбуждает Not_found, если такая запись не существует.

val getprotobynumber : int -> protocol_entry

Находит запись в protocols с заданным номером протокола.

Возбуждает Not_found, если такая запись не существует.

val getservbyname : string -> protocol:string -> service_entry

Находит запись в services с заданным именем.

Возбуждает Not_found, если такая запись не существует.

val getservbyport : int -> protocol:string -> service_entry

Находит запись в services с заданным номером службы.

Возбуждает Not_found, если такая запись не существует.

type addr_info = Unix.addr_info = {

`ai_family : socket_domain;`	`(*`	Домен сокета	`*)`
`ai_socktype : socket_type;`	`(*`	Тип сокета	`*)`
`ai_protocol : int;`	`(*`	Номер протокола сокета	`*)`
`ai_addr : sockaddr;`	`(*`	Адрес	`*)`
`ai_canonname : string;`	`(*`	Каноническое имя хоста	`*)`

}

Информация об адресе, возвращаемая UnixLabels.getaddrinfo.

type getaddrinfo_option = Unix.getaddrinfo_option =

`\|`	`AI_FAMILY of socket_domain`	`(*`	Назначить заданный домен сокета	`*)`
`\|`	`AI_SOCKTYPE of socket_type`	`(*`	Назначить заданный тип сокета	`*)`
`\|`	`AI_PROTOCOL of int`	`(*`	Назначить заданный протокол	`*)`
`\|`	`AI_NUMERICHOST`	`(*`	Не вызывать разрешитель имен, ожидать числовой IP-адрес	`*)`
`\|`	`AI_CANONNAME`	`(*`	Заполнить поле `ai_canonname` результата	`*)`
`\|`	`AI_PASSIVE`	`(*`	Установить адрес на адрес «любой» для использования с `UnixLabels.bind`	`*)`

Параметры для UnixLabels.getaddrinfo.

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

getaddrinfo host service opts возвращает список записей UnixLabels.addr_info, описывающих параметры сокета и адреса, подходящие для связи с заданным хостом и службой. Если имена хоста или службы неизвестны, или ограничения, выраженные в opts, не могут быть выполнены, возвращается пустой список.

host — это имя хоста или строковое представление IP-адреса. host может быть задано как пустая строка; в этом случае используется адрес «любой» или адрес «обратной петли», в зависимости от того, содержит ли opts AI_PASSIVE. service — это имя службы или строковое представление номера порта. service может быть задано как пустая строка; в этом случае поле порта возвращаемых адресов устанавливается в 0. opts — это, возможно, пустой список параметров, который позволяет вызывающей стороне принудительно установить определённый домен сокета (например, только IPv6 или только IPv4) или определённый тип сокета (например, только TCP или только UDP).

type name_info = Unix.name_info = {

	`ni_hostname : string;`	`(*`	Имя или IP-адрес хоста	`*)`
	`ni_service : string;`	`(*`	Имя службы или номер порта	`*)`

}

Информация о хосте и службе, возвращаемая UnixLabels.getnameinfo.

type getnameinfo_option = Unix.getnameinfo_option =

`\|`	`NI_NOFQDN`	`(*`	Не квалифицировать имена локального хоста	`*)`
`\|`	`NI_NUMERICHOST`	`(*`	Всегда возвращать хост в виде IP-адреса	`*)`
`\|`	`NI_NAMEREQD`	`(*`	Ошибка, если имя хоста не может быть определено	`*)`
`\|`	`NI_NUMERICSERV`	`(*`	Всегда возвращать службу как номер порта	`*)`
`\|`	`NI_DGRAM`	`(*`	Рассматривать службу как основанную на UDP вместо стандартного TCP	`*)`

Параметры для UnixLabels.getnameinfo.

val getnameinfo : sockaddr ->       getnameinfo_option list -> name_info

getnameinfo addr opts возвращает имя хоста и имя службы, соответствующие адресу сокета addr. opts — это, возможно, пустой список параметров, определяющий, как получить эти имена.

Raises Not_found если произошла ошибка.

Интерфейс терминала

Следующие функции реализуют стандарт POSIX интерфейса терминала. Они обеспечивают управление асинхронными портами связи и псевдотерминалами. Для получения полного описания обратитесь к странице справки termios.

type terminal_io = Unix.terminal_io = {

`mutable c_ignbrk : bool;`	`(*`	Игнорировать условие прерывания.	`*)`
`mutable c_brkint : bool;`	`(*`	Сигнализировать прерывание при условии прерывания.	`*)`
`mutable c_ignpar : bool;`	`(*`	Игнорировать символы с ошибками чётности.	`*)`
`mutable c_parmrk : bool;`	`(*`	Помечать ошибки чётности.	`*)`
`mutable c_inpck : bool;`	`(*`	Включить проверку чётности на входе.	`*)`
`mutable c_istrip : bool;`	`(*`	Удалять 8-й бит у входных символов.	`*)`
`mutable c_inlcr : bool;`	`(*`	Преобразовывать NL в CR на входе.	`*)`
`mutable c_igncr : bool;`	`(*`	Игнорировать CR на входе.	`*)`
`mutable c_icrnl : bool;`	`(*`	Преобразовывать CR в NL на входе.	`*)`
`mutable c_ixon : bool;`	`(*`	Распознавать символы XON/XOFF на входе.	`*)`
`mutable c_ixoff : bool;`	`(*`	Выводить символы XON/XOFF для управления потоком ввода.	`*)`
`mutable c_opost : bool;`	`(*`	Включить обработку вывода.	`*)`
`mutable c_obaud : int;`	`(*`	Скорость вывода (0 означает закрытие соединения).	`*)`
`mutable c_ibaud : int;`	`(*`	Скорость ввода.	`*)`
`mutable c_csize : int;`	`(*`	Количество бит на символ (5-8).	`*)`
`mutable c_cstopb : int;`	`(*`	Количество стоповых бит (1-2).	`*)`
`mutable c_cread : bool;`	`(*`	Приём включён.	`*)`
`mutable c_parenb : bool;`	`(*`	Включить генерацию и детектирование чётности.	`*)`
`mutable c_parodd : bool;`	`(*`	Установить нечётную чётность вместо чётной.	`*)`
`mutable c_hupcl : bool;`	`(*`	Прерывание при последнем закрытии.	`*)`
`mutable c_clocal : bool;`	`(*`	Игнорировать линии статуса модема.	`*)`
`mutable c_isig : bool;`	`(*`	Генерировать сигнал на INTR, QUIT, SUSP.	`*)`
`mutable c_icanon : bool;`	`(*`	Включить каноническую обработку (буферизация и редактирование строки).	`*)`
`mutable c_noflsh : bool;`	`(*`	Отключить сброс после INTR, QUIT, SUSP.	`*)`
`mutable c_echo : bool;`	`(*`	Эхо входных символов.	`*)`
`mutable c_echoe : bool;`	`(*`	Эхо ERASE (для стирания предыдущего символа).	`*)`

`mutable c_echok : bool;`	`(*`	Эхо KILL (для удаления текущей строки).	`*)`
`mutable c_echonl : bool;`	`(*`	Эхо NL, даже если c_echo не задано.	`*)`
`mutable c_vintr : char;`	`(*`	Символ прерывания (обычно Ctrl-C).	`*)`
`mutable c_vquit : char;`	`(*`	Символ выхода (обычно Ctrl-\).	`*)`
`mutable c_verase : char;`	`(*`	Символ стирания (обычно DEL или Ctrl-H).	`*)`
`mutable c_vkill : char;`	`(*`	Символ удаления строки (обычно Ctrl-U).	`*)`
`mutable c_veof : char;`	`(*`	Символ конца файла (обычно Ctrl-D).	`*)`
`mutable c_veol : char;`	`(*`	Альтернативный символ конца строки (обычно отсутствует).	`*)`
`mutable c_vmin : int;`	`(*`	Минимальное количество символов для чтения перед удовлетворением запроса на чтение.	`*)`
`mutable c_vtime : int;`	`(*`	Максимальное время ожидания чтения (в единицах 0,1 секунды).	`*)`
`mutable c_vstart : char;`	`(*`	Символ начала (обычно Ctrl-Q).	`*)`
`mutable c_vstop : char;`	`(*`	Символ остановки (обычно Ctrl-S).	`*)`

}

val tcgetattr : file_descr -> terminal_io

Возвращает состояние терминала, связанного с заданным дескриптором файла.

Raises Invalid_argument на Windows

type setattr_when = Unix.setattr_when =

`\|`	`TCSANOW`
`\|`	`TCSADRAIN`
`\|`	`TCSAFLUSH`

val tcsetattr : file_descr ->       mode:setattr_when -> terminal_io -> unit

Устанавливает состояние терминала, связанного с заданным дескриптором файла. Второй аргумент указывает, когда происходит изменение состояния: немедленно (TCSANOW), когда все ожидаемые данные вывода были переданы (TCSADRAIN), или после сброса всех полученных, но не прочитанных данных ввода (TCSAFLUSH). Рекомендуется использовать TCSADRAIN при изменении параметров вывода; TCSAFLUSH — при изменении параметров ввода.

Raises Invalid_argument на Windows

val tcsendbreak : file_descr -> duration:int -> unit

Отправляет условие прерывания для заданного дескриптора файла. Второй аргумент — продолжительность прерывания в единицах 0,1 с; 0 означает стандартную продолжительность (0,25 с).

Raises Invalid_argument на Windows

val tcdrain : file_descr -> unit

Ожидает, пока все данные вывода, записанные в заданный дескриптор файла, будут переданы.

Raises Invalid_argument на Windows

type flush_queue = Unix.flush_queue =

`\|`	`TCIFLUSH`
`\|`	`TCOFLUSH`
`\|`	`TCIOFLUSH`

val tcflush : file_descr -> mode:flush_queue -> unit

Отбрасывает данные, записанные в заданный дескриптор файла, но еще не переданные, или данные, полученные, но еще не прочитанные, в зависимости от второго аргумента: TCIFLUSH сбрасывает полученные, но не прочитанные данные, TCOFLUSH сбрасывает данные, записанные, но не переданные, и TCIOFLUSH сбрасывает оба типа данных.

Raises Invalid_argument на Windows

type flow_action = Unix.flow_action =

`\|`	`TCOOFF`
`\|`	`TCOON`
`\|`	`TCIOFF`
`\|`	`TCION`

val tcflow : file_descr -> mode:flow_action -> unit

Приостанавливает или возобновляет прием или передачу данных по заданному дескриптору файла, в зависимости от второго аргумента: TCOOFF приостанавливает вывод, TCOON возобновляет вывод, TCIOFF отправляет символ STOP для приостановки ввода, и TCION отправляет символ START для возобновления ввода.

Raises Invalid_argument на Windows

val setsid : unit -> int

Переводит вызывающий процесс в новую сессию и отсоединяет его от контролирующего терминала.

Raises Invalid_argument на Windows