| A | |
| abort [Nethttpd_kernel.http_protocol] | Stops the transmission of data. | 
| abort [Netftp_client.ftp_client_pi] | Shuts any active connection immediately down, and changes the
 state of the engine to  | 
| abort [Uq_engines_compat.cache_t] | |
| abort [Uq_engines_compat.engine] | |
| abort [Uq_engines.cache_t] | Any engine running to get the cache value is aborted, and the contents of the cache are invalidated. | 
| abort [Uq_engines.engine] | Forces that the engine aborts operation. | 
| abort [Uq_resolver.engine] | |
| abort_rw [Rpc_transport.rpc_multiplex_controller] | Aborts the current reader and/or writer forever. | 
| accept [Uq_engines_compat.server_endpoint_acceptor] | |
| accept [Uq_server.server_endpoint_acceptor] | Instantiates an engine that accepts connections on the listening endpoint. | 
| accept [Uq_engines.server_endpoint_acceptor] | |
| accept_body [Nethttpd_reactor.http_reactive_request] | Call this method to unlock the body channels. | 
| accept_sec_context [Netsys_gssapi.poly_gss_api] | On the first call, pass  | 
| acceptor_name [Netsys_gssapi.server_config] | |
| acquire_cred [Netsys_gssapi.poly_gss_api] | |
| activate_lever [Netplex_types.container] | Runs a lever function registered in the controller. | 
| activate_lever [Netplex_types.controller] | Runs the registered lever directly | 
| add [Netsys_pollset.pollset] | Add a descriptor or modify an existing descriptor | 
| add [Nethttp_client.pipeline] | Adds the call to the end of the pipeline. | 
| add_abort_action [Unixqueue_select.sb_event_system] | |
| add_abort_action [Unixqueue.event_system] | |
| add_admin [Netplex_types.controller] | 
 | 
| add_auth_handler [Nethttp_client.pipeline] | adds a new-style authentication handler | 
| add_close_action [Unixqueue_select.sb_event_system] | |
| add_close_action [Unixqueue.event_system] | |
| add_cred [Netsys_gssapi.poly_gss_api] | |
| add_e [Nethttp_client.pipeline] | The same as engine: The call  | 
| add_event [Unixqueue_select.sb_event_system] | |
| add_event [Unixqueue.event_system] | |
| add_handler [Unixqueue_select.sb_event_system] | |
| add_handler [Unixqueue.event_system] | |
| add_key [Nethttp_client.key_ring] | Adds a key to the ring | 
| add_memory [Netsys_digests.digest_ctx] | Add data | 
| add_message_receiver [Netplex_types.controller] | Adds a message receiver. | 
| add_plugin [Netplex_types.controller] | Adds a plugin. | 
| add_resource [Unixqueue_select.sb_event_system] | |
| add_resource [Unixqueue.event_system] | |
| add_service [Netplex_types.controller] | Adds a new service. | 
| add_subbytes [Netsys_digests.digest_ctx] | Add data | 
| add_substring [Netsys_digests.digest_ctx] | Add data | 
| add_tstring [Netsys_digests.digest_ctx] | Add data | 
| add_weak_resource [Unixqueue_select.sb_event_system] | |
| add_weak_resource [Unixqueue.event_system] | |
| add_with_callback [Nethttp_client.pipeline] | Adds the call to the end of the pipeline. | 
| addressed_server [Nettls_support.tls_session_props] | The name of the server (for name-based virtual servers). | 
| addresses [Netplex_types.protocol] | The addresses of the master sockets. | 
| adjust [Netplex_types.workload_manager] | This function is called by the controller at certain events to adjust the number of available containers. | 
| advance [Nethttpd_kernel.http_response] | Tell this object that  | 
| alive [Rpc_transport.rpc_multiplex_controller] | If the controller is alive, the socket is not yet completely down. | 
| alive [Uq_engines_compat.multiplex_controller] | |
| alive [Uq_multiplex.multiplex_controller] | If the controller is alive, the socket is not yet completely down. | 
| alive [Uq_engines.multiplex_controller] | |
| apop [Netpop.client] | Specifies the user and password using APOP authentication. | 
| argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| argument [Netcgi.cgi] | 
 | 
| argument [Netcgi_common.cgi] | |
| argument_exists [Netcgi.cgi] | 
 | 
