Module Nethttp

module Nethttp: sig .. end

Basic definitions for the HTTP protocol

These definitions can be used by both HTTP clients and servers, and by protocols in the middle, e.g. CGI.

type protocol_version = int * int

A pair of a major and minor version number

type protocol_attribute = [ `Secure_https ]

type protocol = [ `Http of protocol_version * protocol_attribute list
       | `Other ]

The base protocol. RFC 2145 defines how to interpret major and minor numbers. In particular, we have:

`Http((0,9),_) is the ancient HTTP version 0.9
`Http((1,n),_) is the HTTP protocol 1.n. It is expected that all these versions are compatible to each other except negotiable features.
`Http((m,_),_) for m>1 is regarded as unknown protocol, incompatible to any `Http((1,n),_)
`Other is anything else (unrecognizes protocol)

val string_of_protocol : protocol -> string

Returns the string representation, e.g. "HTTP/1.0". Fails for `Other

val protocol_of_string : string -> protocol

Parses the protocol string, e.g. "HTTP/1.0". Returns `Other for unrecognized strings

type http_status = [ `Accepted
       | `Bad_gateway
       | `Bad_request
       | `Conflict
       | `Continue
       | `Created
       | `Expectation_failed
       | `Forbidden
       | `Found
       | `Gateway_timeout
       | `Gone
       | `Http_version_not_supported
       | `Internal_server_error
       | `Length_required
       | `Method_not_allowed
       | `Moved_permanently
       | `Multiple_choices
       | `No_content
       | `Non_authoritative
       | `Not_acceptable
       | `Not_found
       | `Not_implemented
       | `Not_modified
       | `Ok
       | `Partial_content
       | `Payment_required
       | `Precondition_failed
       | `Proxy_auth_required
       | `Request_entity_too_large
       | `Request_timeout
       | `Request_uri_too_long
       | `Requested_range_not_satisfiable
       | `Reset_content
       | `See_other
       | `Service_unavailable
       | `Switching_protocols
       | `Temporary_redirect
       | `Unauthorized
       | `Unsupported_media_type
       | `Use_proxy ]

HTTP response status:

Informational (1xx):

`Continue
`Switching_protocols

Successful (2xx):

`Ok
`Created
`Accepted
`Non_authoritative
`No_content
`Reset_content
`Partial_content

Redirection (3xx):

`Multiple_choices
`Moved_permanently
`Found
`See_other
`Not_modified
`Use_proxy
`Temporary_redirect

Client error (4xx):

`Bad_request
`Unauthorized
`Payment_required
`Forbidden
`Not_found
`Method_not_allowed
`Not_acceptable
`Proxy_auth_required
`Request_timeout
`Conflict
`Gone
`Length_required
`Precondition_failed
`Request_entity_too_large
`Request_uri_too_long
`Unsupported_media_type
`Request_range_not_satisfiable
`Expectation_failed

Server Error (5xx):

`Internal_server_error
`Not_implemented
`Bad_gateway
`Service_unavailable
`Gateway_timeout
`Http_version_not_supported

val int_of_http_status : http_status -> int

Returns the integer code for a status value

val http_status_of_int : int -> http_status

Returns the status value for an integer code, or raises Not_found

val string_of_http_status : http_status -> string

Returns the informational text for a status value

type http_method = string * string

Method name, URI

type cache_control_token = [ `Extension of string * string option
       | `Max_age of int
       | `Max_stale of int option
       | `Min_fresh of int
       | `Must_revalidate
       | `No_cache of string list
       | `No_store
       | `No_transform
       | `Only_if_cached
       | `Private of string list
       | `Proxy_revalidate
       | `Public
       | `S_maxage of int ]

The cache control token for the Cache-control header

type etag = [ `Strong of string | `Weak of string ]

Entity tags can be weak or strong

val weak_validator_match : etag -> etag -> bool

Whether the tags match weakly (see RFC 2616 for definition)

val strong_validator_match : etag -> etag -> bool

Whether the tags match strongly (see RFC 2616 for definition)

exception Bad_header_field of string

Raised when a header field cannot be parsed. The string argument is the name of the failing function

class type http_header = Netmime.mime_header

class type http_header_ro = Netmime.mime_header_ro

The HTTP header is represented as MIME header

class type http_trailer = Netmime.mime_header

class type http_trailer_ro = Netmime.mime_header_ro

The HTTP trailer is represented as MIME header

val status_of_cgi_header : http_header -> int * string

Returns the status code and the status text corresponding to the Status header

type cookie = {

`cookie_name : string;`	`(*`	The name of the cookie	`*)`
`cookie_value : string;`	`(*`	The value of the cookie. There are no restrictions on the value of the cookie	`*)`
`cookie_expires : float option;`	`(*`	Expiration: `None`: the cookie expires when the browser session ends. `Some t`: the cookie expires at the time `t` (seconds since the epoch)	`*)`
`cookie_domain : string option;`	`(*`	Cookies are bound to a certain domain, i.e. the browser sends them only when web pages of the domain are requested: `None`: the domain is the hostname of the server `Some domain`: the domain is `domain`	`*)`
`cookie_path : string option;`	`(*`	Cookies are also bound to certain path prefixes, i.e. the browser sends them only when web pages at the path or below are requested. `None`: the path is script name + path_info `Some p`: the path is `p`. With `Some "/"` you can disable the path restriction completely.	`*)`
`cookie_secure : bool;`	`(*`	Cookies are also bound to the type of the web server: `false` means servers without SSL, `true` means servers with activated SSL ("https").	`*)`

}

val decode_query : string -> string * string

Splits the URI into a "script name" and a "query string"

val split_host_port : string -> string * int option

Splits the Host header in hostname and optional port number. Fails on syntax error

val uripath_encode : string -> string

Encodes unsafe characters in URI paths. The slash character is not encoded. This function should only be applied to the part before '?'.

val uripath_decode : string -> string

Decodes %XX sequences in URI paths. %2F is forbidden (failure). This function should only be applied to the part before '?'.

Parsing and Printing of Headers

module Header: sig .. end

This web site is published by Informatikbüro Gerd Stolpmann

Plasma	GitLab	Archive
Projects	Blog	Knowledge