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] | |
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_openpgp_crt_status_t [Nettls_gnutls_bindings] | |
gnutls_openpgp_keyring_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] | |
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] | |
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] | |
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] |
Parameters may occur quoted (
`Q ) or as already decoded values (`V )
|
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] | |
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] | |
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] |