# Index of types

A
addr_spec [Netaddress] | The pair `local_part@domain` as O'Caml type.
argument_processing [Netcgi] | How to process CGI arguments: ``Memory`: Keep the value of the argument in memory, ``File`: Store the value of the argument in an external file, ``Automatic`: If the argument is structured and carries a file name, the value will be stored in a file; otherwise it is loaded into memory. (Note: The meaning of ``Automatic` changed in OcamlNet 0.92.)
auth [Netcgi_jserv] | Authentication record
C
cache_control [Netcgi_types] | This is only a small subset of the HTTP 1.1 cache control features, but they are usually sufficient, and they work for HTTP/1.0 as well.
cgi_config [Netcgi_env] |
cgi_cookie [Netcgi_types] |
charset [Netconversion] | A `charset` is simply a set of code points.
close_mode [Netchannels] | Whether a `close_out` implies a commit or rollback operation
complex_mime_body [Netmime] |
complex_mime_body_ro [Netmime] | The read-only view of a complex_mime_message
complex_mime_message [Netmime] |
complex_mime_message_ro [Netmime] |
controlpipe [Netcgi_jserv] | The type of the control pipe
cursor [Netconversion] | A cursor denotes a character position in an encoded string
D
document [Nethtml] | The type `document` represents parsed HTML documents:
domain [Netaddress] | The domain of the mailbox
E
element_class [Nethtml] | Element classes are a property used in the HTML DTD.
encoding [Netconversion] | The polymorphic variant enumerating the supported encodings.
entity_set [Netencoding.Html] |
F
fcgiBeginRequestBody [Netcgi_fcgi_10] |
fcgiEndRequestBody [Netcgi_fcgi_10] |
fcgiHeader [Netcgi_fcgi_10] |
fcgiRequest [Netcgi_fcgi_10] |
from_uni_list [Netmappings] |
I
input_mode [Netcgi_env] | Determines how to read the request: ``Standard`: Only the request body is read from the input channel (CGI standard), Not yet implemented: ``Direct`: Both header and body of the request are read from the input channel
input_result [Netchannels] | This type is for the method `enhanced_input` of `enhanced_raw_in_channel`.

input_state [Netcgi_env]

The input processing state: ``Start`: Input data have not yet been received, ``Receiving_header`: The request header is currently being received, ``Received_header`: The request header has been completely received, and nothing of the request body has yet been received, ``Receiving_body`: The request body is currently being received, ``Received_body`: The request body has been completely received Transition diagram:

     `Start ->
     `Receiving_header ->
     `Received_header ->
     `Receiving_body ->
     `Received_body

J

jserv_config [Netcgi_jserv_app]

Server configuration: `js_backlog` is the maximum length of the backlog queue (containing client connections that are not yet accepted by the application server), `js_reuseaddr`: Whether to reuse the port immediately, `js_cgiconfig`: The CGI-level configuration, `js_init_process`: This hook is called when a new process is initialized. For ``Sequential` servers it is called once before the server begins to accept connections. For ``Forking` and ``Process_pool` servers it is called when new processes are forking., `js_fini_process`: The reverse hook of `js_init_process`: Called after a process receives the shutdown notification. For ``Sequential` servers it is called once after the server stops to accept connections. For ``Forking` and ``Process_pool` servers it is called before sub processes exit., `js_idle_master`: This hook is called every second by the master process that accepts new connections. When it raises an exception, the master socket is closed, and the exception falls through to the caller., `js_idle_worker`: This hook is called every second by the worker process that processes connections. Exceptions are logged. Examples: `js_init_process`: Open a new database connection for every process, `js_fini_process`: Close the database connection, `js_idle_master`: Check whether the server should shut down, and if so, raise an exception to exit, `js_idle_worker`: Close database connections after a period of inactivity

L
lexbuf [Netulex.Ulexing] |
local_part [Netaddress] | Usually the user name
M
mime_message [Netmime] | Simple MIME message, in a form that is compatible with complex ones.
mime_message_ro [Netmime] | Read-only variant of simple messages
mime_scanner [Mimestring] | The opaque type of a scanner for structured values

model_constraint [Nethtml]

Model constraints define the possible sub elements of an element: ``Inline`: The sub elements must belong to the class ``Inline`, ``Block`: The sub elements must be members of the classes ``Block` or ``Essential_block`, ``Flow`: The sub elements must belong to the classes ``Inline`, ``Block`, or ``Essential_block`, ``Empty`: There are no sub elements, ``Any`: Any sub element is allowed, ``Special`: The element has special content (e.g. `<script>`). Functionally equivalent to ``Empty`, ``Elements l`: Only these enumerated elements may occur as sub elements, ``Or(m1,m2)`: One of the constraints `m1` or `m2` must hold, ``Except(m1,m2)`: The constraint `m1` must hold, and `m2` must not hold, ``Sub_exclusions(l,m)`: The constraint `m` must hold; furthermore, the elements enumerated in list `l` are not allowed as direct or indirect subelements, even if `m` or the model of a subelement would allow them. The difference to ``Except(m, `Elements l)` is that the exclusion is inherited to the subelements. The ``Sub_exclusions` expression must be toplevel, i.e. it must not occur within an ``Or`, ``Except`, or another `'Sub_exclusions` expression. Note that the members of the class ``Everywhere` are allowed everywhere, regardless of whether the model constraint allows them or not.

multipart_style [Netmime]

How to parse multipart messages: ``None`: Do not handle multipart messages specially. Multipart bodies are not further decoded, and returned as ``Body b` where `b` is the transfer-encoded text representation., ``Flat`: If the top-level message is a multipart message, the parts are separated and returned as list. If the parts are again multipart messages, these inner multipart messages are not furher decoded and returned as ``Body b`., ``Deep`: Multipart messages are recursively decoded and returned as tree structure. This value determines how far the `complex_mime_message` structure is created for a parsed MIME message.

