# 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
access_description_flag [Netx509] |
action [Netsys_signal] | ``Callback` is used for normal handlers, and ``Install` for exclusive handlers.
addr_spec [Netaddress] | The pair `local_part@domain` as O'Caml type.
address [Netsys_gssapi] | Addresses tagged by address types
address [Netplex_types] |
advice [Netsys_posix] |
alg_id [Netx509_pubkey] |
alg_param [Netx509_pubkey] |
algorithm [Netsys_crypto_types.PUBKEY_CRYPTO] |
announcement [Nethttpd_kernel] | See config
anon_semaphore [Netsys_sem] |
anon_semaphore [Netsys_posix] |
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] |
armor_spec [Netascii_armor] | Which types of armor to decode, and how.
armor_type [Netascii_armor] |
armored_message [Netascii_armor] | Messages: ``Plain m`: The body `m` is written as-is, ``Base64 m`: The body `m` needs to be BASE-64-encoded in order to create the ASCII armor, ``OpenPGP(h,m,chksum)`: There is a header `h`, a body `m` which will be BASE-64-encoded, and a checksum `chksum`
armored_message_ro [Netascii_armor] | The read-only version of `armored_message`
assignment [Shell] | An assignment redirects file descriptors while calling a process
at_flag [Netsys_posix] |
auth_challenge [Nethttp.Header] | The type of a single challenge, used during authentication.
auth_credentials [Nethttp.Header] | The type of a single credentials response, used during authentication.
auth_peeker [Rpc_server] |
auth_result [Rpc_server] |

auth_status [Nethttp_client]

Status of HTTP-level authentication: ``None`: Authentication wasn't tried., ``OK`: The authentication protocol finished. What this means exactly depends on the protocol. For most protocols it just means that the server authenticated the client. For some protocols it may also mean that the client authenticated the server (mutual authentication)., ``Auth_error`: The authentication protocol did not succeed. Note that this state can also be reached for an otherwise successful HTTP response (i.e. code 200) when the client could not authenticate the server and the protocol demands this., ``Reroute trans_id`: The request should be retried on a new connection for the transport identified by `trans_id`, ``Continue`: The authentication is still in progress. Normally the user should not see this state as the engine automatically continues the protocol. The argument of ``Continue` is private., ``Continue_reroute`: the combination of continue and reroute: the auth protocol continues, but the next request must be sent on the indicated transport.

authority_access_description_flag [Netx509] |
authority_key_identifier [Netx509] |
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.
bind_creds [Netldap] |
binding [Rpc_server] |
binding_async [Rpc_server] |
binding_sync [Rpc_server] |
bitstring_value [Netasn1.Value] |
buffer [Netmcore_buffer] | A buffer with a header of type `'h`
buffer_descr [Netmcore_buffer] | The marshallable buffer descriptor
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] |
calling_error [Netsys_gssapi] | Possible errors caused by the caller
camlbox [Netcamlbox] | A `camlbox` may receive messages of type `'a`
camlbox_address [Netcamlbox] | The address of a camlbox is a string that does not contain slashes.
camlbox_sender [Netcamlbox] | An endpoint that may send messages of type `'a` to a camlbox

capacity [Netplex_types]

How many connections a container can accept in addition to the existing connections: ``Normal_quality(n,greedy)`: It can accept n connections with normal service quality, `n > 0`, ``Low_quality(n,greedy)`: It can accept n connections with low service quality (e.g. because it is already quite loaded), `n > 0`, ``Unavailable`: No capacity free The `greedy` flag sets whether greedy accepts are allowed.

cb [Netsys_sasl_types]

Possible channel bindings: ``None`: this is the default, ``SASL_none_but_advertise`: the client supports channel binding and advertises this. For this time, the SCRAM protocol is run without channel binding, though. (Only available in the SASL profile.), ``SASL_require(type,data)`: Require channel binding. E.g. type="tls-unique", and `data` is set to the channel identifier (RFC 5929). (Only available in the SASL profile.), ``GSSAPI data`: use this channel binding for GSS-API This type is shared by SASL and GSSAPI providers.

cb [Netmech_scram] | Using the same channel binding type as for SASL
cgi_config [Netcgi1_compat.Netcgi_env] | Now simply called `Netcgi.config`.
cgi_cookie [Netcgi1_compat.Netcgi_types] |
channel_bindings [Netsys_gssapi] | Channel binding as tuple `(initiator_address, acceptor_address, application_data)`
charset [Netconversion] | A `charset` is simply a set of code points.
client_session [Netsys_sasl_types.SASL_MECHANISM] |
client_session [Netmech_scram] | Session context for clients
client_session [Nethttp.HTTP_CLIENT_MECHANISM] |

client_state [Netsys_sasl_types]

The state of the client session: ``Wait`: it is waited for the server challenge., ``Emit`: a new client response can be emitted., ``OK`: the authentication protocol succeeded, ``Auth_error`: authentication error (it is unspecified which); the string may be used for logging), ``Stale`: The client session is refused as too old. The password, though, is correct. Otherwise this is the same as ``Emit`, i.e. the authentication process can continue.

clock [Netsys_posix] |
clock_id [Netsys_posix] |
close_mode [Netchannels] | Whether a `close_out` implies a commit or rollback operation
cmd [Netftp_client] | An FTP command.

cmd_state [Netftp_client]

The command state: ``Not_connected`: Not connected., ``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, ``Auth_data`: an ADAT reply inidicating that another round of authentication is necessary.

cmdline_config [Netplex_main] |
color [Netsys_mem] |
command [Shell_sys] | A command describes how to start a new process
command_context [Shell_fs] |
command_interpreter [Shell_fs] | The interpreter runs the command, and fills in `sfs_status`
compiled_localization [Netdate] |
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] |

compute_resource_repr [Netmcore]

Centrally managed resources include: ``File name`: (Temporary) file `name` (absolute name), ``Posix_shm name`: Shared memory objects with `name`, ``Posix_shm_sc(name,p)`: Shared memory objects with `name`, and attached container for semaphores with prefix `p`, ``Posix_shm_preallocated(name,m)`: Shared memory objects already allocated by the master process. These objects are passed over to the worker processes by inheritance, and are always mapped at the same address. `m` is the bigarray mapping the object., ``Posix_shm_preallocated_sc(name,m.p)`: Same, plus attached container for semaphores with prefix `p`, ``Posix_sem name`: Semaphores with `name`, ``Fork_point(inh,f)`: Fork points where `let pid=f arg` fork a new process with argument `arg`. `pid` is the process identifier. The list `inh` are resources inherited from the master., ``Joint_point f`: Joint points where `let res=f pid` wait until the process `pid` terminates. If `res` is non-`None` it is the result value. If it is `None`, no result was passed back (including all pathological cases like crashes) Except fork and join points, these resources are also added to the pmanage object of Netplex (see `Netplex_cenv.pmanage` and `Netsys_pmanage`).

compute_resource_type [Netmcore] |
condition [Netmcore_condition] | The condition variable
config [Netsys_crypto_types.TLS_PROVIDER] |
config [Netcgi] |
config [Netcgi_common] | See `Netcgi.config`.
config_error_response [Nethttpd_plex] | Three type abbreviations for logging functions
config_log_access [Nethttpd_plex] |
config_log_error [Nethttpd_plex] |
config_tree [Netplex_types] |
conn_state [Nethttp_client_conncache] | A TCP connection may be either ``Inactive`, i.e.
connect_address [Uq_engines_compat] |
connect_address [Uq_client] | Specifies the service to connect to:
connect_address [Uq_engines] | Moved to `Uq_client.connect_address`
connect_options [Uq_engines_compat] |
connect_options [Uq_client] |
connect_options [Uq_engines] |
connect_status [Uq_engines_compat] |
connect_status [Uq_client] | This type corresponds with `Uq_engines.connect_address`: An engine connecting with an address `X will return a status of `X.
connect_status [Uq_engines] | Moved to `Uq_client.connect_status`
connection [Netcgi_dbi.DBI_DRIVER] |
connection [Netcgi_dbi.DBI_POOL] |
connection_cache [Nethttp_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_server] |
connector [Rpc_client] |
const_str_datum_p [Nettls_gnutls_bindings] |
consumer [Shell] | A consumer receives data from a called process
container [Netsys_sem] | The container of the semaphore is the shared memory object
container_id [Netplex_types] | Such objects identify containers.

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.

