# Index of types

A
ac_by_host [Nethttpd_services] | The service is protected by the access control rule
ac_by_host_rule [Nethttpd_services] | Access control by host: ``Allow`: Only the listed hosts are allowed; all other are denied, ``Deny`: The listed hosts are denied; all other are allowed
action [Ftp_client.Action] |
addr_spec [Netaddress] | The pair `local_part@domain` as O'Caml type.
address [Netplex_types] |
announcement [Nethttpd_kernel] | See config
arg_store [Netcgi] | This is the type of functions `arg_store` so that `arg_store env name header` tells whether to ``Discard` the argument or to store it into a ``File` or in ``Memory`.
arg_store [Netcgi_common] | See `Netcgi.arg_store`.
arg_store_type [Netcgi_common] |
argument_processing [Netcgi1_compat.Netcgi] |
assignment [Shell] | An assignment redirects file descriptors while calling a process
auth_peeker [Rpc_server] |
auth_result [Rpc_server] |
B
bad_request_error [Nethttpd_kernel] | A bad request is a violation where the current request cannot be decoded, and it is not possible to accept further requests over the current connection.
binding [Rpc_server] |
binding_async [Rpc_server] |
binding_sync [Rpc_server] |
C
cache_control [Netcgi1_compat.Netcgi_types] |
cache_control [Netcgi] | This is only a small subset of the HTTP 1.1 cache control features, but they are usually sufficient, and they work for HTTP/1.0 as well.
cache_control [Netcgi_common] | See `Netcgi.cache_control`.
cache_control_token [Nethttp] | The cache control token for the `Cache-control` header
call_args [Rpc_portmapper_aux] |
call_result [Rpc_portmapper_aux] |
capacity [Netplex_types] | How many connections a container can accept in addition to the existing connections: ``Normal_quality n`: It can accept n connections with normal service quality, `n > 0`, ``Low_quality n`: It can accept n connections with low service quality (e.g. because it is already quite loaded), `n > 0`, ``Unavailable`: No capacity free
cgi_config [Netcgi1_compat.Netcgi_env] | Now simply called `Netcgi.config`.
cgi_cookie [Netcgi1_compat.Netcgi_types] |
charset [Netconversion] | A `charset` is simply a set of code points.
close_mode [Netchannels] | Whether a `close_out` implies a commit or rollback operation
cmd [Ftp_client] | An FTP command.

cmd_state [Ftp_client]

The command state: ``Init`: Just connected, no greeting message arrived yet, ``Success`: Got the greeting message/last command was successful, ``Proto_error`: currently unused, ``Temp_failure`: Last command was not successful, and the code was between 400 and 499, ``Perm_failure`: Last command was not successful, and the code was between 500 and 599, ``Rename_seq`: Used instead of ``Success` after the RNFR command, ``Restart_seq`: Used instead of ``Success` after the REST command, ``User_pass_seq`: Used instead of ``Success` after the USER command when a password must be typed in, ``User_acct_seq`: Used instead of ``Success` after the USER command when an account ID must be typed in, ``Pass_acct_seq`: Used instead of ``Success` after the PASS command when an account iD must be typed in, ``Preliminary`: a reply with code 100 to 199. There will be another final reply for the command

cmdline_config [Netplex_main] |
command [Shell_sys] | A command describes how to start a new process
complex_mime_body [Netmime] |
complex_mime_body_ro [Netmime] | The read-only view of a complex_mime_message
complex_mime_message [Netmime] |
complex_mime_message_ro [Netmime] |
config [Netcgi] |
config [Netcgi_common] | See `Netcgi.config`.
config_log_error [Nethttpd_plex] |
config_tree [Netplex_types] |
connect_address [Uq_engines] | Specifies the service to connect to:
connect_options [Uq_engines] |
connect_status [Uq_engines] | This type corresponds with `Uq_engines.connect_address`: An engine connecting with an address `X will return a status of `X.
connection [Netcgi_dbi.DBI_DRIVER] |
connection [Netcgi_dbi.DBI_POOL] |
connection_cache [Http_client] |
connection_directive [Netcgi] | Directive how to go on with the current connection: ``Conn_close`: Just shut down and close descriptor, ``Conn_close_linger`: Linger, shut down, and close descriptor, ``Conn_keep_alive`: Check for another request on the same connection, ``Conn_error e`: Shut down and close descriptor, and handle the exception `e`
connection_id [Rpc_server] | identifies the connection of a session.
connector [Rpc_xti_client] | Same as `Rpc_key_service.connector`
connector [Rpc_server] |
connector [Rpc_client] |
connector [Rpc_key_service] | How to connect to keyserv: ``Direct(c,p)`: Create a direct RPC connection to the keyserv program listening at `c` using protocol `p`. This usually only works if `c` is a local transport like Unix Domain., ``Keyenvoy path`: Call the `keyenvoy` program installed at `path`
consumer [Shell] | A consumer receives data from a called process
container_id [Netplex_types] | Identifies a container

