Plasma GitLab Archive
Projects Blog Knowledge

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
val base_code : int -> int
Allows to handle unknown status codes that are untranslatable by http_status_of_int:
  • for a code 100 to 199 the value 100 is returned
  • for a code 200 to 299 the value 200 is returned
  • for a code 300 to 399 the value 300 is returned
  • for a code 400 to 499 the value 400 is returned
  • for all other codes 500 is returned
E.g.
  let st =
    try Nethttp.http_status_of_int code
    with Not_found ->
      Nethttp.http_status_of_int (Nethttp.base_code code)
      

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 netscape_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").
*)
}
These are old-style cookies, as introduced by Netscape. For a better representation of cookies see the Nethttp.Cookie module.

This type is kept for now (and is also not considered as deprecated), as the access functions in the Nethttp.Header module are more complete than those for Nethttp.Cookie.

type cookie = netscape_cookie 
Compatibility name. Deprecated
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 Cookie: sig .. end
module Header: sig .. end

HTTP transport registry


type transport_layer_id = int 
val new_trans_id : unit -> transport_layer_id
Allocates and returns a new ID
val http_trans_id : transport_layer_id
Identifies the pure HTTP transport (without SSL), with or without web proxies
val https_trans_id : transport_layer_id
Identifies anonymous HTTPS transport (i.e. no client certificates), with or without web proxies.
val spnego_trans_id : transport_layer_id
Identifies an anonymous HTTPS transport that is additionally authenticated via SPNEGO (as described in RFC 4559)
val proxy_only_trans_id : transport_layer_id
Identifies web proxy connections. Use this to e.g. send an FTP URL to a web proxy via HTTP

Types for authentication



Types for authentication



See also Netsys_sasl_types.SASL_MECHANISM. This is very similar, only that
  • the messages are encapsulated as HTTP headers, and
  • the "realm" parameter is commonly supported by mechanisms
In SASL terms, HTTP authentication is normally "server first". There is only one exception: re-authentication, which is "client first".
type match_result = [ `Accept of string * string option
| `Accept_reroute of string * string option * transport_layer_id
| `Reject
| `Reroute of string * transport_layer_id ]
module type HTTP_CLIENT_MECHANISM = sig .. end
This web site is published by Informatikbüro Gerd Stolpmann
Powered by Caml