context [Netsys_gssapi.GSSAPI] | A context is also opaque.
cookie [Nethttp] | Compatibility name.
copy_flag [Netfs] |
copy_task [Uq_engines_compat] |
copy_task [Uq_transfer] | Specifies the task the `copier` class has to do:
copy_task [Uq_engines] | Moved to `Uq_transfer.copy_task`
create_process_option [Netsys_win32] |
cred_type [Nettls_support] | The type of credential types
cred_usage [Netsys_gssapi] |
credential [Netsys_gssapi.GSSAPI] | A credential is opaque for the caller of the GSS-API.
credentials [Netsys_sasl] | Credentials are given as list `(type,value,params)`.
credentials [Netsys_crypto_types.TLS_PROVIDER] |
credentials [Netsys_sasl_types.SASL_MECHANISM] |
credentials [Netmech_scram] | Two forms of providing credentials: ``Salted_password(spw,salt,iteration_count)`: get the salted password with `spw = salt_password h password salt iteration_count`, ``Stored(stkey, srvkey, salt, iteration_count)`: get the pair (stkey, srvkey) with `stored_key h password salt iteration_count`
credentials [Nettls_support] | The types of credentials
credentials [Nethttp.HTTP_CLIENT_MECHANISM] |
crl_list [Netsys_tls] | Certificate revocation lists are given either as:
crl_list [Netsys_crypto_types.TLS_PROVIDER] | Certificate revocation lists are given either as:
crt_list [Netsys_tls] | Certificates are given either as:
crt_list [Netsys_crypto_types.TLS_PROVIDER] | Certificates are given either as:
ctrl_op [Netshm] |
cursor [Netconversion] |
custom_ops [Netsys_mem] |
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_compat] |
datagram_type [Uq_datagram] | - ``Unix_dgram`: Datagrams over Unix domain sockets ``Inet_udp`: Internet v4 UDP protocol, ``Inet6_udp`: Internet v6 UDP protocol
datagram_type [Uq_engines] | Moved to `Uq_datagram.datagram_type`
debug_target [Equeue.Debug] |
decoder [Netxdr] | see text above

deref_aliases [Netldap]

What to do when aliases (server-dereferenced symbolic links) are found in the tree: ``Never`: do not dereference aliases but return them as part of the search result, ``In_searching`: when aliases are found in the children of the base object dereference the aliases, and continue the search there, and repeat this recursively if needed, ``Finding_base_obj`: dereference alises in base objects but not in children, ``Always`: always dereference aliases

descr [Netmcore_heap] | A descriptor ("address") pointing to the heap.
descr_state [Netftp_data_endpoint] | Describes the state of the socket used for data transfers.
dh_params [Netsys_tls] | Diffie-Hellman parameters:
dh_params [Netsys_crypto_types.TLS_PROVIDER] | Diffie-Hellman parameters:
digest [Netsys_crypto_types.DIGESTS] | Describes a digest
digest_ctx [Netsys_crypto_types.DIGESTS] | A digest context stores state while digesting data
digests [Netsys_crypto_types] |
dlogger [Netlog.Debug] | Debug logger: The first string is the module name, and the second is the message
dn [Netdn] | This is the raw version of the DN: a sequence of relative DNs, and a relative DN is a set of (type,value) pairs.
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.
empty_flags [Nettls_gnutls_bindings] |
empty_flags_flag [Nettls_gnutls_bindings] |
encap [Netplex_encap] | An encapsulated value with a type identifier
encap [Netplex_types] |
encap [Nethttpd_plex] |
encoder [Netxdr] | see text above
encoding [Netconversion] | The polymorphic variant enumerating the supported encodings.
encrypt_alg [Netx509_pubkey] |
endpoint [Netsys_crypto_types.TLS_PROVIDER] |
engine_req_state [Nethttpd_engine] |
engine_state [Uq_engines_compat] |

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

engine_state [Uq_resolver] |
entity_set [Netencoding.Html] |
entry [Netsys_signal] |
entry [Netftp_client] | A file entry `(name, facts)`.

entry_perm [Netftp_client]

Permissions: ``Append`: append to file possible, ``Create`: file can be created in this dir, ``Delete`: file or dir can be deleted, ``Enter`: dir can be entered, ``Rename`: file or dir can be renamed, ``List`: dir can be listed, ``Mkdir`: subdir can be created in this dir, ``Delete_member`: a file or dir can be deleted in this directory, ``Read`: a file can be retrieved, ``Write`: a file can be stored

entry_type [Netftp_client] | Types: ``File`: entry refers to file, ``Cdir`: entry refers to the directory being listed, ``Pdir`: entry is a parent of the directory being listed, ``Dir`: entry refers to directory, ``Other`: entry is neither file nor directory
environment [Shell_sys] | The abstract type of a process environment
eq [Netplex_types] | Equality witness
error_code [Nettls_gnutls_bindings] |
etag [Nethttp] | Entity tags can be weak or strong
event [Uq_libevent.LIBOEVENT] |
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).
event_aggregator [Netsys_posix] |
event_callback [Uq_libevent.LIBOEVENT] |
event_flags [Uq_libevent.LIBOEVENT] |
event_source [Netsys_posix] |
exn_handler [Netcgi] | A function of type `exn_handler` allows to define a custom handler of uncaught exceptions raised by the `unit -> unit` parameter.
ext_key_usage_flag [Netx509] |

extended_address [Netplex_types]

