module Http_client: sig .. end

• chunked message transport
• persistent connections
• connections in pipelining mode ("full duplex" connections)
• modular authentication methods, currently Basic and Digest
• event-driven implementation; allows concurrent service for several network connections
• HTTP proxy support, also with Basic and Digest authentication
• SOCKS proxy support (1)
• HTTPS support via extension module Https_client (in library equeue-ssl). HTTPS proxies are also supported (CONNECT method) (1)
• Automatic and configurable retry of failed idempotent requests
• Redirections can be followed automatically
• Compressed message bodies can be automatically decoded (gzip only, method set_accept_encoding) (1)

• multipart messages, including multipart/byterange
• content digests specified by RFC 2068 and 2069 (2)
• content negotiation (2)
• conditional and partial GET (2)
• client-side caching (2)
• HTTP/0.9 compatibility

(2) These features can be implemented on top of this module if really needed, but there is no special support for them.

Related modules/software:

• Http_fs allows you to access HTTP servers in the style of filesystems
• WebDAV: If you are looking for WebDAV there is an extension of this module: Webdav, which is separately available.

The module can be compiled such that it is thread-safe. In particular, one has to link the http_client_mt.cmxo object, and thread-safety is restricted to the following kinds of usage:

• The golden rule is that threads must not share pipeline objects. If every thread uses its own pipeline, every thread will have its own set of state variables. It is not detected if two threads errornously share a pipeline, neither by an error message nor by implicit serialization. Strange things may happen.
• The same applies to the other objects, e.g. http_call objects
• The Convenience module even serializes; see below.

exception Bad_message of string

exception No_reply

exception Too_many_redirections

exception Name_resolution_error of string

exception URL_syntax_error of string

exception Timeout of string

exception Proxy_error of int

exception Response_too_large

exception Http_protocol of exn

exception Http_error of (int * string)

type status = [ `Client_error
       | `Http_protocol_error of exn
       | `Redirection
       | `Server_error
       | `Successful
       | `Unserved ] 

type private_api 

type response_body_storage = [ `Body of unit -> Netmime.mime_body
       | `Device of unit -> Uq_io.out_device
       | `File of unit -> string
       | `Memory ] 

type resolver = Unixqueue.unix_event_system ->
       string -> (Unix.inet_addr option -> unit) -> unit 

type channel_binding_id = int 

    let opts = pipeline # get_options in
    let new_opts = { opts with <field> = <value>; ... } in
    pipeline # set_options new_opts
 

type header_kind = [ `Base | `Effective ] 

class type http_call = object .. end

class type transport_channel_type = object .. end

class virtual generic_call : object .. end

class get_call : http_call

class trace_call : http_call

class options_call : http_call

class head_call : http_call

class post_call : http_call

class put_call : http_call

class delete_call : http_call

class get : string -> http_call

class trace : string -> int -> http_call

class options : string -> http_call

class head : string -> http_call

class post : string -> (string * string) list -> http_call

class post_raw : string -> string -> http_call

class put : string -> string -> http_call

class delete : string -> http_call

class type key = object .. end

val key : user:string ->
       password:string -> realm:string -> domain:string list -> key

class type key_handler = object .. end

class key_ring : ?uplink:#key_handler -> unit -> object .. end

class type auth_session = object .. end

class type auth_handler = object .. end

class basic_auth_handler : ?enable_auth_in_advance:bool -> #key_handler -> auth_handler

class digest_auth_handler : ?enable_auth_in_advance:bool -> #key_handler -> auth_handler

class unified_auth_handler : #key_handler -> auth_handler

class basic_auth_method : object .. end

class digest_auth_method : basic_auth_method

type connection_cache = Http_client_conncache.connection_cache 

val close_connection_cache : connection_cache -> unit

val create_restrictive_cache : unit -> connection_cache

val create_aggressive_cache : unit -> connection_cache

val http_cb_id : channel_binding_id

val https_cb_id : channel_binding_id

val proxy_only_cb_id : channel_binding_id

val new_cb_id : unit -> channel_binding_id

val http_transport_channel_type : transport_channel_type

class pipeline : object .. end

 let call = new get "http://server/path" in
 let pipeline = new pipeline in
 pipeline # add call;
 pipeline # run();    (* Now the HTTP client is working... *)
 match call # status with
 | `Successful -> ...
 | ...
 

module Convenience: sig .. end

module Debug: sig .. end