From 9e2622becb4d1a37d410f484a14ef32101e560ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20Hoguin?= Date: Mon, 27 Aug 2012 12:58:04 +0200 Subject: Rename cowboy_http_protocol to cowboy_protocol --- src/cowboy.erl | 4 +- src/cowboy_http_protocol.erl | 512 ------------------------------------------ src/cowboy_http_static.erl | 2 +- src/cowboy_http_websocket.erl | 2 +- src/cowboy_protocol.erl | 512 ++++++++++++++++++++++++++++++++++++++++++ test/http_SUITE.erl | 2 +- 6 files changed, 517 insertions(+), 517 deletions(-) delete mode 100644 src/cowboy_http_protocol.erl create mode 100644 src/cowboy_protocol.erl diff --git a/src/cowboy.erl b/src/cowboy.erl index 94cae16..9e4a66a 100644 --- a/src/cowboy.erl +++ b/src/cowboy.erl @@ -24,14 +24,14 @@ start_http(Ref, NbAcceptors, TransOpts, ProtoOpts) when is_integer(NbAcceptors), NbAcceptors > 0 -> ranch:start_listener(Ref, NbAcceptors, - ranch_tcp, TransOpts, cowboy_http_protocol, ProtoOpts). + ranch_tcp, TransOpts, cowboy_protocol, ProtoOpts). %% @doc Start an HTTPS listener. -spec start_https(any(), non_neg_integer(), any(), any()) -> {ok, pid()}. start_https(Ref, NbAcceptors, TransOpts, ProtoOpts) when is_integer(NbAcceptors), NbAcceptors > 0 -> ranch:start_listener(Ref, NbAcceptors, - ranch_ssl, TransOpts, cowboy_http_protocol, ProtoOpts). + ranch_ssl, TransOpts, cowboy_protocol, ProtoOpts). %% @doc Stop a listener. -spec stop_listener(any()) -> ok. diff --git a/src/cowboy_http_protocol.erl b/src/cowboy_http_protocol.erl deleted file mode 100644 index 5ef76be..0000000 --- a/src/cowboy_http_protocol.erl +++ /dev/null @@ -1,512 +0,0 @@ -%% Copyright (c) 2011-2012, Loïc Hoguin -%% Copyright (c) 2011, Anthony Ramine -%% -%% Permission to use, copy, modify, and/or distribute this software for any -%% purpose with or without fee is hereby granted, provided that the above -%% copyright notice and this permission notice appear in all copies. -%% -%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES -%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF -%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR -%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN -%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF -%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - -%% @doc HTTP protocol handler. -%% -%% The available options are: -%%
-%%
dispatch
The dispatch list for this protocol.
-%%
max_empty_lines
Max number of empty lines before a request. -%% Defaults to 5.
-%%
timeout
Time in milliseconds before an idle -%% connection is closed. Defaults to 5000 milliseconds.
-%%
urldecode
Function and options argument to use when decoding -%% URL encoded strings. Defaults to `{fun cowboy_http:urldecode/2, crash}'. -%%
-%%
-%% -%% Note that there is no need to monitor these processes when using Cowboy as -%% an application as it already supervises them under the listener supervisor. -%% -%% @see cowboy_dispatcher -%% @see cowboy_http_handler --module(cowboy_http_protocol). - -%% API. --export([start_link/4]). - -%% Internal. --export([init/4]). --export([parse_request/1]). --export([handler_loop/3]). - --include("http.hrl"). --include_lib("eunit/include/eunit.hrl"). - --record(state, { - listener :: pid(), - socket :: inet:socket(), - transport :: module(), - dispatch :: cowboy_dispatcher:dispatch_rules(), - handler :: {module(), any()}, - onrequest :: undefined | fun((#http_req{}) -> #http_req{}), - onresponse = undefined :: undefined | fun((cowboy_http:status(), - cowboy_http:headers(), #http_req{}) -> #http_req{}), - urldecode :: {fun((binary(), T) -> binary()), T}, - req_empty_lines = 0 :: integer(), - max_empty_lines :: integer(), - req_keepalive = 1 :: integer(), - max_keepalive :: integer(), - max_line_length :: integer(), - timeout :: timeout(), - buffer = <<>> :: binary(), - hibernate = false :: boolean(), - loop_timeout = infinity :: timeout(), - loop_timeout_ref :: undefined | reference() -}). - -%% API. - -%% @doc Start an HTTP protocol process. --spec start_link(pid(), inet:socket(), module(), any()) -> {ok, pid()}. -start_link(ListenerPid, Socket, Transport, Opts) -> - Pid = spawn_link(?MODULE, init, [ListenerPid, Socket, Transport, Opts]), - {ok, Pid}. - -%% Internal. - -%% @private --spec init(pid(), inet:socket(), module(), any()) -> ok. -init(ListenerPid, Socket, Transport, Opts) -> - Dispatch = proplists:get_value(dispatch, Opts, []), - MaxEmptyLines = proplists:get_value(max_empty_lines, Opts, 5), - MaxKeepalive = proplists:get_value(max_keepalive, Opts, infinity), - MaxLineLength = proplists:get_value(max_line_length, Opts, 4096), - OnRequest = proplists:get_value(onrequest, Opts), - OnResponse = proplists:get_value(onresponse, Opts), - Timeout = proplists:get_value(timeout, Opts, 5000), - URLDecDefault = {fun cowboy_http:urldecode/2, crash}, - URLDec = proplists:get_value(urldecode, Opts, URLDecDefault), - ok = ranch:accept_ack(ListenerPid), - wait_request(#state{listener=ListenerPid, socket=Socket, transport=Transport, - dispatch=Dispatch, max_empty_lines=MaxEmptyLines, - max_keepalive=MaxKeepalive, max_line_length=MaxLineLength, - timeout=Timeout, onrequest=OnRequest, onresponse=OnResponse, - urldecode=URLDec}). - -%% @private --spec parse_request(#state{}) -> ok. -%% We limit the length of the Request-line to MaxLength to avoid endlessly -%% reading from the socket and eventually crashing. -parse_request(State=#state{buffer=Buffer, max_line_length=MaxLength}) -> - case erlang:decode_packet(http_bin, Buffer, []) of - {ok, Request, Rest} -> request(Request, State#state{buffer=Rest}); - {more, _Length} when byte_size(Buffer) > MaxLength -> - error_terminate(413, State); - {more, _Length} -> wait_request(State); - {error, _Reason} -> error_terminate(400, State) - end. - --spec wait_request(#state{}) -> ok. -wait_request(State=#state{socket=Socket, transport=Transport, - timeout=T, buffer=Buffer}) -> - case Transport:recv(Socket, 0, T) of - {ok, Data} -> parse_request(State#state{ - buffer= << Buffer/binary, Data/binary >>}); - {error, _Reason} -> terminate(State) - end. - --spec request({http_request, cowboy_http:method(), cowboy_http:uri(), - cowboy_http:version()}, #state{}) -> ok. -request({http_request, _Method, _URI, Version}, State) - when Version =/= {1, 0}, Version =/= {1, 1} -> - error_terminate(505, State); -%% We still receive the original Host header. -request({http_request, Method, {absoluteURI, _Scheme, _Host, _Port, Path}, - Version}, State) -> - request({http_request, Method, {abs_path, Path}, Version}, State); -request({http_request, Method, {abs_path, AbsPath}, Version}, - State=#state{socket=Socket, transport=Transport, - req_keepalive=Keepalive, max_keepalive=MaxKeepalive, - onresponse=OnResponse, urldecode={URLDecFun, URLDecArg}=URLDec}) -> - URLDecode = fun(Bin) -> URLDecFun(Bin, URLDecArg) end, - {Path, RawPath, Qs} = cowboy_dispatcher:split_path(AbsPath, URLDecode), - ConnAtom = if Keepalive < MaxKeepalive -> version_to_connection(Version); - true -> close - end, - parse_header(#http_req{socket=Socket, transport=Transport, - connection=ConnAtom, pid=self(), method=Method, version=Version, - path=Path, raw_path=RawPath, raw_qs=Qs, onresponse=OnResponse, - urldecode=URLDec}, State); -request({http_request, Method, '*', Version}, - State=#state{socket=Socket, transport=Transport, - req_keepalive=Keepalive, max_keepalive=MaxKeepalive, - onresponse=OnResponse, urldecode=URLDec}) -> - ConnAtom = if Keepalive < MaxKeepalive -> version_to_connection(Version); - true -> close - end, - parse_header(#http_req{socket=Socket, transport=Transport, - connection=ConnAtom, pid=self(), method=Method, version=Version, - path='*', raw_path= <<"*">>, raw_qs= <<>>, onresponse=OnResponse, - urldecode=URLDec}, State); -request({http_request, _Method, _URI, _Version}, State) -> - error_terminate(501, State); -request({http_error, <<"\r\n">>}, - State=#state{req_empty_lines=N, max_empty_lines=N}) -> - error_terminate(400, State); -request({http_error, <<"\r\n">>}, State=#state{req_empty_lines=N}) -> - parse_request(State#state{req_empty_lines=N + 1}); -request(_Any, State) -> - error_terminate(400, State). - --spec parse_header(#http_req{}, #state{}) -> ok. -parse_header(Req, State=#state{buffer=Buffer, max_line_length=MaxLength}) -> - case erlang:decode_packet(httph_bin, Buffer, []) of - {ok, Header, Rest} -> header(Header, Req, State#state{buffer=Rest}); - {more, _Length} when byte_size(Buffer) > MaxLength -> - error_terminate(413, State); - {more, _Length} -> wait_header(Req, State); - {error, _Reason} -> error_terminate(400, State) - end. - --spec wait_header(#http_req{}, #state{}) -> ok. -wait_header(Req, State=#state{socket=Socket, - transport=Transport, timeout=T, buffer=Buffer}) -> - case Transport:recv(Socket, 0, T) of - {ok, Data} -> parse_header(Req, State#state{ - buffer= << Buffer/binary, Data/binary >>}); - {error, timeout} -> error_terminate(408, State); - {error, closed} -> terminate(State) - end. - --spec header({http_header, integer(), cowboy_http:header(), any(), binary()} - | http_eoh, #http_req{}, #state{}) -> ok. -header({http_header, _I, 'Host', _R, RawHost}, Req=#http_req{ - transport=Transport, host=undefined}, State) -> - RawHost2 = cowboy_bstr:to_lower(RawHost), - case catch cowboy_dispatcher:split_host(RawHost2) of - {Host, RawHost3, undefined} -> - Port = default_port(Transport:name()), - parse_header(Req#http_req{ - host=Host, raw_host=RawHost3, port=Port, - headers=[{'Host', RawHost}|Req#http_req.headers]}, State); - {Host, RawHost3, Port} -> - parse_header(Req#http_req{ - host=Host, raw_host=RawHost3, port=Port, - headers=[{'Host', RawHost}|Req#http_req.headers]}, State); - {'EXIT', _Reason} -> - error_terminate(400, State) - end; -%% Ignore Host headers if we already have it. -header({http_header, _I, 'Host', _R, _V}, Req, State) -> - parse_header(Req, State); -header({http_header, _I, 'Connection', _R, Connection}, - Req=#http_req{headers=Headers}, State=#state{ - req_keepalive=Keepalive, max_keepalive=MaxKeepalive}) - when Keepalive < MaxKeepalive -> - Req2 = Req#http_req{headers=[{'Connection', Connection}|Headers]}, - {ConnTokens, Req3} - = cowboy_http_req:parse_header('Connection', Req2), - ConnAtom = cowboy_http:connection_to_atom(ConnTokens), - parse_header(Req3#http_req{connection=ConnAtom}, State); -header({http_header, _I, Field, _R, Value}, Req, State) -> - Field2 = format_header(Field), - parse_header(Req#http_req{headers=[{Field2, Value}|Req#http_req.headers]}, - State); -%% The Host header is required in HTTP/1.1. -header(http_eoh, #http_req{version={1, 1}, host=undefined}, State) -> - error_terminate(400, State); -%% It is however optional in HTTP/1.0. -header(http_eoh, Req=#http_req{version={1, 0}, transport=Transport, - host=undefined}, State=#state{buffer=Buffer}) -> - Port = default_port(Transport:name()), - onrequest(Req#http_req{host=[], raw_host= <<>>, - port=Port, buffer=Buffer}, State#state{buffer= <<>>}); -header(http_eoh, Req, State=#state{buffer=Buffer}) -> - onrequest(Req#http_req{buffer=Buffer}, State#state{buffer= <<>>}); -header(_Any, _Req, State) -> - error_terminate(400, State). - -%% Call the global onrequest callback. The callback can send a reply, -%% in which case we consider the request handled and move on to the next -%% one. Note that since we haven't dispatched yet, we don't know the -%% handler, host_info, path_info or bindings yet. --spec onrequest(#http_req{}, #state{}) -> ok. -onrequest(Req, State=#state{onrequest=undefined}) -> - dispatch(Req, State); -onrequest(Req, State=#state{onrequest=OnRequest}) -> - Req2 = OnRequest(Req), - case Req2#http_req.resp_state of - waiting -> dispatch(Req2, State); - _ -> next_request(Req2, State, ok) - end. - --spec dispatch(#http_req{}, #state{}) -> ok. -dispatch(Req=#http_req{host=Host, path=Path}, - State=#state{dispatch=Dispatch}) -> - case cowboy_dispatcher:match(Host, Path, Dispatch) of - {ok, Handler, Opts, Binds, HostInfo, PathInfo} -> - handler_init(Req#http_req{host_info=HostInfo, path_info=PathInfo, - bindings=Binds}, State#state{handler={Handler, Opts}}); - {error, notfound, host} -> - error_terminate(400, State); - {error, notfound, path} -> - error_terminate(404, State) - end. - --spec handler_init(#http_req{}, #state{}) -> ok. -handler_init(Req, State=#state{transport=Transport, - handler={Handler, Opts}}) -> - try Handler:init({Transport:name(), http}, Req, Opts) of - {ok, Req2, HandlerState} -> - handler_handle(HandlerState, Req2, State); - {loop, Req2, HandlerState} -> - handler_before_loop(HandlerState, Req2, State); - {loop, Req2, HandlerState, hibernate} -> - handler_before_loop(HandlerState, Req2, - State#state{hibernate=true}); - {loop, Req2, HandlerState, Timeout} -> - handler_before_loop(HandlerState, Req2, - State#state{loop_timeout=Timeout}); - {loop, Req2, HandlerState, Timeout, hibernate} -> - handler_before_loop(HandlerState, Req2, - State#state{hibernate=true, loop_timeout=Timeout}); - {shutdown, Req2, HandlerState} -> - handler_terminate(HandlerState, Req2, State); - %% @todo {upgrade, transport, Module} - {upgrade, protocol, Module} -> - upgrade_protocol(Req, State, Module) - catch Class:Reason -> - error_terminate(500, State), - PLReq = lists:zip(record_info(fields, http_req), tl(tuple_to_list(Req))), - error_logger:error_msg( - "** Handler ~p terminating in init/3~n" - " for the reason ~p:~p~n" - "** Options were ~p~n" - "** Request was ~p~n** Stacktrace: ~p~n~n", - [Handler, Class, Reason, Opts, PLReq, erlang:get_stacktrace()]) - end. - --spec upgrade_protocol(#http_req{}, #state{}, atom()) -> ok. -upgrade_protocol(Req, State=#state{listener=ListenerPid, - handler={Handler, Opts}}, Module) -> - case Module:upgrade(ListenerPid, Handler, Opts, Req) of - {UpgradeRes, Req2} -> next_request(Req2, State, UpgradeRes); - _Any -> terminate(State) - end. - --spec handler_handle(any(), #http_req{}, #state{}) -> ok. -handler_handle(HandlerState, Req, State=#state{handler={Handler, Opts}}) -> - try Handler:handle(Req, HandlerState) of - {ok, Req2, HandlerState2} -> - terminate_request(HandlerState2, Req2, State) - catch Class:Reason -> - PLReq = lists:zip(record_info(fields, http_req), tl(tuple_to_list(Req))), - error_logger:error_msg( - "** Handler ~p terminating in handle/2~n" - " for the reason ~p:~p~n" - "** Options were ~p~n** Handler state was ~p~n" - "** Request was ~p~n** Stacktrace: ~p~n~n", - [Handler, Class, Reason, Opts, - HandlerState, PLReq, erlang:get_stacktrace()]), - handler_terminate(HandlerState, Req, State), - error_terminate(500, State) - end. - -%% We don't listen for Transport closes because that would force us -%% to receive data and buffer it indefinitely. --spec handler_before_loop(any(), #http_req{}, #state{}) -> ok. -handler_before_loop(HandlerState, Req, State=#state{hibernate=true}) -> - State2 = handler_loop_timeout(State), - catch erlang:hibernate(?MODULE, handler_loop, - [HandlerState, Req, State2#state{hibernate=false}]), - ok; -handler_before_loop(HandlerState, Req, State) -> - State2 = handler_loop_timeout(State), - handler_loop(HandlerState, Req, State2). - -%% Almost the same code can be found in cowboy_http_websocket. --spec handler_loop_timeout(#state{}) -> #state{}. -handler_loop_timeout(State=#state{loop_timeout=infinity}) -> - State#state{loop_timeout_ref=undefined}; -handler_loop_timeout(State=#state{loop_timeout=Timeout, - loop_timeout_ref=PrevRef}) -> - _ = case PrevRef of undefined -> ignore; PrevRef -> - erlang:cancel_timer(PrevRef) end, - TRef = erlang:start_timer(Timeout, self(), ?MODULE), - State#state{loop_timeout_ref=TRef}. - --spec handler_loop(any(), #http_req{}, #state{}) -> ok. -handler_loop(HandlerState, Req, State=#state{loop_timeout_ref=TRef}) -> - receive - {timeout, TRef, ?MODULE} -> - terminate_request(HandlerState, Req, State); - {timeout, OlderTRef, ?MODULE} when is_reference(OlderTRef) -> - handler_loop(HandlerState, Req, State); - Message -> - handler_call(HandlerState, Req, State, Message) - end. - --spec handler_call(any(), #http_req{}, #state{}, any()) -> ok. -handler_call(HandlerState, Req, State=#state{handler={Handler, Opts}}, - Message) -> - try Handler:info(Message, Req, HandlerState) of - {ok, Req2, HandlerState2} -> - terminate_request(HandlerState2, Req2, State); - {loop, Req2, HandlerState2} -> - handler_before_loop(HandlerState2, Req2, State); - {loop, Req2, HandlerState2, hibernate} -> - handler_before_loop(HandlerState2, Req2, - State#state{hibernate=true}) - catch Class:Reason -> - PLReq = lists:zip(record_info(fields, http_req), tl(tuple_to_list(Req))), - error_logger:error_msg( - "** Handler ~p terminating in info/3~n" - " for the reason ~p:~p~n" - "** Options were ~p~n** Handler state was ~p~n" - "** Request was ~p~n** Stacktrace: ~p~n~n", - [Handler, Class, Reason, Opts, - HandlerState, PLReq, erlang:get_stacktrace()]), - handler_terminate(HandlerState, Req, State), - error_terminate(500, State) - end. - --spec handler_terminate(any(), #http_req{}, #state{}) -> ok. -handler_terminate(HandlerState, Req, #state{handler={Handler, Opts}}) -> - try - Handler:terminate(Req#http_req{resp_state=locked}, HandlerState) - catch Class:Reason -> - PLReq = lists:zip(record_info(fields, http_req), tl(tuple_to_list(Req))), - error_logger:error_msg( - "** Handler ~p terminating in terminate/2~n" - " for the reason ~p:~p~n" - "** Options were ~p~n** Handler state was ~p~n" - "** Request was ~p~n** Stacktrace: ~p~n~n", - [Handler, Class, Reason, Opts, - HandlerState, PLReq, erlang:get_stacktrace()]) - end. - --spec terminate_request(any(), #http_req{}, #state{}) -> ok. -terminate_request(HandlerState, Req, State) -> - HandlerRes = handler_terminate(HandlerState, Req, State), - next_request(Req, State, HandlerRes). - --spec next_request(#http_req{}, #state{}, any()) -> ok. -next_request(Req=#http_req{connection=Conn}, State=#state{ - req_keepalive=Keepalive}, HandlerRes) -> - RespRes = ensure_response(Req), - {BodyRes, Buffer} = ensure_body_processed(Req), - %% Flush the resp_sent message before moving on. - receive {cowboy_http_req, resp_sent} -> ok after 0 -> ok end, - case {HandlerRes, BodyRes, RespRes, Conn} of - {ok, ok, ok, keepalive} -> - ?MODULE:parse_request(State#state{ - buffer=Buffer, req_empty_lines=0, - req_keepalive=Keepalive + 1}); - _Closed -> - terminate(State) - end. - --spec ensure_body_processed(#http_req{}) -> {ok | close, binary()}. -ensure_body_processed(#http_req{body_state=done, buffer=Buffer}) -> - {ok, Buffer}; -ensure_body_processed(Req=#http_req{body_state=waiting}) -> - case cowboy_http_req:skip_body(Req) of - {ok, Req2} -> {ok, Req2#http_req.buffer}; - {error, _Reason} -> {close, <<>>} - end; -ensure_body_processed(Req=#http_req{body_state={multipart, _, _}}) -> - {ok, Req2} = cowboy_http_req:multipart_skip(Req), - ensure_body_processed(Req2). - --spec ensure_response(#http_req{}) -> ok. -%% The handler has already fully replied to the client. -ensure_response(#http_req{resp_state=done}) -> - ok; -%% No response has been sent but everything apparently went fine. -%% Reply with 204 No Content to indicate this. -ensure_response(Req=#http_req{resp_state=waiting}) -> - _ = cowboy_http_req:reply(204, [], [], Req), - ok; -%% Terminate the chunked body for HTTP/1.1 only. -ensure_response(#http_req{method='HEAD', resp_state=chunks}) -> - ok; -ensure_response(#http_req{version={1, 0}, resp_state=chunks}) -> - ok; -ensure_response(#http_req{socket=Socket, transport=Transport, - resp_state=chunks}) -> - Transport:send(Socket, <<"0\r\n\r\n">>), - ok. - -%% Only send an error reply if there is no resp_sent message. --spec error_terminate(cowboy_http:status(), #state{}) -> ok. -error_terminate(Code, State=#state{socket=Socket, transport=Transport, - onresponse=OnResponse}) -> - receive - {cowboy_http_req, resp_sent} -> ok - after 0 -> - _ = cowboy_http_req:reply(Code, #http_req{ - socket=Socket, transport=Transport, onresponse=OnResponse, - connection=close, pid=self(), resp_state=waiting}), - ok - end, - terminate(State). - --spec terminate(#state{}) -> ok. -terminate(#state{socket=Socket, transport=Transport}) -> - Transport:close(Socket), - ok. - -%% Internal. - --spec version_to_connection(cowboy_http:version()) -> keepalive | close. -version_to_connection({1, 1}) -> keepalive; -version_to_connection(_Any) -> close. - --spec default_port(atom()) -> 80 | 443. -default_port(ssl) -> 443; -default_port(_) -> 80. - -%% @todo While 32 should be enough for everybody, we should probably make -%% this configurable or something. --spec format_header(atom()) -> atom(); (binary()) -> binary(). -format_header(Field) when is_atom(Field) -> - Field; -format_header(Field) when byte_size(Field) =< 20; byte_size(Field) > 32 -> - Field; -format_header(Field) -> - format_header(Field, true, <<>>). - --spec format_header(binary(), boolean(), binary()) -> binary(). -format_header(<<>>, _Any, Acc) -> - Acc; -%% Replicate a bug in OTP for compatibility reasons when there's a - right -%% after another. Proper use should always be 'true' instead of 'not Bool'. -format_header(<< $-, Rest/bits >>, Bool, Acc) -> - format_header(Rest, not Bool, << Acc/binary, $- >>); -format_header(<< C, Rest/bits >>, true, Acc) -> - format_header(Rest, false, << Acc/binary, (cowboy_bstr:char_to_upper(C)) >>); -format_header(<< C, Rest/bits >>, false, Acc) -> - format_header(Rest, false, << Acc/binary, (cowboy_bstr:char_to_lower(C)) >>). - -%% Tests. - --ifdef(TEST). - -format_header_test_() -> - %% {Header, Result} - Tests = [ - {<<"Sec-Websocket-Version">>, <<"Sec-Websocket-Version">>}, - {<<"Sec-WebSocket-Version">>, <<"Sec-Websocket-Version">>}, - {<<"sec-websocket-version">>, <<"Sec-Websocket-Version">>}, - {<<"SEC-WEBSOCKET-VERSION">>, <<"Sec-Websocket-Version">>}, - %% These last tests ensures we're formatting headers exactly like OTP. - %% Even though it's dumb, it's better for compatibility reasons. - {<<"Sec-WebSocket--Version">>, <<"Sec-Websocket--version">>}, - {<<"Sec-WebSocket---Version">>, <<"Sec-Websocket---Version">>} - ], - [{H, fun() -> R = format_header(H) end} || {H, R} <- Tests]. - --endif. diff --git a/src/cowboy_http_static.erl b/src/cowboy_http_static.erl index 1513eea..d204e5a 100644 --- a/src/cowboy_http_static.erl +++ b/src/cowboy_http_static.erl @@ -173,7 +173,7 @@ -include("http.hrl"). -include_lib("kernel/include/file.hrl"). -%% cowboy_http_protocol callbacks +%% cowboy_protocol callbacks -export([init/3]). %% cowboy_http_rest callbacks diff --git a/src/cowboy_http_websocket.erl b/src/cowboy_http_websocket.erl index 4509479..2078e04 100644 --- a/src/cowboy_http_websocket.erl +++ b/src/cowboy_http_websocket.erl @@ -138,7 +138,7 @@ upgrade_error(Req) -> Req#http_req{resp_state=waiting}), closed. -%% @see cowboy_http_protocol:ensure_response/1 +%% @see cowboy_protocol:ensure_response/1 -spec upgrade_denied(#http_req{}) -> closed. upgrade_denied(#http_req{resp_state=done}) -> closed; diff --git a/src/cowboy_protocol.erl b/src/cowboy_protocol.erl new file mode 100644 index 0000000..614f409 --- /dev/null +++ b/src/cowboy_protocol.erl @@ -0,0 +1,512 @@ +%% Copyright (c) 2011-2012, Loïc Hoguin +%% Copyright (c) 2011, Anthony Ramine +%% +%% Permission to use, copy, modify, and/or distribute this software for any +%% purpose with or without fee is hereby granted, provided that the above +%% copyright notice and this permission notice appear in all copies. +%% +%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +%% @doc HTTP protocol handler. +%% +%% The available options are: +%%
+%%
dispatch
The dispatch list for this protocol.
+%%
max_empty_lines
Max number of empty lines before a request. +%% Defaults to 5.
+%%
timeout
Time in milliseconds before an idle +%% connection is closed. Defaults to 5000 milliseconds.
+%%
urldecode
Function and options argument to use when decoding +%% URL encoded strings. Defaults to `{fun cowboy_http:urldecode/2, crash}'. +%%
+%%
+%% +%% Note that there is no need to monitor these processes when using Cowboy as +%% an application as it already supervises them under the listener supervisor. +%% +%% @see cowboy_dispatcher +%% @see cowboy_http_handler +-module(cowboy_protocol). + +%% API. +-export([start_link/4]). + +%% Internal. +-export([init/4]). +-export([parse_request/1]). +-export([handler_loop/3]). + +-include("http.hrl"). +-include_lib("eunit/include/eunit.hrl"). + +-record(state, { + listener :: pid(), + socket :: inet:socket(), + transport :: module(), + dispatch :: cowboy_dispatcher:dispatch_rules(), + handler :: {module(), any()}, + onrequest :: undefined | fun((#http_req{}) -> #http_req{}), + onresponse = undefined :: undefined | fun((cowboy_http:status(), + cowboy_http:headers(), #http_req{}) -> #http_req{}), + urldecode :: {fun((binary(), T) -> binary()), T}, + req_empty_lines = 0 :: integer(), + max_empty_lines :: integer(), + req_keepalive = 1 :: integer(), + max_keepalive :: integer(), + max_line_length :: integer(), + timeout :: timeout(), + buffer = <<>> :: binary(), + hibernate = false :: boolean(), + loop_timeout = infinity :: timeout(), + loop_timeout_ref :: undefined | reference() +}). + +%% API. + +%% @doc Start an HTTP protocol process. +-spec start_link(pid(), inet:socket(), module(), any()) -> {ok, pid()}. +start_link(ListenerPid, Socket, Transport, Opts) -> + Pid = spawn_link(?MODULE, init, [ListenerPid, Socket, Transport, Opts]), + {ok, Pid}. + +%% Internal. + +%% @private +-spec init(pid(), inet:socket(), module(), any()) -> ok. +init(ListenerPid, Socket, Transport, Opts) -> + Dispatch = proplists:get_value(dispatch, Opts, []), + MaxEmptyLines = proplists:get_value(max_empty_lines, Opts, 5), + MaxKeepalive = proplists:get_value(max_keepalive, Opts, infinity), + MaxLineLength = proplists:get_value(max_line_length, Opts, 4096), + OnRequest = proplists:get_value(onrequest, Opts), + OnResponse = proplists:get_value(onresponse, Opts), + Timeout = proplists:get_value(timeout, Opts, 5000), + URLDecDefault = {fun cowboy_http:urldecode/2, crash}, + URLDec = proplists:get_value(urldecode, Opts, URLDecDefault), + ok = ranch:accept_ack(ListenerPid), + wait_request(#state{listener=ListenerPid, socket=Socket, transport=Transport, + dispatch=Dispatch, max_empty_lines=MaxEmptyLines, + max_keepalive=MaxKeepalive, max_line_length=MaxLineLength, + timeout=Timeout, onrequest=OnRequest, onresponse=OnResponse, + urldecode=URLDec}). + +%% @private +-spec parse_request(#state{}) -> ok. +%% We limit the length of the Request-line to MaxLength to avoid endlessly +%% reading from the socket and eventually crashing. +parse_request(State=#state{buffer=Buffer, max_line_length=MaxLength}) -> + case erlang:decode_packet(http_bin, Buffer, []) of + {ok, Request, Rest} -> request(Request, State#state{buffer=Rest}); + {more, _Length} when byte_size(Buffer) > MaxLength -> + error_terminate(413, State); + {more, _Length} -> wait_request(State); + {error, _Reason} -> error_terminate(400, State) + end. + +-spec wait_request(#state{}) -> ok. +wait_request(State=#state{socket=Socket, transport=Transport, + timeout=T, buffer=Buffer}) -> + case Transport:recv(Socket, 0, T) of + {ok, Data} -> parse_request(State#state{ + buffer= << Buffer/binary, Data/binary >>}); + {error, _Reason} -> terminate(State) + end. + +-spec request({http_request, cowboy_http:method(), cowboy_http:uri(), + cowboy_http:version()}, #state{}) -> ok. +request({http_request, _Method, _URI, Version}, State) + when Version =/= {1, 0}, Version =/= {1, 1} -> + error_terminate(505, State); +%% We still receive the original Host header. +request({http_request, Method, {absoluteURI, _Scheme, _Host, _Port, Path}, + Version}, State) -> + request({http_request, Method, {abs_path, Path}, Version}, State); +request({http_request, Method, {abs_path, AbsPath}, Version}, + State=#state{socket=Socket, transport=Transport, + req_keepalive=Keepalive, max_keepalive=MaxKeepalive, + onresponse=OnResponse, urldecode={URLDecFun, URLDecArg}=URLDec}) -> + URLDecode = fun(Bin) -> URLDecFun(Bin, URLDecArg) end, + {Path, RawPath, Qs} = cowboy_dispatcher:split_path(AbsPath, URLDecode), + ConnAtom = if Keepalive < MaxKeepalive -> version_to_connection(Version); + true -> close + end, + parse_header(#http_req{socket=Socket, transport=Transport, + connection=ConnAtom, pid=self(), method=Method, version=Version, + path=Path, raw_path=RawPath, raw_qs=Qs, onresponse=OnResponse, + urldecode=URLDec}, State); +request({http_request, Method, '*', Version}, + State=#state{socket=Socket, transport=Transport, + req_keepalive=Keepalive, max_keepalive=MaxKeepalive, + onresponse=OnResponse, urldecode=URLDec}) -> + ConnAtom = if Keepalive < MaxKeepalive -> version_to_connection(Version); + true -> close + end, + parse_header(#http_req{socket=Socket, transport=Transport, + connection=ConnAtom, pid=self(), method=Method, version=Version, + path='*', raw_path= <<"*">>, raw_qs= <<>>, onresponse=OnResponse, + urldecode=URLDec}, State); +request({http_request, _Method, _URI, _Version}, State) -> + error_terminate(501, State); +request({http_error, <<"\r\n">>}, + State=#state{req_empty_lines=N, max_empty_lines=N}) -> + error_terminate(400, State); +request({http_error, <<"\r\n">>}, State=#state{req_empty_lines=N}) -> + parse_request(State#state{req_empty_lines=N + 1}); +request(_Any, State) -> + error_terminate(400, State). + +-spec parse_header(#http_req{}, #state{}) -> ok. +parse_header(Req, State=#state{buffer=Buffer, max_line_length=MaxLength}) -> + case erlang:decode_packet(httph_bin, Buffer, []) of + {ok, Header, Rest} -> header(Header, Req, State#state{buffer=Rest}); + {more, _Length} when byte_size(Buffer) > MaxLength -> + error_terminate(413, State); + {more, _Length} -> wait_header(Req, State); + {error, _Reason} -> error_terminate(400, State) + end. + +-spec wait_header(#http_req{}, #state{}) -> ok. +wait_header(Req, State=#state{socket=Socket, + transport=Transport, timeout=T, buffer=Buffer}) -> + case Transport:recv(Socket, 0, T) of + {ok, Data} -> parse_header(Req, State#state{ + buffer= << Buffer/binary, Data/binary >>}); + {error, timeout} -> error_terminate(408, State); + {error, closed} -> terminate(State) + end. + +-spec header({http_header, integer(), cowboy_http:header(), any(), binary()} + | http_eoh, #http_req{}, #state{}) -> ok. +header({http_header, _I, 'Host', _R, RawHost}, Req=#http_req{ + transport=Transport, host=undefined}, State) -> + RawHost2 = cowboy_bstr:to_lower(RawHost), + case catch cowboy_dispatcher:split_host(RawHost2) of + {Host, RawHost3, undefined} -> + Port = default_port(Transport:name()), + parse_header(Req#http_req{ + host=Host, raw_host=RawHost3, port=Port, + headers=[{'Host', RawHost}|Req#http_req.headers]}, State); + {Host, RawHost3, Port} -> + parse_header(Req#http_req{ + host=Host, raw_host=RawHost3, port=Port, + headers=[{'Host', RawHost}|Req#http_req.headers]}, State); + {'EXIT', _Reason} -> + error_terminate(400, State) + end; +%% Ignore Host headers if we already have it. +header({http_header, _I, 'Host', _R, _V}, Req, State) -> + parse_header(Req, State); +header({http_header, _I, 'Connection', _R, Connection}, + Req=#http_req{headers=Headers}, State=#state{ + req_keepalive=Keepalive, max_keepalive=MaxKeepalive}) + when Keepalive < MaxKeepalive -> + Req2 = Req#http_req{headers=[{'Connection', Connection}|Headers]}, + {ConnTokens, Req3} + = cowboy_http_req:parse_header('Connection', Req2), + ConnAtom = cowboy_http:connection_to_atom(ConnTokens), + parse_header(Req3#http_req{connection=ConnAtom}, State); +header({http_header, _I, Field, _R, Value}, Req, State) -> + Field2 = format_header(Field), + parse_header(Req#http_req{headers=[{Field2, Value}|Req#http_req.headers]}, + State); +%% The Host header is required in HTTP/1.1. +header(http_eoh, #http_req{version={1, 1}, host=undefined}, State) -> + error_terminate(400, State); +%% It is however optional in HTTP/1.0. +header(http_eoh, Req=#http_req{version={1, 0}, transport=Transport, + host=undefined}, State=#state{buffer=Buffer}) -> + Port = default_port(Transport:name()), + onrequest(Req#http_req{host=[], raw_host= <<>>, + port=Port, buffer=Buffer}, State#state{buffer= <<>>}); +header(http_eoh, Req, State=#state{buffer=Buffer}) -> + onrequest(Req#http_req{buffer=Buffer}, State#state{buffer= <<>>}); +header(_Any, _Req, State) -> + error_terminate(400, State). + +%% Call the global onrequest callback. The callback can send a reply, +%% in which case we consider the request handled and move on to the next +%% one. Note that since we haven't dispatched yet, we don't know the +%% handler, host_info, path_info or bindings yet. +-spec onrequest(#http_req{}, #state{}) -> ok. +onrequest(Req, State=#state{onrequest=undefined}) -> + dispatch(Req, State); +onrequest(Req, State=#state{onrequest=OnRequest}) -> + Req2 = OnRequest(Req), + case Req2#http_req.resp_state of + waiting -> dispatch(Req2, State); + _ -> next_request(Req2, State, ok) + end. + +-spec dispatch(#http_req{}, #state{}) -> ok. +dispatch(Req=#http_req{host=Host, path=Path}, + State=#state{dispatch=Dispatch}) -> + case cowboy_dispatcher:match(Host, Path, Dispatch) of + {ok, Handler, Opts, Binds, HostInfo, PathInfo} -> + handler_init(Req#http_req{host_info=HostInfo, path_info=PathInfo, + bindings=Binds}, State#state{handler={Handler, Opts}}); + {error, notfound, host} -> + error_terminate(400, State); + {error, notfound, path} -> + error_terminate(404, State) + end. + +-spec handler_init(#http_req{}, #state{}) -> ok. +handler_init(Req, State=#state{transport=Transport, + handler={Handler, Opts}}) -> + try Handler:init({Transport:name(), http}, Req, Opts) of + {ok, Req2, HandlerState} -> + handler_handle(HandlerState, Req2, State); + {loop, Req2, HandlerState} -> + handler_before_loop(HandlerState, Req2, State); + {loop, Req2, HandlerState, hibernate} -> + handler_before_loop(HandlerState, Req2, + State#state{hibernate=true}); + {loop, Req2, HandlerState, Timeout} -> + handler_before_loop(HandlerState, Req2, + State#state{loop_timeout=Timeout}); + {loop, Req2, HandlerState, Timeout, hibernate} -> + handler_before_loop(HandlerState, Req2, + State#state{hibernate=true, loop_timeout=Timeout}); + {shutdown, Req2, HandlerState} -> + handler_terminate(HandlerState, Req2, State); + %% @todo {upgrade, transport, Module} + {upgrade, protocol, Module} -> + upgrade_protocol(Req, State, Module) + catch Class:Reason -> + error_terminate(500, State), + PLReq = lists:zip(record_info(fields, http_req), tl(tuple_to_list(Req))), + error_logger:error_msg( + "** Handler ~p terminating in init/3~n" + " for the reason ~p:~p~n" + "** Options were ~p~n" + "** Request was ~p~n** Stacktrace: ~p~n~n", + [Handler, Class, Reason, Opts, PLReq, erlang:get_stacktrace()]) + end. + +-spec upgrade_protocol(#http_req{}, #state{}, atom()) -> ok. +upgrade_protocol(Req, State=#state{listener=ListenerPid, + handler={Handler, Opts}}, Module) -> + case Module:upgrade(ListenerPid, Handler, Opts, Req) of + {UpgradeRes, Req2} -> next_request(Req2, State, UpgradeRes); + _Any -> terminate(State) + end. + +-spec handler_handle(any(), #http_req{}, #state{}) -> ok. +handler_handle(HandlerState, Req, State=#state{handler={Handler, Opts}}) -> + try Handler:handle(Req, HandlerState) of + {ok, Req2, HandlerState2} -> + terminate_request(HandlerState2, Req2, State) + catch Class:Reason -> + PLReq = lists:zip(record_info(fields, http_req), tl(tuple_to_list(Req))), + error_logger:error_msg( + "** Handler ~p terminating in handle/2~n" + " for the reason ~p:~p~n" + "** Options were ~p~n** Handler state was ~p~n" + "** Request was ~p~n** Stacktrace: ~p~n~n", + [Handler, Class, Reason, Opts, + HandlerState, PLReq, erlang:get_stacktrace()]), + handler_terminate(HandlerState, Req, State), + error_terminate(500, State) + end. + +%% We don't listen for Transport closes because that would force us +%% to receive data and buffer it indefinitely. +-spec handler_before_loop(any(), #http_req{}, #state{}) -> ok. +handler_before_loop(HandlerState, Req, State=#state{hibernate=true}) -> + State2 = handler_loop_timeout(State), + catch erlang:hibernate(?MODULE, handler_loop, + [HandlerState, Req, State2#state{hibernate=false}]), + ok; +handler_before_loop(HandlerState, Req, State) -> + State2 = handler_loop_timeout(State), + handler_loop(HandlerState, Req, State2). + +%% Almost the same code can be found in cowboy_http_websocket. +-spec handler_loop_timeout(#state{}) -> #state{}. +handler_loop_timeout(State=#state{loop_timeout=infinity}) -> + State#state{loop_timeout_ref=undefined}; +handler_loop_timeout(State=#state{loop_timeout=Timeout, + loop_timeout_ref=PrevRef}) -> + _ = case PrevRef of undefined -> ignore; PrevRef -> + erlang:cancel_timer(PrevRef) end, + TRef = erlang:start_timer(Timeout, self(), ?MODULE), + State#state{loop_timeout_ref=TRef}. + +-spec handler_loop(any(), #http_req{}, #state{}) -> ok. +handler_loop(HandlerState, Req, State=#state{loop_timeout_ref=TRef}) -> + receive + {timeout, TRef, ?MODULE} -> + terminate_request(HandlerState, Req, State); + {timeout, OlderTRef, ?MODULE} when is_reference(OlderTRef) -> + handler_loop(HandlerState, Req, State); + Message -> + handler_call(HandlerState, Req, State, Message) + end. + +-spec handler_call(any(), #http_req{}, #state{}, any()) -> ok. +handler_call(HandlerState, Req, State=#state{handler={Handler, Opts}}, + Message) -> + try Handler:info(Message, Req, HandlerState) of + {ok, Req2, HandlerState2} -> + terminate_request(HandlerState2, Req2, State); + {loop, Req2, HandlerState2} -> + handler_before_loop(HandlerState2, Req2, State); + {loop, Req2, HandlerState2, hibernate} -> + handler_before_loop(HandlerState2, Req2, + State#state{hibernate=true}) + catch Class:Reason -> + PLReq = lists:zip(record_info(fields, http_req), tl(tuple_to_list(Req))), + error_logger:error_msg( + "** Handler ~p terminating in info/3~n" + " for the reason ~p:~p~n" + "** Options were ~p~n** Handler state was ~p~n" + "** Request was ~p~n** Stacktrace: ~p~n~n", + [Handler, Class, Reason, Opts, + HandlerState, PLReq, erlang:get_stacktrace()]), + handler_terminate(HandlerState, Req, State), + error_terminate(500, State) + end. + +-spec handler_terminate(any(), #http_req{}, #state{}) -> ok. +handler_terminate(HandlerState, Req, #state{handler={Handler, Opts}}) -> + try + Handler:terminate(Req#http_req{resp_state=locked}, HandlerState) + catch Class:Reason -> + PLReq = lists:zip(record_info(fields, http_req), tl(tuple_to_list(Req))), + error_logger:error_msg( + "** Handler ~p terminating in terminate/2~n" + " for the reason ~p:~p~n" + "** Options were ~p~n** Handler state was ~p~n" + "** Request was ~p~n** Stacktrace: ~p~n~n", + [Handler, Class, Reason, Opts, + HandlerState, PLReq, erlang:get_stacktrace()]) + end. + +-spec terminate_request(any(), #http_req{}, #state{}) -> ok. +terminate_request(HandlerState, Req, State) -> + HandlerRes = handler_terminate(HandlerState, Req, State), + next_request(Req, State, HandlerRes). + +-spec next_request(#http_req{}, #state{}, any()) -> ok. +next_request(Req=#http_req{connection=Conn}, State=#state{ + req_keepalive=Keepalive}, HandlerRes) -> + RespRes = ensure_response(Req), + {BodyRes, Buffer} = ensure_body_processed(Req), + %% Flush the resp_sent message before moving on. + receive {cowboy_http_req, resp_sent} -> ok after 0 -> ok end, + case {HandlerRes, BodyRes, RespRes, Conn} of + {ok, ok, ok, keepalive} -> + ?MODULE:parse_request(State#state{ + buffer=Buffer, req_empty_lines=0, + req_keepalive=Keepalive + 1}); + _Closed -> + terminate(State) + end. + +-spec ensure_body_processed(#http_req{}) -> {ok | close, binary()}. +ensure_body_processed(#http_req{body_state=done, buffer=Buffer}) -> + {ok, Buffer}; +ensure_body_processed(Req=#http_req{body_state=waiting}) -> + case cowboy_http_req:skip_body(Req) of + {ok, Req2} -> {ok, Req2#http_req.buffer}; + {error, _Reason} -> {close, <<>>} + end; +ensure_body_processed(Req=#http_req{body_state={multipart, _, _}}) -> + {ok, Req2} = cowboy_http_req:multipart_skip(Req), + ensure_body_processed(Req2). + +-spec ensure_response(#http_req{}) -> ok. +%% The handler has already fully replied to the client. +ensure_response(#http_req{resp_state=done}) -> + ok; +%% No response has been sent but everything apparently went fine. +%% Reply with 204 No Content to indicate this. +ensure_response(Req=#http_req{resp_state=waiting}) -> + _ = cowboy_http_req:reply(204, [], [], Req), + ok; +%% Terminate the chunked body for HTTP/1.1 only. +ensure_response(#http_req{method='HEAD', resp_state=chunks}) -> + ok; +ensure_response(#http_req{version={1, 0}, resp_state=chunks}) -> + ok; +ensure_response(#http_req{socket=Socket, transport=Transport, + resp_state=chunks}) -> + Transport:send(Socket, <<"0\r\n\r\n">>), + ok. + +%% Only send an error reply if there is no resp_sent message. +-spec error_terminate(cowboy_http:status(), #state{}) -> ok. +error_terminate(Code, State=#state{socket=Socket, transport=Transport, + onresponse=OnResponse}) -> + receive + {cowboy_http_req, resp_sent} -> ok + after 0 -> + _ = cowboy_http_req:reply(Code, #http_req{ + socket=Socket, transport=Transport, onresponse=OnResponse, + connection=close, pid=self(), resp_state=waiting}), + ok + end, + terminate(State). + +-spec terminate(#state{}) -> ok. +terminate(#state{socket=Socket, transport=Transport}) -> + Transport:close(Socket), + ok. + +%% Internal. + +-spec version_to_connection(cowboy_http:version()) -> keepalive | close. +version_to_connection({1, 1}) -> keepalive; +version_to_connection(_Any) -> close. + +-spec default_port(atom()) -> 80 | 443. +default_port(ssl) -> 443; +default_port(_) -> 80. + +%% @todo While 32 should be enough for everybody, we should probably make +%% this configurable or something. +-spec format_header(atom()) -> atom(); (binary()) -> binary(). +format_header(Field) when is_atom(Field) -> + Field; +format_header(Field) when byte_size(Field) =< 20; byte_size(Field) > 32 -> + Field; +format_header(Field) -> + format_header(Field, true, <<>>). + +-spec format_header(binary(), boolean(), binary()) -> binary(). +format_header(<<>>, _Any, Acc) -> + Acc; +%% Replicate a bug in OTP for compatibility reasons when there's a - right +%% after another. Proper use should always be 'true' instead of 'not Bool'. +format_header(<< $-, Rest/bits >>, Bool, Acc) -> + format_header(Rest, not Bool, << Acc/binary, $- >>); +format_header(<< C, Rest/bits >>, true, Acc) -> + format_header(Rest, false, << Acc/binary, (cowboy_bstr:char_to_upper(C)) >>); +format_header(<< C, Rest/bits >>, false, Acc) -> + format_header(Rest, false, << Acc/binary, (cowboy_bstr:char_to_lower(C)) >>). + +%% Tests. + +-ifdef(TEST). + +format_header_test_() -> + %% {Header, Result} + Tests = [ + {<<"Sec-Websocket-Version">>, <<"Sec-Websocket-Version">>}, + {<<"Sec-WebSocket-Version">>, <<"Sec-Websocket-Version">>}, + {<<"sec-websocket-version">>, <<"Sec-Websocket-Version">>}, + {<<"SEC-WEBSOCKET-VERSION">>, <<"Sec-Websocket-Version">>}, + %% These last tests ensures we're formatting headers exactly like OTP. + %% Even though it's dumb, it's better for compatibility reasons. + {<<"Sec-WebSocket--Version">>, <<"Sec-Websocket--version">>}, + {<<"Sec-WebSocket---Version">>, <<"Sec-Websocket---Version">>} + ], + [{H, fun() -> R = format_header(H) end} || {H, R} <- Tests]. + +-endif. diff --git a/test/http_SUITE.erl b/test/http_SUITE.erl index 3be0735..a83da34 100644 --- a/test/http_SUITE.erl +++ b/test/http_SUITE.erl @@ -489,7 +489,7 @@ http10_hostless(Config) -> Name = list_to_atom("http10_hostless_" ++ integer_to_list(Port10)), ranch:start_listener(Name, 5, ?config(transport, Config), ?config(opts, Config) ++ [{port, Port10}], - cowboy_http_protocol, [ + cowboy_protocol, [ {dispatch, [{'_', [ {[<<"http1.0">>, <<"hostless">>], http_handler, []}]}]}, {max_keepalive, 50}, -- cgit v1.2.3