Possible addresses: ``Socket s`: The socket at this socket address, ``Socket_file f`: The file `f` contains the (anonymous) port number of a socket bound to `127.0.0.1` (This is meant as substitute for Unix Domain sockets on Win32.), ``W32_pipe name`: The Win32 pipe with this `name` which must be of the form "\\.\pipe\<pname>", ``W32_pipe_file f`: The file `f` contains the (random) name of a Win32 pipe, ``Container(socket_dir,service_name,proto_name,thread_id)`: The special endpoint of the container for `service_name` that is running as `thread_id`. It is system-dependent what this endpoint "is" in reality, usually a socket or named pipe. If any container of a service is meant, the value ``Any` is substituted as a placeholder for a not yet known `thread_id`., ``Internal name`: an internal service called `name`. Internal sockets are only available for multithreaded programs, and are registered at `Netplex_internal`.

extfd [Netplex_types] | Internally used
F
fatal_error [Nethttpd_kernel] | These are the serious protocol violations after that the daemon stops any further processing.
fd_action [Netsys_posix] |

fd_style [Netsys]

Some information what kind of operations are reasonable for descriptors: ``Read_write`: The descriptor is neither a socket not one of the other special cases, so only read/write is possible if read/write is possible at all. This style is also used if it is meaningless to use data I/O like read/write at all., ``Recv_send(sockaddr,peeraddr)`: The descriptor is a connected socket. recv/send are the preferred operations., ``Recvfrom_sendto`: The descriptor is an unconnected socket, and it is possible to ask for addresses when exchanging data, so recvfrom/sendto are the preferred operations., ``Recv_send_implied`: The descriptor is a socket with implied connection. There are no socket addresses. recv/send are the preferred operations. It is not possible to call `getsockname` or `getpeername`., ``W32_pipe`: The descriptor is a proxy descriptor for a Win32 named pipe as returned by `Netsys_win32.pipe_descr`. , ``W32_pipe_server`: The descriptor is a proxy descriptor for a Win32 pipe server as returned by `Netsys_win32.pipe_server_descr`. , ``W32_event`: The descriptor is a Win32 proxy descriptor for an event as returned by `Netsys_win32.create_event`. It is not possible to read/write with these descriptors., ``W32_process`: The descriptor is a proxy descriptor for a Win32 process as returned by `Netsys_win32.create_process`. It is not possible to read/write with these descriptors., ``W32_input_thread`: The descriptor is a proxy descriptor for a Win32-specific input thread as returned by `Netsys_win32.create_input_thread`. , ``W32_output_thread`: The descriptor is a proxy descriptor for a Win32-specific output thread as returned by `Netsys_win32.create_output_thread`. , ``TLS endpoint`: A TLS tunnel is running over the descriptor. The details of the tunnel can be found in `endpoint`. Note that it is allowed that the endpoint uses a second descriptor for either reading or writing (i.e. reading and writing go via different descriptors). In this case, it is sufficient that one of these descriptors is accompanied with ``TLS endpoint`. Win32: For the exact meaning of proxy descriptors, please see `Netsys_win32`.

file_kind [Netfs] |

file_option [Nethttpd_services]

Add-on features for file services: ``Enable_gzip`: Deprecated. Same as ``Enable_cooked_compression`., ``Enable_cooked_compression`: Modifies the way compressed files are handled. Normally it is required that one accesses the compressed file (with suffix such as "gz") directly to get it in compressed form. If this option is enabled, though, the server also compresses the base file (without suffix such as "gz"), but only if the base file is accompanied by a compressed version (with suffix). E.g. if there is "foo" and "foo.gz", this enables that the accesses to "foo" can make use of 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., ``Override_compression_suffixes l`: Tags the file suffixes in `l` as compression schemes. A pair `(suffix,ce)` sets that the `suffix` means the content encoding `ce`. Knowing this is important for determining the media type of the file.

file_service [Nethttpd_services] | Describes a file service
file_tls_endpoint [Netsys_crypto_types] |

filename [Netftp_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., ``TVFS name`: The optional "Trivial Network File System" avoids the `CWD` and `CDUP` commands. The tagged `name` is normalized (double slashed removed etc.), and is passed to the server as-is. Before using the faster TVFS one should check whether it is supported (feature "TVFS"). Note that even for TVFS there are no special files "." and ".."!, ``Verbatim name`: The string `name` is passed to the server without transforming it in any way.

filter [Netldap]

Filter: ``Equality_match(attr_descr, value)`, ``Substrings(attr_descr, prefix_match, substring_matches, suffix_match)`, ``Greater_or_equal(attr_descr,value)`, ``Less_or_equal(attr_descr,value)`, ``Present(attr_descr)`, ``Approx_match(attr_descr,value)`, ``Extensible_match(matching_rule_id, attr_descr, value, dn_attrs)` Here, `attr_descr` is the name of the attribute, either given by an OID (in dotted representation) or a by a descriptive name.