container_state [Netplex_types]

The container state for workload management: ``Accepting(n,t)`: The container is accepting further connections. It currently processes `n` connections. The last connection was accepted at time `t` (seconds since the epoch)., ``Busy`: The container does not accept connections, ``Starting t`: The container was started at time `t` and is not yet ready., ``Shutting_down`: The container is being shutted down.

cookie [Nethttp] |
copy_task [Uq_engines] | Specifies the task the `copier` class has to do:
ctrl_op [Netshm] |
cursor [Netconversion] | A cursor denotes a character position in an encoded string
D
data_chunk [Nethttpd_kernel] | A `data_chunk` is a substring of a string.
data_manager [Netshm_data] | The data manager consists of several manager functions.
datagram_type [Uq_engines] | - ``Unix_dgram`: Datagrams over Unix domain sockets ``Inet_udp`: Internet v4 UDP protocol, ``Inet6_udp`: Internet v6 UDP protocol
descr_state [Ftp_data_endpoint] | Describes the state of the socket used for data transfers.
document [Nethtml] | The type `document` represents parsed HTML documents:
domain [Netaddress] | The domain of the mailbox
dynamic_service [Nethttpd_services] |
E
element_class [Nethtml] | Element classes are a property used in the HTML DTD.
encoding [Netconversion] | The polymorphic variant enumerating the supported encodings.
engine_req_state [Nethttpd_engine] |

engine_state [Uq_engines]

The type of states with result values of type `'t`: ``Working n`: The engine is working. The number `n` counts the number of events that have been processed., ``Done arg`: The engine has completed its task without errors. The argument `arg` is the result value of the engine, ``Error exn`: The engine has aborted because of an error. The argument `exn` describes the error as an exception., ``Aborted`: The engine has aborted because the `abort` method was called

entity_set [Netencoding.Html] |
environment [Shell_sys] | The abstract type of a process environment
etag [Nethttp] | Entity tags can be weak or strong
event [Unixqueue] | An `event` is triggered when the condition of an `operation` becomes true, when a signal happens, or when the event is (artificially) added to the event queue (`add_event`, below).
exn_handler [Netcgi] | A function of type `exn_handler` allows to define a custom handler of uncaught exceptions raised by the `unit -> unit` parameter.
F
fatal_error [Nethttpd_kernel] | These are the serious protocol violations after that the daemon stops any further processing.

file_option [Nethttpd_services]

Add-on features for file services: ``Enable_gzip`: If enabled, files ending in `.gz` are assumed to be in `gzip` compression. When there is both the base file and the gzip file ending in `.gz`, accesses to the base file (!) are transmitted with `gzip` compression., ``Enable_index_file`: If enabled, accesses to directories are redirected to index files. The possible file names are given in the string list. E.g. ``Enable_index_file ["index.html"; "index.htm"]`. It is redirected to these files, so these can be handled by different services if neccessary., ``Enable_listings`: If enabled, directory listings are generated by calling the argument function. The `PATH_TRANSLATED` property of the environment contains the absolute name of the directory to list. The `PATH_INFO` property is the corresponding URI path. `SCRIPT_NAME` is meaningless.

file_service [Nethttpd_services] | Describes a file service

filename [Ftp_client]

There are several methods how to specify filenames: ``NVFS name`: The "Network Virtual File System" is the normal way of accessing FTP files. The client walks into the directory containing the file using `CWD` and `CDUP` commands, and calls the file operation from this directory. For simplicity, this client interprets slashes in `name` as path component separators. The FTP server will never see these slashes., ``Verbatim name`: The string `name` is passed to the server without transforming it in any way. In the future, there will be a third way of referring to files: TVFS, the "Trivial Virtual File System".

