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. |