O
operating_type [Netcgi] | The operating type determines how generated data are buffered.
other_url_spec [Netcgi_types] | Determines how an URL part is generated:
output_mode [Netcgi_env] | Determines how to deliver the response: ``Standard`: The format of the response header has CGI format, followed by the response body, Not yet implemented: ``Direct`: The format of the response header has HTTP format, followed by the response body. This is also known as "non-parsed header" format.

output_state [Netcgi_env]

The output processing state: ``Start`: Output has not yet been sent, ``Sending_header`: The response header is currently being sent, ``Sent_header`: The response header has been completely sent, and nothing of the body has yet been sent, ``Sending_body`: The response body is currently being sent, ``Sent_body`: The response body has been sent up to a check point, ``End`: The response has been completely sent Transition diagram:

                  `Start ->
                  `Sending_header ->
                  `Sent_header ->
              +-> `Sending_body
              |      |
              |      V
              +-- `Sent_body
                     |
                     V
                  `End

P
pattern [Netaux.KMP] |
protocol [Netcgi_env] | The base protocol
protocol_attribute [Netcgi_env] |
protocol_type [Netcgi_jserv_app] | Selects the protocol.
protocol_version [Netcgi_env] |
Q
query_string_spec [Netcgi_types] | Determines how the query part of URLs is generated:
R
regexp [Netstring_pcre] | The type of regular expressions; now based on `Pcre`
regexp [Netstring_str] | The type of regular expressions; now based on `Pcre`
representation [Netcgi_types] | Representations of CGI arguments: ``Simple msg`: The argument is unstructured, ``MIME msg`: The argument has a MIME header in addition to the value

request_handler [Netcgi_jserv_app]

The request handler consists of: `req_activate`: A function to process requests and to generate responses. The function gets a fully initialized `cgi_activation` object, and is expected to write the response., `req_processing`: Style of CGI argument processing. Same meaning as in `Netcgi`., `req_operating_type`: Style of CGI response buffering. Same meaning as in `Netcgi`.

request_method [Netcgi_types] | The supported request methods: ``GET`: Side effect-free request of a web resource, ``POST`: Request with side effects, ``HEAD`: Only the header of the corresponding ``GET` are requested, ``DELETE`: Request to delete the web resource, ``PUT arg`: Request to upload the web resource
result [Netstring_pcre] | The type of matching results
result [Netstring_str] | The type of matching results
S
s_extended_token [Mimestring] | An opaque type containing the information of `s_token` plus: where the token occurs, RFC-2047 access functions
s_option [Mimestring] |
s_param [Mimestring] | The type of encoded parameters (RFC 2231)

s_token [Mimestring]

A token may be one of: `QString s`: The quoted string `s`, i.e a string between double quotes. Quoted pairs are already decoded in `s`., `Control c`: The control character `c` (0-31, 127, 128-255), `Special c`: The special character `c`, i.e. a character from the `specials` list, `DomainLiteral s`: The bracketed string `s`, i.e. a string between brackets. Quoted pairs are already decoded in `s`., `Comment`: A string between parentheses. This kind of token is only generated when the option `Return_comments` is in effect., `EncodedWord((charset,lang),encoding,encoded_word)`: An RFC-2047 style encoded word: `charset` is the name of the character set; `lang` is the language specifier (from RFC 2231) or ""; `encoding` is either "Q" or "B"; and `encoded_word` is the word encoded in `charset` and `encoding`. This kind of token is only generated when the option `Recognize_encoded_words` is in effect (if not, `Atom` is generated instead)., `Atom s`: A string which is neither quoted not bracketed nor written in RFC 2047 notation, and which is not a control or special character, i.e. the "rest", `End`: The end of the string

server_type [Netcgi_jserv_app]

Server type: ``Sequential servlets`: The server processes the requests sequentially., ``Forking(n,servlets)`: The server forks for every request, and processes it in the child process. The integer `n` is the maximum number of children processes; if it is exceeded, an error message is displayed immediately without forking., ``Process_pool(n,servlets)`: The server forks a fixed number of times (the integer `n`). The children will process the requests concurrently. If more requests arrive than children are available, the requests must wait until a child becomes free again. In `servlets` the list of available servlets is passed.

simplified_dtd [Nethtml] | A `simplified_dtd` is an associative list of tuples `(element_name, (element_class, constraint))`: For every `element_name` it is declared that it is a member of `element_class`, and that the sub elements must satisfy `constraint`.
split_result [Netstring_pcre] |
split_result [Netstring_str] |
state [Netpop] |
status [Netcgi_types] | HTTP response status:
store [Netcgi_types] | Determines where the data of the CGI argument are actually stored.
store [Netmime] | Specifies where to store the body of a mail message.
T
t [Netcgi_jserv] | The type of an AJP server
t [Netdate] |
t [Netbuffer] |
t [Netaddress] | The union of `mailbox` and `group`
U
unicode_lexbuf [Netulex.ULB] |
url [Neturl] | Values of type `url` describe concrete URLs.
url_syntax [Neturl] | Values of type `url_syntax` describe which components of an URL are recognized, which are allowed (and optional), and which are required.
url_syntax_option [Neturl] |
W
workaround [Netcgi_env] | Indicates special behaviour: ``Work_around_MSIE_Content_type_bug`: Versions of the Internet Explorer send illegal content types. This workaround extracts the right data from the malformed data field, ``Work_around_backslash_bug`: Almost all browsers send illegal backslash sequences when backslashes occur in filenames. This workaround accepts such sequences.