%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 2001-2011. All Rights Reserved. %% %% The contents of this file are subject to the Erlang Public License, %% Version 1.1, (the "License"); you may not use this file except in %% compliance with the License. You should have received a copy of the %% Erlang Public License along with this software. If not, it can be %% retrieved online at http://www.erlang.org/. %% %% Software distributed under the License is distributed on an "AS IS" %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See %% the License for the specific language governing rights and limitations %% under the License. %% %% %CopyrightEnd% %% %% -module(httpd_test_lib). -include("inets_test_lib.hrl"). %% Poll functions -export([verify_request/6, verify_request/7, is_expect/1]). -record(state, {request, % string() socket, % socket() status_line, % {Version, StatusCode, ReasonPharse} headers, % #http_response_h{} body, % binary() mfa = {httpc_response, parse, [nolimit, false]}, canceled = [], % [RequestId] max_header_size = nolimit, % nolimit | integer() max_body_size = nolimit, % nolimit | integer() print = false }). %%% Part of http.hrl - Temporary solution %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%% Response headers -record(http_response_h,{ %%% --- Standard "General" headers 'cache-control', connection, date, pragma, trailer, 'transfer-encoding', upgrade, via, warning, %%% --- Standard "Response" headers 'accept-ranges', age, etag, location, 'proxy-authenticate', 'retry-after', server, vary, 'www-authenticate', %%% --- Standard "Entity" headers allow, 'content-encoding', 'content-language', 'content-length' = "0", 'content-location', 'content-md5', 'content-range', 'content-type', expires, 'last-modified', other=[] % list() - Key/Value list with other headers }). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%-------------------------------------------------------------------- %% API %%------------------------------------------------------------------ verify_request(SocketType, Host, Port, Node, RequestStr, Options) -> verify_request(SocketType, Host, Port, Node, RequestStr, Options, 30000). verify_request(SocketType, Host, Port, Node, RequestStr, Options, TimeOut) -> io:format("~p ~w[~w]verify_request -> entry with" "~n Host: ~p" "~n Port: ~p" "~n RequestStr: ~p" "~n Options: ~p" "~n", [self(), ?MODULE, ?LINE, Host, Port, RequestStr, Options]), {ok, Socket} = inets_test_lib:connect_bin(SocketType, Host, Port), inets_test_lib:send(SocketType, Socket, RequestStr), State = case inets_regexp:match(RequestStr, "printenv") of nomatch -> #state{}; _ -> #state{print = true} end, case request(State#state{request = RequestStr, socket = Socket}, TimeOut) of {error, Reson} -> {error, Reson}; NewState -> ValidateResult = validate(RequestStr, NewState, Options, Node, Port), inets_test_lib:close(SocketType, Socket), ValidateResult end. request(#state{mfa = {Module, Function, Args}, request = RequestStr, socket = Socket} = State, TimeOut) -> io:format("~p ~w[~w]request -> entry with" "~n Module: ~p" "~n Function: ~p" "~n Args: ~p" "~n", [self(), ?MODULE, ?LINE, Module, Function, Args]), HeadRequest = lists:sublist(RequestStr, 1, 4), receive {tcp, Socket, Data} -> io:format("~p ~w[~w]request -> received (tcp) data" "~n Data: ~p" "~n", [self(), ?MODULE, ?LINE, Data]), print(tcp, Data, State), case Module:Function([Data | Args]) of {ok, Parsed} -> handle_http_msg(Parsed, State); {_, whole_body, _} when HeadRequest == "HEAD" -> State#state{body = <<>>}; NewMFA -> request(State#state{mfa = NewMFA}, TimeOut) end; {tcp_closed, Socket} when Function == whole_body -> io:format("~p ~w[~w]request -> " "received (tcp) closed when whole_body" "~n", [self(), ?MODULE, ?LINE]), print(tcp, "closed", State), State#state{body = hd(Args)}; {tcp_closed, Socket} -> io:format("~p ~w[~w]request -> received (tcp) closed" "~n", [self(), ?MODULE, ?LINE]), test_server:fail(connection_closed); {tcp_error, Socket, Reason} -> io:format("~p ~w[~w]request -> received (tcp) error" "~n Reason: ~p" "~n", [self(), ?MODULE, ?LINE, Reason]), test_server:fail({tcp_error, Reason}); {ssl, Socket, Data} -> print(ssl, Data, State), case Module:Function([Data | Args]) of {ok, Parsed} -> handle_http_msg(Parsed, State); {_, whole_body, _} when HeadRequest == "HEAD" -> State#state{body = <<>>}; NewMFA -> request(State#state{mfa = NewMFA}, TimeOut) end; {ssl_closed, Socket} when Function == whole_body -> print(ssl, "closed", State), State#state{body = hd(Args)}; {ssl_closed, Socket} -> test_server:fail(connection_closed); {ssl_error, Socket, Reason} -> test_server:fail({ssl_error, Reason}) after TimeOut -> io:format("~p ~w[~w]request -> timeout" "~n", [self(), ?MODULE, ?LINE]), test_server:fail(connection_timed_out) end. handle_http_msg({Version, StatusCode, ReasonPharse, Headers, Body}, State = #state{request = RequestStr}) -> io:format("~p ~w[~w]handle_http_msg -> entry with" "~n Version: ~p" "~n StatusCode: ~p" "~n ReasonPharse: ~p" "~n Headers: ~p" "~n Body: ~p" "~n", [self(), ?MODULE, ?LINE, Version, StatusCode, ReasonPharse, Headers, Body]), case is_expect(RequestStr) of true -> State#state{status_line = {Version, StatusCode, ReasonPharse}, headers = Headers}; false -> handle_http_body(Body, State#state{status_line = {Version, StatusCode, ReasonPharse}, headers = Headers}) end; handle_http_msg({ChunkedHeaders, Body}, State = #state{headers = Headers}) -> NewHeaders = http_chunk:handle_headers(Headers, ChunkedHeaders), State#state{headers = NewHeaders, body = Body}; handle_http_msg(Body, State) -> State#state{body = Body}. handle_http_body(<<>>, State = #state{request = "HEAD" ++ _}) -> State#state{body = <<>>}; handle_http_body(Body, State = #state{headers = Headers, max_body_size = MaxBodySize}) -> case Headers#http_response_h.'transfer-encoding' of "chunked" -> case http_chunk:decode(Body, State#state.max_body_size, State#state.max_header_size) of {Module, Function, Args} -> request(State#state{mfa = {Module, Function, Args}}, 30000); {ok, {ChunkedHeaders, NewBody}} -> NewHeaders = http_chunk:handle_headers(Headers, ChunkedHeaders), State#state{headers = NewHeaders, body = NewBody} end; _ -> Length = list_to_integer(Headers#http_response_h.'content-length'), case ((Length =< MaxBodySize) or (MaxBodySize == nolimit)) of true -> case httpc_response:whole_body(Body, Length) of {ok, NewBody} -> State#state{body = NewBody}; MFA -> request(State#state{mfa = MFA}, 5000) end; false -> test_server:fail(body_too_big) end end. validate(RequestStr, #state{status_line = {Version, StatusCode, _}, headers = Headers, body = Body}, Options, N, P) -> %io:format("Status~p: H:~p B:~p~n", [StatusCode, Headers, Body]), check_version(Version, Options), case lists:keysearch(statuscode, 1, Options) of {value, _} -> check_status_code(StatusCode, Options, Options); _ -> ok end, do_validate(http_response:header_list(Headers), Options, N, P), check_body(RequestStr, StatusCode, Headers#http_response_h.'content-type', list_to_integer(Headers#http_response_h.'content-length'), Body). %%-------------------------------------------------------------------- %% Internal functions %%------------------------------------------------------------------ check_version(Version, Options) -> case lists:keysearch(version, 1, Options) of {value, {version, Version}} -> ok; {value, {version, Ver}} -> test_server:fail({wrong_version, [{got, Version}, {expected, Ver}]}); _ -> case Version of "HTTP/1.1" -> ok; _ -> test_server:fail({wrong_version, [{got, Version}, {expected, "HTTP/1.1"}]}) end end. check_status_code(StatusCode, [], Options) -> test_server:fail({wrong_status_code, [{got, StatusCode}, {expected, Options}]}); check_status_code(StatusCode, Current = [_ | Rest], Options) -> case lists:keysearch(statuscode, 1, Current) of {value, {statuscode, StatusCode}} -> ok; {value, {statuscode, _OtherStatus}} -> check_status_code(StatusCode, Rest, Options); false -> test_server:fail({wrong_status_code, [{got, StatusCode}, {expected, Options}]}) end. do_validate(_, [], _, _) -> ok; do_validate(Header, [{statuscode, _Code} | Rest], N, P) -> do_validate(Header, Rest, N, P); do_validate(Header, [{header, HeaderField}|Rest], N, P) -> LowerHeaderField = http_util:to_lower(HeaderField), case lists:keysearch(LowerHeaderField, 1, Header) of {value, {LowerHeaderField, _Value}} -> ok; false -> test_server:fail({missing_header_field, LowerHeaderField, Header}); _ -> test_server:fail({missing_header_field, LowerHeaderField, Header}) end, do_validate(Header, Rest, N, P); do_validate(Header, [{header, HeaderField, Value}|Rest],N,P) -> LowerHeaderField = http_util:to_lower(HeaderField), case lists:keysearch(LowerHeaderField, 1, Header) of {value, {LowerHeaderField, Value}} -> ok; false -> test_server:fail({wrong_header_field_value, LowerHeaderField, Header}); _ -> test_server:fail({wrong_header_field_value, LowerHeaderField, Header}) end, do_validate(Header, Rest, N, P); do_validate(Header,[{no_last_modified,HeaderField}|Rest],N,P) -> % io:format("Header: ~p~nHeaderField: ~p~n",[Header,HeaderField]), case lists:keysearch(HeaderField,1,Header) of {value,_} -> test_server:fail({wrong_header_field_value, HeaderField, Header}); _ -> ok end, do_validate(Header, Rest, N, P); do_validate(Header, [_Unknown | Rest], N, P) -> do_validate(Header, Rest, N, P). is_expect(RequestStr) -> case inets_regexp:match(RequestStr, "xpect:100-continue") of {match, _, _}-> true; _ -> false end. %% OTP-5775, content-length check_body("GET /cgi-bin/erl/httpd_example:get_bin HTTP/1.0\r\n\r\n", 200, "text/html", Length, _Body) when Length /= 274-> test_server:fail(content_length_error); check_body("GET /cgi-bin/cgi_echo HTTP/1.0\r\n\r\n", 200, "text/plain", _, Body) -> case size(Body) of 100 -> ok; _ -> test_server:fail(content_length_error) end; check_body(RequestStr, 200, "text/html", _, Body) -> HeadRequest = lists:sublist(RequestStr, 1, 3), case HeadRequest of "GET" -> inets_test_lib:check_body(binary_to_list(Body)); _ -> ok end; check_body(_, _, _, _,_) -> ok. print(Proto, Data, #state{print = true}) -> test_server:format("Received ~p: ~p~n", [Proto, Data]); print(_, _, #state{print = false}) -> ok.