form_code [Ftp_client] | The `form_code` has a meaning when FTP is used to print files: ``Non_print`: This is not the case., ``Telnet`: Telnet control codes are used for vertical movement, ``ASA`: ASA (Fortran) control codes are used for vertical movement
fp4 [Rtypes] | single precision float
fp8 [Rtypes] | double precision float
from_uni_list [Netmappings] |
front_token [Nethttpd_kernel] | Tokens generated by `http_response`: ``Resp_wire_data` are data tokens., ``Resp_end` indicates the end of the response.
ftp_state [Ftp_client] | The ftp_state reflects the knowledge of the client about what has been agreed upon with the server.
G
group [Unixqueue] | A group is an abstract tag for a set of events, resources, and event handlers.
group_action [Shell_sys] | Determines in which process group the new process will run
group_mode [Shell_sys] | Specifies how the job instance is related to process groups
H
header_kind [Http_client] | The ``Base` header is set by the user of `http_call` and is never changed during processing the call.
host [Nethttpd_services] | For name- and IP-based virtual hosting this record describes the individual host.
host_distributor [Nethttpd_services] | Describes virtual hosting by pairs `(host,service)`: If `host` matches the incoming request, the corresponding `service` is performed to generate the response.
how_to_reconnect [Http_client] | How to deal with automatic reconnections, especially when the connection crashes.
how_to_redirect [Http_client] |
http_method [Nethttp] | Method name, URI
http_options [Http_client] | Options for the whole pipeline

http_service_reaction [Nethttpd_types]

Indicates the immediate reaction upon an arriving HTTP header: ``Accept_body` is the regular way of processing requests. If necessary, the client is told to continue sending the rest of the request., ``Reject_body` can be used when the body of the request is not needed, and the response will be negative., ``Static` means to send the header and a constant string back as response. The header is taken from the environment if not explicitly passed, Note: The `Content-Length` header is automatically added. The `Content-Type` defaults to "text/html"., ``File` is similar to this, but the data come from a file. The file is specified by an absolute pathname. The range of the file is given by the start position and the length of the range. The header is taken from the environment if not explicitly passed, Note: The `Content-Length` header is automatically added. The `Content-Type` defaults to "text/html"., ``Std_response` is similar to ``Static`, however the body is the standard text for the status code. If the header is omitted, it is taken as empty. The third argument is an optional entry into the error log. Note: The `Content-Length` header is automatically added. The `Content-Type` defaults to "text/html".

