%% ``Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% The Initial Developer of the Original Code is Mobile Arts AB
%% Portions created by Mobile Arts are Copyright 2002, Mobile Arts AB
%% All Rights Reserved.''
%%
%%% TODO:
%%% - If an error is returned when sending a request, don't use this
%%% session anymore.
%%% - Closing of sessions not properly implemented for some cases
%%% File : httpc_handler.erl
%%% Author : Johan Blom <[email protected]>
%%% Description : Handles HTTP client responses, for a single TCP session
%%% Created : 4 Mar 2002 by Johan Blom
-module(httpc_handler).
-include("http.hrl").
-include("jnets_httpd.hrl").
-export([init_connection/2,http_request/2]).
%%% ==========================================================================
%%% "Main" function in the spawned process for the session.
init_connection(Req,Session) when record(Req,request) ->
case catch http_lib:connect(Req) of
{ok,Socket} ->
case catch http_request(Req,Socket) of
ok ->
case Session#session.clientclose of
true ->
ok;
false ->
httpc_manager:register_socket(Req#request.address,
Session#session.id,
Socket)
end,
next_response_with_request(Req,
Session#session{socket=Socket});
{error,Reason} -> % Not possible to use new session
gen_server:cast(Req#request.from,
{Req#request.ref,Req#request.id,{error,Reason}}),
exit_session_ok(Req#request.address,
Session#session{socket=Socket})
end;
{error,Reason} -> % Not possible to set up new session
gen_server:cast(Req#request.from,
{Req#request.ref,Req#request.id,{error,Reason}}),
exit_session_ok2(Req#request.address,
Session#session.clientclose,Session#session.id)
end.
next_response_with_request(Req,Session) ->
Timeout=(Req#request.settings)#client_settings.timeout,
case catch read(Timeout,Session#session.scheme,Session#session.socket) of
{Status,Headers,Body} ->
NewReq=handle_response({Status,Headers,Body},Timeout,Req,Session),
next_response_with_request(NewReq,Session);
{error,Reason} ->
gen_server:cast(Req#request.from,
{Req#request.ref,Req#request.id,{error,Reason}}),
exit_session(Req#request.address,Session,aborted_request);
{'EXIT',Reason} ->
gen_server:cast(Req#request.from,
{Req#request.ref,Req#request.id,{error,Reason}}),
exit_session(Req#request.address,Session,aborted_request)
end.
handle_response(Response,Timeout,Req,Session) ->
case http_response(Response,Req,Session) of
ok ->
next_response(Timeout,Req#request.address,Session);
stop ->
exit(normal);
{error,Reason} ->
gen_server:cast(Req#request.from,
{Req#request.ref,Req#request.id,{error,Reason}}),
exit_session(Req#request.address,Session,aborted_request)
end.
%%% Wait for the next respond until
%%% - session is closed by the other side
%%% => set up a new a session, if there are pending requests in the que
%%% - "Connection:close" header is received
%%% => close the connection (release socket) then
%%% set up a new a session, if there are pending requests in the que
%%%
%%% Note:
%%% - When invoked there are no pending responses on received requests.
%%% - Never close the session explicitly, let it timeout instead!
next_response(Timeout,Address,Session) ->
case httpc_manager:next_request(Address,Session#session.id) of
no_more_requests ->
%% There are no more pending responses, now just wait for
%% timeout or a new response.
case catch read(Timeout,
Session#session.scheme,Session#session.socket) of
{error,Reason} when Reason==session_remotely_closed;
Reason==session_local_timeout ->
exit_session_ok(Address,Session);
{error,Reason} ->
exit_session(Address,Session,aborted_request);
{'EXIT',Reason} ->
exit_session(Address,Session,aborted_request);
{Status2,Headers2,Body2} ->
case httpc_manager:next_request(Address,
Session#session.id) of
no_more_requests -> % Should not happen!
exit_session(Address,Session,aborted_request);
{error,Reason} -> % Should not happen!
exit_session(Address,Session,aborted_request);
NewReq ->
handle_response({Status2,Headers2,Body2},
Timeout,NewReq,Session)
end
end;
{error,Reason} -> % The connection has been closed by httpc_manager
exit_session(Address,Session,aborted_request);
NewReq ->
NewReq
end.
%% ===========================================================================
%% Internals
%%% Read in and parse response data from the socket
read(Timeout,SockType,Socket) ->
Info=#response{scheme=SockType,socket=Socket},
http_lib:setopts(SockType,Socket,[{packet, http}]),
Info1=read_response(SockType,Socket,Info,Timeout),
http_lib:setopts(SockType,Socket,[binary,{packet, raw}]),
case (Info1#response.headers)#res_headers.content_type of
"multipart/byteranges"++Param ->
range_response_body(Info1,Timeout,Param);
_ ->
#response{status=Status2,headers=Headers2,body=Body2}=
http_lib:read_client_body(Info1,Timeout),
{Status2,Headers2,Body2}
end.
%%% From RFC 2616:
%%% Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
%%% HTTP-Version = "HTTP" "/" 1*DIGIT "." 1*DIGIT
%%% Status-Code = 3DIGIT
%%% Reason-Phrase = *<TEXT, excluding CR, LF>
read_response(SockType,Socket,Info,Timeout) ->
case http_lib:recv0(SockType,Socket,Timeout) of
{ok,{http_response,{1,VerMin}, Status, _Phrase}} when VerMin==0;
VerMin==1 ->
Info1=Info#response{status=Status,http_version=VerMin},
http_lib:read_client_headers(Info1,Timeout);
{ok,{http_response,_Version, _Status, _Phrase}} ->
throw({error,bad_status_line});
{error, timeout} ->
throw({error,session_local_timeout});
{error, Reason} when Reason==closed;Reason==enotconn ->
throw({error,session_remotely_closed});
{error, Reason} ->
throw({error,Reason})
end.
%%% From RFC 2616, Section 4.4, Page 34
%% 4.If the message uses the media type "multipart/byteranges", and the
%% transfer-length is not otherwise specified, then this self-
%% delimiting media type defines the transfer-length. This media type
%% MUST NOT be used unless the sender knows that the recipient can parse
%% it; the presence in a request of a Range header with multiple byte-
%% range specifiers from a 1.1 client implies that the client can parse
%% multipart/byteranges responses.
%%% FIXME !!
range_response_body(Info,Timeout,Param) ->
Headers=Info#response.headers,
case {Headers#res_headers.content_length,
Headers#res_headers.transfer_encoding} of
{undefined,undefined} ->
#response{status=Status2,headers=Headers2,body=Body2}=
http_lib:read_client_multipartrange_body(Info,Param,Timeout),
{Status2,Headers2,Body2};
_ ->
#response{status=Status2,headers=Headers2,body=Body2}=
http_lib:read_client_body(Info,Timeout),
{Status2,Headers2,Body2}
end.
%%% ----------------------------------------------------------------------------
%%% Host: field is required when addressing multi-homed sites ...
%%% It must not be present when the request is being made to a proxy.
http_request(#request{method=Method,id=Id,
scheme=Scheme,address={Host,Port},pathquery=PathQuery,
headers=Headers, content={ContentType,Body},
settings=Settings},
Socket) ->
PostData=
if
Method==post;Method==put ->
case Headers#req_headers.expect of
"100-continue" ->
content_type_header(ContentType) ++
content_length_header(length(Body)) ++
"\r\n";
_ ->
content_type_header(ContentType) ++
content_length_header(length(Body)) ++
"\r\n" ++ Body
end;
true ->
"\r\n"
end,
Message=
case useProxy(Settings#client_settings.useproxy,
{Scheme,Host,Port,PathQuery}) of
false ->
method(Method)++" "++PathQuery++" HTTP/1.1\r\n"++
host_header(Host)++te_header()++
headers(Headers) ++ PostData;
AbsURI ->
method(Method)++" "++AbsURI++" HTTP/1.1\r\n"++
te_header()++
headers(Headers)++PostData
end,
http_lib:send(Scheme,Socket,Message).
useProxy(false,_) ->
false;
useProxy(true,{Scheme,Host,Port,PathQuery}) ->
[atom_to_list(Scheme),"://",Host,":",integer_to_list(Port),PathQuery].
headers(#req_headers{expect=Expect,
other=Other}) ->
H1=case Expect of
undefined ->[];
_ -> "Expect: "++Expect++"\r\n"
end,
H1++headers_other(Other).
headers_other([]) ->
[];
headers_other([{Key,Value}|Rest]) when atom(Key) ->
Head = atom_to_list(Key)++": "++Value++"\r\n",
Head ++ headers_other(Rest);
headers_other([{Key,Value}|Rest]) ->
Head = Key++": "++Value++"\r\n",
Head ++ headers_other(Rest).
host_header(Host) ->
"Host: "++lists:concat([Host])++"\r\n".
content_type_header(ContentType) ->
"Content-Type: " ++ ContentType ++ "\r\n".
content_length_header(ContentLength) ->
"Content-Length: "++integer_to_list(ContentLength) ++ "\r\n".
te_header() ->
"TE: \r\n".
method(Method) ->
httpd_util:to_upper(atom_to_list(Method)).
%%% ----------------------------------------------------------------------------
http_response({Status,Headers,Body},Req,Session) ->
case Status of
100 ->
status_continue(Req,Session);
200 ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{Status,Headers,Body}}),
ServerClose=http_lib:connection_close(Headers),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session);
300 -> status_multiple_choices(Headers,Body,Req,Session);
301 -> status_moved_permanently(Req#request.method,
Headers,Body,Req,Session);
302 -> status_found(Headers,Body,Req,Session);
303 -> status_see_other(Headers,Body,Req,Session);
304 -> status_not_modified(Headers,Body,Req,Session);
305 -> status_use_proxy(Headers,Body,Req,Session);
%% 306 This Status code is not used in HTTP 1.1
307 -> status_temporary_redirect(Headers,Body,Req,Session);
503 -> status_service_unavailable({Status,Headers,Body},Req,Session);
Status50x when Status50x==500;Status50x==501;Status50x==502;
Status50x==504;Status50x==505 ->
status_server_error_50x({Status,Headers,Body},Req,Session);
_ -> % FIXME May want to take some action on other Status codes as well
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{Status,Headers,Body}}),
ServerClose=http_lib:connection_close(Headers),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session)
end.
%%% Status code dependent functions.
%%% Received a 100 Status code ("Continue")
%%% From RFC2616
%%% The client SHOULD continue with its request. This interim response is
%%% used to inform the client that the initial part of the request has
%%% been received and has not yet been rejected by the server. The client
%%% SHOULD continue by sending the remainder of the request or, if the
%%% request has already been completed, ignore this response. The server
%%% MUST send a final response after the request has been completed. See
%%% section 8.2.3 for detailed discussion of the use and handling of this
%%% status code.
status_continue(Req,Session) ->
{_,Body}=Req#request.content,
http_lib:send(Session#session.scheme,Session#session.socket,Body),
next_response_with_request(Req,Session).
%%% Received a 300 Status code ("Multiple Choices")
%%% The resource is located in any one of a set of locations
%%% - If a 'Location' header is present (preserved server choice), use that
%%% to automatically redirect to the given URL
%%% - else if the Content-Type/Body both are non-empty let the user agent make
%%% the choice and thus return a response with status 300
%%% Note:
%%% - If response to a HEAD request, the Content-Type/Body both should be empty.
%%% - The behaviour on an empty Content-Type or Body is unspecified.
%%% However, e.g. "Apache/1.3" servers returns both empty if the header
%%% 'if-modified-since: Date' was sent in the request and the content is
%%% "not modified" (instead of 304). Thus implicitly giving the cache as the
%%% only choice.
status_multiple_choices(Headers,Body,Req,Session)
when ((Req#request.settings)#client_settings.autoredirect)==true ->
ServerClose=http_lib:connection_close(Headers),
case Headers#res_headers.location of
undefined ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{300,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session);
RedirUrl ->
Scheme=Session#session.scheme,
case uri:parse(RedirUrl) of
{error,Reason} ->
{error,Reason};
{Scheme,Host,Port,PathQuery} -> % Automatic redirection
NewReq=Req#request{redircount=Req#request.redircount+1,
address={Host,Port},pathquery=PathQuery},
handle_redirect(Session#session.clientclose,ServerClose,
NewReq,Session)
end
end;
status_multiple_choices(Headers,Body,Req,Session) ->
ServerClose=http_lib:connection_close(Headers),
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{300,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,Req,Session).
%%% Received a 301 Status code ("Moved Permanently")
%%% The resource has been assigned a new permanent URI
%%% - If a 'Location' header is present, use that to automatically redirect to
%%% the given URL if GET or HEAD request
%%% - else return
%%% Note:
%%% - The Body should contain a short hypertext note with a hyperlink to the
%%% new URI. Return this if Content-Type acceptable (some HTTP servers doesn't
%%% deal properly with Accept headers)
status_moved_permanently(Method,Headers,Body,Req,Session)
when (((Req#request.settings)#client_settings.autoredirect)==true) and
(Method==get) or (Method==head) ->
ServerClose=http_lib:connection_close(Headers),
case Headers#res_headers.location of
undefined ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{301,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session);
RedirUrl ->
Scheme=Session#session.scheme,
case uri:parse(RedirUrl) of
{error,Reason} ->
{error,Reason};
{Scheme,Host,Port,PathQuery} -> % Automatic redirection
NewReq=Req#request{redircount=Req#request.redircount+1,
address={Host,Port},pathquery=PathQuery},
handle_redirect(Session#session.clientclose,ServerClose,
NewReq,Session)
end
end;
status_moved_permanently(_Method,Headers,Body,Req,Session) ->
ServerClose=http_lib:connection_close(Headers),
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{301,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,Req,Session).
%%% Received a 302 Status code ("Found")
%%% The requested resource resides temporarily under a different URI.
%%% Note:
%%% - Only cacheable if indicated by a Cache-Control or Expires header
status_found(Headers,Body,Req,Session)
when ((Req#request.settings)#client_settings.autoredirect)==true ->
ServerClose=http_lib:connection_close(Headers),
case Headers#res_headers.location of
undefined ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{302,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session);
RedirUrl ->
Scheme=Session#session.scheme,
case uri:parse(RedirUrl) of
{error,Reason} ->
{error,Reason};
{Scheme,Host,Port,PathQuery} -> % Automatic redirection
NewReq=Req#request{redircount=Req#request.redircount+1,
address={Host,Port},pathquery=PathQuery},
handle_redirect(Session#session.clientclose,ServerClose,
NewReq,Session)
end
end;
status_found(Headers,Body,Req,Session) ->
ServerClose=http_lib:connection_close(Headers),
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{302,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,Req,Session).
%%% Received a 303 Status code ("See Other")
%%% The request found under a different URI and should be retrieved using GET
%%% Note:
%%% - Must not be cached
status_see_other(Headers,Body,Req,Session)
when ((Req#request.settings)#client_settings.autoredirect)==true ->
ServerClose=http_lib:connection_close(Headers),
case Headers#res_headers.location of
undefined ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{303,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session);
RedirUrl ->
Scheme=Session#session.scheme,
case uri:parse(RedirUrl) of
{error,Reason} ->
{error,Reason};
{Scheme,Host,Port,PathQuery} -> % Automatic redirection
NewReq=Req#request{redircount=Req#request.redircount+1,
method=get,
address={Host,Port},pathquery=PathQuery},
handle_redirect(Session#session.clientclose,ServerClose,
NewReq,Session)
end
end;
status_see_other(Headers,Body,Req,Session) ->
ServerClose=http_lib:connection_close(Headers),
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{303,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,Req,Session).
%%% Received a 304 Status code ("Not Modified")
%%% Note:
%%% - The response MUST NOT contain a body.
%%% - The response MUST include the following header fields:
%%% - Date, unless its omission is required
%%% - ETag and/or Content-Location, if the header would have been sent
%%% in a 200 response to the same request
%%% - Expires, Cache-Control, and/or Vary, if the field-value might
%%% differ from that sent in any previous response for the same
%%% variant
status_not_modified(Headers,Body,Req,Session)
when ((Req#request.settings)#client_settings.autoredirect)==true ->
ServerClose=http_lib:connection_close(Headers),
case Headers#res_headers.location of
undefined ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{304,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session);
RedirUrl ->
Scheme=Session#session.scheme,
case uri:parse(RedirUrl) of
{error,Reason} ->
{error,Reason};
{Scheme,Host,Port,PathQuery} -> % Automatic redirection
NewReq=Req#request{redircount=Req#request.redircount+1,
address={Host,Port},pathquery=PathQuery},
handle_redirect(Session#session.clientclose,ServerClose,
NewReq,Session)
end
end;
status_not_modified(Headers,Body,Req,Session) ->
ServerClose=http_lib:connection_close(Headers),
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{304,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,Req,Session).
%%% Received a 305 Status code ("Use Proxy")
%%% The requested resource MUST be accessed through the proxy given by the
%%% Location field
status_use_proxy(Headers,Body,Req,Session)
when ((Req#request.settings)#client_settings.autoredirect)==true ->
ServerClose=http_lib:connection_close(Headers),
case Headers#res_headers.location of
undefined ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{305,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session);
RedirUrl ->
Scheme=Session#session.scheme,
case uri:parse(RedirUrl) of
{error,Reason} ->
{error,Reason};
{Scheme,Host,Port,PathQuery} -> % Automatic redirection
NewReq=Req#request{redircount=Req#request.redircount+1,
address={Host,Port},pathquery=PathQuery},
handle_redirect(Session#session.clientclose,ServerClose,
NewReq,Session)
end
end;
status_use_proxy(Headers,Body,Req,Session) ->
ServerClose=http_lib:connection_close(Headers),
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{305,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,Req,Session).
%%% Received a 307 Status code ("Temporary Redirect")
status_temporary_redirect(Headers,Body,Req,Session)
when ((Req#request.settings)#client_settings.autoredirect)==true ->
ServerClose=http_lib:connection_close(Headers),
case Headers#res_headers.location of
undefined ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{307,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,
Req,Session);
RedirUrl ->
Scheme=Session#session.scheme,
case uri:parse(RedirUrl) of
{error,Reason} ->
{error,Reason};
{Scheme,Host,Port,PathQuery} -> % Automatic redirection
NewReq=Req#request{redircount=Req#request.redircount+1,
address={Host,Port},pathquery=PathQuery},
handle_redirect(Session#session.clientclose,ServerClose,
NewReq,Session)
end
end;
status_temporary_redirect(Headers,Body,Req,Session) ->
ServerClose=http_lib:connection_close(Headers),
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{307,Headers,Body}}),
handle_connection(Session#session.clientclose,ServerClose,Req,Session).
%%% Received a 503 Status code ("Service Unavailable")
%%% The server is currently unable to handle the request due to a
%%% temporary overloading or maintenance of the server. The implication
%%% is that this is a temporary condition which will be alleviated after
%%% some delay. If known, the length of the delay MAY be indicated in a
%%% Retry-After header. If no Retry-After is given, the client SHOULD
%%% handle the response as it would for a 500 response.
%% Note:
%% - This session is now considered busy, thus cancel any requests in the
%% pipeline and close the session.
%% FIXME! Implement a user option to automatically retry if the 'Retry-After'
%% header is given.
status_service_unavailable(Resp,Req,Session) ->
% RetryAfter=Headers#res_headers.retry_after,
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,Resp}),
close_session(server_connection_close,Req,Session).
%%% Received a 50x Status code (~ "Service Error")
%%% Response status codes beginning with the digit "5" indicate cases in
%%% which the server is aware that it has erred or is incapable of
%%% performing the request.
status_server_error_50x(Resp,Req,Session) ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,Resp}),
close_session(server_connection_close,Req,Session).
%%% Handles requests for redirects
%%% The redirected request might be:
%%% - FIXME! on another TCP session, another scheme
%%% - on the same TCP session, same scheme
%%% - on another TCP session , same scheme
%%% However, in all cases treat it as a new request, with redircount updated.
%%%
%%% The redirect may fail, but this not a reason to close this session.
%%% Instead return a error for this request, and continue as ok.
handle_redirect(ClientClose,ServerClose,Req,Session) ->
case httpc_manager:request(Req) of
{ok,_ReqId} -> % FIXME Should I perhaps reuse the Reqid?
handle_connection(ClientClose,ServerClose,Req,Session);
{error,Reason} ->
gen_server:cast(Req#request.from,{Req#request.ref,Req#request.id,
{error,Reason}}),
handle_connection(ClientClose,ServerClose,Req,Session)
end.
%%% Check if the persistent connection flag is false (ie client request
%%% non-persistive connection), or if the server requires a closed connection
%%% (by sending a "Connection: close" header). If the connection required
%%% non-persistent, we may close the connection immediately.
handle_connection(ClientClose,ServerClose,Req,Session) ->
case {ClientClose,ServerClose} of
{false,false} ->
ok;
{false,true} -> % The server requests this session to be closed.
close_session(server_connection_close,Req,Session);
{true,_} -> % The client requested a non-persistent connection
close_session(client_connection_close,Req,Session)
end.
%%% Close the session.
%%% We now have three cases:
%%% - Client request a non-persistent connection when initiating the request.
%%% Session info not stored in httpc_manager
%%% - Server requests a non-persistent connection when answering a request.
%%% No need to resend request, but there might be a pipeline.
%%% - Some kind of error
%%% Close the session, we may then try resending all requests in the pipeline
%%% including the current depending on the error.
%%% FIXME! Should not always abort the session (see close_session in
%%% httpc_manager for more details)
close_session(client_connection_close,_Req,Session) ->
http_lib:close(Session#session.scheme,Session#session.socket),
stop;
close_session(server_connection_close,Req,Session) ->
http_lib:close(Session#session.scheme,Session#session.socket),
httpc_manager:abort_session(Req#request.address,Session#session.id,
aborted_request),
stop.
exit_session(Address,Session,Reason) ->
http_lib:close(Session#session.scheme,Session#session.socket),
httpc_manager:abort_session(Address,Session#session.id,Reason),
exit(normal).
%%% This is the "normal" case to close a persistent connection. I.e., there are
%%% no more requests waiting and the session was closed by the client, or
%%% server because of a timeout or user request.
exit_session_ok(Address,Session) ->
http_lib:close(Session#session.scheme,Session#session.socket),
exit_session_ok2(Address,Session#session.clientclose,Session#session.id).
exit_session_ok2(Address,ClientClose,Sid) ->
case ClientClose of
false ->
httpc_manager:close_session(Address,Sid);
true ->
ok
end,
exit(normal).
%%% ============================================================================
%%% This is deprecated code, to be removed
format_time() ->
{_,_,MicroSecs}=TS=now(),
{{Y,Mon,D},{H,M,S}}=calendar:now_to_universal_time(TS),
lists:flatten(io_lib:format("~4.4.0w-~2.2.0w-~2.2.0w,~2.2.0w:~2.2.0w:~6.3.0f",
[Y,Mon,D,H,M,S+(MicroSecs/1000000)])).
%%% Read more data from the open socket.
%%% Two different read functions is used because for the {active, once} socket
%%% option is (currently) not available for SSL...
%%% FIXME
% read_more_data(http,Socket,Timeout) ->
% io:format("read_more_data(ip_comm) -> "
% "~n set active = 'once' and "
% "await a chunk data", []),
% http_lib:setopts(Socket, [{active,once}]),
% read_more_data_ipcomm(Socket,Timeout);
% read_more_data(https,Socket,Timeout) ->
% case ssl:recv(Socket,0,Timeout) of
% {ok,MoreData} ->
% MoreData;
% {error,closed} ->
% throw({error, session_remotely_closed});
% {error,etimedout} ->
% throw({error, session_local_timeout});
% {error,Reason} ->
% throw({error, Reason});
% Other ->
% throw({error, Other})
% end.
% %%% Send any incoming requests on the open session immediately
% read_more_data_ipcomm(Socket,Timeout) ->
% receive
% {tcp,Socket,MoreData} ->
% % ?vtrace("read_more_data(ip_comm) -> got some data:~p",
% % [MoreData]),
% MoreData;
% {tcp_closed,Socket} ->
% % ?vtrace("read_more_data(ip_comm) -> socket closed",[]),
% throw({error,session_remotely_closed});
% {tcp_error,Socket,Reason} ->
% % ?vtrace("read_more_data(ip_comm) -> ~p socket error: ~p",
% % [self(),Reason]),
% throw({error, Reason});
% stop ->
% throw({error, user_req})
% after Timeout ->
% throw({error, session_local_timeout})
% end.
