httpc

request(Url) ->

request(Url, Profile) -> {ok, Result} | {error, Reason}

• Url = url()
• Result = {status_line(), headers(), Body} | {status_code(), Body} | request_id()
• Body = string() | binary()
• Profile = profile() | pid() (when started stand_alone)
• Reason = term()

request(Method, Request, HTTPOptions, Options) ->

request(Method, Request, HTTPOptions, Options, Profile) -> {ok, Result} | {ok, saved_to_file} | {error, Reason}

• Method = method()
• Request = request()
• HTTPOptions = http_options()
• http_options() = [http_option()]
• http_option() = {timeout, timeout()} | {connect_timeout, timeout()} | {ssl, ssloptions()} | {essl, ssloptions()} | {autoredirect, boolean()} | {proxy_auth, {userstring(), passwordstring()}} | {version, http_version()} | {relaxed, boolean()} | {url_encode, boolean()}
• timeout() = integer() >= 0 | infinity
• Options = options()
• options() = [option()]
• option() = {sync, boolean()} | {stream, stream_to()} | {body_format, body_format()} | {full_result, boolean()} | {headers_as_is, boolean() | {socket_opts, socket_opts()} | {receiver, receiver()}, {ipv6_host_with_brackets, boolean()}}
• stream_to() = none | self | {self, once} | filename()
• socket_opts() = [socket_opt()]
• receiver() = pid() | function()/1 | {Module, Function, Args}
• Module = atom()
• Function = atom()
• Args = list()
• body_format() = string | binary
• Result = {status_line(), headers(), Body} | {status_code(), Body} | request_id()
• Body = string() | binary()
• Profile = profile() | pid() (when started stand_alone)
• Reason = {connect_failed, term()} | {send_failed, term()} | term()

{http, ReplyInfo}

Receiver(ReplyInfo)

apply(Module, Function, [ReplyInfo | Args])

{RequestId, saved_to_file}
{RequestId, {error, Reason}}
{RequestId, Result}
{RequestId, stream_start, Headers}
{RequestId, stream_start, Headers, HandlerPid}
{RequestId, stream,       BinBodyPart}
{RequestId, stream_end,   Headers}

cancel_request(RequestId) ->

cancel_request(RequestId, Profile) -> ok

• RequestId = request_id() - A unique identifier as returned by request/4
• Profile = profile() | pid() (when started stand_alone)

set_options(Options) ->

set_options(Options, Profile) -> ok | {error, Reason}

• Options = [Option]
• Option = {proxy, {Proxy, NoProxy}} | {https_proxy, {Proxy, NoProxy}} | {max_sessions, MaxSessions} | {max_keep_alive_length, MaxKeepAlive} | {keep_alive_timeout, KeepAliveTimeout} | {max_pipeline_length, MaxPipeline} | {pipeline_timeout, PipelineTimeout} | {cookies, CookieMode} | {ipfamily, IpFamily} | {ip, IpAddress} | {port, Port} | {socket_opts, socket_opts()} | {verbose, VerboseMode}
• Proxy = {Hostname, Port}
• Hostname = string()
ex: "localhost" or "foo.bar.se"
• Port = integer()
ex: 8080
• NoProxy = [NoProxyDesc]
• NoProxyDesc = DomainDesc | HostName | IPDesc
• DomainDesc = "*.Domain"
ex: "*.ericsson.se"
• IpDesc = string()
ex: "134.138" or "[FEDC:BA98" (all IP-addresses starting with 134.138 or FEDC:BA98), "66.35.250.150" or "[2010:836B:4179::836B:4179]" (a complete IP-address). proxy defaults to {undefined, []} e.i. no proxy is configured and https_proxy defaults to the value of proxy.
• MaxSessions = integer()
Default is 2. Maximum number of persistent connections to a host.
• MaxKeepAlive = integer()
Default is 5. Maximum number of outstanding requests on the same connection to a host.
• KeepAliveTimeout = integer()
Default is 120000 (= 2 min). If a persistent connection is idle longer than the keep_alive_timeout in milliseconds, the client will close the connection. The server may also have such a time out but you should not count on it!
• MaxPipeline = integer()
Default is 2. Maximum number of outstanding requests on a pipelined connection to a host.
• PipelineTimeout = integer()
Default is 0, which will result in pipelining not being used. If a persistent connection is idle longer than the pipeline_timeout in milliseconds, the client will close the connection.
• CookieMode = enabled | disabled | verify
Default is disabled. If Cookies are enabled all valid cookies will automatically be saved in the client manager's cookie database. If the option verify is used the function store_cookies/2 has to be called for the cookies to be saved.
• IpFamily = inet | inet6 | inet6fb4
By default inet. When it is set to inet6fb4 you can use both ipv4 and ipv6. It first tries inet6 and if that does not works falls back to inet. The option is here to provide a workaround for buggy ipv6 stacks to ensure that ipv4 will always work.
• IpAddress = ip_address()
If the host has several network interfaces, this option specifies which one to use. See gen_tcp:connect/3,4 for more info.
• Port = integer()
Specify which local port number to use. See gen_tcp:connect/3,4 for more info.
• socket_opts() = [socket_opt()]
The options are appended to the socket options used by the client. These are the default values when a new request handler is started (for the initial connect). They are passed directly to the underlying transport (gen_tcp or ssl) without verification!
• VerboseMode = false | verbose | debug | trace
Default is false. This option is used to switch on (or off) different levels of erlang trace on the client. It is a debug feature.
• Profile = profile() | pid() (when started stand_alone)

get_options(OptionItems) -> {ok, Values} | {error, Reason}

get_options(OptionItems, Profile) -> {ok, Values} | {error, Reason}

• OptionItems = all | [option_item()]
• option_item() = proxy | https_proxy max_sessions | keep_alive_timeout | max_keep_alive_length | pipeline_timeout | max_pipeline_length | cookies | ipfamily | ip | port | socket_opts | verbose
• Profile = profile() | pid() (when started stand_alone)
• Values = [{option_item(), term()}]
• Reason = term()

stream_next(Pid) -> ok

• Pid = pid() - as received in the stream_start message

store_cookies(SetCookieHeaders, Url) ->

store_cookies(SetCookieHeaders, Url, Profile) -> ok | {error, Reason}

• SetCookieHeaders = headers() - where field = "set-cookie"
• Url = url()
• Profile = profile() | pid() (when started stand_alone)

cookie_header(Url) ->

cookie_header(Url, Profile | Opts) -> header() | {error, Reason}

cookie_header(Url, Opts, Profile) -> header() | {error, Reason}

• Url = url()
• Opts = [cookie_header_opt()]
• Profile = profile() | pid() (when started stand_alone)
• cookie_header_opt() = {ipv6_host_with_brackets, boolean()}

reset_cookies() -> void()

reset_cookies(Profile) -> void()

• Profile = profile() | pid() (when started stand_alone)

which_cookies() -> cookies()

which_cookies(Profile) -> cookies()

• Profile = profile() | pid() (when started stand_alone)
• cookies() = [cookie_stores()]
• cookie_stores() = {cookies, cookies()} | {session_cookies, cookies()}
• cookies() = [cookie()]
• cookie() = term()

which_sessions() -> session_info()

which_sessions(Profile) -> session_info()

• Profile = profile() | pid() (when started stand_alone)
• session_info() = {GoodSessions, BadSessions, NonSessions}
• GoodSessions = session()
• BadSessions = tuple()
• NonSessions = term()

info() -> list()

info(Profile) -> list()

• Profile = profile() | pid() (when started stand_alone)