http_status [Nethttp] | HTTP response status:
I
identity [Rpc_auth_sys] | Specifies the user: ``Effective_user`: Take the effective user of the process, ``Real_user`: Take the real user of the process, ``This_user(uid,gid,sup_groups,hostname)`: Pretend to be this user
input_mode [Netcgi1_compat.Netcgi_env] | This is not used anywhere.
input_result [Netchannels] | This type is for the method `enhanced_input` of `enhanced_raw_in_channel`.
input_state [Netcgi1_compat.Netcgi_env] | This is not the business of the user.
int32_array [Netshm] |
int4 [Rtypes] | 32 bit signed integer
int8 [Rtypes] | 64 bit signed integer
J
job [Shell_sys] |
job_instance [Shell_sys] |
job_status [Shell_sys] | Indicates the status of the job
L
level [Netplex_types] |
lexbuf [Netulex.Ulexing] |
linear_distributor [Nethttpd_services] | Services are selected by calling the selector function.
listen_address [Uq_engines] | Specifies the resource to listen on:
listen_options [Uq_engines] |
local_part [Netaddress] | Usually the user name
local_receiver [Ftp_data_endpoint] | The `local_receiver` is the object that gets the data received over the data connection.
local_sender [Ftp_data_endpoint] | The `local_sender` is the object that provides the data sent over the data connection.
locking_method [Netshm] | The locking method is used to ensure that parallel read and write operations to the memory object do not interfer with each other.
M
mapping [Rpc_portmapper_aux] |
method_distributor [Nethttpd_services] | The first service is selected for which the method filter accepts the request
method_filter [Nethttpd_services] | The request is only accepted if listed (for ``Limit`), or if not listed (for ``Limit_except`).
mime_message [Netmime] | Simple MIME message, in a form that is compatible with complex ones.
mime_message_ro [Netmime] | Read-only variant of simple messages
mime_scanner [Mimestring] | The opaque type of a scanner for structured values
mode [Rpc] |
mode2 [Rpc_server] | Determines the type of the server for `create2`:
mode2 [Rpc_client] | Determines the type of the client for `create2`:

model_constraint [Nethtml]

Model constraints define the possible sub elements of an element: ``Inline`: The sub elements must belong to the class ``Inline`, ``Block`: The sub elements must be members of the classes ``Block` or ``Essential_block`, ``Flow`: The sub elements must belong to the classes ``Inline`, ``Block`, or ``Essential_block`, ``Empty`: There are no sub elements, ``Any`: Any sub element is allowed, ``Special`: The element has special content (e.g. `<script>`). Functionally equivalent to ``Empty`, ``Elements l`: Only these enumerated elements may occur as sub elements, ``Or(m1,m2)`: One of the constraints `m1` or `m2` must hold, ``Except(m1,m2)`: The constraint `m1` must hold, and `m2` must not hold, ``Sub_exclusions(l,m)`: The constraint `m` must hold; furthermore, the elements enumerated in list `l` are not allowed as direct or indirect subelements, even if `m` or the model of a subelement would allow them. The difference to ``Except(m, `Elements l)` is that the exclusion is inherited to the subelements. The ``Sub_exclusions` expression must be toplevel, i.e. it must not occur within an ``Or`, ``Except`, or another `'Sub_exclusions` expression. Note that the members of the class ``Everywhere` are allowed everywhere, regardless of whether the model constraint allows them or not.

mountpoint [Netcgi_plex] |

multipart_style [Netmime]

How to parse multipart messages: ``None`: Do not handle multipart messages specially. Multipart bodies are not further decoded, and returned as ``Body b` where `b` is the transfer-encoded text representation., ``Flat`: If the top-level message is a multipart message, the parts are separated and returned as list. If the parts are again multipart messages, these inner multipart messages are not furher decoded and returned as ``Body b`., ``Deep`: Multipart messages are recursively decoded and returned as tree structure. This value determines how far the `complex_mime_message` structure is created for a parsed MIME message.

O
onshutdown_in_spec [Uq_engines] | See class `input_async_mplex` for explanations
onshutdown_out_spec [Uq_engines] | See class `output_async_mplex` for explanations
operating_type [Netcgi1_compat.Netcgi] |
operation [Unixqueue] | An `operation` specifies the condition to wait for.
other_url_spec [Netcgi1_compat.Netcgi_types] |
other_url_spec [Netcgi] | Determines how an URL part is generated: ``Env`: Take the value from the environment., ``This v`: Use this value `v`. It must already be URL-encoded., ``None`: Do not include this part into the URL.
other_url_spec [Netcgi_common] | See `Netcgi.other_url_spec`.
output_mode [Netcgi1_compat.Netcgi_env] | This is not used anywhere.
output_state [Netcgi1_compat.Netcgi_env] | This is not the business of the user.
output_type [Netcgi] | The ouput type determines how generated data is buffered.
output_type [Netcgi_common] | See `Netcgi.output_type`.
P
packed_value [Rpc_packer] |
parallelization_type [Netplex_types] | Type of parallelization: ``Multi_processing` on a single host, ``Multi_threading` on a single host, ``Controller_attached` means that the service runs within the controller. This is (for now) only allowed for controller-internal services.
param_value [Netplex_types] |
param_value_or_any [Netplex_types] |
pattern [Netaux.KMP] |
plan [Ftp_client.Action] |
pmaplist [Rpc_portmapper_aux] |
pmaplist_p [Rpc_portmapper_aux] |
port [Ftp_client] | The port of the data connection: ``Active` means that the server initiates the data connection to the listening client, and in the case of ``Passive` the client initiates the data connection to the listening server.
private_api [Http_client] | The private part of the `http_call` class type
process [Shell_sys] | A process is the running instance of a command (a Unix process)
process_event [Shell_sys] | Events used by `wait`
producer [Shell] | A producer generates data sent to a called process
protocol [Rpc] |
protocol [Nethttp] | The base protocol.
protocol [Netcgi1_compat.Netcgi_env] |
protocol_attribute [Nethttp] |
protocol_attribute [Netcgi1_compat.Netcgi_env] |
protocol_version [Nethttp] |
protocol_version [Netcgi1_compat.Netcgi_env] |
Q
query_string_spec [Netcgi1_compat.Netcgi_types] |
query_string_spec [Netcgi] | Determines how the query part of URLs is generated: ``Env`: The query string of the current request., ``This l`: The query string is created from the specified argument list `l`., ``None`: The query string is omitted., ``Args`: deprecated, use ``This` (left for backward compatibility).
query_string_spec [Netcgi_common] | See `Netcgi.query_string_spec`.
R
regexp [Netstring_pcre] | The type of regular expressions; now based on `Pcre`
regexp [Netstring_str] | The type of regular expressions; now based on `Pcre`
reply [Ftp_client] | Reply code plus text

representation [Ftp_client]

The representation of the transferred file: ``ASCII`: An ASCII variant is used, i.e. the server sends files in ASCII encoding with CR/LF as end-of-line marker. Supported by all servers., ``EBCDIC`: An EBCDIC variant is used, i.e. the server sends files in EBCDIC encoding with NEL as end-of-line marker, ``Image`: The file is transferred in its original binary representation. Supported by all servers. "Local" representations are not supported.

representation [Netcgi1_compat.Netcgi_types] | Embedded in the single place of use.
representation [Netcgi_common] |

req_token [Nethttpd_kernel]

A `req_token` represents a textual part of the received request: ``Req_header` is the full received header. Together with the header, the corresponding `http_response` object is returned which must be used to transmit the response., ``Req_expect_100_continue` is generated when the client expects that the server sends a "100 Contínue" response (or a final status code) now. One should add ``Resp_info_line resp_100_continue` to the send queue if the header is acceptable, or otherwise generate an error response. In any case, the rest of the request must be read until ``Req_end`., ``Req_body` is a part of the request body. The transfer-coding, if any, is already decoded., ``Req_trailer` is the received trailer, ``Req_end` indicates the end of the request (the next request may begin immediately)., ``Eof` indicates the end of the stream, ``Bad_request_error` indicates that the request violated the HTTP protocol in a serious way and cannot be decoded. It is required to send a "400 Bad Request" response. The following token will be ``Eof`., ``Fatal_error` indicates that the connection crashed. The following token will be ``Eof`., ``Timeout` means that nothing has been received for a certain amount of time, and the protocol is in a state that the next request can begin. The following token will be ``Eof`. Note that it is always allowed to `send` tokens to the client.

request_line [Nethttpd_kernel] | The method (including the URI), and the HTTP version
request_method [Netcgi1_compat.Netcgi_types] |
request_method [Netcgi_common] |
resolver [Http_client] | A name resolver is a function `r` called as `r esys name reply`.

resp_state [Nethttpd_kernel]

The response state: ``Inhibited` = it is not yet allowed to start the response, ``Queued` = the response waits on the queue for activation, ``Active` = the response is currently being transmitted, ``Processed` = the response has been completely sent, ``Error` = an error occurred during the transmission of this response, ``Dropped` = an earlier response forced to close the connection, and this response is dequeued

resp_token [Nethttpd_kernel]

The `resp_token` represents a textual part of the response to send: ``Resp_info_line` is an informational status line (code=100..199). There can be several informational lines, and they can be accompanied with their own headers. Such lines are only sent to HTTP/1.1 clients., ``Resp_status_line` is the final status line to send (code >= 200), ``Resp_header` is the whole response header to send, ``Resp_body` is the next part of the response body to send., ``Resp_trailer` is the whole response trailer to send (currently ignored), ``Resp_action` is special because it does not directly represent a token to send. The argument is a function which is called when the token is the next token on the active event queue. The function is also called when the event queue is dropped because of an error (the state of the response object indicates this). The function must not raise exceptions except `Unix_error`, and it must not block.

response_body_storage [Http_client] | How to create the response body: ``Memory`: The response body is in-memory, ``File f`: The response body is stored into the file whose name is returned by `f()`, ``Body f`: The response body is stored into the object returned by `f()`
result [Rpc_transport] |
result [Netstring_pcre] | The type of matching results
result [Netstring_str] | The type of matching results
result_eof [Rpc_transport] |
rule [Rpc_server] |
runner [Uq_tcl] |
runner [Uq_gtk] |
S
s_extended_token [Mimestring] | An opaque type containing the information of `s_token` plus: where the token occurs, RFC-2047 access functions
s_option [Mimestring] |
s_param [Mimestring] | The type of encoded parameters (RFC 2231)

s_token [Mimestring]

A token may be one of: `QString s`: The quoted string `s`, i.e a string between double quotes. Quoted pairs are already decoded in `s`., `Control c`: The control character `c` (0-31, 127, 128-255), `Special c`: The special character `c`, i.e. a character from the `specials` list, `DomainLiteral s`: The bracketed string `s`, i.e. a string between brackets. Quoted pairs are already decoded in `s`., `Comment`: A string between parentheses. This kind of token is only generated when the option `Return_comments` is in effect., `EncodedWord((charset,lang),encoding,encoded_word)`: An RFC-2047 style encoded word: `charset` is the name of the character set; `lang` is the language specifier (from RFC 2231) or ""; `encoding` is either "Q" or "B"; and `encoded_word` is the word encoded in `charset` and `encoding`. This kind of token is only generated when the option `Recognize_encoded_words` is in effect (if not, `Atom` is generated instead)., `Atom s`: A string which is neither quoted not bracketed nor written in RFC 2047 notation, and which is not a control or special character, i.e. the "rest", `End`: The end of the string

server_error [Rpc] |
session [Rpc_server] | identifies a pair of a call and a reply
shm_descr [Netshm] | A shared memory descriptor refers to a shared memory object.
shm_name [Netshm] | A `shm_name` is a name for a shared memory object.
shm_open_flag [Netsys] |
shm_table [Netshm] |
shm_type [Netshm] |
simplified_dtd [Nethtml] | A `simplified_dtd` is an associative list of tuples `(element_name, (element_class, constraint))`: For every `element_name` it is declared that it is a member of `element_class`, and that the sub elements must satisfy `constraint`.
sockaddr [Rpc_transport] |

socket_state [Netplex_types]

The state of a socket: ``Enabled`: The controller allows containers to accept connections. Note that this does not necessarily means that there such containers., ``Disabled`: It is not allowed to accept new connections. The socket is kept open, however., ``Restarting b`: The containers are being restarted. The boolean argument says whether the socket will be enabled after that., ``Down`: The socket is down/closed

sockspec [Uq_engines] | Extended names for socket addresses.
split_result [Netstring_pcre] |
split_result [Netstring_str] |
state [Netpop] |

status [Http_client]

Condensed status information of a HTTP call: ``Unserved`: The call has not yet been finished, ``HTTP_protocol_error e`: An error on HTTP level occurred. Corresponds to the exception `Http_protocol`., ``Successful`: The call is successful, and the response code is between 200 and 299., ``Redirection`: The call is successful, and the response code is between 300 and 399., ``Client_error`: The call failed with a response code between 400 and 499., ``Server_error`: The call failed for any other reason.

status [Netcgi1_compat.Netcgi_types] |
status_line [Nethttpd_kernel] | = (code, phrase)
std_activation [Nethttpd_services] | The way the `Netcgi_types.cgi_activation` object is created.
std_activation_options [Nethttpd_services] | These are options for ``Std_activation`.
store [Netmime] | Specifies where to store the body of a mail message.
store [Netcgi1_compat.Netcgi_types] | Embedded in the single place of use.
store [Netcgi_common] |

structure [Ftp_client]

The client supports two structures: ``File_structure`: Files are simply contiguous streams of bytes, ``Record_structure`: Files are sequences of records. FTP does not make a difference between variable and fixed length records. It is not forbidden that the records are themselves structured into lines, in fact it can happen that end-of-line markers are contained in binary records. Operating systems that support record-structured files often store text files in this format, i.e. every line is stored in its own record, without end-of-line marker. If record structure is selected by a STRU command, it is recommended to use the classes `Ftp_data_endpoint.out_record_channel` and `Ftp_data_endpoint.in_record_channel` for the local representation of the files, otherwise the records may be incorrectly mapped to the local conventions. Page-structured files (i.e.

synchronization [Http_client] | This type determines whether to keep requests and responses synchronized or not.
system_handler [Shell_sys] | There are two record components:
T
t [Rpc_server] | represents a server for an RPC program
t [Rpc_portmapper] | represents a client for the portmapper
t [Rpc_simple_client] | The type of simple clients
t [Rpc_client] | The type of RPC clients
t [Rpc_program] | Type of RPC programs
t [Rpc_key_service] | represents a client of the keyserv daemon
t [Netdate] |
t [Netbuffer] |
t [Netaddress] | The union of `mailbox` and `group`
t [Netshm_array] |
t [Netshm_hashtbl] |
t [Netcgi.Cookie] | Mutable cookie type.
t [Netcgi_common.Cookie] |
t [Equeue] | This is the type of an event system with events of type 'a
t_PMAP'V2'pmapproc_callit'arg [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_callit'res [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_dump'arg [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_dump'res [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_getport'arg [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_getport'res [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_null'arg [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_null'res [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_set'arg [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_set'res [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_unset'arg [Rpc_portmapper_aux] |
t_PMAP'V2'pmapproc_unset'res [Rpc_portmapper_aux] |
telnet_command [Telnet_client] | A `telnet_command` is the interpretation of the octets in a Telnet session, i.e.

telnet_connector [Telnet_client]

Connectors: `Telnet_connect(host,port)`: The client connects to this port., `Telnet_socket s`: The client uses an already connected socket. Why `Telnet_socket`? Telnet is a symmetrical protocol; client and servers implement the same protocol features (the only difference is the environment: a client is typically connected with a real terminal; a server is connected with a pseudo terminal).

telnet_negotiated_option [Telnet_client] | `telnet_negotiated_option`: names for the most common options, and the generic name `Telnet_option` for other options.

telnet_option_state [Telnet_client]

An option has one of three states: `Not_negotiated`: There was no negotiation about the option. This means that the option is turned off (but this client is allowed to reject it explicitly), `Accepted`: Both sides have accepted the option., `Rejected`: One side has rejected the option. This also means that the option is off, but the client refuses to send further acknoledgements that the option is off (to avoid endless negotiation loops).

telnet_options [Telnet_client] | `telnet_options`: modifies the behaviour of the client.
text_data_repr [Ftp_data_endpoint] | Possible representation of text data: ``ASCII` means an ASCII-compatible encoding where the newline character is represented by CR/LF.
transfer_coding [Nethttpd_kernel] |
transmission_mode [Ftp_client] | The transmission mode selects how the data are encoded in the data connection.
transmission_mode [Ftp_data_endpoint] | The transmission mode as described in RFC 959.
U
uint4 [Rtypes] | 32 bit unsigned integer
uint8 [Rtypes] | 64 bit unsigned integer
unicode_lexbuf [Netulex.ULB] |
uri_distributor [Nethttpd_services] | Describes that services are bound to URI prefixes.
url [Neturl] | Values of type `url` describe concrete URLs.
url_syntax [Neturl] | Values of type `url_syntax` describe which components of an URL are recognized, which are allowed (and optional), and which are required.
url_syntax_option [Neturl] |

user_name_format [Rpc_auth_sys]

How `Rpc_server.get_user` returns the user as string: ``Full`: The format includes all transmitted details: `"<uid>.<gid>.<gid1>.<gid2>...@<hostname>"`. All user and group IDs are numeric. The first two numbers, <uid> and <gid> are always present. The other numbers are the supplementary group IDs and can be omitted. The <hostname> is the name passed in the credentials., ``UID`: The string is the numeric user ID, ``Custom f`: The string is returned by the function `f`. The arguments are `uid`, `gid`, the array of the supplementary group IDs and the hostname.

W
wait_id [Unixqueue] | A wait identifier is used to distinguish between several timers, see type `operation`.
workaround [Netcgi1_compat.Netcgi_env] | The `Work_around_` part has been dropped as it is clear at the spot of use.
write_op [Netshm] |
X
xdr_type [Xdr] | This is the validated version of `xdr_type_term`.
xdr_type_system [Xdr] | A validated type system.
xdr_type_term [Xdr] |
xdr_type_term_system [Xdr] | Bind names to types.
xdr_value [Xdr] |