| argument_exists [Netcgi_common.cgi] | |
| argument_value [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| argument_value [Netcgi.cgi] | 
 | 
| argument_value [Netcgi_common.cgi] | |
| arguments [Netcgi1_compat.Netcgi_types.cgi_activation] | Mutability of arguments has been dropped. | 
| arguments [Netcgi.cgi] | The complete list of arguments. | 
| arguments [Netcgi_common.cgi] | |
| as_bytes [Netsys_types.mstring] | |
| as_bytes [Netxdr_mstring.mstring] | Returns the contents as bytes. | 
| as_memory [Netsys_types.mstring] | |
| as_memory [Netxdr_mstring.mstring] | Returns the contents as memory. | 
| as_string [Netsys_types.mstring] | |
| as_string [Netxdr_mstring.mstring] | Returns the contents as string (this is always a copy) | 
| assoc_multi_req_header [Nethttp_client.http_call] | Return all header values for a given field name (header entries which allow several values separated by commas can also be transmitted by several header lines with the same name). | 
| assoc_multi_resp_header [Nethttp_client.http_call] | Return all response header values for a given field name (header entries which allow several values separated by commas can also be transmitted by several header lines with the same name). | 
| assoc_req_header [Nethttp_client.http_call] | Query a specific header entry, or raise  | 
| assoc_resp_header [Nethttp_client.http_call] | Query a specific header entry of the response. | 
| at_exit [Netcgi.cgi] | 
 | 
| at_exit [Netcgi_common.cgi] | |
| attach [Nettelnet_client.telnet_session] | Attach to the event system. | 
| auth [Netpop.client] | 
 | 
| auth [Netsmtp.client] | 
 | 
| auth_domain [Nethttp_client.auth_session] | The list of domain URIs defines the protection space. | 
| auth_method [Rpc_client.auth_protocol] | |
| auth_protocol [Rpc_client.auth_session] | Return the corresponding protocol | 
| auth_realm [Nethttp_client.auth_session] | The realm | 
| auth_scheme [Nethttp_client.auth_session] | The authentication scheme, e.g. | 
| auth_session_id [Nethttp_client.auth_session] | An optional ID which is only needed for multi-step authentication protocols (i.e. | 
| auth_status [Nethttp_client.http_call] | Authenticaton status. | 
| auth_user [Nethttp_client.auth_session] | The user identifier (UTF-8) | 
| authenticate [Rpc_server.auth_method] | 
 | 
| authenticate [Nethttp_client.auth_session] | Returns a list of additional headers that will authenticate the passed call for this session. | 
| authenticated [Netsmtp.client] | Whether the  | 
| avoid_proxy_for [Nethttp_client.pipeline] | sets a list of host names or domain suffixes for which no proxy should be used. | 
| B | |
| bidirectional_phase [Nethttpd_kernel.http_response] | The bidrectional phase starts after "100 Continue" has been sent to the client, and stops when the response body begins. | 
| blit_to_bytes [Netsys_types.mstring] | |
| blit_to_bytes [Netxdr_mstring.mstring] | 
 | 
| blit_to_memory [Netsys_types.mstring] | |
| blit_to_memory [Netxdr_mstring.mstring] | 
 | 
| blit_to_string [Netsys_types.mstring] | |
| blit_to_string [Netxdr_mstring.mstring] | |
| block_constraint [Netsys_ciphers.cipher] | The buffers used with encrypt/decrypt must have a length that is a multiple of this number. | 
| block_constraint [Netsys_ciphers.cipher_ctx] | The buffers used with encrypt/decrypt must have a length that is a multiple of this number. | 
| block_length [Netsys_digests.digest] | The block length of the hash function (for HMAC) in bytes | 
| block_size [Netstream.in_obj_stream] | The block size of the stream | 
| body_size [Nethttpd_kernel.http_response] | Accumulated size of the response body | 
| bool_param [Netplex_types.config_file] | |
| broadcast [Netsys_oothr.condition] | In a multi-threaded program: Signal all waiting processes that the condition holds. | 
| C | |
| call_plugin [Netplex_types.container] | 
 | 
| callback [Netcgi_modtpl.template] | Set a callback in the template. | 
| can_input [Uq_engines_compat.async_in_channel] | |
| can_input [Uq_transfer.async_in_channel] | Whether input is possible, i.e. | 
| can_input [Uq_engines.async_in_channel] | |
| can_output [Uq_engines_compat.async_out_channel] | |
| can_output [Uq_transfer.async_out_channel] | Whether output is possible, i.e. | 
| can_output [Uq_engines.async_out_channel] | |
| cancel [Netfs.stream_fs] | Cancels any ongoing  | 
| cancel [Nethttp_fs.http_stream_fs] | |
| cancel_rd_polling [Rpc_transport.rpc_multiplex_controller] | Cancels polling for the next input message. | 
| cancel_reading [Uq_engines_compat.multiplex_controller] | |
| cancel_reading [Uq_multiplex.multiplex_controller] | Cancels the read job. | 
| cancel_reading [Uq_engines.multiplex_controller] | |
| cancel_shutting_down [Rpc_transport.rpc_multiplex_controller] | Cancels the shutdown procedure. | 
| cancel_shutting_down [Uq_engines_compat.multiplex_controller] | |
| cancel_shutting_down [Uq_multiplex.multiplex_controller] | Cancels the shutdown procedure. | 
| cancel_shutting_down [Uq_engines.multiplex_controller] | |
| cancel_wait [Netsys_pollset.pollset] | There is a cancel bit in the pollset, and this method sets it to the argument value. | 
| cancel_writing [Uq_engines_compat.multiplex_controller] | |
| cancel_writing [Uq_multiplex.multiplex_controller] | Cancels the write job. | 
| cancel_writing [Uq_engines.multiplex_controller] | |
| canonicalize_name [Netsys_gssapi.poly_gss_api] | |
| capa [Netpop.client] | Requests a list of capabilities (RFC 2449). | 
| capabilities [Netpop.client] | The result of the last  | 
| capacity [Netplex_types.workload_manager] | Computes the capacity, i.e. | 
| cgi_auth_type [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_auth_type [Netcgi.cgi_environment] | |
| cgi_auth_type [Netcgi_common.cgi_environment] | |
| cgi_gateway_interface [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_gateway_interface [Netcgi.cgi_environment] | |
| cgi_gateway_interface [Netcgi_common.cgi_environment] | |
| cgi_https [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_https [Netcgi.cgi_environment] | A well-known extension is the HTTPS property. | 
| cgi_https [Netcgi_common.cgi_environment] | |
| cgi_path_info [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_path_info [Netcgi.cgi_environment] | |
| cgi_path_info [Netcgi_common.cgi_environment] | |
| cgi_path_translated [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_path_translated [Netcgi.cgi_environment] | |
| cgi_path_translated [Netcgi_common.cgi_environment] | |
| cgi_properties [Nethttpd_types.request_info] | The distilled CGI properties | 
| cgi_properties [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_properties [Netcgi.cgi_environment] | Return all properties as an associative list. | 
| cgi_properties [Netcgi_common.cgi_environment] | Return the parameter  | 
| cgi_property [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_property [Netcgi.cgi_environment] | Returns a (possibly non-standard) CGI environment property. | 
| cgi_property [Netcgi_common.cgi_environment] | |
| cgi_query_string [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_query_string [Netcgi.cgi_environment] | This is the row query string. | 
| cgi_query_string [Netcgi_common.cgi_environment] | |
| cgi_remote_addr [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_remote_addr [Netcgi.cgi_environment] | |
| cgi_remote_addr [Netcgi_common.cgi_environment] | |
| cgi_remote_host [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_remote_host [Netcgi.cgi_environment] | |
| cgi_remote_host [Netcgi_common.cgi_environment] | |
| cgi_remote_ident [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_remote_ident [Netcgi.cgi_environment] | |
| cgi_remote_ident [Netcgi_common.cgi_environment] | |
| cgi_remote_user [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_remote_user [Netcgi.cgi_environment] | |
| cgi_remote_user [Netcgi_common.cgi_environment] | |
| cgi_request_method [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_request_method [Netcgi.cgi_environment] | We recommend you to use the method  | 
| cgi_request_method [Netcgi_common.cgi_environment] | |
| cgi_request_uri [Nethttpd_types.v_extended_environment] | The full request URI. | 
| cgi_request_uri [Netcgi1_compat.Netcgi_env.cgi_environment] | I rest to be convinced we need this. | 
| cgi_script_name [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_script_name [Netcgi.cgi_environment] | |
| cgi_script_name [Netcgi_common.cgi_environment] | |
| cgi_server_name [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_server_name [Netcgi.cgi_environment] | |
| cgi_server_name [Netcgi_common.cgi_environment] | |
| cgi_server_port [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_server_port [Netcgi.cgi_environment] | |
| cgi_server_port [Netcgi_common.cgi_environment] | |
| cgi_server_protocol [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_server_protocol [Netcgi.cgi_environment] | |
| cgi_server_protocol [Netcgi_common.cgi_environment] | |
| cgi_server_software [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| cgi_server_software [Netcgi.cgi_environment] | |
| cgi_server_software [Netcgi_common.cgi_environment] | |
| change_user_to [Netplex_types.socket_service_config] | Instructs the container to change the user of the process after starting the service. | 
| charset [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| charset [Netcgi.cgi_argument] | The  | 
| charset [Netcgi_common.cgi_argument] | |
| cipher_algo [Nettls_support.tls_session_props] | The name of the algorithm for encrypting the data stream, e.g. | 
| cipher_suite_type [Nettls_support.tls_session_props] | A string describing the authentication and privacy mechanism that is in effect: "X509": X509 certificates are used, "OPENPGP": OpenPGP certificates are used, "ANON": anonymous credentials, "SRP": SRP credentials, "PSK": PSK credentials | 
| cleanup [Uq_lwt.lwt_backend] | |
| clear [Nethttp_client.tls_cache] | Clear the cache | 
| clear [Nethttp_client.key_ring] | Deletes all keys from this key ring | 
| clear [Unixqueue_select.sb_event_system] | |
| clear [Unixqueue.event_system] | |
| client_addr [Rpc_server.auth_details] | |
| close [Netfs.local_file] | Indicate that we are done with the file | 
| close [Nethttpd_reactor.http_reactor] | Closes the file descriptor with a reliable method. | 
| close [Netpop.client] | Closes the file descriptors | 
| close [Netsmtp.client] | Closes the file descriptors | 
| close [Netftp_fs.ftp_stream_fs] | Forces that the FTP client is closed. | 
| close_all [Nethttp_client_conncache.connection_cache] | Closes all descriptors known to the cache | 
| close_connection [Nethttpd_kernel.http_response] | Returns whether the connection should be closed after this response. | 
| close_connection [Nethttp_client_conncache.connection_cache] | Deletes the connection from the cache, and closes it | 
| close_in [Netchannels.augment_raw_in_channel] | As in  | 
| close_in [Netchannels.rec_in_channel] | Closes the channel for input. | 
| close_in [Uq_engines_compat.async_in_channel] | |
| close_in [Uq_transfer.async_in_channel] | Closes the channel | 
| close_in [Uq_engines.async_in_channel] | |
| close_out [Netchannels.augment_raw_out_channel] | As in  | 
| close_out [Netchannels.rec_out_channel] | Flushes the buffer, if any, and closes the channel for output. | 
| close_out [Uq_engines_compat.async_out_channel] | |
| close_out [Uq_transfer.async_out_channel] | Closes the channel | 
| close_out [Uq_engines.async_out_channel] | |
| cnt_crashed_connections [Nethttp_client.pipeline] | Counts connections with network or protocol errors | 
| cnt_failed_connections [Nethttp_client.pipeline] | Counts totally failed connections (no more reconnects allowed) | 
| cnt_new_connections [Nethttp_client.pipeline] | Counts new connections (or better: attempts to establish connections) | 
| cnt_server_eof_connections [Nethttp_client.pipeline] | Counts connections the server terminated with EOF | 
| cnt_successful_connections [Nethttp_client.pipeline] | Counts connections closed because pipelines become empty | 
| cnt_timed_out_connections [Nethttp_client.pipeline] | Counts connections given up because of timeouts | 
| code [Netldap.ldap_result] | The code,  | 
| command [Netsmtp.client] | Sends this command, and returns the status code and the status texts. | 
| commit_work [Netchannels.trans_out_obj_channel] | Flushes the transaction buffer, and writes its contents to the underlying resource. | 
| compare_name [Netsys_gssapi.poly_gss_api] | |
| compression_algo [Nettls_support.tls_session_props] | The name of the compression algorithm (or "NULL"), on the TLS layer. | 
| conditional [Netcgi_modtpl.template] | Set a conditional in the template. | 
| config [Nethttpd_kernel.http_protocol] | Just returns the configuration | 
| config [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| config [Netcgi.cgi_environment] | The configuration of the request. | 
| config [Netcgi_common.cgi_environment] | |
| config_announce_server [Nethttpd_kernel.http_protocol_config] | Whether to set the  | 
| config_cgi [Nethttpd_reactor.http_processor_config] | The CGI configuration to use in the Netcgi environment | 
| config_error_response [Nethttpd_reactor.http_processor_config] | Get HTML error text for the HTTP status code. | 
| config_error_response [Nethttpd_types.min_config] | |
| config_input_flow_control [Nethttpd_engine.http_engine_config] | If  | 
| config_internal [Netplex_types.processor_hooks] | For internal services, this list configures which message kind is used for which protocol. | 
| config_limit_pipeline_length [Nethttpd_kernel.http_protocol_config] | Limits the length of the pipeline (= unreplied requests). | 
| config_limit_pipeline_size [Nethttpd_kernel.http_protocol_config] | Limits the size of the pipeline in bytes. | 
| config_log_access [Nethttpd_reactor.http_processor_config] | Logs the access after the request/response cycle is complete. | 
| config_log_error [Nethttpd_reactor.http_processor_config] | 
 | 
| config_log_error [Nethttpd_types.min_config] | |
| config_max_header_length [Nethttpd_kernel.http_protocol_config] | Maximum size of the header, including the request line. | 
| config_max_reqline_length [Nethttpd_kernel.http_protocol_config] | Maximum size of the request line. | 
| config_max_trailer_length [Nethttpd_kernel.http_protocol_config] | Maximum size of the trailer | 
| config_output_flow_control [Nethttpd_engine.http_engine_config] | If  | 
| config_reactor_synch [Nethttpd_reactor.http_reactor_config] | Specifies when to synchronize output, i.e. | 
| config_suppress_broken_pipe [Nethttpd_kernel.http_protocol_config] | Whether to suppress  | 
| config_synch_input [Nethttpd_engine.http_engine_processing_config] | The "input synchronizer": It is called as  | 
| config_synch_output [Nethttpd_engine.http_engine_processing_config] | The "output synchronizer": It is called as  | 
| config_timeout [Nethttpd_reactor.http_processor_config] | General timeout for network I/O (per I/O primitive). | 
| config_timeout_next_request [Nethttpd_reactor.http_processor_config] | Timeout in seconds to wait for the next request after the previous one has been completely received. | 
| config_tls [Nethttpd_kernel.http_protocol_config] | If set, the server enables TLS with the arugment config | 
| config_tls_cert_props [Nethttpd_reactor.http_processor_config] | Whether to include certificate properties in the cgi environment. | 
| config_tls_remote_user [Nethttpd_reactor.http_processor_config] | |
| configure_slave_socket [Netplex_types.protocol] | A user-supplied function to configure slave sockets (after  | 
| configure_timeout [Netftp_client.ftp_client] | Configures a timeout for both the control and the data connection. | 
| configure_transport [Nethttp_client.pipeline] | 
 | 
| conn_limit [Netplex_types.socket_service_config] | An optional limit of the number of connections this container can accept. | 
| connect [Uq_engines_compat.client_endpoint_connector] | |
| connect [Uq_client.client_endpoint_connector] | Instantiates an engine that connects to the endpoint given by the
  | 
| connect [Uq_engines.client_endpoint_connector] | |
| connection_cache [Nethttp_client.pipeline] | The current connection cache. | 
| connections [Nethttp_client.pipeline] | Reports which connections exist:  | 
| container_count [Netplex_types.controller] | The number of containers for a certain socket service name | 
| container_event_system [Netplex_types.processor_hooks] | This method is called to get the event systems for containers. | 
| container_id [Netplex_types.container] | Return the container ID | 
| container_run [Netplex_types.processor_hooks] | 
 | 
| container_state [Netplex_types.socket_controller] | |
| containers [Netplex_types.controller] | Lists the containers | 
| containers_for [Netplex_types.controller] | Lists the containers for a certain socket service name | 
| content_type [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| content_type [Netcgi.cgi_argument] | Returns the content type of the header and its parameters as a
	couple  | 
| content_type [Netcgi_common.cgi_argument] | |
| content_type_params [Netcgi1_compat.Netcgi_types.cgi_argument] | Method  | 
| context_time [Netsys_gssapi.poly_gss_api] | |
| continue [Nethttp_client.transport_channel_type] | 
 | 
| controller_config [Netplex_types.netplex_config] | |
| controller_config [Netplex_types.socket_service_config] | Make this config accessible here too, for convenience | 
| controller_config [Netplex_types.controller] | |
| cookie [Netcgi.cgi_environment] | 
 | 
| cookie [Netcgi_common.cgi_environment] | |
| cookies [Netcgi1_compat.Netcgi_env.cgi_environment] | Cookies are returned in decoded form. | 
| cookies [Netcgi.cgi_environment] | Returns the list of valid cookies found in the request header. | 
| cookies [Netcgi_common.cgi_environment] | |
| copy [Netfs.stream_fs] | Copies a file to a new name. | 
| copy [Nethttp_fs.http_stream_fs] | |
| create [Netsys_digests.digest] | Start digestion | 
| create [Netsys_ciphers.cipher] | 
 | 
| create_condition [Netsys_oothr.mtprovider] | In a multi-threaded program: Creates a condition variable and returns the object. | 
| create_container [Netplex_types.socket_service] | Internal method. | 
| create_datagram_socket [Uq_engines_compat.datagram_socket_provider] | |
| create_datagram_socket [Uq_datagram.datagram_socket_provider] | Creates an engine that creates a  | 
| create_datagram_socket [Uq_engines.datagram_socket_provider] | |
| create_from_bytes [Netxdr_mstring.mstring_factory] | 
 | 
| create_from_memory [Netxdr_mstring.mstring_factory] | 
 | 
| create_from_string [Netxdr_mstring.mstring_factory] | 
 | 
| create_logger [Netplex_types.logger_factory] | |
| create_logger [Netplex_types.controller_config] | Create a logger to be used for the whole Netplex system. | 
| create_mem_mutex [Netplex_types.parallelizer] | 
 | 
| create_mutex [Netsys_oothr.mtprovider] | In a multi-threaded program: Creates a mutex and returns the object. | 
| create_processor [Netplex_types.processor_factory] | |
| create_proxy_session [Nethttp_client.auth_handler] | Same for proxy authentication (status 407) | 
| create_session [Nethttp_client.auth_handler] | Create a new authentication session. | 
| create_thread [Netsys_oothr.mtprovider] | In a multi-threaded program: Starts a new thread, and calls the
        passed function with the passed argument in the new thread
        (like  | 
| create_workload_manager [Netplex_types.workload_manager_factory] | |
| credential [Rpc_server.auth_details] | |
| credentials [Nethttp_client.key] | The key in the common "credentials" format that is used by generic mechanisms. | 
| ctrl_added [Netplex_types.plugin] | This method is invoked when the plugin has been added to this controller. | 
| ctrl_container_finished [Netplex_types.plugin] | This method is called when a container finishes 
        (after  | 
| ctrl_receive_call [Netplex_types.plugin] | 
 | 
| ctrl_unplugged [Netplex_types.plugin] | The plugin has been unplugged from this controller | 
| current_sys_id [Netplex_types.parallelizer] | Returns the system-dependent thread identifier of the caller | 
| cycle [Nethttpd_kernel.lingering_close] | Reads data from the file descriptor until EOF or until a fixed timeout is over. | 
| cycle [Nethttpd_kernel.http_protocol] | Looks at the file descriptor. | 
| D | |
| data [Netsmtp.client] | This method really send the mail. | 
| data [Netcgi_fcgi.cgi] | This the the channel on which the filter data is available. | 
| data_length [Netcgi_fcgi.cgi] | How many bytes of the data are available. | 
| data_mtime [Netcgi_fcgi.cgi] | The data last modification time, expressed as an integer number of seconds since the epoch (January 1, 1970 UTC). | 
| datagram_type [Uq_engines_compat.wrapped_datagram_socket] | |
| datagram_type [Uq_datagram.wrapped_datagram_socket] | |
| datagram_type [Uq_engines.wrapped_datagram_socket] | |
| decrypt [Netsys_ciphers.cipher_ctx] | 
 | 
| decrypt_bytes [Netsys_ciphers.cipher_ctx] | Decrypts this string as a whole | 
| decrypt_string [Netsys_ciphers.cipher_ctx] | Decrypts this string as a whole | 
| def_empty_path_replacement [Nethttp_client.generic_call] | |
| def_has_req_body [Nethttp_client.generic_call] | |
| def_has_resp_body [Nethttp_client.generic_call] | |
| def_is_idempotent [Nethttp_client.generic_call] | |
| def_request_method [Nethttp_client.generic_call] | The following methods define the values for the corresponding 
 methods without the  | 
| def_term [Nethttpd_types.http_service] | The definition term | 
| default_port [Nethttp_client.transport_channel_type] | If set, the  | 
| default_user_name [Netmech_scram_gssapi.client_key_ring] | This method may return a default user name | 
| dele [Netpop.client] | Marks the message number of the current mailbox for deletion. | 
| deleg_credential [Netsys_gssapi.server_props] | If a credential was delegated it is returned here as  | 
| delete_argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| delete_field [Netmime.mime_header] | These methods modify the fields of the header. | 
| delete_sec_context [Netsys_gssapi.poly_gss_api] | Output tokens are not supported (this is a deprecated feature of GSSAPI) | 
| descr [Netftp_data_endpoint.ftp_data_engine] | The socket to use for data transfers. | 
| descr_state [Netftp_data_endpoint.ftp_data_engine] | The socket state | 
| descriptor [Uq_engines_compat.wrapped_datagram_socket] | |
| descriptor [Uq_datagram.wrapped_datagram_socket] | The underlying file descriptor. | 
| descriptor [Uq_engines.wrapped_datagram_socket] | |
| dest_status [Nethttp_client.http_call] | Returns the status line of the last response (but status lines with code 100 are ignored). | 
| destroy [Rpc_client.auth_protocol] | Destroys the session (e.g. | 
| diag_msg [Netldap.ldap_result] | diagnostic message | 
| disable [Netplex_types.socket_controller] | Disable a socket service temporarily | 
| disable_local_option [Nettelnet_client.telnet_session] | |
| disable_remote_option [Nettelnet_client.telnet_session] | |
| display_minor_status [Netsys_gssapi.poly_gss_api] | Note that  | 
| display_name [Netsys_gssapi.poly_gss_api] | |
| dispose [Netsys_pollset.pollset] | Release any OS resources associated with the pollset. | 
| do_input [Nethttpd_kernel.http_protocol] | Returns  | 
| do_output [Nethttpd_kernel.http_protocol] | Returns  | 
| domain [Nethttp_client.key] | The domain URIs defining the protection space. | 
| duplicate_name [Netsys_gssapi.poly_gss_api] | |
| E | |
| effective_request_uri [Nethttp_client.http_call] | The URI actually sent to the server in the request line of the protocol. | 
| emit [Rpc_client.auth_protocol] | Emits a token for this  | 
| empty_path_replacement [Nethttp_client.http_call] | The string to substitute in the request line for the empty path. | 
| enable [Netplex_types.socket_controller] | Enables a disabled socket service again | 
| enable_local_option [Nettelnet_client.telnet_session] | |
| enable_remote_option [Nettelnet_client.telnet_session] | |
| encrypt [Netsys_ciphers.cipher_ctx] | 
 | 
| encrypt_bytes [Netsys_ciphers.cipher_ctx] | Encrypts this string as a whole | 
| encrypt_string [Netsys_ciphers.cipher_ctx] | Encrypts this string as a whole | 
| endpoint_credentials [Nettls_support.tls_session_props] | Returns the decoded credentials of this endpoint | 
| endpoint_credentials_raw [Nettls_support.tls_session_props] | Returns the credentials in the raw form. | 
| endpoint_credentials_type [Nettls_support.tls_session_props] | The type of credentials | 
| engine [Nethttpd_engine.http_engine_processing_context] | The engine doing HTTP | 
| enhanced_input [Netchannels.enhanced_raw_in_channel] | Works similar to  | 
| enhanced_input_line [Netchannels.enhanced_raw_in_channel] | An improved implementation of  | 
| environment [Nethttpd_engine.http_request_notification] | The request environment. | 
| environment [Nethttpd_engine.http_request_header_notification] | The request environment. | 
| environment [Nethttpd_reactor.http_reactive_request] | The Netcgi environment representing the request header, the response header, and the channels to receive the request body and to send the response body. | 
| environment [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| environment [Netcgi.cgi] | The environment object. | 
| environment [Netcgi_common.cgi] | |
| eq_name [Netx509.directory_name] | The name normalized for equality comparisons. | 
| eq_string [Netx509.directory_name] | The  | 
| error_message [Nethttpd_types.error_response_params] | The error message explaining the detail that went wrong | 
| event_system [Rpc_transport.rpc_multiplex_controller] | Returns the event system | 
| event_system [Netplex_types.container] | The event system the container uses | 
| event_system [Netplex_types.controller] | The event system used by the controller. | 
| event_system [Netftp_client.ftp_client_pi] | The used event system | 
| event_system [Netftp_client.ftp_client] | |
| event_system [Nethttp_client.pipeline] | Returns the event system | 
| event_system [Uq_engines_compat.multiplex_controller] | |
| event_system [Uq_engines_compat.engine_mixin] | |
| event_system [Uq_engines_compat.engine] | |
| event_system [Uq_multiplex.multiplex_controller] | Returns the event system | 
| event_system [Uq_engines.multiplex_controller] | |
| event_system [Uq_engines.engine_mixin] | |
| event_system [Uq_engines.engine] | Returns the event system the engine is attached to | 
| event_system [Uq_resolver.engine] | |
| exec [Netftp_client.ftp_client] | Runs the method synchronously. | 
| exec_e [Netftp_client.ftp_client_pi] | Run another command as engine. | 
| exec_e [Netftp_client.ftp_client] | Runs the method asynchronously as engine. | 
| exists_resource [Unixqueue_select.sb_event_system] | |
| exists_resource [Unixqueue.event_system] | |
| expect_input [Nettelnet_client.telnet_session] | Set whether the timeout value is to be applied to the input side of the connection. | 
| expn [Netsmtp.client] | Expand command :  | 
| export_name [Netsys_gssapi.poly_gss_api] | |
| export_sec_context [Netsys_gssapi.poly_gss_api] | |
| extensions [Netx509.x509_certificate] | Extensions (version 3 certificates) as triples  | 
| F | |
| fd [Nethttpd_kernel.lingering_close] | The file descriptor | 
| fd [Nethttpd_kernel.http_protocol] | Just returns the socket | 
| fetch_subnegotiation [Nettelnet_client.telnet_session] | This method should be called as follows:
 If you find a  | 
| field [Netmime.mime_header_ro] | |
| fields [Netmime.mime_header_ro] | |
| file_descr [Rpc_transport.rpc_multiplex_controller] | If the transport mechanism is on top of a file descriptor, this is returned here. | 
| file_exists [Netglob.glob_fsys] | Whether the file name is valid and refers to an existing file, or to a symlink pointing to an existing file. | 
| file_is_dir [Netglob.glob_fsys] | Whether the file name is valid and a directory, or a symlink to a directory. | 
| filename [Netfs.local_file] | The filename | 
| filename [Netplex_types.config_file] | |
| filename [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| filename [Netcgi.cgi_argument] | The  | 
| filename [Netcgi_common.cgi_argument] | |
| finalize [Netmime.mime_body_ro] | After the body has been finalized, it cannot be accessed any longer. | 
| finalize [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| finalize [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| finalize [Netcgi.cgi] | This method calls  | 
| finalize [Netcgi.cgi_argument] | Arguments stored in temp files must be deleted when the argument is no longer used. | 
| finalize [Netcgi_common.cgi_argument] | |
| finalize [Netcgi_common.cgi] | |
| find [Netsys_pollset.pollset] | Checks whether a descriptor is member of the set, and returns its event mask. | 
| find_inactive_connection [Nethttp_client_conncache.connection_cache] | Returns an inactive connection to the passed peer, or raise
  | 
| find_my_connections [Nethttp_client_conncache.connection_cache] | Returns all active connections owned by the object | 
| finish [Netsys_digests.digest_ctx] | Finish digestion, and return the digest | 
| finish [Nethttpd_reactor.http_reactive_request] | This method should be called after the request has been fully processed. | 
| finish_request [Nethttpd_reactor.http_reactive_request] | Reads the rest of the body (if any), and discards that data | 
| fixup_request [Nethttp_client.generic_call] | This method is called just before sending the request. | 
| flags [Netsys_gssapi.server_props] | Actual flags | 
| flags [Netsys_gssapi.server_config] | |
| flags [Netsys_gssapi.client_props] | Actual flags | 
| flags [Netsys_gssapi.client_config] | |
| flavors [Rpc_server.auth_method] | Which credential flavors are handled by this method | 
| float_param [Netplex_types.config_file] | |
| flush [Netchannels.augment_raw_out_channel] | As in  | 
| flush [Netchannels.rec_out_channel] | If there is a write buffer, it will be flushed. | 
| flush [Uq_engines_compat.async_out_channel] | |
| flush [Uq_transfer.async_out_channel] | Flushes the channel. | 
| flush [Uq_engines.async_out_channel] | |
| frame_len [Rpc_server.auth_details] | |
| free_resources [Netplex_types.controller] | Should be called when the controller is finished, in order to free resources again. | 
| front_token [Nethttpd_kernel.http_response] | The first token of the queue, represented as  | 
| ftp_client [Netftp_fs.ftp_stream_fs] | The FTP client backing this filesystem | 
| ftp_state [Netftp_client.ftp_client_pi] | Returns the current ftp_state | 
| G | |
| gc_when_idle [Netplex_types.socket_service_config] | If set, idle containers run a  | 
| generate_response [Nethttpd_types.http_service_generator] | Third stage of HTTP processing: This method is called when the HTTP request has been completely received, and the response is going to be generated. | 
| get [Nethttp_client.tls_cache] | Get a cached session (data string) | 
| get_connection_state [Nethttp_client_conncache.connection_cache] | Returns the state of the file descriptor, or raises  | 
| get_engine [Uq_engines_compat.cache_t] | |
| get_engine [Uq_engines.cache_t] | Requests the value. | 
| get_host [Nethttp_client.http_call] | The host name of the content server, extracted from the URI. | 
| get_local_option [Nettelnet_client.telnet_session] | |
| get_mic [Netsys_gssapi.poly_gss_api] | |
| get_opt [Uq_engines_compat.cache_t] | |
| get_opt [Uq_engines.cache_t] | Returns the cached value if available | 
| get_options [Nettelnet_client.telnet_session] | Get the configuration options. | 
| get_options [Nethttp_client.pipeline] | |
| get_path [Nethttp_client.http_call] | The path (incl. | 
| get_port [Nethttp_client.http_call] | The port number of the content server, extracted from the URI. | 
| get_reconnect_mode [Nethttp_client.http_call] | Get what to do if the server needs to be reconnected, i.e. | 
| get_redirect_mode [Nethttp_client.http_call] | By default, the redirect mode is  | 
| get_remote_option [Nettelnet_client.telnet_session] | |
| get_req_body [Nethttp_client.http_call] | What has been sent as body in the (last) request. | 
| get_req_header [Nethttp_client.http_call] | Deprecated. | 
| get_req_method [Nethttp_client.http_call] | Get the name of the request method. | 
| get_resp_body [Nethttp_client.http_call] | Deprecated. | 
| get_resp_header [Nethttp_client.http_call] | Deprecated. | 
| get_uri [Nethttp_client.http_call] | the full URI of this message: http://server:port/path. | 
| getpeername [Rpc_transport.rpc_multiplex_controller] | The address of the peer's socket. | 
| getsockname [Rpc_transport.rpc_multiplex_controller] | The address of this socket | 
| global_exception_handler [Netplex_types.processor_hooks] | This method is called when an uncaught exception would otherwise terminate the container. | 
| greedy_accepts [Netplex_workload.dynamic_workload_config] | Whether greedy accepts are permitted | 
| group [Uq_engines_compat.poll_engine] | |
| group [Uq_engines.poll_engine] | Returns the group the engine is member of | 
| gssapi_props [Rpc_client.auth_protocol] | Properties of the GSSAPI session (if existing) | 
| gssapi_props [Netpop.client] | Returns GSSAPI properties, if available | 
| gssapi_props [Netsmtp.client] | Returns GSSAPI properties, if available | 
| gssapi_props [Netftp_client.ftp_client_pi] | GSSAPI props if GSSAPI security is negotiated | 
| gssapi_props [Nethttp_client.http_call] | If GSSAPI is active, return the properties | 
| H | |
| has_req_body [Nethttp_client.http_call] | Whether the method allows to send a request body | 
| has_resp_body [Nethttp_client.http_call] | Whether the method allows to reply with a body. | 
| hello [Netplex_types.workload_manager] | Called by the controller when the service is added | 
| helo [Netsmtp.client] | Sends an EHLO command to the server. | 
| helo_response [Netsmtp.client] | The response from the last HELO or EHLO | 
| help [Netsmtp.client] | Performs the Help command. | 
| home_directory [Netglob.user_info] | Returns the home directory of the passed user, or the home directory of the current user for the empty string. | 
| hooks [Nethttpd_kernel.http_protocol] | Set hooks | 
| host_by_name [Uq_resolver.resolver] | Look up the passed host name up. | 
| I | |
| iana_hash_fn [Netsys_digests.digest] | Whether registered at IANA, and if so, which ID we use here | 
| iana_name [Netsys_digests.digest] | The name as registered by IANA (if registered) | 
| id [Netsys_oothr.thread] | In a multi-threaded program: Returns the thread ID. | 
| id [Nettls_support.tls_session_props] | The ID of the session (non-printable string) | 
| id [Netmcore.compute_resource] | an ID of the resource that is valid in the whole Netplex system | 
| identify_conn_by_name [Nethttp_client.transport_channel_type] | Whether connections must be identified by name, and not by IP address. | 
| identify_proxy_session [Nethttp_client.auth_handler] | Same for proxies. | 
| identify_session [Nethttp_client.auth_handler] | Extracts (mech_name,realm,sess_id,trans_id) if possible. | 
| import_name [Netsys_gssapi.poly_gss_api] | |
| import_sec_context [Netsys_gssapi.poly_gss_api] | |
| inactivate [Rpc_transport.rpc_multiplex_controller] | Inactivates the connection immediately, and releases any resources the controller is responsible for (e.g. | 
| inactivate [Uq_engines_compat.multiplex_controller] | |
| inactivate [Uq_multiplex.multiplex_controller] | Inactivates the connection immediately, and releases any resources the controller is responsible for (e.g. | 
| inactivate [Uq_engines.multiplex_controller] | |
| inactivity_timeout [Netplex_workload.dynamic_workload_config] | After this number of seconds a free thread can be terminated | 
| indicate_mechs [Netsys_gssapi.poly_gss_api] | |
| info_string [Netplex_types.par_thread] | Outputs the process or thread ID | 
| init [Netplex_types.parallelizer] | Initializes the main process for usage with this parallelizer. | 
| init_sec_context [Netsys_gssapi.poly_gss_api] | On the first call, pass  | 
| initial_argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| initial_argument_value [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| initial_arguments [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| initial_multiple_argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| initiator_cred [Netsys_gssapi.client_config] | |
| initiator_name [Netsys_gssapi.server_props] | The name of the initiator. | 
| initiator_name [Netsys_gssapi.client_config] | |
| initiator_name_exported [Netsys_gssapi.server_props] | The name of the initiator in exported format | 
| input [Netchannels.augment_raw_in_channel] | As in  | 
| input [Netchannels.rec_in_channel] | Reads octets from the channel and puts them into the string. | 
| input [Uq_engines_compat.async_in_channel] | |
| input [Uq_transfer.async_in_channel] | 
 | 
| input [Uq_engines.async_in_channel] | |
| input_body_size [Nethttpd_types.request_info] | The size of the input body. | 
| input_body_size [Nethttpd_types.v_extended_environment] | so far known, or 0L | 
| input_byte [Netchannels.compl_in_channel] | Reads exactly one octet from the channel and returns its code, 
 or raises  | 
| input_ch [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business. | 
| input_ch_async [Nethttpd_engine.extended_async_environment] | This is the  | 
| input_channel [Nethttpd_types.v_extended_environment] | The input channel for reading the body of the request | 
| input_char [Netchannels.compl_in_channel] | Reads exactly one character from the channel, or raises  | 
| input_content_length [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| input_content_length [Netcgi.cgi_environment] | Returns the  | 
| input_content_length [Netcgi_common.cgi_environment] | |
| input_content_type [Netcgi1_compat.Netcgi_env.cgi_environment] | Type now is  | 
| input_content_type [Netcgi.cgi_environment] | Returns the parsed  | 
| input_content_type [Netcgi_common.cgi_environment] | |
| input_content_type_string [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| input_content_type_string [Netcgi.cgi_environment] | Returns the  | 
| input_content_type_string [Netcgi_common.cgi_environment] | |
| input_eor [Netftp_data_endpoint.in_record_channel] | Skips over the remaining data of the current record and the record boundary to the next record. | 
| input_header [Nethttpd_types.request_info] | The request header. | 
| input_header [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| input_header [Netcgi.cgi_environment] | The whole HTTP header. | 
| input_header [Netcgi_common.cgi_environment] | For special header structures, just override this method. | 
| input_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| input_header_field [Netcgi.cgi_environment] | 
 | 
| input_header_field [Netcgi_common.cgi_environment] | |
| input_header_fields [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| input_header_fields [Netcgi.cgi_environment] | Returns the input header as (name,value) pairs. | 
| input_header_fields [Netcgi_common.cgi_environment] | |
| input_line [Netchannels.compl_in_channel] | Reads the next line from the channel. | 
| input_queue [Nettelnet_client.telnet_session] | The queue of commands received from the remote side. | 
| input_state [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business. | 
| input_timeout_class [Nethttpd_kernel.http_protocol] | Suggests the calculation of a timeout value for input:  | 
| inquire_context [Netsys_gssapi.poly_gss_api] | |
| inquire_cred [Netsys_gssapi.poly_gss_api] | |
| inquire_cred_by_mech [Netsys_gssapi.poly_gss_api] | |
| inquire_key [Nethttp_client.key_handler] | The method is called when a new session must be authenticated. | 
| inquire_mechs_for_name [Netsys_gssapi.poly_gss_api] | |
| inquire_names_for_mech [Netsys_gssapi.poly_gss_api] | |
| int_param [Netplex_types.config_file] | |
| integrity [Netsys_gssapi.server_config] | |
| integrity [Netsys_gssapi.client_config] | |
| internal_sockets [Netplex_types.socket_service] | The internal sockets for internal services: pairs of
        ( | 
| invalidate [Rpc_server.auth_method] | Remove all auth sessions | 
| invalidate [Nethttp_client.auth_session] | The session is notified that authentication failed. | 
| invalidate [Uq_engines_compat.cache_t] | |
| invalidate [Uq_engines.cache_t] | Invalidates the cache - if a value exists in the cache, it is removed. | 
| invalidate_connection [Rpc_server.auth_method] | Removes all auth sessions for this connection | 
| invalidate_key [Nethttp_client.key_handler] | The handler is notified that authentication failed for this key | 
| ipv6 [Uq_resolver.resolver] | Whether  | 
| is_empty [Netftp_client.ftp_client_pi] | Whether the queue is empty | 
| is_idempotent [Nethttp_client.http_call] | Whether the method is to be considered as idempotent ( = repeated invocations have the same result and no side effect). | 
| is_no_credential [Netsys_gssapi.poly_gss_api] | A test for  | 
| is_no_name [Netsys_gssapi.poly_gss_api] | A test for  | 
| is_proxy_allowed [Nethttp_client.http_call] | Deprecated. | 
| is_running [Unixqueue_select.sb_event_system] | |
| is_running [Unixqueue.event_system] | |
| is_served [Nethttp_client.http_call] | 
 | 
| issuer [Netx509.x509_certificate] | The DN of the issuer | 
| issuer_unique_id [Netx509.x509_certificate] | The unique ID of the issuer | 
| iter [Uq_lwt.lwt_backend] | |
| iv_lengths [Netsys_ciphers.cipher] | Supported iv lengths as pairs  | 
| J | |
| job [Shell_uq.job_handler_engine_type] | Returns the called job | 
| job [Shell_sys.job_handler_engine_type] | Returns the called job | 
| job_instance [Shell_uq.job_handler_engine_type] | Returns the job instance | 
| job_instance [Shell_sys.job_handler_engine_type] | Returns the job instance | 
| join [Netsys_oothr.thread] | In a multi-threaded program: Suspends the calling thread until this thread terminates. | 
| K | |
| key_lengths [Netsys_ciphers.cipher] | Supported key lengths as pairs  | 
| keys [Nethttp_client.key_ring] | List of all known keys | 
| kx_algo [Nettls_support.tls_session_props] | The name of the key exchange algorithm, e.g. | 
| L | |
| last_ftp_state [Netftp_fs.ftp_stream_fs] | The last state of the last operation, or  | 
| last_response_header [Nethttp_fs.http_stream_fs] | Returns the header of the HTTP response of the last operation. | 
| last_response_status [Nethttp_fs.http_stream_fs] | Return the response status of the last operation, as triple
         | 
| last_stderr [Shell_fs.shell_stream_fs] | The stderr output of the last operation | 
| ldap_endpoint [Netldap.ldap_server] | |
| ldap_peer_name [Netldap.ldap_server] | |
| ldap_timeout [Netldap.ldap_server] | |
| ldap_tls_config [Netldap.ldap_server] | |
| ldap_tls_mode [Netldap.ldap_server] | |
| length [Netsys_types.mstring] | |
| length [Netxdr_mstring.mstring] | The length of the managed string | 
| lingering [Nethttpd_kernel.lingering_close] | Whether the socket is still lingering | 
| list [Netpop.client] | Returns the scan listing for an optional message number or for all messages in the current mailbox. | 
| listen [Uq_engines_compat.server_endpoint_listener] | |
| listen [Uq_engines.server_endpoint_listener] | |
| listen_options [Rpc_server.socket_config] | |
| local_chmod [Netplex_types.protocol] | Whether to chmod Unix Domain sockets | 
| local_chown [Netplex_types.protocol] | Whether to chown (user,group) Unix Domain sockets | 
| local_receiver [Netftp_data_endpoint.ftp_data_receiver] | The local receiver. | 
| local_sender [Netftp_data_endpoint.ftp_data_sender] | The local sender. | 
| lock [Netsys_oothr.mutex] | In a multi-threaded program: Suspends the calling thread until the mutex is locked. | 
| log [Netplex_types.container] | Sends a log message to the controller. | 
| log [Netplex_types.logger] | Same as  | 
| log_access [Nethttpd_reactor.internal_environment] | |
| log_component [Netplex_log.generic_config] | |
| log_directory [Netplex_log.multi_file_config] | |
| log_error [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| log_error [Netcgi.cgi_environment] | 
 | 
| log_error [Netcgi_common.cgi_environment] | You may want to override this with your custom logging method. | 
| log_facility [Netplex_log.syslog_config] | |
| log_files [Netplex_log.multi_file_config] | Triples  | 
| log_format [Netplex_log.generic_config] | |
| log_identifier [Netplex_log.syslog_config] | |
| log_max_level [Netplex_log.generic_config] | |
| log_props [Nethttpd_types.v_extended_environment] | Remember this version of  | 
| log_subch [Netplex_types.container] | Sends a log message to the controller. | 
| log_subch [Netplex_types.logger] | Receive a log  | 
| log_subchannel [Netplex_log.generic_config] | |
| logger [Netplex_types.controller] | The logger | 
| lookup [Netplex_types.container] | 
 | 
| lookup_container_sockets [Netplex_types.container] | 
 | 
| lstn_backlog [Netplex_types.protocol] | The backlog (argument of Unix.listen) | 
| lstn_reuseaddr [Netplex_types.protocol] | Whether to reuse ports immediately | 
| M | |
| mac [Netsys_ciphers.cipher_ctx] | Returns the MAC for AEAD ciphers. | 
| mac [Netchannels_crypto.crypto_in_filter] | Get the MAC of the processed data | 
| mac [Netchannels_crypto.crypto_out_filter] | Get the MAC of the processed data | 
| mac_algo [Nettls_support.tls_session_props] | The name of the data integrity algorithm (actually only the digest algorithm for HMAC), e.g. | 
| mail [Netsmtp.client] | Performs a MAIL FROM command. | 
| mailboxes [Netaddress.group] | The member mailboxes | 
| matched_dn [Netldap.ldap_result] | The matchedDN field sent with some codes | 
| max_free_job_capacity [Netplex_workload.dynamic_workload_config] | If more job capacity is available than this number, threads are terminated. | 
| max_jobs_per_thread [Netplex_workload.dynamic_workload_config] | How many jobs every thread can execute concurrently until it is considered as fully loaded. | 
| max_level [Netplex_types.controller_config] | Return the maximum global log level | 
| max_response_body_length [Nethttp_client.http_call] | Returns the current maximum length (initially  | 
| max_threads [Netplex_workload.dynamic_workload_config] | The manager does not start more threads than this number | 
| mech_type [Netsys_gssapi.server_props] | Actual mechanism | 
| mech_type [Netsys_gssapi.client_props] | Actual mechanism | 
| mech_type [Netsys_gssapi.client_config] | |
| mech_types [Netsys_gssapi.server_config] | |
| mem_supported [Uq_engines_compat.multiplex_controller] | |
| mem_supported [Uq_multiplex.multiplex_controller] | Whether  | 
| mem_supported [Uq_engines.multiplex_controller] | |
| message [Rpc_server.auth_details] | |
| min_free_job_capacity [Netplex_workload.dynamic_workload_config] | The manager starts as many threads as required to ensure that this number of jobs can be executed. | 
| mkdir [Netfs.stream_fs] | Creates a new directory. | 
| mkdir [Nethttp_fs.http_stream_fs] | |
| mlst_enabled_facts [Netftp_client.ftp_client_pi] | The enabled facts for  | 
| mlst_facts [Netftp_client.ftp_client_pi] | All available facts for  | 
| mode [Netsys_ciphers.cipher] | The mode of the cipher | 
| multiple_argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| multiple_argument [Netcgi.cgi] | 
 | 
| multiple_argument [Netcgi_common.cgi] | |
| multiple_connections [Uq_engines_compat.server_endpoint_acceptor] | |
| multiple_connections [Uq_server.server_endpoint_acceptor] | Whether it is possible to accept multiple connections | 
| multiple_connections [Uq_engines.server_endpoint_acceptor] | |
| multiple_field [Netmime.mime_header_ro] | The current fields of the header. | 
| multiple_input_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| multiple_input_header_field [Netcgi.cgi_environment] | Returns the values of all fields with the passed name of the request header. | 
| multiple_input_header_field [Netcgi_common.cgi_environment] | |
| multiple_output_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| multiple_output_header_field [Netcgi.cgi_environment] | Returns the values of all fields with the passed name of the repsonse header. | 
| multiple_output_header_field [Netcgi_common.cgi_environment] | |
| multiplexing [Rpc_server.socket_config] | |
| multiplexing [Rpc_client.socket_config] | |
| N | |
| n_connections [Netplex_types.container] | The current number of connections | 
| n_total [Netplex_types.container] | The sum of all connections so far | 
| name [Rpc_server.auth_method] | The name of the authentication method | 
| name [Rpc_client.auth_method] | The name of this method, used for errors etc. | 
| name [Netsys_digests.digest] | The name conventionally follows the  | 
| name [Netsys_ciphers.cipher] | The name of the cipher | 
| name [Netsys_posix.post_fork_handler] | |
| name [Netx509.directory_name] | This is the raw version of the DN: a sequence of relative DNs, and a relative DN is a set of (type,value) pairs. | 
| name [Netaddress.group] | The name of the group | 
| name [Netaddress.mailbox] | The name of the mailbox. | 
| name [Netplex_types.logger_factory] | |
| name [Netplex_types.workload_manager_factory] | |
| name [Netplex_types.processor_factory] | |
| name [Netplex_types.ctrl_message_receiver] | The name of this receiver | 
| name [Netplex_types.protocol] | The protocol name is an arbitrary string identifying groups of
 sockets serving the same protocol for a  | 
| name [Netplex_types.socket_service_config] | The proposed name for the  | 
| name [Netplex_types.socket_service] | The name of the  | 
| name [Nethttpd_types.http_service] | The name of the type of the service provider | 
| name [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| name [Netcgi.cgi_argument] | The name of the argument. | 
| name [Netcgi_common.cgi_argument] | |
| need_ip6 [Netftp_client.ftp_client_pi] | Whether  | 
| need_linger [Nethttpd_kernel.http_protocol] | Returns  | 
| new_group [Unixqueue_select.sb_event_system] | |
| new_group [Unixqueue.event_system] | |
| new_session [Rpc_client.auth_method] | Request a new session. | 
| new_wait_id [Unixqueue_select.sb_event_system] | |
| new_wait_id [Unixqueue.event_system] | |
| next_credentials [Rpc_client.auth_session] | Called with  | 
| next_request [Nethttpd_reactor.http_reactor] | Tries to read the next request. | 
| no_credential [Netsys_gssapi.poly_gss_api] | A substitute credential for  | 
| no_name [Netsys_gssapi.poly_gss_api] | A substitute name for  | 
| no_proxy [Nethttp_client.http_call] | Same as  | 
| nominal_dot_dot [Netfs.stream_fs] | Whether the effect of  | 
| nominal_dot_dot [Nethttp_fs.http_stream_fs] | |
| non_blocking_connect [Rpc_client.socket_config] | 
 | 
| noop [Netpop.client] | Pings the server to keep the session alive. | 
| noop [Netsmtp.client] | NOOP : does nothing, keeps the connection alive. | 
| notify [Uq_engines_compat.engine_mixin] | |
| notify [Uq_engines.engine_mixin] | |
| number_of_open_connections [Nethttp_client.pipeline] | Returns the number of connections which are open at the same time and currently being used by this object (i.e. | 
| number_of_open_messages [Nethttp_client.pipeline] | Returns the number of messages which are still in the pipeline. | 
| O | |
| offer_local_option [Nettelnet_client.telnet_session] | |
| oid [Netsys_digests.digest] | The OID (if registered) | 
| on_add [Netplex_types.socket_service] | Get some runtime configuration aspects from this controller. | 
| open_value_rd [Netmime.mime_body_ro] | Opens the value for reading. | 
| open_value_rd [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| open_value_rd [Netcgi.cgi_argument] | Open the contents of the value as an input channel. | 
| open_value_rd [Netcgi_common.cgi_argument] | |
| open_value_wr [Netcgi1_compat.Netcgi_types.cgi_argument] | See  | 
| open_value_wr [Netmime.mime_body] | Opens the value for writing. | 
| open_value_wr [Netcgi.rw_cgi_argument] | |
| open_value_wr [Netcgi_common.rw_cgi_argument] | |
| option_negotiation_is_over [Nettelnet_client.telnet_session] | |
| out_channel [Netcgi.cgi] | The output channel to which the generated content is intended to be written. | 
| out_channel [Netcgi.cgi_environment] | The "raw" output channel. | 
| out_channel [Netcgi_common.cgi] | |
| out_channel [Netcgi_common.cgi_environment] | |
| output [Netchannels.augment_raw_out_channel] | As in  | 
| output [Netchannels.rec_out_channel] | Takes octets from the string and writes them into the channel. | 
| output [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| output [Netcgi.cgi] | |
| output [Netcgi_common.cgi] | |
| output [Netcgi_modtpl.template] | 
 | 
| output [Uq_engines_compat.async_out_channel] | |
| output [Uq_transfer.async_out_channel] | 
 | 
| output [Uq_engines.async_out_channel] | |
| output_body_size [Nethttpd_types.full_info] | The size of the output body. | 
| output_buffer [Netchannels.compl_out_channel] | Writes exactly the contents of the buffer | 
| output_byte [Netchannels.compl_out_channel] | Writes exactly one byte passed as integer code | 
| output_bytes [Netchannels.compl_out_channel] | Writes exactly the passed string | 
| output_ch [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| output_ch [Netcgi.cgi_environment] | |
| output_ch [Netcgi_common.cgi_environment] | |
| output_ch_async [Nethttpd_engine.extended_async_environment] | This is the  | 
| output_channel [Netchannels.compl_out_channel] | Writes the contents of an  | 
| output_char [Netchannels.compl_out_channel] | Writes exactly one character | 
| output_eor [Netftp_data_endpoint.out_record_channel] | Finishes the current record. | 
| output_header [Nethttpd_types.full_info] | The response header | 
| output_header [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| output_header [Netcgi.cgi_environment] | The whole HTTP response header | 
| output_header [Netcgi_common.cgi_environment] | For special header structures, override this method and
	maybe  | 
| output_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| output_header_field [Netcgi.cgi_environment] | Returns the value of a field of the response header. | 
| output_header_field [Netcgi_common.cgi_environment] | |
| output_header_fields [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| output_header_fields [Netcgi.cgi_environment] | Returns the output header as (name,value) pairs. | 
| output_header_fields [Netcgi_common.cgi_environment] | |
| output_queue [Nettelnet_client.telnet_session] | The queue of commands to send to the remote side. | 
| output_state [Nethttpd_types.v_extended_environment] | Reflects the state of the output generation:  | 
| output_state [Nethttpd_types.extended_environment] | |
| output_state [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business. | 
| output_string [Netchannels.compl_out_channel] | Writes exactly the passed string | 
| owned_container_sockets [Netplex_types.container] | List of pairs  | 
| P | |
| padding [Netsys_ciphers.cipher_ctx] | The padding scheme of the cipher | 
| parallelizer [Netplex_types.par_thread] | Returns the parallelizer that created this thread. | 
| partial_value [Netldap.ldap_result] | the value so far available, independently of the code | 
| pass [Netpop.client] | Authenticates a user with the plain-text password  | 
| password [Nethttp_client.key] | The password in cleartext (UTF-8) | 
| password_of_user_name [Netmech_scram_gssapi.client_key_ring] | Returns the cleartext password for a user name, or
	raises  | 
| path_encoding [Netglob.glob_fsys] | Paths of filesystems may be encoded | 
| path_encoding [Netglob.user_info] | Paths of filesystems may be encoded | 
| path_encoding [Netfs.stream_fs] | The encoding must be ASCII-compatible
	( | 
| path_encoding [Nethttp_fs.http_stream_fs] | |
| path_exclusions [Netfs.stream_fs] | Code points that must not occur in path components between slashes. | 
| path_exclusions [Nethttp_fs.http_stream_fs] | |
| peek [Rpc_server.auth_method] | If available, this function is called for every accepted connection. | 
| peek_recv [Nethttpd_kernel.http_protocol] | Peeks the first token, but leaves it in the queue. | 
| peer_credentials [Nettls_support.tls_session_props] | Returns the decoded peer credentials | 
| peer_credentials_raw [Nettls_support.tls_session_props] | Returns the peer credentials in the raw form. | 
| peer_credentials_type [Nettls_support.tls_session_props] | The type of credentials | 
| peer_user_name [Rpc_transport.rpc_multiplex_controller] | If the transport mechanism provides a way to authenticate the peer, it can return the name here. | 
| pi [Netftp_client.ftp_client] | The curerent protocol interpreter. | 
| pipeline [Nethttp_fs.http_stream_fs] | The HTTP pipeline backing this file system | 
| pipeline_len [Nethttpd_kernel.http_protocol] | Returns the number of unanswered requests = Number of received  | 
| pos_in [Netchannels.augment_raw_in_channel] | As in  | 
| pos_in [Netchannels.raw_in_channel] | Returns the current channel position. | 
| pos_in [Uq_engines_compat.async_in_channel] | |
| pos_in [Uq_transfer.async_in_channel] | Returns the number of characters read from the channel | 
| pos_in [Uq_engines.async_in_channel] | |
| pos_out [Netchannels.augment_raw_out_channel] | As in  | 
| pos_out [Netchannels.raw_out_channel] | Returns the current channel position. | 
| pos_out [Uq_engines_compat.async_out_channel] | |
| pos_out [Uq_transfer.async_out_channel] | Returns the number of characters output into the channel | 
| pos_out [Uq_engines.async_out_channel] | |
| post_add_hook [Netplex_types.processor_hooks] | A user-supplied function that is called after the service has been added to the controller | 
| post_finish_hook [Netplex_types.processor_hooks] | A user-supplied function that is called after the container is terminated. | 
| post_rm_hook [Netplex_types.processor_hooks] | A user-supplied function that is called after the service has been removed from the controller | 
| post_start_hook [Netplex_types.processor_hooks] | A user-supplied function that is called after the container is created and started, but before the first service request arrives. | 
| pre_finish_hook [Netplex_types.processor_hooks] | A user-supplied function that is called just before the container is terminated. | 
| pre_start_hook [Netplex_types.processor_hooks] | A user-supplied function that is called before the container is created and started. | 
| preferred [Netsys_types.mstring] | |
| preferred [Netxdr_mstring.mstring] | Whether  | 
| print [Netplex_types.config_file] | |
| print [Nethttpd_types.http_service] | Outputs the definition term to a formatter | 
| prioritized [Uq_engines_compat.prioritizer_t] | |
| prioritized [Uq_engines.prioritizer_t] | 
 | 
| privacy [Netsys_gssapi.server_config] | |
| privacy [Netsys_gssapi.client_config] | |
| private_api [Nethttp_client.http_call] | |
| procedure [Rpc_server.auth_details] | |
| process [Netplex_kit.v_processor] | |
| process [Netplex_types.processor] | A user-supplied function that is called when a new socket connection is established. | 
| process_body [Nethttpd_types.http_service_receiver] | Second stage of HTTP processing: This method is called when the body is expected to be arriving. | 
| process_context_token [Netsys_gssapi.poly_gss_api] | |
| process_header [Nethttpd_types.http_service] | First stage of HTTP processing: This method is called when the HTTP header has been received. | 
| process_internal [Netplex_types.processor_hooks] | 
 | 
| process_option_command [Nettelnet_client.telnet_session] | |
| processor [Netplex_types.socket_service] | A user-supplied object to process incoming connections | 
| program [Rpc_server.auth_details] | |
| program [Netplex_types.plugin] | The RPC program structure on which the messaging bases. | 
| propagate [Netsys_global.propagator] | 
 | 
| protocol [Rpc_transport.rpc_multiplex_controller] | The protocol encapsulation | 
| protocol [Nettls_support.tls_session_props] | The name of the TLS protocol version, e.g. | 
| protocol [Nethttpd_kernel.http_response] | The HTTP version of the response. | 
| protocol [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| protocol [Netcgi.cgi_environment] | The server protocol in a decoded form. | 
| protocol [Netcgi_common.cgi_environment] | |
| protocols [Netplex_types.socket_service_config] | This list describes the sockets to create in detail | 
| provider [Netsys_gssapi.poly_gss_api] | A string name identifying the provider | 
| proxy_enabled [Nethttp_client.http_call] | Returns the proxy mode | 
| proxy_type [Nethttp_client.pipeline] | 
 | 
| proxy_type_of_call [Nethttp_client.pipeline] | Same for an already created call object | 
| proxy_use_connect [Nethttp_client.http_call] | Whether to use the CONNECT method if the connection is made via a web proxy. | 
| ptype [Netplex_types.netplex_config] | |
| ptype [Netplex_types.parallelizer] | |
| ptype [Netplex_types.par_thread] | |
| ptype [Netplex_types.container] | The parallelization type actually used for this container | 
| ptype [Netplex_types.controller] | The actually effective parallelization type | 
| public_key [Netx509.x509_certificate] | The subject's public key | 
| public_key_algorithm [Netx509.x509_certificate] | The algorithm of the public key (OID, and algorithm-specific parameters) | 
| put [Uq_engines_compat.cache_t] | |
| put [Uq_engines.cache_t] | Puts a value immediately into the cache. | 
| Q | |
| queue_events [Unixqueue_select.sb_event_system] | |
| quit [Netpop.client] | Requests the server to end this session. | 
| quit [Netsmtp.client] | Requests the server to end this session. | 
| R | |
| rcpt [Netsmtp.client] | Performs a RCPT TO command. | 
| read [Netfs.stream_fs] | 
 | 
| read [Nethttp_fs.http_stream_fs] | Additional flag:  | 
| read_dir [Netglob.glob_fsys] | Returns the file names contained in the directory, without path. | 
| read_eof [Rpc_transport.rpc_multiplex_controller] | Whether the EOF marker has been read | 
| read_eof [Uq_engines_compat.multiplex_controller] | |
| read_eof [Uq_multiplex.multiplex_controller] | Whether the EOF marker has been read | 
| read_eof [Uq_engines.multiplex_controller] | |
| read_file [Netfs.stream_fs] | 
 | 
| read_file [Nethttp_fs.http_stream_fs] | Additional flag:  | 
| readdir [Netfs.stream_fs] | Reads the contents of a directory. | 
| readdir [Nethttp_fs.http_stream_fs] | |
| reading [Rpc_transport.rpc_multiplex_controller] | True iff there is a reader | 
| reading [Uq_engines_compat.multiplex_controller] | |
| reading [Uq_multiplex.multiplex_controller] | True iff there is a reader | 
| reading [Uq_engines.multiplex_controller] | |
| readlink [Netfs.stream_fs] | Reads the target of a symlink | 
| readlink [Nethttp_fs.http_stream_fs] | |
| really_input [Netchannels.compl_in_channel] | Reads exactly as many octets from the channel as the second  | 
| really_input_string [Netchannels.compl_in_channel] | 
 | 
| really_output [Netchannels.compl_out_channel] | Writes exactly as many octets to the channel as the second  | 
| really_output_string [Netchannels.compl_out_channel] | Same for strings | 
| realm [Nethttp_client.key] | The realm | 
| receive [Rpc_client.auth_protocol] | Receive a token for the  | 
| receive [Nethttpd_kernel.http_protocol] | Returns the first  | 
| receive_admin_message [Netplex_types.processor_hooks] | This function is called when a broadcast admin message is received. | 
| receive_admin_message [Netplex_types.ctrl_message_receiver] | This function is called when a broadcast admin message is received. | 
| receive_message [Netplex_types.processor_hooks] | This function is called when a broadcast message is received. | 
| receive_message [Netplex_types.ctrl_message_receiver] | This function is called when a broadcast message is received. | 
| received_from [Uq_engines_compat.datagram_multiplex_controller] | |
| received_from [Uq_multiplex.datagram_multiplex_controller] | Returns the socket address of the last received datagram. | 
| received_from [Uq_engines.datagram_multiplex_controller] | |
| recommended_jobs_per_thread [Netplex_workload.dynamic_workload_config] | The number of jobs every thread can execute with normal service quality. | 
| recv_queue_byte_size [Nethttpd_kernel.http_protocol] | Returns the (estimated) size of the input queue in bytes | 
| recv_queue_len [Nethttpd_kernel.http_protocol] | Returns the length of the receive queue (number of tokens) | 
| recvfrom [Uq_engines_compat.wrapped_datagram_socket] | |
| recvfrom [Uq_datagram.wrapped_datagram_socket] | Receive data from the (unconnected) socket. | 
| recvfrom [Uq_engines.wrapped_datagram_socket] | |
| referral [Netldap.ldap_result] | if non-empty, a list of URIs where to find more results | 
| register [Netsys_pmanage.pmanage] | Mass-register a list of objects | 
| register_file [Netsys_pmanage.pmanage] | Register a temporary file | 
| register_lever [Netplex_types.controller] | 
 | 
| register_posix_sem [Netsys_pmanage.pmanage] | Register a POSIX named semaphore identified by this path | 
| register_posix_shm [Netsys_pmanage.pmanage] | Register a POSIX shared memory object identified by this path | 
| register_readable [Uq_lwt.lwt_backend] | |
| register_sem_cont [Netsys_pmanage.pmanage] | Register a semaphore container (see  | 
| register_timer [Uq_lwt.lwt_backend] | |
| register_writable [Uq_lwt.lwt_backend] | |
| registered [Netsys_pmanage.pmanage] | Return the registered objects | 
| reject_body [Nethttpd_reactor.http_reactive_request] | Call this method to unlock the body channels. | 
| release [Netmcore.compute_resource] | Notify the manager that the resource is not used any longer by this process. | 
| remote_socket_addr [Nethttpd_types.request_info] | The socket address of the client. | 
| remote_socket_addr [Nethttpd_types.v_extended_environment] | These are always the physical IP addresses and ports of the two endpoints of the current connection. | 
| remote_socket_addr [Nethttpd_types.extended_environment] | |
| remove [Netsys_pollset.pollset] | Remove a descriptor from the set (if it is member) | 
| remove [Netfs.stream_fs] | Removes the file or symlink. | 
| remove [Nethttp_fs.http_stream_fs] | |
| remove_resource [Unixqueue_select.sb_event_system] | |
| remove_resource [Unixqueue.event_system] | |
| rename [Netfs.stream_fs] | Renames the file. | 
| rename [Nethttp_fs.http_stream_fs] | |
| reopen [Netplex_types.logger] | Reopen the log files | 
| repr [Netsys_oothr.condition] | May be used internally be the implementation | 
| repr [Netsys_oothr.mutex] | May be used internally be the implementation | 
| repr [Netsys_oothr.thread] | May be used internally be the implementation | 
| repr [Netmcore.compute_resource] | the resource detail | 
| representation [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| representation [Netcgi.cgi_argument] | The representation of the argument. | 
| representation [Netcgi_common.cgi_argument] | |
| req_method [Nethttpd_reactor.internal_environment] | |
| req_state [Nethttpd_engine.http_request_notification] | Returns the request processing state which is  | 
| req_state [Nethttpd_engine.http_request_header_notification] | Returns the request processing state which is  | 
| request [Netcgi_apache.cgi] | The underlying apache request structure. | 
| request_body [Nethttp_client.http_call] | The whole body of the request. | 
| request_body_rejected [Nethttpd_types.v_extended_environment] | so far known, or false | 
| request_body_rejected [Nethttpd_types.full_info] | Whether the request body was rejected | 
| request_header [Nethttp_client.http_call] | The whole header of the request. | 
| request_method [Nethttpd_types.request_info] | The method like  | 
| request_method [Nethttp_client.http_call] | The HTTP method as string | 
| request_method [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| request_method [Netcgi.cgi] | The HTTP method used to make the request. | 
| request_method [Netcgi_common.cgi] | |
| request_notification [Netftp_client.ftp_client_pi] | as in  | 
| request_notification [Uq_engines_compat.async_in_channel] | |
| request_notification [Uq_engines_compat.async_out_channel] | |
| request_notification [Uq_engines_compat.engine_mixin] | |
| request_notification [Uq_engines_compat.engine] | |
| request_notification [Uq_transfer.async_in_channel] | After the notification has been requested, the passed function is
 be called whenever  | 
| request_notification [Uq_transfer.async_out_channel] | After the notification has been requested, the passed function is
 be called whenever  | 
| request_notification [Uq_engines.async_in_channel] | |
| request_notification [Uq_engines.async_out_channel] | |
| request_notification [Uq_engines.engine_mixin] | |
| request_notification [Uq_engines.engine] | Requests notification about state changes. | 
| request_notification [Uq_resolver.engine] | |
| request_proxy_notification [Netftp_client.ftp_client_pi] | as in  | 
| request_proxy_notification [Uq_engines_compat.engine_mixin] | |
| request_proxy_notification [Uq_engines_compat.engine] | |
| request_proxy_notification [Uq_engines.engine_mixin] | |
| request_proxy_notification [Uq_engines.engine] | Requests to call back the function when there is another engine that can be used as proxy for this object. | 
| request_proxy_notification [Uq_resolver.engine] | |
| request_remote_option [Nettelnet_client.telnet_session] | |
| request_uri [Nethttpd_types.request_info] | The URI of the client request. | 
| request_uri [Nethttp_client.http_call] | The request URI as string. | 
| required [Netplex_types.plugin] | Required plugins | 
| reset [Netftp_client.ftp_client] | Aborts all current activities if any, and re-initializes the client | 
| reset [Nettelnet_client.telnet_session] | Closes the connection immediately and empties all queues. | 
| reset [Nethttp_client.pipeline] | Empties the pipeline and inactivates any open connection. | 
| reset_counters [Nethttp_client.pipeline] | |
| reset_local_option [Nettelnet_client.telnet_session] | |
| reset_remote_option [Nettelnet_client.telnet_session] | |
| resolve_parameter [Netplex_types.config_file] | |
| resolve_section [Netplex_types.config_file] | |
| resp_queue_filled [Nethttpd_kernel.http_protocol] | Whether there is data to send in the internal output queue. | 
| resp_queue_len [Nethttpd_kernel.http_protocol] | Returns the length of the internal response queue (number of  | 
| response [Nethttpd_reactor.internal_environment] | |
| response_body [Nethttp_client.http_call] | The whole body of the response. | 
| response_body_storage [Nethttp_client.http_call] | How to create the response body. | 
| response_header [Nethttp_client.http_call] | The whole header of the response. | 
| response_protocol [Nethttp_client.http_call] | The HTTP version indicated in the response | 
| response_status [Nethttp_client.http_call] | The decoded code. | 
| response_status_code [Nethttpd_types.error_response_params] | The HTTP status code to response | 
| response_status_code [Nethttpd_types.full_info] | The HTTP status code to response | 
| response_status_code [Nethttp_client.http_call] | The three-digit status code | 
| response_status_text [Nethttp_client.http_call] | The text transmitted along with the code | 
| restart [Netplex_types.socket_controller] | Restarts the containers for this socket service only | 
| restart [Netplex_types.controller] | Initiates a restart of all containers: All threads/processes are terminated and replaced by newly initialized ones. | 
| restart [Uq_engines_compat.poll_engine] | |
| restart [Uq_engines.poll_engine] | Activate the engine again when it is already in a final state. | 
| restrict_parameters [Netplex_types.config_file] | |
| restrict_subsections [Netplex_types.config_file] | |
| retr [Netpop.client] | Retrieves a message from the server. | 
| rmdir [Netfs.stream_fs] | Removes an empty directory | 
| rmdir [Nethttp_fs.http_stream_fs] | |
| ro [Netmime.mime_header] | whether the header is read-only or not | 
| ro [Netcgi1_compat.Netcgi_types.cgi_argument] | Irrelevant: there are no methods to mutate an argument. | 
| ro [Netmime.mime_body] | whether this body is read-only or not | 
| ro [Netcgi.rw_cgi_argument] | |
| ro [Netcgi_common.rw_cgi_argument] | |
| role [Netcgi_fcgi.cgi] | A FastCGI application can fulfill each of the following three roles: | 
| rollback_work [Netchannels.trans_out_obj_channel] | Empties the transaction buffer | 
| root_addr [Netplex_types.config_file] | |
| root_name [Netplex_types.config_file] | |
| route [Netaddress.mailbox] | The route to the mailbox | 
| rset [Netpop.client] | Unmarks any messages that have previously been marked as deleted. | 
| rset [Netsmtp.client] | Reset the current transaction | 
| run [Netsys_posix.post_fork_handler] | |
| run [Netftp_client.ftp_client_pi] | Starts the event system; same as  | 
| run [Netftp_client.ftp_client] | Starts the event system; same as  | 
| run [Nettelnet_client.telnet_session] | Run the event system | 
| run [Nethttp_client.pipeline] | Runs through the requests in the pipeline. | 
| run [Unixqueue_select.sb_event_system] | |
| run [Unixqueue.event_system] | |
| S | |
| same_call [Nethttp_client.http_call] | This method returns a new object that will perform the same call as this object (this function is called "reload" in browsers). | 
| schedule_accept_body [Nethttpd_engine.http_request_header_notification] | Schedules that the request body is accepted. | 
| schedule_finish [Nethttpd_engine.http_request_notification] | Schedules that the request is finished. | 
| schedule_finish [Nethttpd_engine.http_request_header_notification] | Schedules that the request is finished. | 
| schedule_reject_body [Nethttpd_engine.http_request_header_notification] | Schedules that the request body is rejected. | 
| scram_credentials [Netmech_scram_gssapi.server_key_verifier] | Returns the credentials for a user, or raises  | 
| self [Netsys_oothr.mtprovider] | In a multi-threaded program: Returns the currently running thread. | 
| send [Nethttpd_kernel.http_response] | Add token to the end of the send queue | 
| send_abort [Netftp_client.ftp_client_pi] | Sends immediately an  | 
| send_admin_message [Netplex_types.controller] | 
 | 
| send_file [Nethttpd_types.v_extended_environment] | Sends the output header with a file as body. | 
| send_message [Netplex_types.container] | 
 | 
| send_message [Netplex_types.controller] | 
 | 
| send_output_header [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| send_output_header [Netcgi.cgi_environment] | This method will encode and send the output header to the output channel. | 
| send_output_header [Netcgi_common.cgi_environment] | |
| send_queue_empty [Nethttpd_kernel.http_response] | Return whether the send queue is empty. | 
| send_synch [Nettelnet_client.telnet_session] | At the next output oppurtunity, a Synch sequence is sent to the remote peer. | 
| send_to [Uq_engines_compat.datagram_multiplex_controller] | |
| send_to [Uq_multiplex.datagram_multiplex_controller] | Sets the socket address of the next datagram to send. | 
| send_to [Uq_engines.datagram_multiplex_controller] | |
| sendto [Uq_engines_compat.wrapped_datagram_socket] | |
| sendto [Uq_datagram.wrapped_datagram_socket] | Send data over the (unconnected) socket | 
| sendto [Uq_engines.wrapped_datagram_socket] | |
| serial_number [Netx509.x509_certificate] | The "serialNumber" field | 
| serialized [Uq_engines_compat.serializer_t] | |
| serialized [Uq_engines.serializer_t] | 
 | 
| server_accepts [Rpc_client.auth_session] | Called if the server accepts the credentials. | 
| server_addr [Rpc_server.auth_details] | |
| server_address [Uq_engines_compat.server_endpoint_acceptor] | |
| server_address [Uq_server.server_endpoint_acceptor] | The contact address under which the clients can establish new connections with this server. | 
| server_address [Uq_engines.server_endpoint_acceptor] | |
| server_rejects [Rpc_client.auth_session] | Called if the server rejects the credentials or the verifier (Auth_xxx). | 
| server_socket_addr [Nethttpd_types.request_info] | The socket address of this server. | 
| server_socket_addr [Nethttpd_types.v_extended_environment] | |
| server_socket_addr [Nethttpd_types.extended_environment] | |
| services [Netplex_types.netplex_config] | |
| services [Netplex_types.controller] | The list of controlled services | 
| set [Nethttp_client.tls_cache] | This is called by the client to store a new session in the cache. | 
| set [Netcgi_modtpl.template] | Set a variable in the template. | 
| set_accept_encoding [Nethttp_client.http_call] | Sets the  | 
| set_arguments [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| set_callback [Nethttpd_kernel.http_response] | The function will be called when either  | 
| set_callback [Nettelnet_client.telnet_session] | Sets the callback function. | 
| set_chunked_request [Nethttp_client.http_call] | Configures that the request is transmitted using chunked encoding. | 
| set_connection [Nettelnet_client.telnet_session] | Sets the host name and the port of the remote server to contact. | 
| set_connection_cache [Nethttp_client.pipeline] | Set the connection cache. | 
| set_connection_state [Nethttp_client_conncache.connection_cache] | Sets the state of the file descriptor. | 
| set_event_system [Nettelnet_client.telnet_session] | Sets the event system to use. | 
| set_event_system [Nethttp_client.pipeline] | Sets the event system. | 
| set_exception_handler [Nettelnet_client.telnet_session] | Sets the exception handler. | 
| set_expect_handshake [Nethttp_client.http_call] | Configures that a handshake is done before sending the request body. | 
| set_fields [Netmime.mime_header] | |
| set_header [Netsys_ciphers.cipher_ctx] | Sets the header to authenticate for AEAD (this must be done before starting the encryption or decryption). | 
| set_header [Netcgi1_compat.Netcgi_types.cgi_activation] | Added  | 
| set_header [Netcgi.cgi] | Sets the header (removing any previous one). | 
| set_header [Netcgi_common.cgi] | |
| set_input_state [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business. | 
| set_iv [Netsys_ciphers.cipher_ctx] | Sets the initialization vector (this must be done before starting the encryption or decryption). | 
| set_max_level [Netplex_types.controller_config] | Set the maximum global log level | 
| set_max_response_body_length [Nethttp_client.http_call] | Sets a new maximum length. | 
| set_multiple_output_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| set_multiple_output_header_field [Netcgi.cgi_environment] | Sets multiple values of a field of the response header. | 
| set_multiple_output_header_field [Netcgi_common.cgi_environment] | |
| set_options [Nettelnet_client.telnet_session] | Set the configuration options. | 
| set_options [Nethttp_client.pipeline] | Get/Set the available options for the HTTP engine. | 
| set_output_header_field [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| set_output_header_field [Netcgi.cgi_environment] | Sets the value of a field of the response header. | 
| set_output_header_field [Netcgi_common.cgi_environment] | |
| set_output_header_fields [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| set_output_header_fields [Netcgi.cgi_environment] | Sets the complete response header at once. | 
| set_output_header_fields [Netcgi_common.cgi_environment] | |
| set_output_state [Netcgi1_compat.Netcgi_env.cgi_environment] | Not the user business. | 
| set_proxy [Nethttp_client.pipeline] | 
 | 
| set_proxy_auth [Nethttp_client.pipeline] | sets user and password for the proxy. | 
| set_proxy_enabled [Nethttp_client.http_call] | Sets the proxy mode | 
| set_proxy_from_environment [Nethttp_client.pipeline] | Inspect the environment variables  | 
| set_reconnect_mode [Nethttp_client.http_call] | Sets the reconnect mode | 
| set_redirect_mode [Nethttp_client.http_call] | Sets the redirect mode | 
| set_redirection_header [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| set_redirection_header [Netcgi.cgi] | Sets the header such that a redirection to the specified URL is performed. | 
| set_redirection_header [Netcgi_common.cgi] | |
| set_req_header [Nethttp_client.http_call] | |
| set_request_body [Nethttp_client.http_call] | Replaces the whole body object | 
| set_request_device [Nethttp_client.http_call] | Sets that the request data is read from the passed device instead of taking it from a body object. | 
| set_request_header [Nethttp_client.http_call] | Replaces the whole  | 
| set_request_uri [Nethttp_client.http_call] | Sets the request URI. | 
| set_response_body_storage [Nethttp_client.http_call] | Sets how to create the response body | 
| set_socks5_proxy [Netftp_client.ftp_client] | Sets that a SOCKS version 5 proxy is used at this host and port. | 
| set_socks5_proxy [Nethttp_client.pipeline] | Sets that a SOCKS version 5 proxy is used at this host and port. | 
| set_state [Nethttpd_kernel.http_response] | Sets the state | 
| set_state [Uq_engines_compat.engine_mixin] | |
| set_state [Uq_engines.engine_mixin] | |
| set_status [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| set_status [Netcgi.cgi_environment] | Sets the response status. | 
| set_status [Netcgi_common.cgi_environment] | |
| set_timeout [Rpc_transport.rpc_multiplex_controller] | If there is no read or write activity for the passed number of
 seconds, the  | 
| set_tls_cache [Nethttp_client.pipeline] | Sets the TLS cache (NB. | 
| set_transport_layer [Nethttp_client.http_call] | Sets the transport layer. | 
| set_transport_proxy [Nethttp_client.pipeline] | 
 | 
| set_transport_proxy_from_environment [Nethttp_client.pipeline] | Like  | 
| set_value [Netcgi1_compat.Netcgi_types.cgi_argument] | Dealing with the arguments is the task of an higher order library. | 
| set_value [Netmime.mime_body] | Sets the value. | 
| set_value [Netcgi.rw_cgi_argument] | |
| set_value [Netcgi_common.rw_cgi_argument] | |
| set_var [Netplex_types.container] | Sets the value of a container variable | 
| setup [Unixqueue_select.sb_event_system] | |
| setup_e [Nethttp_client.transport_channel_type] | 
 | 
| shut_down [Uq_engines_compat.wrapped_datagram_socket] | |
| shut_down [Uq_engines_compat.server_endpoint_acceptor] | |
| shut_down [Uq_datagram.wrapped_datagram_socket] | Close the descriptor, shuts down any further needed resources | 
| shut_down [Uq_server.server_endpoint_acceptor] | The server endpoint is shut down such that no further connections are possible. | 
| shut_down [Uq_engines.wrapped_datagram_socket] | |
| shut_down [Uq_engines.server_endpoint_acceptor] | |
| shutdown [Netplex_types.workload_manager] | Called by the controller to notify the manager about a shutdown | 
| shutdown [Netplex_types.container] | Initiates a shutdown of the container. | 
| shutdown [Netplex_types.processor_hooks] | A user-supplied function that is called when a shutdown notification arrives. | 
| shutdown [Netplex_types.socket_controller] | Closes the socket service forever, and initiates a shutdown of all containers serving this type of service. | 
| shutdown [Netplex_types.socket_service] | Shuts down the master sockets | 
| shutdown [Netplex_types.controller] | Initiates a shutdown of all containers. | 
| shutdown [Nethttpd_kernel.http_protocol] | Shuts the socket down. | 
| shutting_down [Uq_engines_compat.multiplex_controller] | |
| shutting_down [Uq_multiplex.multiplex_controller] | True iff the shutdown is in progress | 
| shutting_down [Uq_engines.multiplex_controller] | |
| signal [Netsys_oothr.condition] | In a multi-threaded program: Signal one process that the condition holds. | 
| signal [Uq_engines_compat.signal_engine] | |
| signal [Uq_engines.signal_engine] | |
| signature [Netx509.x509_certificate] | The signature | 
| signature_algorithm [Netx509.x509_certificate] | The algorithm of the signature (OID, and algorithm-specific parameters) | 
| single_threaded [Netsys_oothr.mtprovider] | Whether this is a single-threaded program. | 
| size [Netsys_digests.digest] | The size of the digest string in bytes | 
| size [Netfs.stream_fs] | Returns the size of a file. | 
| size [Nethttp_fs.http_stream_fs] | |
| skip [Netstream.in_obj_stream] | Skip the n bytes of the stream. | 
| skip_challenge [Nethttp_client.auth_handler] | If true, this method allows to skip the challenge entirely for authentication. | 
| skip_challenge_session [Nethttp_client.auth_handler] | Create a session for the case that the challenge was skipped | 
| so_keepalive [Netplex_types.protocol] | Whether to set the keep-alive socket option | 
| socket_directory [Netplex_types.controller_config] | The directory where Unix domain sockets are created. | 
| socket_domain [Uq_engines_compat.wrapped_datagram_socket] | |
| socket_domain [Uq_datagram.wrapped_datagram_socket] | |
| socket_domain [Uq_engines.wrapped_datagram_socket] | |
| socket_protocol [Uq_engines_compat.wrapped_datagram_socket] | |
| socket_protocol [Uq_datagram.wrapped_datagram_socket] | |
| socket_protocol [Uq_engines.wrapped_datagram_socket] | |
| socket_service [Netplex_types.container] | |
| socket_service_config [Netplex_types.socket_service] | The configuration | 
| socket_service_name [Netplex_types.container] | |
| socket_type [Uq_engines_compat.wrapped_datagram_socket] | |
| socket_type [Uq_datagram.wrapped_datagram_socket] | |
| socket_type [Uq_engines.wrapped_datagram_socket] | |
| sockets [Netplex_types.socket_service] | A  | 
| source [Netcgi_modtpl.template] | Return the original source code for the template. | 
| source [Unixqueue_select.sb_event_system] | |
| spec [Netaddress.mailbox] | The formal address specification | 
| start [Netplex_types.container] | Internal Method. | 
| start_containers [Netplex_types.socket_controller] | |
| start_mem_reading [Uq_engines_compat.multiplex_controller] | |
| start_mem_reading [Uq_multiplex.multiplex_controller] | Same as  | 
| start_mem_reading [Uq_engines.multiplex_controller] | |
| start_mem_writing [Uq_engines_compat.multiplex_controller] | |
| start_mem_writing [Uq_multiplex.multiplex_controller] | Same as  | 
| start_mem_writing [Uq_engines.multiplex_controller] | |
| start_reading [Rpc_transport.rpc_multiplex_controller] | Start reading from the connection. | 
| start_reading [Uq_engines_compat.multiplex_controller] | |
| start_reading [Uq_multiplex.multiplex_controller] | Start reading from the connection. | 
| start_reading [Uq_engines.multiplex_controller] | |
| start_shutting_down [Rpc_transport.rpc_multiplex_controller] | Start shutting down the connection. | 
| start_shutting_down [Uq_engines_compat.multiplex_controller] | |
| start_shutting_down [Uq_multiplex.multiplex_controller] | Start shutting down the connection. | 
| start_shutting_down [Uq_engines.multiplex_controller] | |
| start_thread [Netplex_types.parallelizer] | 
 | 
| start_tls [Nettelnet_client.telnet_session] | Switch to TLS. | 
| start_writing [Rpc_transport.rpc_multiplex_controller] | Starts writing the message. | 
| start_writing [Uq_engines_compat.multiplex_controller] | |
| start_writing [Uq_multiplex.multiplex_controller] | Start writing to the connection. | 
| start_writing [Uq_engines.multiplex_controller] | |
| start_writing_eof [Uq_engines_compat.multiplex_controller] | |
| start_writing_eof [Uq_multiplex.multiplex_controller] | Start writing the EOF marker to the connection. | 
| start_writing_eof [Uq_engines.multiplex_controller] | |
| starttls [Netsmtp.client] | Sends STARTTLS, and negotiates a secure connection. | 
| startup_directory [Netplex_types.container] | The current directory at Netplex startup time (same view as controller) | 
| startup_directory [Netplex_types.socket_service] | The current directory at Netplex startup time (same view as controller) | 
| startup_directory [Netplex_types.controller] | The current directory at startup time | 
| startup_timeout [Netplex_types.socket_service_config] | After this many seconds the container must have finished the
         | 
| stat [Netpop.client] | Returns information about the current mailbox as tuple
  | 
| state [Rpc_client.auth_protocol] | The state of the authentication protocol:  | 
| state [Netplex_types.socket_controller] | The current state | 
| state [Nethttpd_kernel.http_response] | Reports the state. | 
| state [Netpop.client] | Current state of this session. | 
| state [Netftp_client.ftp_client_pi] | The state in the sense of  | 
| state [Uq_engines_compat.engine_mixin] | |
| state [Uq_engines_compat.engine] | |
| state [Uq_engines.engine_mixin] | |
| state [Uq_engines.engine] | Returns the state of the engine | 
| state [Uq_resolver.engine] | |
| status [Nethttp_client.http_call] | The condensed status | 
| stls [Netpop.client] | Sends STLS (STARTTLS), and negotiates a secure connection. | 
| stop_containers [Netplex_types.socket_controller] | |
| store [Netmime.mime_body_ro] | Where the body is actually stored. | 
| store [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| store [Netcgi.cgi_argument] | Tells whether the argument is stored in memory (as a string)
        or as a file (the argument of  | 
| store [Netcgi_common.cgi_argument] | |
| string [Netx509.directory_name] | The DN as string (RFC 4514) | 
| string_param [Netplex_types.config_file] | |
| subject [Netx509.x509_certificate] | The DN of the subject | 
| subject_unique_id [Netx509.x509_certificate] | The unique ID of the subject | 
| supported_ptypes [Netplex_kit.v_processor] | |
| supported_ptypes [Netplex_types.processor] | The supported parallelization types | 
| supports_aead [Netsys_ciphers.cipher] | Whether this cipher integrates authentication | 
| supports_aead [Netsys_ciphers.cipher_ctx] | Whether this cipher integrates authentication | 
| supports_aead [Netchannels_crypto.crypto_in_filter] | Whether the cipher supports authentication, and will provide a MAC | 
| supports_aead [Netchannels_crypto.crypto_out_filter] | Whether the cipher supports authentication, and will provide a MAC | 
| supports_half_open_connection [Uq_engines_compat.multiplex_controller] | |
| supports_half_open_connection [Uq_multiplex.multiplex_controller] | Whether the underlying transport mechanism can close the write side of the connection only (half-open connection). | 
| supports_half_open_connection [Uq_engines.multiplex_controller] | |
| supports_mdtm [Netftp_client.ftp_client_pi] | Whether the  | 
| supports_mlst [Netftp_client.ftp_client_pi] | Whether the  | 
| supports_size [Netftp_client.ftp_client_pi] | Whether the  | 
| supports_tls [Netftp_client.ftp_client_pi] | Whether TLS is supported | 
| supports_tvfs [Netftp_client.ftp_client_pi] | Whether TVFS filenames are supported | 
| supports_utf8 [Netftp_client.ftp_client_pi] | Whether the UTF-8 extension is understood by the server (RFC 2640) | 
| symlink [Netfs.stream_fs] | 
 | 
| symlink [Nethttp_fs.http_stream_fs] | |
| sys_id [Netplex_types.par_thread] | Returns a system-dependent identifier for the thread:  | 
| sys_id [Netplex_types.controller] | The thread running the controller | 
| system [Netplex_types.container] | An RPC client that can be used to send messages to the controller. | 
| system_monitor [Netplex_types.container] | The thread monitor protecting the  | 
| system_shutdown [Netplex_types.processor_hooks] | A user-supplied function that is called when a system shutdown notification arrives. | 
| T | |
| table [Netcgi_modtpl.template] | Set a table in the template. | 
| target_name [Netsys_gssapi.client_config] | |
| tcp_nodelay [Netplex_types.protocol] | Whether to set the TCP_NODELAY option | 
| test [Netfs.stream_fs] | Returns whether the test is true. | 
| test [Nethttp_fs.http_stream_fs] | |
| test_coverage [Nethttpd_kernel.http_protocol] | For testing: returns a list of tokens indicating into which cases the program ran. | 
| test_list [Netfs.stream_fs] | Similar to  | 
| test_list [Nethttp_fs.http_stream_fs] | |
| time [Netsys_gssapi.server_props] | Actual context lifetime | 
| time [Netsys_gssapi.client_props] | Actual context lifetime | 
| timeout [Nethttpd_kernel.http_protocol] | Process a timeout condition as  | 
| tls_endpoint [Netchannels_crypto.tls_channel] | |
| tls_endpoint [Netpop.client] | Returns the TLS endpoint (after  | 
| tls_endpoint [Netsmtp.client] | Returns the TLS endpoint (after  | 
| tls_session [Uq_engines_compat.multiplex_controller] | |
| tls_session [Uq_multiplex.multiplex_controller] | If TLS is enabled, this returns (session_id, session_data). | 
| tls_session [Uq_engines.multiplex_controller] | |
| tls_session_data [Nettelnet_client.telnet_session] | TLS session data (if on) | 
| tls_session_props [Rpc_transport.rpc_multiplex_controller] | The TLS session properties (if TLS is enabled) | 
| tls_session_props [Nethttpd_kernel.http_protocol] | If TLS is enabled, this returns the session properties. | 
| tls_session_props [Nethttpd_types.request_info] | The TLS properties | 
| tls_session_props [Nethttpd_types.v_extended_environment] | The TLS session properties if TLS is active | 
| tls_session_props [Netpop.client] | Returns the TLS session properties (after  | 
| tls_session_props [Netsmtp.client] | Returns the TLS session properties (after  | 
| tls_session_props [Nettelnet_client.telnet_session] | TLS session properties (if on) | 
| tls_session_props [Nethttp_client.http_call] | If TLS is enabled, this returns the session properties | 
| tls_session_props [Uq_engines_compat.multiplex_controller] | |
| tls_session_props [Uq_multiplex.multiplex_controller] | If TLS is enabled, this returns the session properties. | 
| tls_session_props [Uq_engines.multiplex_controller] | |
| tls_set_cache [Nethttpd_kernel.http_protocol_hooks] | Sets the functions for accessing the session cache | 
| tls_stashed_endpoint [Uq_engines_compat.multiplex_controller] | |
| tls_stashed_endpoint [Uq_multiplex.multiplex_controller] | Returns the TLS endpoint in stashed form. | 
| tls_stashed_endpoint [Uq_engines.multiplex_controller] | |
| to_channel [Netcgi_modtpl.template] | Write the template to a channel. | 
| to_string [Netcgi_modtpl.template] | Return the template as a string. | 
| top [Netpop.client] | Returns the message header plus a limited number of lines of the message body. | 
| transfer_encoding [Nethttpd_kernel.http_response] | Returns the selected transfer encoding. | 
| translate [Netftp_fs.ftp_stream_fs] | Translates a path into a URL | 
| translate [Nethttp_fs.http_stream_fs] | Translates a path into a URL | 
| transport_layer [Nethttp_client.pipeline] | Reports the current transport of this call | 
| transport_user [Rpc_server.auth_details] | |
| tree [Netplex_types.config_file] | |
| try_lock [Netsys_oothr.mutex] | In a multi-threaded program: Tries to immediately lock the mutex, and returns whether the lock could be obtained. | 
| typ [Netmcore.compute_resource] | which type of resource | 
| U | |
| uidl [Netpop.client] | Returns the unique identifier(s) for an optional message number or for all messages in the current mailbox. | 
| unlink [Netsys_pmanage.pmanage] | Delete all registered objects | 
| unlock [Netsys_oothr.mutex] | In a multi-threaded program: Unlocks a mutex. | 
| unlock [Nethttpd_reactor.internal_environment] | |
| unregister_file [Netsys_pmanage.pmanage] | Unregister a temporary file | 
| unregister_posix_sem [Netsys_pmanage.pmanage] | Unregister a POSIX named semaphore identified by this path | 
| unregister_posix_shm [Netsys_pmanage.pmanage] | Unregister a POSIX shared memory object identified by this path | 
| unregister_sem_cont [Netsys_pmanage.pmanage] | Unregister a semaphore container (see  | 
| unwrap [Netsys_gssapi.poly_gss_api] | Note that the  | 
| update [Netsys_global.propagator] | 
 | 
| update [Nettelnet_client.telnet_session] | If there are commands in the output queue, the event system is signaled that this client wants to do network I/O. | 
| update_argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| update_detail [Netplex_types.container] | Update the detail string output for the  | 
| update_field [Netmime.mime_header] | |
| update_multiple_argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| update_multiple_field [Netmime.mime_header] | |
| url [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| url [Netcgi.cgi] | Returns the URL of the current CGI-like script. | 
| url [Netcgi_common.cgi] | The following environment properties must be available for this
      method to work properly (please make sure your connector
      provides them; the CGI spec make them compulsory anyway):  | 
| user [Netpop.client] | Specifies the name of the mailbox the client would like to open using plain-text authentication. | 
| user [Nethttp_client.key] | The user name (UTF-8) | 
| user_agent [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| user_agent [Netcgi.cgi_environment] | This is a convenience method that returns the  | 
| user_agent [Netcgi_common.cgi_environment] | |
| V | |
| valid_not_after [Netx509.x509_certificate] | Expiration time as seconds since the epoch ("notAfter" field) | 
| valid_not_before [Netx509.x509_certificate] | Activation time as seconds since the epoch ("notBefore" field) | 
| value [Netmime.mime_body_ro] | The  | 
| value [Netldap.ldap_result] | the value when  | 
| value [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| value [Netcgi.cgi_argument] | The value of the argument, after all transfer encodings have been removed. | 
| value [Netcgi_common.cgi_argument] | |
| var [Netplex_types.container] | Returns the value of a container variable or  | 
| verifier [Rpc_server.auth_details] | |
| verify_mic [Netsys_gssapi.poly_gss_api] | |
| version [Rpc_server.auth_details] | |
| version [Netx509.x509_certificate] | The "version" field, 1 to 3 | 
| W | |
| wait [Netsys_oothr.condition] | In a multi-threaded program: Wait for the condition to be true and use the mutex to protect this situation. | 
| wait [Netsys_pollset.pollset] | Wait for events, and return the output events matching the event mask. | 
| waiting_for_next_message [Nethttpd_kernel.http_protocol] | Whether the kernel is currently waiting for the beginning of a new arriving HTTP request. | 
| want [Netstream.in_obj_stream] | Increases the length of the window such that the length is at least the passed number of bytes or that the window reaches EOF (whatever happens first). | 
| want_another_block [Netstream.in_obj_stream] | The same as:  | 
| watch_shutdown [Netplex_types.par_thread] | Called by the controller if it thinks the container is down. | 
| when_blocking [Unixqueue_select.sb_event_system] | |
| when_blocking [Unixqueue.event_system] | |
| window [Netstream.in_obj_stream] | The look-ahead window. | 
| window_at_eof [Netstream.in_obj_stream] | Whether the window is at eof | 
| window_length [Netstream.in_obj_stream] | Returns the length of the window | 
| workload_hook [Netplex_types.processor_hooks] | A user-supplied function that is called when the workload changes, i.e. | 
| wrap [Netsys_gssapi.poly_gss_api] | 
 | 
| wrap_size_limit [Netsys_gssapi.poly_gss_api] | |
| write [Netfs.stream_fs] | 
 | 
| write [Nethttp_fs.http_stream_fs] | Additional flag:  | 
| write_file [Netfs.stream_fs] | 
 | 
| write_file [Nethttp_fs.http_stream_fs] | Additional flag:  | 
| writing [Rpc_transport.rpc_multiplex_controller] | True iff there is a writer | 
| writing [Uq_engines_compat.multiplex_controller] | |
| writing [Uq_multiplex.multiplex_controller] | True iff there is a writer | 
| writing [Uq_engines.multiplex_controller] | |
| wrote_eof [Uq_engines_compat.multiplex_controller] | |
| wrote_eof [Uq_multiplex.multiplex_controller] | Whether the EOF marker has been written | 
| wrote_eof [Uq_engines.multiplex_controller] | |
| X | |
| xid [Rpc_server.auth_details] | |
| Y | |
| yield [Netsys_oothr.mtprovider] | In a multi-threaded program: gives a hint that another thread should better run now. |