| A | |
| abort [Nethttpd_kernel.http_protocol] | 
Stops the transmission of data.
 | 
| abort [Ftp_client.ftp_client_pi] | 
Shuts any active connection immediately down, and changes the
 state of the engine to  `Aborted. | 
| 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.server_endpoint_acceptor] | 
Instantiates an engine that accepts connections on the listening
 endpoint.
 | 
| accept_body [Nethttpd_reactor.http_reactive_request] | 
Call this method to unlock the body channels.
 | 
| accept_sec_context [Netgssapi.gss_api] | 
On the first call, pass  ~context:None. | 
| acquire_cred [Netgssapi.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 [Http_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_admin setup: Allows to bind another RPC program to the admin
 socket. | 
| add_auth_handler [Http_client.pipeline] | 
adds a new-style authentication handler
 | 
| add_authentication_method [Http_client.pipeline] | 
adds an old-style authentication method
 | 
| add_close_action [Unixqueue_select.sb_event_system] | |
| add_close_action [Unixqueue.event_system] | |
| add_cred [Netgssapi.gss_api] | |
| add_e [Http_client.pipeline] | 
The same as engine: The call  cis added to the pipeline, and
	  when it is processed, the returned engine transitions to the
	  state`Done c. | 
| 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 [Http_client.key_ring] | 
Adds a key to the ring
 | 
| 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_weak_resource [Unixqueue_select.sb_event_system] | |
| add_weak_resource [Unixqueue.event_system] | |
| add_with_callback [Http_client.pipeline] | 
Adds the call to the end of the pipeline.
 | 
| 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  nbytes of the front token could be really
 sent usingUnix.write. | 
| alive [Rpc_transport.rpc_multiplex_controller] | 
If the controller is alive, the socket is not yet completely down.
 | 
| alive [Uq_engines.multiplex_controller] | 
If the controller is alive, the socket is not yet completely down.
 | 
| apop [Netpop.client] | 
Specifies the user and password using APOP authentication.
 | 
| argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| argument [Netcgi.cgi] | #argument namereturns the value of the argument namedname. | 
| argument [Netcgi_common.cgi] | |
| argument_exists [Netcgi.cgi] | #argument_existsreturnsfalseif the named parameter is
        missing andtrueotherwise. | 