final_state [Uq_engines_compat] |
final_state [Uq_engines] | Same as `engine_state` without ``Working`.
flags [Netgss_bindings] |
flags_flag [Netgss_bindings] |
fork_point [Netmcore_process] | A fork point can start a new process with argument `'a`
form_code [Netftp_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
format [Netlog] |
fp4 [Netnumber] | single precision float (IEEE "float")
fp8 [Netnumber] | double precision float (IEEE "double")
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_auth [Netftp_client] |
ftp_data_prot [Netftp_client] | Meaning: ``C`: no protection (clear), ``S`: integrity protection, ``E`: encryption without integrity protection, ``P`: integrity protection and encryption (= privacy)
ftp_data_prot [Netftp_data_endpoint] | See `Netftp_client.ftp_data_prot`
ftp_method [Netftp_client] | An `ftp_method` is a small procedure doing some task
ftp_protector [Netftp_data_endpoint] | The functions for encrypting (wrapping) and decrypting (unwrapping) messages when an RFC 2228 security layer is active.
ftp_state [Netftp_client] | The ftp_state reflects the knowledge of the client about what has been agreed upon with the server.
fwd_mode [Shell_sys] | Determines whether and how keyboard signals (SIGINT, SIGQUIT) are forwarded from the caller to the new child.
G

general_name [Netx509]

General names: ``Other_name(oid, value)`: the `oid` determines the extension name format, ``Rfc822_name n`: an email address `n` (ASCII encoded), ``DNS_name n`: an Internet domain `n` (ASCII encoded - no internationalization), ``X400_address v`: an X.400 address, which is not decoded here and just given as unparsed ASN.1 value `v`, ``Directory_name n`: a directory name `n` (i.e. a name using the syntax of distinguished names), ``Edi_party_name(assigner,party)`, both names as UTF-8, ``Uniform_resource_identifier uri`: this `uri` (ASCII-encoded, no internationalization), ``IP_address(dom,addr,mask)`: the address with mask, ``Registered oid`: a symbolical pre-registered name known under `oid`

glob_expr [Netglob] |
glob_expr_atom [Netglob] | Atoms:

glob_mode [Netglob]

Modes: ``Existing_paths`: Only paths are returned that really exist, ``All_paths`: Generated paths not including `*`, `?` and bracket expressions are returned even if they do not exist. For example, globbing for `"fictive{1,2,3}"` would return `["ficitve1";"fictive2";"fictive3"]` independent of whether these files exist., ``All_words`: Patterns that cannot be resolved are returned as-is (like the shell does)

glob_set [Netglob] | A set of code points is given as a list of ranges `(from,to)`, with `from <= to`.
gnutls_alert_description_t [Nettls_gnutls_bindings] |
gnutls_alert_level_t [Nettls_gnutls_bindings] |
gnutls_anon_client_credentials_t [Nettls_gnutls_bindings] |
gnutls_anon_server_credentials_t [Nettls_gnutls_bindings] |
gnutls_certificate_credentials_t [Nettls_gnutls_bindings] |
gnutls_certificate_import_flags [Nettls_gnutls_bindings] |
gnutls_certificate_import_flags_flag [Nettls_gnutls_bindings] |
gnutls_certificate_print_formats_t [Nettls_gnutls_bindings] |
gnutls_certificate_request_t [Nettls_gnutls_bindings] |
gnutls_certificate_status_t [Nettls_gnutls_bindings] |
gnutls_certificate_status_t_flag [Nettls_gnutls_bindings] |
gnutls_certificate_type_t [Nettls_gnutls_bindings] |
gnutls_certificate_verify_flags [Nettls_gnutls_bindings] |
gnutls_certificate_verify_flags_flag [Nettls_gnutls_bindings] |
gnutls_channel_binding_t [Nettls_gnutls_bindings] |
gnutls_cipher_algorithm_t [Nettls_gnutls_bindings] |
gnutls_cipher_hd_t [Nettls_gnutls_bindings] |
gnutls_close_request_t [Nettls_gnutls_bindings] |
gnutls_compression_method_t [Nettls_gnutls_bindings] |
gnutls_credentials [Nettls_gnutls_bindings] |
gnutls_credentials_type_t [Nettls_gnutls_bindings] |
gnutls_dh_params_t [Nettls_gnutls_bindings] |
gnutls_digest_algorithm_t [Nettls_gnutls_bindings] |
gnutls_ecc_curve_t [Nettls_gnutls_bindings] |
gnutls_handshake_description_t [Nettls_gnutls_bindings] |
gnutls_info_access_what_t [Nettls_gnutls_bindings] |
gnutls_init_flags [Nettls_gnutls_bindings] |
gnutls_init_flags_flag [Nettls_gnutls_bindings] |
gnutls_kx_algorithm_t [Nettls_gnutls_bindings] |
gnutls_mac_algorithm_t [Nettls_gnutls_bindings] |
gnutls_params_type_t [Nettls_gnutls_bindings] |
gnutls_pk_algorithm_t [Nettls_gnutls_bindings] |
gnutls_pkcs_encrypt_flags_t [Nettls_gnutls_bindings] |
gnutls_pkcs_encrypt_flags_t_flag [Nettls_gnutls_bindings] |
gnutls_priority_t [Nettls_gnutls_bindings] |
gnutls_privkey_t [Nettls_gnutls_bindings] |
gnutls_privkey_type_t [Nettls_gnutls_bindings] |
gnutls_protocol_t [Nettls_gnutls_bindings] |
gnutls_psk_client_credentials_t [Nettls_gnutls_bindings] |
gnutls_psk_key_flags [Nettls_gnutls_bindings] |
gnutls_psk_server_credentials_t [Nettls_gnutls_bindings] |
gnutls_pubkey_t [Nettls_gnutls_bindings] |
gnutls_sec_param_t [Nettls_gnutls_bindings] |
gnutls_server_name_type_t [Nettls_gnutls_bindings] |
gnutls_session_t [Nettls_gnutls_bindings] |
gnutls_sign_algorithm_t [Nettls_gnutls_bindings] |
gnutls_srp_client_credentials_t [Nettls_gnutls_bindings] |
gnutls_srp_server_credentials_t [Nettls_gnutls_bindings] |
gnutls_supplemental_data_format_type_t [Nettls_gnutls_bindings] |
gnutls_x509_crl_t [Nettls_gnutls_bindings] |
gnutls_x509_crt_fmt_t [Nettls_gnutls_bindings] |
gnutls_x509_crt_t [Nettls_gnutls_bindings] |
gnutls_x509_privkey_t [Nettls_gnutls_bindings] |
gnutls_x509_subject_alt_name_t [Nettls_gnutls_bindings] |
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
gss_OID [Netgss_bindings] |
gss_OID_set [Netgss_bindings] |
gss_buffer_t [Netgss_bindings] |
gss_channel_bindings_t [Netgss_bindings] |
gss_cred_id_t [Netgss_bindings] |
gss_cred_usage_t [Netgss_bindings] |
gss_ctx_id_t [Netgss_bindings] |
gss_name_t [Netgss_bindings] |
gss_qop_t [Netgss_bindings] |
H
hash_function [Netx509_pubkey] |
header_kind [Nethttp_client] | The ``Base` header is set by the user of `http_call` and is never changed during processing the call.
heap [Netmcore_heap] | A heap where the type of the root element is `'a`
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 [Nethttp_client] | How to deal with automatic reconnections, especially when the connection crashes.
how_to_redirect [Nethttp_client] |
http_method [Nethttp] | Method name, URI
http_method [Netcgi] |
http_method [Netcgi_common] |
http_options [Nethttp_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:
httpd_factory [Nethttpd_plex] | The type of the `nethttpd_processor` function
I
iana_hash_fn [Netsys_digests] | The hash functions contained in the IANA registry (http://www.iana.org/assignments/hash-function-text-names/hash-function-text-names.xhtml).
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
in_bdevice [Uq_io] | Devices with look-ahead
in_buffer [Uq_io] |

in_device [Uq_io]

Currently supported devices for input: ``Polldescr(st,fd,esys)`: The `poll` system call is used with file descriptor `fd` to wait for incoming data. The event system `esys` is the underlying event queue. This works well for pipes, sockets etc. but not for normal files. The style `st` can be obtained from `fd` via `Netsys.get_fd_style`., ``Multiplex mplex`: The multiplex controller `mplex` is used as device. , ``Buffer buf`: Data comes from the buffer `buf` (which in turn is connected with a second device), ``Count_in(f,d)`: Data is read from `d`, and every time a few bytes `n` are read the function `f n` is called (which may raise an exception) Generally, it is not well supported to read in parallel several times from the same device.

in_record [Rpc_transport] |
in_rule [Rpc_transport] |
inactive_data [Nethttp_client_conncache] |
inetspec [Uq_engines_compat] |
inetspec [Uq_client] |
inetspec [Uq_engines] | Moved to `Uq_client.inetspec`
inherit_request [Netmcore] |
init_credentials [Netsys_sasl.Server] | A function for preparing credentials, provided by the mechanism.
init_value_flag [Netsys_mem] |
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 [Netnumber] | 32 bit signed integer
int8 [Netnumber] | 64 bit signed integer
int_value [Netasn1.Value] |
internal_pipe [Rpc_server] |
internal_pipe [Rpc_client] |
internal_pipe [Rpc_transport] |
internal_socket [Rpc_server] |
internal_socket [Rpc_client] |
interprocess_token [Netsys_gssapi] | Interprocess tokens.
io_device [Uq_io] | Bidirectional devices
ioprio [Netsys_posix] |
ioprio_target [Netsys_posix] |
J
job [Shell_sys] |
job_instance [Shell_sys] |
job_status [Shell_sys] | Indicates the status of the job
join_point [Netmcore_process] | A join point can wait until a process finishes with a result `'b`
K
kex_alg [Netx509_pubkey] |
key_type [Netauth] | Key types: ``Kc` is used for computing checksums, ``Ke` is used for encrypting confidential messages, ``Ki` is used for computing integrity checksums for encrypted messages
key_usage [Nettls_gnutls_bindings] |
key_usage_flag [Nettls_gnutls_bindings] |
key_usage_flag [Netx509] |
kind_check [Netplex_types] | Helper type for a polymorphic check whether a kind this the expected kind
L
langinfo [Netsys_posix] |
ldap_connection [Netldap] |
level [Netlog] | The log levels (syslog-like)
level [Netsys_posix] |
level [Netplex_types] | Log levels, modeled after syslog
lexbuf [Netulex.Ulexing] |
linear_distributor [Nethttpd_services] | Services are selected by calling the selector function.
listen_address [Uq_engines_compat] |
listen_address [Uq_server] | Specifies the resource to listen on:
listen_address [Uq_engines] | Moved to `Uq_server.listen_address`
listen_options [Uq_engines_compat] |
listen_options [Uq_server] |
listen_options [Uq_engines] |
local_part [Netaddress] | Usually the user name
local_receiver [Netftp_data_endpoint] | The `local_receiver` is the object that gets the data received over the data connection.
local_sender [Netftp_data_endpoint] | The `local_sender` is the object that provides the data sent over the data connection.
localization [Netdate] |
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.
logger [Netlog] | A logging function takes a level, and the message
lookup [Netsys_sasl.Server] | see `create_session`
loop_flags [Uq_libevent.LIBOEVENT] |
M
major_status [Netsys_gssapi] | The major status consists of these three elements.
mapping [Rpc_portmapper_aux] |
maskgen_function [Netx509_pubkey] |
match_result [Nethttp] | See `Nethttp.HTTP_CLIENT_MECHANISM.client_match`
mbox [Netplex_mbox.MBOX] | The type of the mailboxes
mclient [Rpc_proxy.ManagedClient] | A managed client
mclient_config [Rpc_proxy.ManagedClient] |
memory [Nettls_gnutls_bindings] | See `Netsys_types.memory`
memory [Netsys_mem] | We consider 1-dimensional bigarrays of chars as memory buffers.
memory [Netsys_types] | We consider 1-dimensional bigarrays of chars as memory buffers.
memory [Netgss_bindings] |
memory_pool [Netsys_mem] | A pool of `memory` blocks that are all the same size and page-aligned (if the OS supports this).
message [Netsys_gssapi] | Messages are represented as lists of `mstring`
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 [Netmime_string] | The opaque type of a scanner for structured values
minor_status [Netsys_gssapi] | The minor status is provider-specific.
mkdir_flag [Netfs] |
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.

monitor [Uq_mt] | A thread monitor governs which threads have access to a set of engines running together on an event system
mountpoint [Netcgi_plex] |
mset [Rpc_proxy.ManagedSet] | a managed set
mset_config [Rpc_proxy.ManagedSet] |

mset_policy [Rpc_proxy.ManagedSet]

Sets in which order managed clients are picked from the `services` array passed to `create_mset`: ``Failover`: Picks an element from the first service in `services` that is enabled and has free capacity. That means that the first service is preferred until it is maxed out or it fails, then the second service is preferred, and so on., ``Balance_load`: Picks an element from the service in `services` that is enabled and has the lowest load.

multipart_style [Netmime_channels]

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.

mutator [Netmcore_heap] | Mutators allow it to push new values onto the heap.
mutex [Netplex_mutex] |
mutex [Netmcore_mutex] |
mutex_type [Netmcore_mutex] | Types: ``Normal` mutexes have no checks for deadlocks., ``Errorcheck` mutexes check whether the process locks the mutex again, and fail in this case. Also, only the owning process can unlock a mutex., ``Recursive` mutexes allow that the owner locks several times. The same number of unlock requests need to be issued to give up the ownership
N
name [Netsys_gssapi.GSSAPI] | A name is also opaque
named_mstring_factories [Netxdr_mstring] |
named_semaphore [Netsys_posix] |
net_nettle_cipher_ctx_t [Nettls_nettle_bindings] |
net_nettle_cipher_t [Nettls_nettle_bindings] |
net_nettle_gcm_aes_ctx_t [Nettls_nettle_bindings] |
net_nettle_hash_ctx_t [Nettls_nettle_bindings] |
net_nettle_hash_t [Nettls_nettle_bindings] |
netbuf [Rpc_portmapper_aux] |
netscape_cookie [Nethttp] | These are old-style cookies, as introduced by Netscape.
node_type [Netsys_posix] |
not_event [Netsys_posix] |
O
oid [Netsys_gssapi] | OIDs like "1.3.6.1.5.6.2" as array of int's.
oid [Netx509_pubkey] | OIDs are just integer sequences
oid [Netx509] | OIDs are just integer sequences
oid [Netdn] |
oid_set [Netsys_gssapi] | A set of OID's.
onshutdown_in_spec [Uq_engines_compat] |
onshutdown_in_spec [Uq_transfer] | See class `input_async_mplex` for explanations
onshutdown_in_spec [Uq_engines] | Moved to `Uq_transfer.onshutdown_in_spec`
onshutdown_out_spec [Uq_engines_compat] |
onshutdown_out_spec [Uq_transfer] | See class `output_async_mplex` for explanations
onshutdown_out_spec [Uq_engines] | Moved to `Uq_transfer.onshutdown_out_spec`
operating_type [Netcgi1_compat.Netcgi] |
operation [Netldap] |
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`.
out_buffer [Uq_io] | Buffers that can be attached to a `device` to get buffered I/O

out_device [Uq_io]

Currently supported devices for output: ``Polldescr(fd,esys)`: The `poll` system call is used with file descriptor `fd` to wait until data can be output. The event system `esys` is the underlying event queue. This works well for pipes, sockets etc. but not for normal files., ``Multiplex mplex`: The multiplex controller `mplex` is used as device. , ``Buffer buf`: Data is written to the buffer `buf` (which in turn is connected with a second device), ``Count_out(f,d)`: Data is written to `d`, and every time a few bytes `n` are written the function `f n` is called (which may raise an exception) Generally, it is not well supported to write in parallel several times to the same device.

output_mode [Netcgi1_compat.Netcgi_env] | This is not used anywhere.
output_state [Nethttpd_types] |
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] |
padding [Netsys_ciphers] | Padding schemes:
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 [Nethttp.Header] | Some parameters may occur quoted and unquoted.
param_value [Netplex_types] |
param_value_or_any [Netplex_types] |
pattern [Netglob] | Input for `Netglob.glob`
pattern [Netaux.KMP] |
pc [Netasn1.Value] |
peer [Nethttp_client_conncache] |
pg_spec [Netsys_posix] |
pin_callback [Netsys_crypto_types.PUBKEY_CRYPTO] |
pipe_mode [Netsys_win32] |
pm_obj [Netsys_pmanage] |
pmaplist [Rpc_portmapper_aux] |
pmaplist_p [Rpc_portmapper_aux] |
poll_act_events [Netsys_posix] | Poll events.
poll_array [Netsys_posix] | The array of `poll_cell` entries
poll_cell [Netsys_posix] | The poll cell refers to the descriptor `poll_fd`.
poll_req_events [Netsys_posix] |
poly_cursor [Netconversion] | A cursor denotes a character position in an encoded string.
polyclient [Netsys_polysocket] | A client, connected or unconnected
polyclient_box [Netplex_types] | This type pairs a `polysocket_kind` with a `polyclient` as GADT.
polyendpoint [Netsys_polysocket] | An endpoint is simply a pair `(rd,wr)` where `rd` is a polypipe open for reading, and `wr` is a polypipe open for writing.
polypipe [Netsys_polypipe] |
polyserver [Netsys_polysocket] | A server
polyserver_box [Netplex_types] | This type pairs a `polysocket_kind` with a `polyserver` as GADT.
polysocket_kind [Netplex_types] | List possible argument types for polysockets (`Netsys_polysocket`), which are the basis for internal services.
polysocket_kind_box [Netplex_types] | Boxed version of `polysocket_kind` where the type parameter is hidden
port [Netftp_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.
posix_timer [Netsys_posix] |
prefix [Netsys_sem] | A name starting with a slash.
private_api [Nethttp_client] | The private part of the `http_call` class type
private_key [Netsys_tls] | Private keys are given either as:
private_key [Netsys_crypto_types.PUBKEY_CRYPTO] |
private_key [Netsys_crypto_types.TLS_PROVIDER] | Private keys are given either as:
privkey [Netx509_pubkey] |
process [Shell_sys] | A process is the running instance of a command (a Unix process)
process_id [Netmcore] | This tagged integer identifies processes.
producer [Shell] | A producer generates data sent to a called process
profile [Netmech_scram] | Profile
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] |
proxy_type [Nethttp_client] |
ptype [Netmech_scram] | Profile types: ``GSSAPI`: as defined in RFC 5802, the gs2-header is omitted, ``SASL`: as defined in RFC 5802
pubkey [Netx509_pubkey] | Public key info: the key as such plus the algorithm.
pubkey_crypto [Netsys_crypto_types] |
public_key [Netsys_crypto_types.PUBKEY_CRYPTO] |
Q
qop [Netsys_gssapi] | Quality-of-proctection parameters are mechanism-specific.
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
r [Netplex_cenv.FUN_TYPE] | result type
r [Netplex_cenv.LEVER] | result type
raw_credentials [Netsys_crypto_types.TLS_PROVIDER] | The encoded credentials: ``X509 s`: The X509 certificate in DER encoding, ``Anonymous`: no certificate or other key is available
raw_credentials [Nettls_support] | The encoded credentials: ``X509 s`: The X509 certificate in DER encoding, ``Anonymous`: no certificate or other key is available
rcache [Rpc_proxy.ReliabilityCache] | The cache
rcache_config [Rpc_proxy.ReliabilityCache] |

rcache_policy [Rpc_proxy.ReliabilityCache]

How failures of individual ports are interpreted: ``Independent`: When a connection to a remote port repeatedly fails, only this port is disabled, ``Failing_port_disables_host p`: When a connection to the TCP port `p` repeatedly fails, the whole remote host is disabled. Other ports do not disable the host, but are treated as in ``Independent`., ``Any_failing_port_disables_host`: When a connection to any TCP port repeatedly fails, the whole remote host is disabled, ``None`: Nothing is disabled Note that the `rcache_availability` hook is not affected by the policy; this hook is called anyway.

read_file_flag [Netfs] |
read_file_flag [Nethttp_fs] |
read_flag [Netfs] |
read_flag [Nethttp_fs] |
read_policy [Netcgi_apache.Apache.Request] | Policy to apply by `setup_client_block` if the request message indicates a body.
readdir_flag [Netfs] |
readlink_flag [Netfs] |
real_value [Netasn1.Value] |
regexp [Netstring_str] | The type of regular expressions
regexp [Netstring_pcre] | The type of regular expressions; now based on `Pcre`
reject_code [Rpc_client] | Reaction on authentication problems: ``Fail`: Stop here, and report to user, ``Retry`: Just try again with current session, ``Renew`: Drop the current session, and get a new session from the current `auth_method`, ``Next`: Try the next authentication method
remove_flag [Netfs] |
rename_flag [Netfs] |
reply [Netftp_client] | Reply code plus text

representation [Netftp_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_flag [Netsys_gssapi] | Flags for the `init_sec_context` method

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 Continue" 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] |
res_id [Netmcore] | This tagged integer identifies resources.
resolver [Nethttp_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 [Nethttp_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()`, ``Device f`: The response is directly forwarded to the device obtained by `f()` (new since Ocamlnet-3.3) When the function `f` is called in the latter cases the response header has already been received, and can be retrieved with the `response_header` method of the call object.

result [Rpc_transport] |
result [Netstring_str] | The type of matching results
result [Netstring_pcre] | The type of matching results
result [Netcgi_apache.Handler] |
result_code [Netldap] |
result_eof [Rpc_transport] |
ret_flag [Netsys_gssapi] | Flags for the `accept_sec_context` method
rmdir_flag [Netfs] |
routine_error [Netsys_gssapi] | Possible errors caused by the provider
rp__list [Rpc_portmapper_aux] |
rpcb [Rpc_portmapper_aux] |
rpcb_entry [Rpc_portmapper_aux] |
rpcb_entry_list [Rpc_portmapper_aux] |
rpcb_entry_list_ptr [Rpc_portmapper_aux] |
rpcb_rmtcallargs [Rpc_portmapper_aux] |
rpcb_rmtcallres [Rpc_portmapper_aux] |
rpcb_stat [Rpc_portmapper_aux] |
rpcb_stat_byvers [Rpc_portmapper_aux] |
rpcblist_ptr [Rpc_portmapper_aux] |
rpcbs_addrlist [Rpc_portmapper_aux] |
rpcbs_addrlist_ptr [Rpc_portmapper_aux] |
rpcbs_proc [Rpc_portmapper_aux] |
rpcbs_rmtcalllist [Rpc_portmapper_aux] |
rpcbs_rmtcalllist_ptr [Rpc_portmapper_aux] |
rule [Rpc_server] |
runner [Uq_tcl] |
runner [Uq_gtk] |
S
s [Netplex_cenv.FUN_TYPE] | argument type
s [Netplex_cenv.LEVER] | argument type
s_extended_token [Netmime_string] | An opaque type containing the information of `s_token` plus: where the token occurs, RFC-2047 access functions
s_option [Netmime_string] |
s_param [Netmime_string] | The type of encoded parameters (RFC 2231)

s_token [Netmime_string]

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

sarray [Netmcore_array] | Arrays where the elements have type `'e` and the header has type `'h`
sarray2 [Netmcore_matrix] | Arrays where the elements have type `'e` and the header has type `'h`
sarray2_descr [Netmcore_matrix] | The marshallable descriptor of a shared matrix
sarray_descr [Netmcore_array] | The marshallable descriptor of a shared array
sasl_mechanism [Netsys_sasl] |
sc [Netsys_crypto_modes.Symmetric_cipher] |
sc_ctx [Netsys_crypto_modes.Symmetric_cipher] |
scipher [Netsys_crypto_types.SYMMETRIC_CRYPTO] | Describes a cipher
scipher_ctx [Netsys_crypto_types.SYMMETRIC_CRYPTO] | A cipher context stores processing data while encrypting or decrypting data
scope [Netldap] | The scope of the search: ``Base`: only the base object, ``One`: only the direct children of the base object, ``Sub`: the base object and all direct and indirect children
search_result [Netldap] | Search results are either entries or references: ``Entry(object_dn, [(attr_descr, values); ...])`, ``Reference urls`: The entry is not present on this server but can be looked up by following one of the `urls`
sem_kind [Netsys_posix] |
sem_open_flag [Netsys_sem] |
sem_open_flag [Netsys_posix] |
sem_wait_behavior [Netsys_sem] |
sem_wait_behavior [Netsys_posix] |
semaphore [Netsys_posix] |
semaphore [Netmcore_sem] |
serial [Netlog.Debug] | A serial number for the optional tracking of ownership
server_error [Rpc] |
server_error [Netmech_scram] | Error codes of this protocol
server_name [Netsys_crypto_types.TLS_PROVIDER] |
server_session [Netsys_sasl_types.SASL_MECHANISM] |
server_session [Netmech_scram] | Session context for servers

server_state [Netsys_sasl_types]

The state of the server session: ``Wait`: it is waited for the client response., ``Emit`: a new server challenge can be emitted., ``OK`: the authentication protocol succeeded, ``Auth_error`: authentication error (it is unspecified which; the string may be used for logging), ``Restart session_id`: this state can be entered after getting the first client response. It means that the saved session `session_id` may be restarted by calling `server_process_response_restart` with the client response.

service_factory [Nethttpd_plex] | The service factory function is called when a `service` configuration section of a certain type needs to be read.
session [Rpc_server] | identifies a pair of a call and a reply
session [Netsys_sasl.Server] |
session [Netsys_sasl.Client] |
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_posix] |
shm_table [Netshm] |
shm_type [Netshm] |
sig_action [Netsys_posix] |
sign_alg [Netx509_pubkey] |
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`.
size_flag [Netfs] |
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_compat] |
sockspec [Uq_client] | Extended names for socket addresses.
sockspec [Uq_engines] | Moved to `Uq_client.sockspec`
socksymbol [Netsockaddr] | Symbolic socket names:
specific_keys [Netmech_scram] | The specific keys to use
split_result [Netstring_str] |
split_result [Netstring_pcre] |
squeue [Netmcore_queue] | Queues where the elements have type `'e` and the header has type `'h`
squeue_descr [Netmcore_queue] | The marshallble descriptor of queues
sref [Netmcore_ref] |
sref_descr [Netmcore_ref] | The marshallable descriptor of a reference

state [Rpc_proxy.ManagedClient]

The state: ``Down`: The initial state, and also reached after a socket error, or after one of the shutdown functions is called. Although ``Down`, there might still some cleanup to do. When RPC functions are called, the client is automatically revived., ``Connecting`: This state is used while the initial ping is done. It does not reflect whether the client is really TCP-connected. Without initial ping, this state cannot occur., ``Up s`: The client is (so far known) up and can be used. `s` is the socket address of the local socket

state [Netsys_crypto_types.TLS_PROVIDER] | The state of a session:
state [Netpop] |

status [Nethttp_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)
status_type_t [Netgss_bindings] |
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] |
str_datum [Nettls_gnutls_bindings] |
str_datum_p [Nettls_gnutls_bindings] |
string_like [Uq_io] | The user can pass data buffers that base either on bytes or on bigarrays of char (memory).

structure [Netftp_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 `Netftp_data_endpoint.out_record_channel` and `Netftp_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.

subject_access_description_flag [Netx509] |
suppl_status [Netsys_gssapi] | Further flags
support_level [Rpc_auth_gssapi] |
support_level [Netsys_gssapi] |
support_level [Netftp_client] |
symlink_flag [Netfs] |
symmetric_crypto [Netsys_crypto_types] |
synchronization [Nethttp_client] | This type determines whether to keep requests and responses synchronized or not.
syslog_facility [Netsys_posix] | The facilities.
syslog_option [Netsys_posix] | The syslog options: ``Cons`: Fall back to console logging if syslog is unavailable, ``Ndelay`: Open the connection immediately, ``Odelay`: Open the connection at the first call `syslog` (default), ``Nowait`: Do not wait until it is ensured that the message is sent, ``Pid`: Log the PID with every message
T
t [Rpc_server] | represents a server for an RPC program
t [Rpc_portmapper] | represents a client for the Portmapper/RPCBIND daemon
t [Rpc_portmapper_clnt.Make'PMAP.V4] |
t [Rpc_portmapper_clnt.Make'PMAP.V3] |
t [Rpc_portmapper_clnt.Make'PMAP.V2] |
t [Rpc_simple_client] | The type of simple clients
t [Rpc_client.USE_CLIENT] | The client type
t [Rpc_client] | The type of RPC clients
t [Rpc_program] | Type of RPC programs
t [Netoid] |
t [Netpagebuffer] |
t [Nethttp.Cookie] | Functions to manipulate cookies.
t [Netdate] |
t [Netbuffer] |
t [Netaddress] | The union of `mailbox` and `group`
t [Netshm_array] |
t [Netshm_hashtbl] |
t [Netplex_mbox.MBOX] | The type of messages
t [Netplex_encap.TYPE] |
t [Netplex_encap.ENCAP] |
t [Netplex_sharedvar.VV_TYPE] |
t [Netplex_cenv.TYPE] |
t [Netplex_cenv.LEVER] |
t [Netplex_cenv.VAR_TYPE] |
t [Netmcore_hashtbl] | The type of hash tables from type `'a` to type `'b` and a header of type `'h`
t [Netcgi.Cookie] | Mutable cookie type.
t [Netcgi_common.Cookie] |
t [Netcgi_apache.Handler] | The type of handler functions.
t [Netcgi_apache.Apache.Request] | Apache `request_rec` structure.
t [Netcgi_apache.Apache.Connection] | Apache `conn_rec` structure.
t [Netcgi_apache.Apache.Server] | Apache `server_rec` structure.
t [Netcgi_apache.Apache.Table] | Apache `table` structure.
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] |
t_PMAP'V3'rpcbproc_callit'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_callit'res [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_dump'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_dump'res [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_getaddr'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_getaddr'res [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_gettime'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_gettime'res [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_null'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_null'res [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_set'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_set'res [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_taddr2uaddr'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_taddr2uaddr'res [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_uaddr2taddr'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_uaddr2taddr'res [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_unset'arg [Rpc_portmapper_aux] |
t_PMAP'V3'rpcbproc_unset'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_bcast'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_bcast'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_dump'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_dump'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_getaddr'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_getaddr'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_getaddrlist'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_getaddrlist'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_getstat'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_getstat'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_gettime'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_gettime'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_getversaddr'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_getversaddr'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_indirect'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_indirect'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_null'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_null'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_set'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_set'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_taddr2uaddr'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_taddr2uaddr'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_uaddr2taddr'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_uaddr2taddr'res [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_unset'arg [Rpc_portmapper_aux] |
t_PMAP'V4'rpcbproc_unset'res [Rpc_portmapper_aux] |
t_descr [Netmcore_hashtbl] | The marshallable descriptor of a shared hash table
table_row [Netcgi_modtpl] |
tag_class [Netasn1.Value] |
tbuffer [Netsys_types] | A tagged buffer.
telnet_command [Nettelnet_client] | A `telnet_command` is the interpretation of the octets in a Telnet session, i.e.

telnet_connector [Nettelnet_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 [Nettelnet_client] | `telnet_negotiated_option`: names for the most common options, and the generic name `Telnet_option` for other options.

telnet_option_state [Nettelnet_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 [Nettelnet_client] | `telnet_options`: modifies the behaviour of the client.
test_flag [Netfs] |
test_type [Netfs] | Tests: ``N`: the file name exists, ``E`: the file exists, ``D`: the file exists and is a directory, ``F`: the file exists and is regular, ``H`: the file exists and is a symlink (possibly to a non-existing target), ``R`: the file exists and is readable, ``W`: the file exists and is writable, ``X`: the file exists and is executable, ``S`: the file exists and is non-empty
text_data_repr [Netftp_data_endpoint] | Possible representation of text data: ``ASCII` means an ASCII-compatible encoding where the newline character is represented by CR/LF.
thread_sys_id [Netplex_types] | A system-specific identifier of the thread/process
time [Netsys_gssapi] |
time_subtype [Netasn1.Value] |
time_value [Netasn1.Value] |
timer [Netplex_cenv] | A timer
timer_expiration [Netsys_posix] |
timespec [Netsys_posix] | `(t,t_nanos)`: Specifies a time by a base time `t` to which the nanoseconds `t_nanos` are added.
tls_config [Netsys_crypto_types] |
tls_endpoint [Netsys_crypto_types] |
tls_mode [Netldap] | Options: ``Disabled`: do not negotiate TLS, ``Immediate`: assume that the connection directly requires TLS, ``StartTLS`: upgrade an initially unprotected connection to TLS, ``StartTLS_if_possible`: upgrade an unprotected connection to TLS if possible (i.e. if supported by both ends of the connection)
tls_provider [Netsys_crypto_types] |
token [Netsys_gssapi] | Authentication tokens.
transfer_coding [Nethttpd_kernel] |
transmission_mode [Netftp_client] | The transmission mode selects how the data are encoded in the data connection.
transmission_mode [Netftp_data_endpoint] | The transmission mode as described in RFC 959.
transport_layer_id [Nethttp] | see `Nethttp_client.transport_layer_id`
transport_layer_id [Nethttp_client] | The ID identifies a requirement for the transport channel, especially whether plain HTTP is sufficient, or HTTPS needs to be used, and if so, whether there are further requirements for the TLS context.
transport_layer_id [Nethttp_client_conncache] | Same as in `Nethttp_client.transport_layer_id`
tstring [Netsys_types] | A tagged string which is considered as immutable.
tstring_box [Netstring_tstring] | GADT for hiding the type parameter
tstring_kind [Netstring_tstring] | GADT for encoding the string type (string/bytes/bigarray)
tstring_ops [Netstring_tstring] | Operations to call on strings
tstring_ops_box [Netstring_tstring] | GADT for hiding the type parameter
tstring_polybox [Netstring_tstring] | GADT for hiding the type parameter.
type_name [Netasn1.Type_name] |
U
uaddr [Rpc_portmapper_aux] |
uint4 [Netnumber] | 32 bit unsigned integer
uint8 [Netnumber] | 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_gssapi] | What to return as user name: ``Exported_name`: the exported name in binary format (as described in RFC 2078, section 3.2). This format can only be read back by the `gss_api` object generating the name., ``Prefixed_name`: the display name in a text format "`{<oid>}<namestring>`"., ``Plain_name`: the string part of the display name

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.

user_name_interpretation [Rpc_auth_gssapi] |
V
valid_glob_expr [Netglob] | A validated `glob_expr`
value [Netasn1.Value] |
var [Netplex_sharedvar.VV_TYPE] |
var [Netcgi_modtpl] |
variable [Netsys_global] |
verbosity [Rpc_util] | How verbose the RPC ftrace is: ``Name_only`: For each RPC call only the name is logged, ``Name_abbrev_args`: The name and the abbreviated argument list are logged, ``Name_full_args`: The name and the full argument list are logged
versioned_value [Netplex_sharedvar] | Cache for the current value
W
w32_console_attr [Netsys_win32] |
w32_console_info [Netsys_win32] |
w32_console_mode [Netsys_win32] | See the msdn docs for GetConsoleMode for details
w32_event [Netsys_win32] |
w32_input_thread [Netsys_win32] |
w32_object [Netsys_win32] |
w32_output_thread [Netsys_win32] |
w32_pipe [Netsys_win32] | A pipe endpoint
w32_pipe_server [Netsys_win32] | A pipe server.
w32_process [Netsys_win32] | A handle to spawned processes
wait_entry [Netmcore_condition] | Each process that wants to `wait` needs a `wait_entry`.
wait_entry_e [Netmcore_condition] | A special kind of `wait_entry` for intergration into an event loop
wait_id [Unixqueue] | A wait identifier is used to distinguish between several timers, see type `operation`.
wait_set [Netmcore_condition] | A set of `wait_entry`, for easier management.
watched_subprocess [Netsys_posix] |
wd_spec [Netsys_posix] |
with_cursor_fun [Netconversion] | Helper type for `Netconversion.with_tstring_cursor`
with_fun [Netstring_tstring] | A polymorphic function for strings
workaround [Netcgi1_compat.Netcgi_env] | The `Work_around_` part has been dropped as it is clear at the spot of use.
write_common [Netfs] | The intersection of `write_flag` and `write_file_flag`
write_file_flag [Netfs] |
write_file_flag [Nethttp_fs] |
write_flag [Netfs] |
write_flag [Nethttp_fs] |
write_op [Netshm] |
X
x509_private_key [Netsys_crypto_types.PUBKEY_CRYPTO] | `(format,data)`, using the formats: "RSA", "DSA", "DH", "EC".
xdr_type [Netxdr] | This is the validated version of `xdr_type_term`.
xdr_type_system [Netxdr] | A validated type system.
xdr_type_term [Netxdr] |
xdr_type_term_system [Netxdr] | Bind names to types.
xdr_value [Netxdr] |
xdr_value_version [Netxdr] | Selects which version of `xdr_value` is returned by `unpack_xdr_value`.
xmap_value [Nethtml] |