| argument_exists [Netcgi_common.cgi] | |
| argument_value [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| argument_value [Netcgi.cgi] | #argument_valuereturns the value of the argument as a
        string. | 
| 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_auth_handler [Http_client.basic_auth_method] | |
| as_memory [Xdr_mstring.mstring] | 
Returns the contents as memory.
 | 
| as_string [Xdr_mstring.mstring] | 
Returns the contents as string.
 | 
| assoc_multi_req_header [Http_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 [Http_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 [Http_client.http_call] | 
Query a specific header entry, or raise  Not_found | 
| assoc_resp_header [Http_client.http_call] | 
Query a specific header entry of the response.
 | 
| at_exit [Netcgi.cgi] | #at_exit fregisters the functionfto be executed when#finalizeis called (which is done automatically when the
	request finishes). | 
| at_exit [Netcgi_common.cgi] | |
| attach [Telnet_client.telnet_session] | 
Attach to the event system.
 | 
| auth_domain [Http_client.auth_session] | 
The list of domain URIs defines the protection space.
 | 
| auth_in_advance [Http_client.auth_session] | 
Whether "authentication in advance" is enabled
 | 
| auth_method [Rpc_client.auth_protocol] | |
| auth_protocol [Rpc_client.auth_session] | 
Return the corresponding protocol
 | 
| auth_realm [Http_client.auth_session] | 
The realm
 | 
| auth_scheme [Http_client.auth_session] | 
The authentication scheme, e.g.
 | 
| auth_user [Http_client.auth_session] | 
The user identifier
 | 
| authenticate [Rpc_server.auth_method] | authenticate srv conn_id details f:
	This method is called when a remote call has arrived. | 
| authenticate [Http_client.auth_session] | 
Returns a list of additional headers that will authenticate 
 the passed call for this session.
 | 
| avoid_proxy_for [Http_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_memory [Xdr_mstring.mstring] | blit_to_string mpos mem mempos len: Copies the substring of the
	managed string frommpostompos+len-1to the substring ofmemfrommempostomempos+len-1 | 
| blit_to_string [Xdr_mstring.mstring] | blit_to_string mpos s spos len: Copies the substring of the
	managed string frommpostompos+len-1to the substring ofsfromspostospos+len-1 | 
| 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] | call_plugin p procname procarg: This method can be called
        from the container context to invoke the pluginpprocedureprocname. | 
| callback [Netcgi_modtpl.template] | 
Set a callback in the template.
 | 
| can_input [Uq_engines.async_in_channel] | 
Whether input is possible, i.e.
 | 
| can_output [Uq_engines.async_out_channel] | 
Whether output is possible, i.e.
 | 
| cancel [Netfs.stream_fs] | 
Cancels any ongoing  write. | 
| cancel [Http_fs.http_stream_fs] | |
| cancel_rd_polling [Rpc_transport.rpc_multiplex_controller] | 
Cancels polling for the next input message.
 | 
| cancel_reading [Uq_engines.multiplex_controller] | 
Cancels the read job.
 | 
| cancel_shutting_down [Rpc_transport.rpc_multiplex_controller] | 
Cancels the shutdown procedure.
 | 
| cancel_shutting_down [Uq_engines.multiplex_controller] | 
Cancels the shutdown procedure.
 | 
| 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.multiplex_controller] | 
Cancels the write job.
 | 
| canonicalize_name [Netgssapi.gss_api] | |
| 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  properties. | 
| 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  Netcgi.cgi.request_methodwhich is more type-safe and informative. | 
| 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.
 | 
| channel_binding [Http_client.pipeline] | 
Reports the current channel binding of this call
 | 
| charset [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| charset [Netcgi.cgi_argument] | 
The  charsetparameter of the content type of the header, or""when there is no such parameter, or no header. | 
| charset [Netcgi_common.cgi_argument] | |
| cleanup [Uq_lwt.lwt_backend] | |
| clear [Http_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 [Ftp_fs.ftp_stream_fs] | 
Forces that the FTP client is closed.
 | 
| close_all [Http_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 [Http_client_conncache.connection_cache] | 
Deletes the connection from the cache, and closes it
 | 
| close_in [Netchannels.augment_raw_in_channel] | 
As in  raw_in_channel | 
| close_in [Netchannels.rec_in_channel] | 
Closes the channel for input.
 | 
| close_in [Uq_engines.async_in_channel] | 
Closes the channel
 | 
| close_out [Netchannels.augment_raw_out_channel] | 
As in  raw_out_channel | 
| close_out [Netchannels.rec_out_channel] | 
Flushes the buffer, if any, and closes the channel for output.
 | 
| close_out [Uq_engines.async_out_channel] | 
Closes the channel
 | 
| cnt_crashed_connections [Http_client.pipeline] | 
Counts connections with network or protocol errors
 | 
| cnt_failed_connections [Http_client.pipeline] | 
Counts totally failed connections (no more reconnects allowed)
 | 
| cnt_new_connections [Http_client.pipeline] | 
Counts new connections (or better: attempts to establish connections)
 | 
| cnt_server_eof_connections [Http_client.pipeline] | 
Counts connections the server terminated with EOF
 | 
| cnt_successful_connections [Http_client.pipeline] | 
Counts connections closed because pipelines become empty
 | 
| cnt_timed_out_connections [Http_client.pipeline] | 
Counts connections given up because of timeouts
 | 
| commit_work [Netchannels.trans_out_obj_channel] | 
Flushes the transaction buffer, and writes its contents to the
 underlying resource.
 | 
| compare_name [Netgssapi.gss_api] | |
| 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  Serverheader:`Ignore: The kernel does not touch theServerheader.,`Ocamlnet: Announce this web server as "Ocamlnet/<version>",`Ocamlnet_and s: Announce this web server assand append
   the Ocamlnet string.,`As s: Announce this web server ass | 
| 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  true, the engine stops reading input tokens from the HTTP kernel when
 there is data in the input channel of the engine not yet read. | 
| 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 info msg: Log the messagemsg. | 
| 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  true, the engine signals the user when there is already enough data
 to output, and no more output should be generated. | 
| 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  `Broken_pipeerrors. | 
| config_synch_input [Nethttpd_engine.http_engine_processing_config] | 
The "input synchronizer": It is called as  obj # config_synch_input f chto create a synchronous input channel from an asynchronous one,ch. | 
| config_synch_output [Nethttpd_engine.http_engine_processing_config] | 
The "output synchronizer": It is called as  obj # config_synch_output f chto create a synchronous output channel from an asynchronous one,ch. | 
| 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.
 | 
| configure_slave_socket [Netplex_types.protocol] | 
A user-supplied function to configure slave sockets (after  accept). | 
| configure_timeout [Ftp_client.ftp_client] | 
Configures a timeout for both the control and the data connection.
 | 
| configure_transport [Http_client.pipeline] | configure_transport id transport: Configures that messages with
	   channel binding IDidare exchanged ontransport. | 
| conn_limit [Netplex_types.socket_service_config] | 
An optional limit of the number of connections this container
	can accept.
 | 
| connect [Uq_engines.client_endpoint_connector] | 
Instantiates an engine that connects to the endpoint given by the
  connect_addressargument. | 
| connection_cache [Http_client.pipeline] | 
The current connection cache.
 | 
| connections [Http_client.pipeline] | 
Reports which connections exist:   (host, port, queue_length)  | 
| 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_run esys: By default, it just runsesys#run(). | 
| 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_disposition [Netmime.mime_header_ro] | 
Returns the Content-disposition field as parsed value.
 | 
| content_length [Netmime.mime_header_ro] | 
Returns the Content-length field as integer
 | 
| content_transfer_encoding [Netmime.mime_header_ro] | 
Returns the Content-transfer-encoding as string
 | 
| content_type [Netmime.mime_header_ro] | 
Returns the Content-type as parsed value.
 | 
| 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  (hdr, params). | 
| content_type [Netcgi_common.cgi_argument] | |
| content_type_params [Netcgi1_compat.Netcgi_types.cgi_argument] | 
Method  content_type : unit -> string * (string *
	  Mimestring.s_param) listdefined instead ofcontent_typeandcontent_type_paramsto be coherent withNetmime.mime_header_ro-- yet as easy to use. | 
| context_time [Netgssapi.gss_api] | |
| continue [Http_client.transport_channel_type] | continueis called when an already established circuit needs to
      be continued. | 
| continue [Https_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 cnreturns the cookie with namecn. | 
| 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 [Http_fs.http_stream_fs] | |
| 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.datagram_socket_provider] | 
Creates an engine that creates a  wrapped_datagram_socketobject
 and that sets up any further resources the objects needs. | 
| create_from_memory [Xdr_mstring.mstring_factory] | create_from_memory m pos len must_copy: Creates themstringfrom the
	sub string of m starting atposwith lengthlen | 
| create_from_string [Xdr_mstring.mstring_factory] | create_from_string s pos len must_copy: Creates themstringfrom the
	sub string of s starting atposwith lengthlen | 
| 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] | let lock, unlock = par#create_mem_locker(): Creates a mutex that
 is sufficient to protect process memory from uncoordinated access. | 
| 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 [Http_client.auth_handler] | 
Same for proxy authentication
 | 
| create_session [Http_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  Thread.create). | 
| create_workload_manager [Netplex_types.workload_manager_factory] | |
| credential [Rpc_server.auth_details] | |
| 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  post_finish_hook). | 
| ctrl_receive_call [Netplex_types.plugin] | ctrl_receive_call ctrl cid procname procarg emit:
        This method is called in the controller contextctrlwhen a procedure
        namedprocnameis called. | 
| 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.wrapped_datagram_socket] | |
| def_empty_path_replacement [Http_client.generic_call] | |
| def_has_req_body [Http_client.generic_call] | |
| def_has_resp_body [Http_client.generic_call] | |
| def_is_idempotent [Http_client.generic_call] | |
| def_request_method [Http_client.generic_call] | 
The following methods define the values for the corresponding 
 methods without the  def_prefix: | 
| def_term [Nethttpd_types.http_service] | 
The definition term
 | 
| 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.
 | 
| delete_argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| delete_field [Netmime.mime_header] | 
These methods modify the fields of the header.
 | 
| delete_sec_context [Netgssapi.gss_api] | 
Output tokens are not supported (this is a deprecated feature of
	 GSSAPI)
 | 
| descr [Ftp_data_endpoint.ftp_data_engine] | 
The socket to use for data transfers.
 | 
| descr_state [Ftp_data_endpoint.ftp_data_engine] | 
The socket state
 | 
| descriptor [Uq_engines.wrapped_datagram_socket] | 
The underlying file descriptor.
 | 
| dest_status [Http_client.http_call] | 
Returns the status line of the last response (but status lines
 with code 100 are ignored).
 | 
| disable [Netplex_types.socket_controller] | 
Disable a socket service temporarily
 | 
| disable_local_option [Telnet_client.telnet_session] | |
| disable_remote_option [Telnet_client.telnet_session] | |
| display_minor_status [Netgssapi.gss_api] | 
Note that  display_minor_statusdecodes all status value parts in
	one step and returns the result asstring list. | 
| display_name [Netgssapi.gss_api] | |
| dispose [Netsys_pollset.pollset] | 
Release any OS resources associated with the pollset.
 | 
| do_input [Nethttpd_kernel.http_protocol] | 
Returns  trueiff the protocol engine is interested in new data from the
 socket. | 
| do_output [Nethttpd_kernel.http_protocol] | 
Returns  trueiff the protocol engine has data to output to the socket | 
| domain [Http_client.key] | 
The domain URIs defining the protection space.
 | 
| E | |
| effective_request_uri [Http_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  xid,prog_nrandvers_nr. | 
| empty_path_replacement [Http_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 [Telnet_client.telnet_session] | |
| enable_remote_option [Telnet_client.telnet_session] | |
| engine [Nethttpd_engine.http_engine_processing_context] | 
The engine doing HTTP
 | 
| enhanced_input [Netchannels.enhanced_raw_in_channel] | 
Works similar to  input, but distinguishes between normal data
 and end-of-line separators. | 
| enhanced_input_line [Netchannels.enhanced_raw_in_channel] | 
An improved implementation of  input_linethat uses the buffer | 
| 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] | |
| 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 [Ftp_client.ftp_client_pi] | 
The used event system
 | 
| event_system [Ftp_client.ftp_client] | |
| event_system [Http_client.pipeline] | 
Returns the event system
 | 
| event_system [Uq_engines.multiplex_controller] | 
Returns the event system
 | 
| 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 [Ftp_client.ftp_client] | 
Runs the method synchronously.
 | 
| exec_e [Ftp_client.ftp_client_pi] | 
Run another command as engine.
 | 
| exec_e [Ftp_client.ftp_client] | 
Runs the method asynchronously as engine.
 | 
| exists_resource [Unixqueue_select.sb_event_system] | |
| exists_resource [Unixqueue.event_system] | |
| expect_input [Telnet_client.telnet_session] | 
Set whether the timeout value is to be applied to the input side
	  of the connection.
 | 
| expn [Netsmtp.client] | 
Expand command :  expn listwill try to expand the Mailing listlist. | 
| export_name [Netgssapi.gss_api] | |
| export_sec_context [Netgssapi.gss_api] | |
| F | |
| fd [Nethttpd_kernel.lingering_close] | 
The file descriptor
 | 
| fd [Nethttpd_kernel.http_protocol] | 
Just returns the socket
 | 
| fetch_subnegotiation [Telnet_client.telnet_session] | 
This method should be called as follows:
 If you find a  Telnet_sbat the beginning of the input queue,
 remove this commandQueue.take, and invokefetch_subnegotiation. | 
| 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  filenameparameter found in the header of file uploads. | 
| 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  #finalizefor every CGI argument
        (including the possible one of PUT) to ensure that all files
        are deleted. | 
| 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 [Http_client_conncache.connection_cache] | 
Returns an inactive connection to the passed peer, or raise
  Not_found. | 
| find_my_connections [Http_client_conncache.connection_cache] | 
Returns all active connections owned by the object
 | 
| 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 [Http_client.generic_call] | 
This method is called just before sending the request.
 | 
| 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  raw_out_channel | 
| flush [Netchannels.rec_out_channel] | 
If there is a write buffer, it will be flushed.
 | 
| flush [Uq_engines.async_out_channel] | 
Flushes the 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  data_chunk. | 
| ftp_client [Ftp_fs.ftp_stream_fs] | 
The FTP client backing this filesystem
 | 
| ftp_state [Ftp_client.ftp_client_pi] | 
Returns the current ftp_state
 | 
| G | |
| gc_when_idle [Netplex_types.socket_service_config] | 
If set, idle containers run a  Gc.full_majorcycle. | 
| 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_connection_state [Http_client_conncache.connection_cache] | 
Returns the state of the file descriptor, or raises  Not_found | 
| get_engine [Uq_engines.cache_t] | 
Requests the value.
 | 
| get_host [Http_client.http_call] | 
The host name of the content server, extracted from the URI.
 | 
| get_local_option [Telnet_client.telnet_session] | |
| get_mic [Netgssapi.gss_api] | |
| get_opt [Uq_engines.cache_t] | 
Returns the cached value if available
 | 
| get_options [Telnet_client.telnet_session] | 
Get the configuration options.
 | 
| get_options [Http_client.pipeline] | |
| get_path [Http_client.http_call] | 
The path (incl.
 | 
| get_port [Http_client.http_call] | 
The port number of the content server, extracted from the URI.
 | 
| get_reconnect_mode [Http_client.http_call] | 
Get what to do if the server needs to be reconnected, i.e.
 | 
| get_redirect_mode [Http_client.http_call] | 
By default, the redirect mode is  Redirect_if_idem. | 
| get_remote_option [Telnet_client.telnet_session] | |
| get_req_body [Http_client.http_call] | 
What has been sent as body in the (last) request.
 | 
| get_req_header [Http_client.http_call] | 
Deprecated.
 | 
| get_req_method [Http_client.http_call] | 
Get the name of the request method.
 | 
| get_resp_body [Http_client.http_call] | 
Deprecated.
 | 
| get_resp_header [Http_client.http_call] | 
Deprecated.
 | 
| get_uri [Http_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.poll_engine] | 
Returns the group the engine is member of
 | 
| H | |
| has_req_body [Http_client.http_call] | 
Whether the method allows to send a request body
 | 
| has_resp_body [Http_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 HELLO command to the server.
 | 
| 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.
 | 
| host_by_name [Uq_resolver.resolver] | 
Look up the passed host name up.
 | 
| I | |
| id [Netsys_oothr.thread] | 
In a multi-threaded program: Returns the thread ID.
 | 
| id [Netmcore.compute_resource] | 
an ID of the resource that is valid in the whole Netplex system
 | 
| import_name [Netgssapi.gss_api] | |
| import_sec_context [Netgssapi.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.multiplex_controller] | 
Inactivates the connection immediately, and releases any resources
 the controller is responsible for (e.g.
 | 
| inactivate_no_close [Uq_ssl.ssl_multiplex_controller] | 
Inactivates the controller by deleting all event handlers.
 | 
| inactivity_timeout [Netplex_workload.dynamic_workload_config] | 
After this number of seconds a free thread can be terminated
 | 
| indicate_mechs [Netgssapi.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 [Netgssapi.gss_api] | 
On the first call, pass  ~context:None. | 
| 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] | |
| input [Netchannels.augment_raw_in_channel] | 
As in  raw_in_channel | 
| input [Netchannels.rec_in_channel] | 
Reads octets from the channel and puts them into the string.
 | 
| input [Uq_engines.async_in_channel] | input s k n: Reads channel data into the substring ofsbeginning at indexkwith lengthn. | 
| 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  End_of_file | 
| input_ch [Netcgi1_compat.Netcgi_env.cgi_environment] | 
Not the user business.
 | 
| input_ch_async [Nethttpd_engine.extended_async_environment] | 
This is the  input_chchannel taken as asynchonous channel. | 
| 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  End_of_file | 
| input_content_length [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| input_content_length [Netcgi.cgi_environment] | 
Returns the  "Content-length"request header field. | 
| input_content_length [Netcgi_common.cgi_environment] | |
| input_content_type [Netcgi1_compat.Netcgi_env.cgi_environment] | 
Type now is  unit -> string * (string * Mimestring.s_param)
	  listto be coherent withNetmime.mime_header_ro. | 
| input_content_type [Netcgi.cgi_environment] | 
Returns the parsed  "Content-type"request header field. | 
| 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  "Content-type"request header field as a plain
        string or""if it is not set. | 
| input_content_type_string [Netcgi_common.cgi_environment] | |
| input_eor [Ftp_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 ?default freturns the value of a fieldfof the HTTP request header. | 
| 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 [Telnet_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:  `Normal: The normal timeout value applies,`Next_message: The timeout value applies while waiting for the next message,`None: The connection is output-driven, no input timeout value | 
| inquire_context [Netgssapi.gss_api] | |
| inquire_cred [Netgssapi.gss_api] | |
| inquire_cred_by_mech [Netgssapi.gss_api] | |
| inquire_key [Http_client.key_handler] | 
The method is called when a new session must be authenticated.
 | 
| inquire_mechs_for_name [Netgssapi.gss_api] | |
| inquire_names_for_mech [Netgssapi.gss_api] | |
| int_param [Netplex_types.config_file] | |
| invalidate [Http_client.auth_session] | 
The session is notified that authentication failed.
 | 
| invalidate [Uq_engines.cache_t] | 
Invalidates the cache - if a value exists in the cache, it is removed.
 | 
| invalidate_key [Http_client.key_handler] | 
The handler is notified that authentication failed for this key
 | 
| is_empty [Ftp_client.ftp_client_pi] | 
Whether the queue is empty
 | 
| is_idempotent [Http_client.http_call] | 
Whether the method is to be considered as idempotent ( = repeated
 invocations have the same result and no side effect).
 | 
| is_proxy_allowed [Http_client.http_call] | 
Deprecated.
 | 
| is_running [Unixqueue_select.sb_event_system] | |
| is_running [Unixqueue.event_system] | |
| is_served [Http_client.http_call] | trueif request/response cycle(s) have been finished, i.e. | 
| iter [Uq_lwt.lwt_backend] | |
| 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 | |
| keys [Http_client.key_ring] | 
List of all known keys
 | 
| L | |
| last_ftp_state [Ftp_fs.ftp_stream_fs] | 
The last state of the last operation, or  Not_found | 
| last_response_header [Http_fs.http_stream_fs] | 
Returns the header of the HTTP response of the last operation.
 | 
| last_response_status [Http_fs.http_stream_fs] | 
Return the response status of the last operation, as triple
         (symbolic_code,numeric_code,text). | 
| last_stderr [Shell_fs.shell_stream_fs] | 
The stderr output of the last operation
 | 
| length [Xdr_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.server_endpoint_listener] | 
Instantiates an engine that listens for connections on the socket given
 by the  listen_addressargument. | 
| listen_options [Rpc_server.socket_config] | |
| local_receiver [Ftp_data_endpoint.ftp_data_receiver] | 
The local receiver.
 | 
| local_sender [Ftp_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_subchwhensubchannelis set to the empty string. | 
| 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 msgappendsmsgto the webserver log. | 
| 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   (component, subchannel, max_level, file, format) . | 
| 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  cgi_propertiesas the one sent to theconfig_log_accessfunction | 
| log_subch [Netplex_types.container] | 
Sends a log message to the controller.
 | 
| log_subch [Netplex_types.logger] | 
Receive a log  messageoflevelfromcomponent. | 
| log_subchannel [Netplex_log.generic_config] | |
| logger [Netplex_types.controller] | 
The logger
 | 
| lookup [Netplex_types.container] | lookup service_name protocol_nametries to find a Unix domain
 socket for the service and returns it. | 
| lookup_container_sockets [Netplex_types.container] | lookup_container_sockets service_name protocol_name: returns
      the Unix Domain paths of all container sockets for this service and
      protocol. | 
| lstn_backlog [Netplex_types.protocol] | 
The backlog (argument of Unix.listen)
 | 
| lstn_reuseaddr [Netplex_types.protocol] | 
Whether to reuse ports immediately
 | 
| M | |
| mail [Netsmtp.client] | 
Performs a MAIL FROM command.
 | 
| mailboxes [Netaddress.group] | 
The member mailboxes
 | 
| 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 [Http_client.http_call] | 
Returns the current maximum length (initially  Int64.max_int) | 
| max_threads [Netplex_workload.dynamic_workload_config] | 
The manager does not start more threads than this number
 | 
| mem_supported [Uq_engines.multiplex_controller] | 
Whether  start_mem_readingandstart_mem_writingare possible | 
| 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 [Http_fs.http_stream_fs] | |
| mlst_enabled_facts [Ftp_client.ftp_client_pi] | 
The enabled facts for  `MLSTand`MLSD | 
| mlst_facts [Ftp_client.ftp_client_pi] | 
All available facts for  `MLSTand`MLSD | 
| multiple_argument [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| multiple_argument [Netcgi.cgi] | #multiple_argument namereturns all the values of the
	argument namedname. | 
| multiple_argument [Netcgi_common.cgi] | |
| multiple_connections [Uq_engines.server_endpoint_acceptor] | 
Whether it is possible to accept multiple connections
 | 
| 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_posix.post_fork_handler] | |
| 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  socket_service. | 
| name [Netplex_types.socket_service_config] | 
The proposed name for the  socket_service | 
| name [Netplex_types.socket_service] | 
The name of the  socket_serviceis used to identify the service
 in the whole netplex process cluster. | 
| name [Nethttpd_types.http_service] | 
The name of the type of the service provider
 | 
| name [Http_client.basic_auth_method] | |
| name [Netcgi1_compat.Netcgi_types.cgi_argument] | |
| name [Netcgi.cgi_argument] | 
The name of the argument.
 | 
| name [Netcgi_common.cgi_argument] | |
| need_ip6 [Ftp_client.ftp_client_pi] | 
Whether  `EPSVor`EPRTare required instead of`PASVand`PORT, respectively. | 
| need_linger [Nethttpd_kernel.http_protocol] | 
Returns  truewhen a lingering close operation is needed to reliably shut
 down the socket. | 
| 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  client prog proc xid. | 
| next_request [Nethttpd_reactor.http_reactor] | 
Tries to read the next request.
 | 
| no_credential [Netgssapi.gss_api] | 
A substitute credential for  GSS_C_NO_CREDENTIAL | 
| no_name [Netgssapi.gss_api] | 
A substitute name for  GSS_C_NO_NAME | 
| no_proxy [Http_client.http_call] | 
Same as  set_proxy_enabled false | 
| nominal_dot_dot [Netfs.stream_fs] | 
Whether the effect of  ..can be obtained by stripping off the
	last path component, i.e. | 
| nominal_dot_dot [Http_fs.http_stream_fs] | |
| non_blocking_connect [Rpc_client.socket_config] | non_blocking_connect: Whether the remote service is connected
   in the background. | 
| noop [Netsmtp.client] | 
NOOP : does nothing, keeps the connection alive.
 | 
| noop [Netpop.client] | 
Pings the server to keep the session alive.
 | 
| notify [Uq_engines.engine_mixin] | |
| number_of_open_connections [Http_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 [Http_client.pipeline] | 
Returns the number of messages which are still in the pipeline.
 | 
| O | |
| offer_local_option [Telnet_client.telnet_session] | |
| 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  #set_value. | 
| 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 [Telnet_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  raw_out_channel | 
| 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 cgioutputs the template to the CGI sessioncgi. | 
| output [Uq_engines.async_out_channel] | output s k n: Writes the substring ofsbeginning at indexkwith lengthninto the 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_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_chchannel taken as asynchronous channel. | 
| output_channel [Netchannels.compl_out_channel] | 
Writes the contents of an  in_obj_channeluntil the end of the
 input channel is reached. | 
| output_char [Netchannels.compl_out_channel] | 
Writes exactly one character
 | 
| output_eor [Ftp_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  #send_output_header. | 
| 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 [Telnet_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:  `Start: Nothing is generated yet,`Sending: Output is already being sent,`End: The response (for a single request) has been fully sent | 
| 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  (protocol_name, path)of all container sockets
        of this container | 
| P | |
| parallelizer [Netplex_types.par_thread] | 
Returns the parallelizer that created this thread.
 | 
| pass [Netpop.client] | 
Authenticates a user with the plain-text password  pass. | 
| password [Http_client.key] | 
The password in cleartext
 | 
| password_of_user_name [Netmech_scram_gssapi.client_key_ring] | 
Returns the cleartext password for a user name, or
	raises  Not_foundif the user is unknown | 
| 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
	( Netconversion.is_ascii_compatible). | 
| path_encoding [Http_fs.http_stream_fs] | |
| path_exclusions [Netfs.stream_fs] | 
Code points that must not occur in path components between slashes.
 | 
| path_exclusions [Http_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_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 [Ftp_client.ftp_client] | 
The curerent protocol interpreter.
 | 
| pipeline [Http_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  `Req_endtokens
 minus number of responses in state`Processed. | 
| pos_in [Netchannels.augment_raw_in_channel] | 
As in  raw_in_channel | 
| pos_in [Netchannels.raw_in_channel] | 
Returns the current channel position.
 | 
| pos_in [Uq_engines.async_in_channel] | 
Returns the number of characters read from the channel
 | 
| pos_out [Netchannels.augment_raw_out_channel] | 
As in  raw_out_channel | 
| pos_out [Netchannels.raw_out_channel] | 
Returns the current channel position.
 | 
| pos_out [Uq_engines.async_out_channel] | 
Returns the number of characters output into the 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 [Xdr_mstring.mstring] | 
Whether  as_memoryoras_stringis cheaper | 
| print [Netplex_types.config_file] | |
| print [Nethttpd_types.http_service] | 
Outputs the definition term to a formatter
 | 
| prioritized [Uq_engines.prioritizer_t] | let pe = prioritized f p: Queues upfon priority levelp. | 
| private_api [Http_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 [Netgssapi.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_option_command [Telnet_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.
 | 
| protocol [Rpc_transport.rpc_multiplex_controller] | 
The protocol encapsulation
 | 
| 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 [Netgssapi.gss_api] | 
A string name identifying the provider
 | 
| proxy_enabled [Http_client.http_call] | 
Returns the proxy mode
 | 
| proxy_type [Http_client.pipeline] | proxy_type urlreturnsSome ptif a proxy would be used for thisurl, andNoneif a direct connection would be made. | 
| proxy_type_of_call [Http_client.pipeline] | 
Same for an already created call object
 | 
| proxy_use_connect [Http_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
 | 
| put [Uq_engines.cache_t] | 
Puts a value immediately into the cache.
 | 
| Q | |
| queue_events [Unixqueue_select.sb_event_system] | |
| quit [Netsmtp.client] | 
Requests the server to end this session.
 | 
| quit [Netpop.client] | 
Requests the server to end this session.
 | 
| R | |
| rcpt [Netsmtp.client] | 
Performs a RCPT TO command.
 | 
| read [Netfs.stream_fs] | read flags filename: Opens the filefilenamefor reading,
	and returns the input stream. | 
| read [Http_fs.http_stream_fs] | 
Additional flag:  `Header h: Set these headers in the submitted GET request | 
| 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.multiplex_controller] | 
Whether the EOF marker has been read
 | 
| read_file [Netfs.stream_fs] | read_file flags filename:  Opens the filefilenamefor reading,
	and returns the contents as alocal_file. | 
| read_file [Http_fs.http_stream_fs] | 
Additional flag:  `Header h: Set these headers in the submitted GET request | 
| readdir [Netfs.stream_fs] | 
Reads the contents of a directory.
 | 
| readdir [Http_fs.http_stream_fs] | |
| reading [Rpc_transport.rpc_multiplex_controller] | 
True iff there is a reader
 | 
| reading [Uq_engines.multiplex_controller] | 
True iff there is a reader
 | 
| readlink [Netfs.stream_fs] | 
Reads the target of a symlink
 | 
| readlink [Http_fs.http_stream_fs] | |
| really_input [Netchannels.compl_in_channel] | 
Reads exactly as many octets from the channel as the second  intargument specifies. | 
| really_output [Netchannels.compl_out_channel] | 
Writes exactly as many octets to the channel as the second  intargument specifies. | 
| realm [Http_client.key] | 
The realm
 | 
| receive [Rpc_client.auth_protocol] | 
Receive a token for the  xidannounced instate. | 
| receive [Nethttpd_kernel.http_protocol] | 
Returns the first  req_tokenfrom the receive queue. | 
| 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.datagram_multiplex_controller] | 
Returns the socket address of the last received datagram.
 | 
| 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.wrapped_datagram_socket] | 
Receive data from the (unconnected) socket.
 | 
| register [Netsys_pmanage.pmanage] | 
Mass-register a list of objects
 | 
| register_file [Netsys_pmanage.pmanage] | 
Register a temporary file
 | 
| register_lever [Netplex_types.controller] | let id = register_lever f: It is possible to register a functionfin the controller, and run it over the internal RPC interface from
        any container. | 
| 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  Netsys_sem) | 
| 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 [Http_fs.http_stream_fs] | |
| remove_resource [Unixqueue_select.sb_event_system] | |
| remove_resource [Unixqueue.event_system] | |
| rename [Netfs.stream_fs] | 
Renames the file.
 | 
| rename [Http_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  `Received_requestat the
 moment when this notification is delivered. | 
| req_state [Nethttpd_engine.http_request_header_notification] | 
Returns the request processing state which is  `Received_headerat the
 moment when this notification is delivered. | 
| request [Netcgi_apache.cgi] | 
The underlying apache request structure.
 | 
| request_body [Http_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 [Http_client.http_call] | 
The whole header of the request.
 | 
| request_method [Nethttpd_types.request_info] | 
The method like  GET. | 
| request_method [Http_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 [Ftp_client.ftp_client_pi] | 
as in  Uq_engines.engine | 
| request_notification [Uq_engines.async_in_channel] | 
After the notification has been requested, the passed function is
 be called whenever  can_inputchanges its value (or might change
 its value). | 
| request_notification [Uq_engines.async_out_channel] | 
After the notification has been requested, the passed function is
 be called whenever  can_outputchanges its value (or might change
 its value). | 
| request_notification [Uq_engines.engine_mixin] | |
| request_notification [Uq_engines.engine] | 
Requests notification about state changes.
 | 
| request_notification [Uq_resolver.engine] | |
| request_remote_option [Telnet_client.telnet_session] | |
| request_uri [Nethttpd_types.request_info] | 
The URI of the client request.
 | 
| request_uri [Http_client.http_call] | 
The request URI as string.
 | 
| required [Netplex_types.plugin] | 
Required plugins
 | 
| reset [Ftp_client.ftp_client] | 
Aborts all current activities if any, and re-initializes the client
 | 
| reset [Telnet_client.telnet_session] | 
Closes the connection immediately and empties all queues.
 | 
| reset [Http_client.pipeline] | 
Empties the pipeline and inactivates any open connection.
 | 
| reset_counters [Http_client.pipeline] | |
| reset_local_option [Telnet_client.telnet_session] | |
| reset_remote_option [Telnet_client.telnet_session] | |
| resolve_parameter [Netplex_types.config_file] | |
| resolve_section [Netplex_types.config_file] | |
| resp_queue_len [Nethttpd_kernel.http_protocol] | 
Returns the length of the internal response queue (number of  http_responseobjects that have not yet fully processed) | 
| response [Nethttpd_reactor.internal_environment] | |
| response_body [Http_client.http_call] | 
The whole body of the response.
 | 
| response_body_storage [Http_client.http_call] | 
How to create the response body.
 | 
| response_header [Http_client.http_call] | 
The whole header of the response.
 | 
| response_protocol [Http_client.http_call] | 
The HTTP version indicated in the response
 | 
| response_status [Http_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 [Http_client.http_call] | 
The three-digit status code
 | 
| response_status_text [Http_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.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 [Http_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 [Netsmtp.client] | 
Reset the current transaction
 | 
| rset [Netpop.client] | 
Unmarks any messages that have previously been marked as
 deleted.
 | 
| run [Netsys_posix.post_fork_handler] | |
| run [Ftp_client.ftp_client_pi] | 
Starts the event system; same as  Unixqueue.run | 
| run [Ftp_client.ftp_client] | 
Starts the event system; same as  Unixqueue.run | 
| run [Telnet_client.telnet_session] | 
Run the event system
 | 
| run [Http_client.pipeline] | 
Runs through the requests in the pipeline.
 | 
| run [Unixqueue_select.sb_event_system] | |
| run [Unixqueue.event_system] | |
| S | |
| same_call [Http_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 triple
	 for a user, or raisesNot_found. | 
| 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 [Ftp_client.ftp_client_pi] | 
Sends immediately an  ABORcommand, even when a data transfer is
 in progress. | 
| send_admin_message [Netplex_types.controller] | send_message destination msgname msgargs: Sends an admin message todestination. | 
| send_file [Nethttpd_types.v_extended_environment] | 
Sends the output header with a file as body.
 | 
| send_message [Netplex_types.container] | send_message service_pattern msg_name msg_arguments: Sends
        a message to all services and message receivers matchingservice_pattern. | 
| send_message [Netplex_types.controller] | send_message destination msgname msgargs: Sends a message todestination. | 
| 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 [Telnet_client.telnet_session] | 
At the next output oppurtunity, a Synch sequence is sent to
 the remote peer.
 | 
| send_to [Uq_engines.datagram_multiplex_controller] | 
Sets the socket address of the next datagram to send.
 | 
| sendto [Uq_engines.wrapped_datagram_socket] | 
Send data over the (unconnected) socket
 | 
| serialized [Uq_engines.serializer_t] | let se = serialized f: Waits until all the previous engines reach
	a final state, and then runse = f esys. | 
| server_accepts [Rpc_client.auth_session] | 
Called if the server accepts the credentials.
 | 
| server_addr [Rpc_server.auth_details] | |
| server_address [Uq_engines.server_endpoint_acceptor] | 
The contact address under which the clients can establish new
 connections with this server.
 | 
| 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 [Netcgi_modtpl.template] | 
Set a variable in the template.
 | 
| set_accept_encoding [Http_client.http_call] | 
Sets the  Accept-Encodingfield in the request header, and 
	includes all decompression algorithms registered inNetcompression. | 
| set_arguments [Netcgi1_compat.Netcgi_types.cgi_activation] | |
| set_callback [Nethttpd_kernel.http_response] | 
The function will be called when either  set_statechanges the state,
 or when the send queue becomes empty. | 
| set_callback [Telnet_client.telnet_session] | 
Sets the callback function.
 | 
| set_channel_binding [Http_client.http_call] | 
Sets the channel binding.
 | 
| set_chunked_request [Http_client.http_call] | 
Configures that the request is transmitted using chunked encoding.
 | 
| set_connection [Telnet_client.telnet_session] | 
Sets the host name and the port of the remote server to contact.
 | 
| set_connection_cache [Http_client.pipeline] | 
Set the connection cache.
 | 
| set_connection_state [Http_client_conncache.connection_cache] | 
Sets the state of the file descriptor.
 | 
| set_event_system [Telnet_client.telnet_session] | 
Sets the event system to use.
 | 
| set_event_system [Http_client.pipeline] | 
Sets the event system.
 | 
| set_exception_handler [Telnet_client.telnet_session] | 
Sets the exception handler.
 | 
| set_expect_handshake [Http_client.http_call] | 
Configures that a handshake is done before sending the request body.
 | 
| set_fields [Netmime.mime_header] | |
| set_header [Netcgi1_compat.Netcgi_types.cgi_activation] | 
Added  ?content_lengthfor user convenience and deprecated?set_cookiein favor of?set_cookiesfor coherence
	  e.g. | 
| 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_max_level [Netplex_types.controller_config] | 
Set the maximum global log level
 | 
| set_max_response_body_length [Http_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 [Telnet_client.telnet_session] | 
Set the configuration options.
 | 
| set_options [Http_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 [Http_client.pipeline] | set_proxy name port:
 sets that an HTTP proxynamelistening onportis to be used | 
| set_proxy_auth [Http_client.pipeline] | 
sets user and password for the proxy.
 | 
| set_proxy_enabled [Http_client.http_call] | 
Sets the proxy mode
 | 
| set_proxy_from_environment [Http_client.pipeline] | 
Inspect the environment variables  http_proxyandno_proxyand set the proxy options from them. | 
| set_realm [Http_client.basic_auth_method] | |
| set_reconnect_mode [Http_client.http_call] | 
Sets the reconnect mode
 | 
| set_redirect_mode [Http_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 [Http_client.http_call] | |
| set_request_body [Http_client.http_call] | 
Replaces the whole body object
 | 
| set_request_device [Http_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 [Http_client.http_call] | 
Replaces the whole  `Baseheader object | 
| set_request_uri [Http_client.http_call] | 
Sets the request URI.
 | 
| set_response_body_storage [Http_client.http_call] | 
Sets how to create the response body
 | 
| set_socks5_proxy [Ftp_client.ftp_client] | 
Sets that a SOCKS version 5 proxy is used at this host and port.
 | 
| set_socks5_proxy [Http_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.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  notifycallback is invoked. | 
| set_transport_proxy [Http_client.pipeline] | set_transport_proxy id host port auth ptype: Sets a special
	  proxy for the transport identified byid. | 
| set_transport_proxy_from_environment [Http_client.pipeline] | 
Like  set_proxy_from_environment, this method inspects environment
	  variables and configures the proxy settings. | 
| 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 [Http_client.transport_channel_type] | setup fd cb tmo tmo_x host port esys: Create or configure a communication
      circuit over the file descriptorfdthat can be driven by the
      returned multiplex controller object. | 
| setup_e [Https_client.transport_channel_type] | |
| shut_down [Uq_engines.wrapped_datagram_socket] | 
Close the descriptor, shuts down any further needed resources
 | 
| shut_down [Uq_engines.server_endpoint_acceptor] | 
The server endpoint is shut down such that no further connections
 are possible.
 | 
| 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.multiplex_controller] | 
True iff the shutdown is in progress
 | 
| signal [Netsys_oothr.condition] | 
In a multi-threaded program: Signal one process that the condition
        holds.
 | 
| signal [Uq_engines.signal_engine] | |
| single_threaded [Netsys_oothr.mtprovider] | 
Whether this is a single-threaded program.
 | 
| size [Netfs.stream_fs] | 
Returns the size of a file.
 | 
| size [Http_fs.http_stream_fs] | |
| skip [Netstream.in_obj_stream] | 
Skip the n bytes of the stream.
 | 
| skip_challenge [Http_client.auth_handler] | 
If non-None, this method allows to skip the challenge entirely
        for authentication.
 | 
| skip_challenge_session [Http_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.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.wrapped_datagram_socket] | |
| sockets [Netplex_types.socket_service] | 
A  socket_serviceconsists of a list of supported protocols
 which are identified by a name. | 
| 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
 | 
| ssl_accepting [Uq_ssl.ssl_multiplex_controller] | 
Whether the initial SSL handshake is in progress that makes this
 socket a server.
 | 
| ssl_connecting [Uq_ssl.ssl_multiplex_controller] | 
Whether the initial SSL handshake is in progress that makes this
 socket a client.
 | 
| ssl_socket [Uq_ssl.ssl_multiplex_controller] | |
| ssl_socket_state [Uq_ssl.ssl_multiplex_controller] | 
Returns the socket state:  `Unset: A fresh socket,`Client: A socket playing the SSL client role,`Server: A socket playing the SSL server role,`Unclean: The socket state is unclean. The socket is no longer usable.,`Clean: The SSL connection has been cleanly shut down. | 
| start [Netplex_types.container] | 
Internal Method.
 | 
| start_containers [Netplex_types.socket_controller] | |
| start_mem_reading [Uq_engines.multiplex_controller] | 
Same as  start_reading, but puts the data into amemorybuffer. | 
| start_mem_writing [Uq_engines.multiplex_controller] | 
Same as  start_writing, but takes the data from amemorybuffer. | 
| start_reading [Rpc_transport.rpc_multiplex_controller] | 
Start reading from the connection.
 | 
| start_reading [Uq_engines.multiplex_controller] | 
Start reading from the connection.
 | 
| start_shutting_down [Rpc_transport.rpc_multiplex_controller] | 
Start shutting down the connection.
 | 
| start_shutting_down [Uq_engines.multiplex_controller] | 
Start shutting down the connection.
 | 
| start_ssl_accepting [Uq_ssl.ssl_multiplex_controller] | 
Makes the socket an SSL server socket by initiating the handshake.
 | 
| start_ssl_connecting [Uq_ssl.ssl_multiplex_controller] | 
Makes the socket an SSL client socket by initiating the handshake.
 | 
| start_thread [Netplex_types.parallelizer] | start_thread f l_close l_share name logger: 
 Starts a new thread or process and callsf threadin that context. | 
| start_writing [Rpc_transport.rpc_multiplex_controller] | 
Starts writing the message.
 | 
| start_writing [Uq_engines.multiplex_controller] | 
Start writing to the connection.
 | 
| start_writing_eof [Uq_engines.multiplex_controller] | 
Start writing the EOF marker to the 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
         post_start_hook. | 
| stat [Netpop.client] | 
Returns information about the current mailbox as tuple
  (count,size,ext)wherecountis the number of messages in 
 the mailbox,sizeis the size of the mailbox in octets, 
 andextis any server extension data. | 
| state [Rpc_client.auth_protocol] | 
The state of the authentication protocol:  `Emit: The client needs to emit another token,`Receive xid: The client waits for another token (with
	  session identifierxid),`Done session: The protocol is finished andsessioncan
	  be used for authenticating,`Error: Something went wrong. | 
| state [Netpop.client] | 
Current state of this session.
 | 
| state [Netplex_types.socket_controller] | 
The current state
 | 
| state [Nethttpd_kernel.http_response] | 
Reports the state.
 | 
| state [Ftp_client.ftp_client_pi] | 
The state in the sense of  Uq_engines. | 
| state [Uq_engines.engine_mixin] | |
| state [Uq_engines.engine] | 
Returns the state of the engine
 | 
| state [Uq_resolver.engine] | |
| status [Http_client.http_call] | 
The condensed status
 | 
| 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  `Filebeing the filename). | 
| store [Netcgi_common.cgi_argument] | |
| string_param [Netplex_types.config_file] | |
| supported_ptypes [Netplex_kit.v_processor] | |
| supported_ptypes [Netplex_types.processor] | 
The supported parallelization types
 | 
| supports_half_open_connection [Uq_engines.multiplex_controller] | 
Whether the underlying transport mechanism can close the write side
 of the connection only (half-open connection).
 | 
| supports_mdtm [Ftp_client.ftp_client_pi] | 
Whether the  `MDTMcommand is supported. | 
| supports_mlst [Ftp_client.ftp_client_pi] | 
Whether the  `MLSTand`MLSDcommands are supported | 
| supports_size [Ftp_client.ftp_client_pi] | 
Whether the  `SIZEcommand is supported. | 
| supports_tvfs [Ftp_client.ftp_client_pi] | 
Whether TVFS filenames are supported
 | 
| supports_utf8 [Ftp_client.ftp_client_pi] | 
Whether the UTF-8 extension is understood by the server (RFC 2640)
 | 
| symlink [Netfs.stream_fs] | symlink flags oldpath newpath: Creates a symlink. | 
| symlink [Http_fs.http_stream_fs] | |
| sys_id [Netplex_types.par_thread] | 
Returns a system-dependent identifier for the thread:  `Thread id: Theidas returned byThread.id,`Process id: Theidis the process ID | 
| 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  systemRPC client | 
| 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.
 | 
| tcp_nodelay [Netplex_types.protocol] | 
Whether to set the TCP_NODELAY option
 | 
| test [Netfs.stream_fs] | 
Returns whether the test is true.
 | 
| test [Http_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  testbut this function performs all tests in the list
	at once, and returns a bool for each test. | 
| test_list [Http_fs.http_stream_fs] | |
| timeout [Nethttpd_kernel.http_protocol] | 
Process a timeout condition as  cycledoes | 
| 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 [Ftp_fs.ftp_stream_fs] | 
Translates a path into a URL
 | 
| translate [Http_fs.http_stream_fs] | 
Translates a path into a URL
 | 
| 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  Netsys_sem) | 
| unwrap [Netgssapi.gss_api] | 
Note that the  output_messagecan be a buffer of different type
	(string vs. | 
| update [Telnet_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  netplex.connectionsadmin message | 
| 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):  cgi_server_name,cgi_server_port,cgi_script_name,cgi_path_info | 
| user [Netpop.client] | 
Specifies the name of the mailbox the client would like to open
       using plain-text authentication.
 | 
| user [Http_client.key] | 
The user name
 | 
| user_agent [Netcgi1_compat.Netcgi_env.cgi_environment] | |
| user_agent [Netcgi.cgi_environment] | 
This is a convenience method that returns the  "User-agent"field of the HTTP request header. | 
| user_agent [Netcgi_common.cgi_environment] | |
| V | |
| value [Netmime.mime_body_ro] | 
The  valuemethod returns the _decoded_ body,
 i.e. | 
| 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  Not_found. | 
| verifier [Rpc_server.auth_details] | |
| verify_mic [Netgssapi.gss_api] | |
| version [Rpc_server.auth_details] | |
| 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:  want block_size | 
| 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 [Netgssapi.gss_api] | output_message_preferred_type: seeunwrap | 
| wrap_size_limit [Netgssapi.gss_api] | |
| write [Netfs.stream_fs] | write flags filename: Opens (and optionally creates) thefilenamefor writing, and returns the output stream. | 
| write [Http_fs.http_stream_fs] | 
Additional flag:  `Header h: Set these headers in the submitted PUT request | 
| write_file [Netfs.stream_fs] | write_file flags filename localfile:  Opens the filefilenamefor writing, and copies the contents of thelocalfileto it. | 
| write_file [Http_fs.http_stream_fs] | 
Additional flag:  `Header h: Set these headers in the submitted PUT request | 
| writing [Rpc_transport.rpc_multiplex_controller] | 
True iff there is a writer
 | 
| writing [Uq_engines.multiplex_controller] | 
True iff there is a writer
 | 
| wrote_eof [Uq_engines.multiplex_controller] | 
Whether the EOF marker has been written
 | 
| 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.
 |