aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/cowboy_dispatcher.erl275
-rw-r--r--src/cowboy_http.erl51
-rw-r--r--src/cowboy_protocol.erl585
-rw-r--r--src/cowboy_req.erl66
4 files changed, 514 insertions, 463 deletions
diff --git a/src/cowboy_dispatcher.erl b/src/cowboy_dispatcher.erl
index c52aba9..f5dfcd9 100644
--- a/src/cowboy_dispatcher.erl
+++ b/src/cowboy_dispatcher.erl
@@ -17,16 +17,14 @@
-module(cowboy_dispatcher).
%% API.
--export([split_host/1]).
--export([split_path/2]).
--export([match/3]).
+-export([match/4]).
--type bindings() :: list({atom(), binary()}).
--type tokens() :: list(binary()).
--type match_rule() :: '_' | '*' | list(binary() | '_' | '...' | atom()).
--type dispatch_path() :: list({match_rule(), module(), any()}).
+-type bindings() :: [{atom(), binary()}].
+-type tokens() :: [binary()].
+-type match_rule() :: '_' | '*' | [binary() | '_' | '...' | atom()].
+-type dispatch_path() :: [{match_rule(), module(), any()}].
-type dispatch_rule() :: {Host::match_rule(), Path::dispatch_path()}.
--type dispatch_rules() :: list(dispatch_rule()).
+-type dispatch_rules() :: [dispatch_rule()].
-export_type([bindings/0]).
-export_type([tokens/0]).
@@ -38,60 +36,6 @@
%% API.
-%% @doc Split a hostname into a list of tokens.
--spec split_host(binary())
- -> {tokens(), binary(), undefined | inet:port_number()}.
-split_host(Host) ->
- case binary:match(Host, <<":">>) of
- nomatch ->
- {do_split_host(Host, []), Host, undefined};
- {Pos, _} ->
- << Host2:Pos/binary, _:8, Port/bits >> = Host,
- {do_split_host(Host2, []), Host2,
- list_to_integer(binary_to_list(Port))}
- end.
-
-do_split_host(Host, Acc) ->
- case binary:match(Host, <<".">>) of
- nomatch when Host =:= <<>> ->
- Acc;
- nomatch ->
- [Host|Acc];
- {Pos, _} ->
- << Segment:Pos/binary, _:8, Rest/bits >> = Host,
- false = byte_size(Segment) == 0,
- do_split_host(Rest, [Segment|Acc])
- end.
-
-%% @doc Split a path into a list of path segments.
-%%
-%% Following RFC2396, this function may return path segments containing any
-%% character, including <em>/</em> if, and only if, a <em>/</em> was escaped
-%% and part of a path segment.
--spec split_path(binary(), fun((binary()) -> binary())) ->
- {tokens(), binary(), binary()}.
-split_path(Path, URLDec) ->
- case binary:match(Path, <<"?">>) of
- nomatch ->
- {do_split_path(Path, URLDec), Path, <<>>};
- {Pos, _} ->
- << Path2:Pos/binary, _:8, Qs/bits >> = Path,
- {do_split_path(Path2, URLDec), Path2, Qs}
- end.
-
-do_split_path(<< "/", Path/bits >>, URLDec) ->
- do_split_path(Path, URLDec, []).
-do_split_path(Path, URLDec, Acc) ->
- case binary:match(Path, <<"/">>) of
- nomatch when Path =:= <<>> ->
- lists:reverse([URLDec(S) || S <- Acc]);
- nomatch ->
- lists:reverse([URLDec(S) || S <- [Path|Acc]]);
- {Pos, _} ->
- << Segment:Pos/binary, _:8, Rest/bits >> = Path,
- do_split_path(Rest, URLDec, [Segment|Acc])
- end.
-
%% @doc Match hostname tokens and path tokens against dispatch rules.
%%
%% It is typically used for matching tokens for the hostname and path of
@@ -119,47 +63,93 @@ do_split_path(Path, URLDec, Acc) ->
%% options found in the dispatch list, a key-value list of bindings and
%% the tokens that were matched by the <em>'...'</em> atom for both the
%% hostname and path.
--spec match(Host::tokens(), Path::tokens(), dispatch_rules())
+-spec match(dispatch_rules(), fun((binary()) -> binary()),
+ Host::binary() | tokens(), Path::binary())
-> {ok, module(), any(), bindings(),
HostInfo::undefined | tokens(),
PathInfo::undefined | tokens()}
| {error, notfound, host} | {error, notfound, path}.
-match(_Host, _Path, []) ->
+match([], _, _, _) ->
{error, notfound, host};
-match(_Host, Path, [{'_', PathMatchs}|_Tail]) ->
- match_path(Path, PathMatchs, [], undefined);
-match(Host, Path, [{HostMatch, PathMatchs}|Tail]) ->
- case list_match(Host, lists:reverse(HostMatch), []) of
+match([{'_', PathMatchs}|_Tail], URLDecode, _, Path) ->
+ match_path(PathMatchs, URLDecode, undefined, Path, []);
+match([{HostMatch, PathMatchs}|Tail], URLDecode, Tokens, Path)
+ when is_list(Tokens) ->
+ case list_match(Tokens, lists:reverse(HostMatch), []) of
false ->
- match(Host, Path, Tail);
- {true, HostBinds, undefined} ->
- match_path(Path, PathMatchs, HostBinds, undefined);
- {true, HostBinds, HostInfo} ->
- match_path(Path, PathMatchs, HostBinds, lists:reverse(HostInfo))
- end.
+ match(Tail, URLDecode, Tokens, Path);
+ {true, Bindings, undefined} ->
+ match_path(PathMatchs, URLDecode, undefined, Path, Bindings);
+ {true, Bindings, HostInfo} ->
+ match_path(PathMatchs, URLDecode, lists:reverse(HostInfo),
+ Path, Bindings)
+ end;
+match(Dispatch, URLDecode, Host, Path) ->
+ match(Dispatch, URLDecode, split_host(Host), Path).
--spec match_path(tokens(), dispatch_path(), bindings(),
- HostInfo::undefined | tokens())
+-spec match_path(dispatch_path(), fun((binary()) -> binary()),
+ HostInfo::undefined | tokens(), binary() | tokens(), bindings())
-> {ok, module(), any(), bindings(),
HostInfo::undefined | tokens(),
PathInfo::undefined | tokens()}
| {error, notfound, path}.
-match_path(_Path, [], _HostBinds, _HostInfo) ->
+match_path([], _, _, _, _) ->
{error, notfound, path};
-match_path(_Path, [{'_', Handler, Opts}|_Tail], HostBinds, HostInfo) ->
- {ok, Handler, Opts, HostBinds, HostInfo, undefined};
-match_path('*', [{'*', Handler, Opts}|_Tail], HostBinds, HostInfo) ->
- {ok, Handler, Opts, HostBinds, HostInfo, undefined};
-match_path(Path, [{PathMatch, Handler, Opts}|Tail], HostBinds, HostInfo) ->
- case list_match(Path, PathMatch, []) of
+match_path([{'_', Handler, Opts}|_Tail], _, HostInfo, _, Bindings) ->
+ {ok, Handler, Opts, Bindings, HostInfo, undefined};
+match_path([{'*', Handler, Opts}|_Tail], _, HostInfo, '*', Bindings) ->
+ {ok, Handler, Opts, Bindings, HostInfo, undefined};
+match_path([{PathMatch, Handler, Opts}|Tail], URLDecode, HostInfo, Tokens,
+ Bindings) when is_list(Tokens) ->
+ case list_match(Tokens, PathMatch, []) of
false ->
- match_path(Path, Tail, HostBinds, HostInfo);
+ match_path(Tail, URLDecode, HostInfo, Tokens, Bindings);
{true, PathBinds, PathInfo} ->
- {ok, Handler, Opts, HostBinds ++ PathBinds, HostInfo, PathInfo}
- end.
+ {ok, Handler, Opts, Bindings ++ PathBinds, HostInfo, PathInfo}
+ end;
+match_path(Dispatch, URLDecode, HostInfo, Path, Bindings) ->
+ match_path(Dispatch, URLDecode, HostInfo,
+ split_path(Path, URLDecode), Bindings).
%% Internal.
+%% @doc Split a hostname into a list of tokens.
+-spec split_host(binary()) -> tokens().
+split_host(Host) ->
+ split_host(Host, []).
+
+split_host(Host, Acc) ->
+ case binary:match(Host, <<".">>) of
+ nomatch when Host =:= <<>> ->
+ Acc;
+ nomatch ->
+ [Host|Acc];
+ {Pos, _} ->
+ << Segment:Pos/binary, _:8, Rest/bits >> = Host,
+ false = byte_size(Segment) == 0,
+ split_host(Rest, [Segment|Acc])
+ end.
+
+%% @doc Split a path into a list of path segments.
+%%
+%% Following RFC2396, this function may return path segments containing any
+%% character, including <em>/</em> if, and only if, a <em>/</em> was escaped
+%% and part of a path segment.
+-spec split_path(binary(), fun((binary()) -> binary())) -> tokens().
+split_path(<< $/, Path/bits >>, URLDec) ->
+ split_path(Path, URLDec, []).
+
+split_path(Path, URLDec, Acc) ->
+ case binary:match(Path, <<"/">>) of
+ nomatch when Path =:= <<>> ->
+ lists:reverse([URLDec(S) || S <- Acc]);
+ nomatch ->
+ lists:reverse([URLDec(S) || S <- [Path|Acc]]);
+ {Pos, _} ->
+ << Segment:Pos/binary, _:8, Rest/bits >> = Path,
+ split_path(Rest, URLDec, [Segment|Acc])
+ end.
+
-spec list_match(tokens(), match_rule(), bindings())
-> {true, bindings(), undefined | tokens()} | false.
%% Atom '...' matches any trailing path, stop right now.
@@ -188,64 +178,32 @@ list_match(_List, _Match, _Binds) ->
split_host_test_() ->
%% {Host, Result}
Tests = [
- {<<"">>, {[], <<"">>, undefined}},
- {<<"*">>, {[<<"*">>], <<"*">>, undefined}},
+ {<<"">>, []},
+ {<<"*">>, [<<"*">>]},
{<<"cowboy.ninenines.eu">>,
- {[<<"eu">>, <<"ninenines">>, <<"cowboy">>],
- <<"cowboy.ninenines.eu">>, undefined}},
+ [<<"eu">>, <<"ninenines">>, <<"cowboy">>]},
{<<"ninenines.eu">>,
- {[<<"eu">>, <<"ninenines">>], <<"ninenines.eu">>, undefined}},
- {<<"ninenines.eu:8080">>,
- {[<<"eu">>, <<"ninenines">>], <<"ninenines.eu">>, 8080}},
+ [<<"eu">>, <<"ninenines">>]},
{<<"a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z">>,
- {[<<"z">>, <<"y">>, <<"x">>, <<"w">>, <<"v">>, <<"u">>, <<"t">>,
- <<"s">>, <<"r">>, <<"q">>, <<"p">>, <<"o">>, <<"n">>, <<"m">>,
- <<"l">>, <<"k">>, <<"j">>, <<"i">>, <<"h">>, <<"g">>, <<"f">>,
- <<"e">>, <<"d">>, <<"c">>, <<"b">>, <<"a">>],
- <<"a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z">>,
- undefined}}
+ [<<"z">>, <<"y">>, <<"x">>, <<"w">>, <<"v">>, <<"u">>, <<"t">>,
+ <<"s">>, <<"r">>, <<"q">>, <<"p">>, <<"o">>, <<"n">>, <<"m">>,
+ <<"l">>, <<"k">>, <<"j">>, <<"i">>, <<"h">>, <<"g">>, <<"f">>,
+ <<"e">>, <<"d">>, <<"c">>, <<"b">>, <<"a">>]}
],
[{H, fun() -> R = split_host(H) end} || {H, R} <- Tests].
-split_host_fail_test_() ->
- Tests = [
- <<".........">>,
- <<"ninenines..eu">>,
- <<"ninenines.eu:owns">>,
- <<"ninenines.eu: owns">>,
- <<"ninenines.eu:42fun">>,
- <<"ninenines.eu: 42fun">>,
- <<"ninenines.eu:42 fun">>,
- <<"ninenines.eu:fun 42">>,
- <<"ninenines.eu: 42">>,
- <<":owns">>,
- <<":42 fun">>
- ],
- [{H, fun() -> case catch split_host(H) of
- {'EXIT', _Reason} -> ok
- end end} || H <- Tests].
-
split_path_test_() ->
%% {Path, Result, QueryString}
Tests = [
- {<<"/?">>, [], <<"/">>, <<"">>},
- {<<"/???">>, [], <<"/">>, <<"??">>},
- {<<"/">>, [], <<"/">>, <<"">>},
- {<<"/extend//cowboy">>, [<<"extend">>, <<>>, <<"cowboy">>],
- <<"/extend//cowboy">>, <<>>},
- {<<"/users">>, [<<"users">>], <<"/users">>, <<"">>},
- {<<"/users?">>, [<<"users">>], <<"/users">>, <<"">>},
- {<<"/users?a">>, [<<"users">>], <<"/users">>, <<"a">>},
- {<<"/users/42/friends?a=b&c=d&e=notsure?whatever">>,
- [<<"users">>, <<"42">>, <<"friends">>],
- <<"/users/42/friends">>, <<"a=b&c=d&e=notsure?whatever">>},
- {<<"/users/a+b/c%21d?e+f=g+h">>,
- [<<"users">>, <<"a b">>, <<"c!d">>],
- <<"/users/a+b/c%21d">>, <<"e+f=g+h">>}
+ {<<"/">>, []},
+ {<<"/extend//cowboy">>, [<<"extend">>, <<>>, <<"cowboy">>]},
+ {<<"/users">>, [<<"users">>]},
+ {<<"/users/42/friends">>, [<<"users">>, <<"42">>, <<"friends">>]},
+ {<<"/users/a+b/c%21d">>, [<<"users">>, <<"a b">>, <<"c!d">>]}
],
URLDecode = fun(Bin) -> cowboy_http:urldecode(Bin, crash) end,
- [{P, fun() -> {R, RawP, Qs} = split_path(P, URLDecode) end}
- || {P, R, RawP, Qs} <- Tests].
+ [{P, fun() -> R = split_path(P, URLDecode) end}
+ || {P, R} <- Tests].
match_test_() ->
Dispatch = [
@@ -270,28 +228,31 @@ match_test_() ->
],
%% {Host, Path, Result}
Tests = [
- {[<<"any">>], [], {ok, match_any, [], []}},
- {[<<"eu">>, <<"ninenines">>, <<"any">>, <<"www">>],
- [<<"users">>, <<"42">>, <<"mails">>],
+ {<<"any">>, <<"/">>, {ok, match_any, [], []}},
+ {<<"www.any.ninenines.eu">>, <<"/users/42/mails">>,
{ok, match_any_subdomain_users, [], []}},
- {[<<"eu">>, <<"ninenines">>, <<"www">>],
- [<<"users">>, <<"42">>, <<"mails">>], {ok, match_any, [], []}},
- {[<<"eu">>, <<"ninenines">>, <<"www">>], [], {ok, match_any, [], []}},
- {[<<"eu">>, <<"ninenines">>, <<"any">>, <<"www">>],
- [<<"not_users">>, <<"42">>, <<"mails">>], {error, notfound, path}},
- {[<<"eu">>, <<"ninenines">>], [], {ok, match_extend, [], []}},
- {[<<"eu">>, <<"ninenines">>], [<<"users">>, <<"42">>, <<"friends">>],
+ {<<"www.ninenines.eu">>, <<"/users/42/mails">>,
+ {ok, match_any, [], []}},
+ {<<"www.ninenines.eu">>, <<"/">>,
+ {ok, match_any, [], []}},
+ {<<"www.any.ninenines.eu">>, <<"/not_users/42/mails">>,
+ {error, notfound, path}},
+ {<<"ninenines.eu">>, <<"/">>,
+ {ok, match_extend, [], []}},
+ {<<"ninenines.eu">>, <<"/users/42/friends">>,
{ok, match_extend_users_friends, [], [{id, <<"42">>}]}},
- {[<<"fr">>, <<"erlang">>], '_',
+ {<<"erlang.fr">>, '_',
{ok, match_erlang_ext, [], [{ext, <<"fr">>}]}},
- {[<<"any">>], [<<"users">>, <<"444">>, <<"friends">>],
+ {<<"any">>, <<"/users/444/friends">>,
{ok, match_users_friends, [], [{id, <<"444">>}]}},
- {[<<"fr">>, <<"ninenines">>], [<<"threads">>, <<"987">>],
+ {<<"ninenines.fr">>, <<"/threads/987">>,
{ok, match_duplicate_vars, [we, {expect, two}, var, here],
- [{var, <<"fr">>}, {var, <<"987">>}]}}
+ [{var, <<"fr">>}, {var, <<"987">>}]}}
],
+ URLDecode = fun(Bin) -> cowboy_http:urldecode(Bin, crash) end,
[{lists:flatten(io_lib:format("~p, ~p", [H, P])), fun() ->
- {ok, Handler, Opts, Binds, undefined, undefined} = match(H, P, Dispatch)
+ {ok, Handler, Opts, Binds, undefined, undefined}
+ = match(Dispatch, URLDecode, H, P)
end} || {H, P, {ok, Handler, Opts, Binds}} <- Tests].
match_info_test_() ->
@@ -304,24 +265,22 @@ match_info_test_() ->
]}
],
Tests = [
- {[<<"eu">>, <<"ninenines">>], [],
+ {<<"ninenines.eu">>, <<"/">>,
{ok, match_any, [], [], [], undefined}},
- {[<<"eu">>, <<"ninenines">>, <<"bugs">>], [],
+ {<<"bugs.ninenines.eu">>, <<"/">>,
{ok, match_any, [], [], [<<"bugs">>], undefined}},
- {[<<"eu">>, <<"ninenines">>, <<"bugs">>, <<"cowboy">>], [],
+ {<<"cowboy.bugs.ninenines.eu">>, <<"/">>,
{ok, match_any, [], [], [<<"cowboy">>, <<"bugs">>], undefined}},
- {[<<"eu">>, <<"ninenines">>, <<"www">>],
- [<<"pathinfo">>, <<"is">>, <<"next">>],
+ {<<"www.ninenines.eu">>, <<"/pathinfo/is/next">>,
{ok, match_path, [], [], undefined, []}},
- {[<<"eu">>, <<"ninenines">>, <<"www">>],
- [<<"pathinfo">>, <<"is">>, <<"next">>, <<"path_info">>],
+ {<<"www.ninenines.eu">>, <<"/pathinfo/is/next/path_info">>,
{ok, match_path, [], [], undefined, [<<"path_info">>]}},
- {[<<"eu">>, <<"ninenines">>, <<"www">>],
- [<<"pathinfo">>, <<"is">>, <<"next">>, <<"foo">>, <<"bar">>],
+ {<<"www.ninenines.eu">>, <<"/pathinfo/is/next/foo/bar">>,
{ok, match_path, [], [], undefined, [<<"foo">>, <<"bar">>]}}
],
+ URLDecode = fun(Bin) -> cowboy_http:urldecode(Bin, crash) end,
[{lists:flatten(io_lib:format("~p, ~p", [H, P])), fun() ->
- R = match(H, P, Dispatch)
+ R = match(Dispatch, URLDecode, H, P)
end} || {H, P, R} <- Tests].
-endif.
diff --git a/src/cowboy_http.erl b/src/cowboy_http.erl
index a936e2c..c3bef2f 100644
--- a/src/cowboy_http.erl
+++ b/src/cowboy_http.erl
@@ -17,7 +17,6 @@
-module(cowboy_http).
%% Parsing.
--export([request_line/1]).
-export([list/2]).
-export([nonempty_list/2]).
-export([content_type/1]).
@@ -51,15 +50,10 @@
-export([urlencode/2]).
-export([x_www_form_urlencoded/2]).
--type uri() :: '*' | {absoluteURI, http | https, Host::binary(),
- Port::integer() | undefined, Path::binary()}
- | {scheme, Scheme::binary(), binary()}
- | {abs_path, binary()} | binary().
-type version() :: {Major::non_neg_integer(), Minor::non_neg_integer()}.
-type headers() :: [{binary(), iodata()}].
-type status() :: non_neg_integer() | binary().
--export_type([uri/0]).
-export_type([version/0]).
-export_type([headers/0]).
-export_type([status/0]).
@@ -70,51 +64,6 @@
%% Parsing.
-%% @doc Parse a request-line.
--spec request_line(binary())
- -> {binary(), binary(), version()} | {error, badarg}.
-request_line(Data) ->
- token(Data,
- fun (Rest, Method) ->
- whitespace(Rest,
- fun (Rest2) ->
- uri_to_abspath(Rest2,
- fun (Rest3, AbsPath) ->
- whitespace(Rest3,
- fun (<< "HTTP/", Maj, ".", Min, _/binary >>)
- when Maj >= $0, Maj =< $9,
- Min >= $0, Min =< $9 ->
- {Method, AbsPath, {Maj - $0, Min - $0}};
- (_) ->
- {error, badarg}
- end)
- end)
- end)
- end).
-
-%% We just want to extract the path/qs and skip everything else.
-%% We do not really parse the URI, nor do we need to.
-uri_to_abspath(Data, Fun) ->
- case binary:match(Data, <<" ">>) of
- nomatch -> %% We require the HTTP version.
- {error, badarg};
- {Pos1, _} ->
- << URI:Pos1/binary, _:8, Rest/bits >> = Data,
- case binary:match(URI, <<"://">>) of
- nomatch -> %% Already is a path or "*".
- Fun(Rest, URI);
- {Pos2, _} ->
- << _:Pos2/binary, _:24, NoScheme/bits >> = Rest,
- case binary:match(NoScheme, <<"/">>) of
- nomatch ->
- Fun(Rest, <<"/">>);
- {Pos3, _} ->
- << _:Pos3/binary, _:8, NoHost/bits >> = NoScheme,
- Fun(Rest, << "/", NoHost/binary >>)
- end
- end
- end.
-
%% @doc Parse a non-empty list of the given type.
-spec nonempty_list(binary(), fun()) -> [any(), ...] | {error, badarg}.
nonempty_list(Data, Fun) ->
diff --git a/src/cowboy_protocol.erl b/src/cowboy_protocol.erl
index 0fe6ed2..b0b5aa6 100644
--- a/src/cowboy_protocol.erl
+++ b/src/cowboy_protocol.erl
@@ -39,8 +39,8 @@
%% Internal.
-export([init/4]).
--export([parse_request/2]).
--export([handler_loop/3]).
+-export([parse_request/3]).
+-export([handler_loop/4]).
-type onrequest_fun() :: fun((Req) -> Req).
-type onresponse_fun() ::
@@ -54,11 +54,9 @@
socket :: inet:socket(),
transport :: module(),
dispatch :: cowboy_dispatcher:dispatch_rules(),
- handler :: {module(), any()},
onrequest :: undefined | onrequest_fun(),
onresponse = undefined :: undefined | onresponse_fun(),
urldecode :: {fun((binary(), T) -> binary()), T},
- req_empty_lines = 0 :: integer(),
max_empty_lines :: integer(),
req_keepalive = 1 :: integer(),
max_keepalive :: integer(),
@@ -66,8 +64,6 @@
max_header_name_length :: integer(),
max_header_value_length :: integer(),
timeout :: timeout(),
- host_tokens = undefined :: undefined | cowboy_dispatcher:tokens(),
- path_tokens = undefined :: undefined | '*' | cowboy_dispatcher:tokens(),
hibernate = false :: boolean(),
loop_timeout = infinity :: timeout(),
loop_timeout_ref :: undefined | reference()
@@ -113,254 +109,425 @@ init(ListenerPid, Socket, Transport, Opts) ->
max_header_name_length=MaxHeaderNameLength,
max_header_value_length=MaxHeaderValueLength,
timeout=Timeout, onrequest=OnRequest, onresponse=OnResponse,
- urldecode=URLDec}).
-
--spec wait_request(binary(), #state{}) -> ok.
-wait_request(Buffer, State=#state{
- socket=Socket, transport=Transport, timeout=T}) ->
- case Transport:recv(Socket, 0, T) of
- {ok, Data} -> parse_request(<< Buffer/binary, Data/binary >>, State);
- {error, _Reason} -> terminate(State)
+ urldecode=URLDec}, 0).
+
+%% Request parsing.
+%%
+%% The next set of functions is the request parsing code. All of it
+%% runs using a single binary match context. This optimization ends
+%% right after the header parsing is finished and the code becomes
+%% more interesting past that point.
+
+-spec wait_request(binary(), #state{}, non_neg_integer()) -> ok.
+wait_request(Buffer, State=#state{socket=Socket, transport=Transport,
+ timeout=Timeout}, ReqEmpty) ->
+ case Transport:recv(Socket, 0, Timeout) of
+ {ok, Data} ->
+ parse_request(<< Buffer/binary, Data/binary >>, State, ReqEmpty);
+ {error, _} ->
+ terminate(State)
end.
%% @private
--spec parse_request(binary(), #state{}) -> ok.
+-spec parse_request(binary(), #state{}, non_neg_integer()) -> ok.
%% Empty lines must be using \r\n.
-parse_request(<< "\n", _/binary >>, State) ->
+parse_request(<< $\n, _/binary >>, State, _) ->
error_terminate(400, State);
%% We limit the length of the Request-line to MaxLength to avoid endlessly
%% reading from the socket and eventually crashing.
parse_request(Buffer, State=#state{max_request_line_length=MaxLength,
- req_empty_lines=ReqEmpty, max_empty_lines=MaxEmpty}) ->
- case binary:match(Buffer, <<"\r\n">>) of
+ max_empty_lines=MaxEmpty}, ReqEmpty) ->
+ case binary:match(Buffer, <<"\n">>) of
nomatch when byte_size(Buffer) > MaxLength ->
error_terminate(413, State);
nomatch ->
- wait_request(Buffer, State);
- {0, _} when ReqEmpty =:= MaxEmpty ->
+ wait_request(Buffer, State, ReqEmpty);
+ {1, _} when ReqEmpty =:= MaxEmpty ->
error_terminate(400, State);
- {0, _} ->
+ {1, _} ->
<< _:16, Rest/binary >> = Buffer,
- parse_request(Rest, State#state{req_empty_lines=ReqEmpty + 1});
- {Pos, _} ->
- << RequestLine:Pos/binary, _:16, Rest/binary >> = Buffer,
- case cowboy_http:request_line(RequestLine) of
- {Method, AbsPath, Version} ->
- request(Rest, State, Method, AbsPath, Version);
- {error, _} ->
- error_terminate(400, State)
- end
+ parse_request(Rest, State, ReqEmpty + 1);
+ {_, _} ->
+ parse_method(Buffer, State, <<>>)
end.
--spec request(binary(), #state{}, binary(), binary(), cowboy_http:version())
- -> ok.
-request(_, State, _, _, Version)
- when Version =/= {1, 0}, Version =/= {1, 1} ->
- error_terminate(505, State);
-request(Buffer, State=#state{socket=Socket, transport=Transport,
- onresponse=OnResponse, urldecode=URLDec},
- Method, <<"*">>, Version) ->
- Connection = version_to_connection(State, Version),
- parse_header(Buffer, State#state{path_tokens= '*'},
- cowboy_req:new(Socket, Transport, Connection, Method, Version,
- <<"*">>, <<>>, OnResponse, URLDec));
-request(Buffer, State=#state{socket=Socket, transport=Transport,
- onresponse=OnResponse, urldecode=URLDec={URLDecFun, URLDecArg}},
- Method, AbsPath, Version) ->
- Connection = version_to_connection(State, Version),
- {PathTokens, Path, Qs} = cowboy_dispatcher:split_path(AbsPath,
- fun(Bin) -> URLDecFun(Bin, URLDecArg) end),
- parse_header(Buffer, State#state{path_tokens=PathTokens},
- cowboy_req:new(Socket, Transport, Connection, Method, Version,
- Path, Qs, OnResponse, URLDec)).
-
--spec parse_header(binary(), #state{}, cowboy_req:req()) -> ok.
-parse_header(<< "\r\n", Rest/binary >>, State, Req) ->
- header_end(Rest, State, Req);
-parse_header(Buffer, State=#state{max_header_name_length=MaxLength}, Req) ->
+parse_method(<< C, Rest/bits >>, State, SoFar) ->
+ case C of
+ $\r -> error_terminate(400, State);
+ $\s -> parse_uri(Rest, State, SoFar);
+ _ -> parse_method(Rest, State, << SoFar/binary, C >>)
+ end.
+
+parse_uri(<< $\r, _/bits >>, State, _) ->
+ error_terminate(400, State);
+parse_uri(<< "* ", Rest/bits >>, State, Method) ->
+ parse_version(Rest, State, Method, <<"*">>, <<>>, <<>>);
+parse_uri(<< "http://", Rest/bits >>, State, Method) ->
+ parse_uri_skip_host(Rest, State, Method);
+parse_uri(<< "https://", Rest/bits >>, State, Method) ->
+ parse_uri_skip_host(Rest, State, Method);
+parse_uri(Buffer, State, Method) ->
+ parse_uri_path(Buffer, State, Method, <<>>).
+
+parse_uri_skip_host(<< C, Rest/bits >>, State, Method) ->
+ case C of
+ $\r -> error_terminate(400, State);
+ $/ -> parse_uri_path(Rest, State, Method, <<"/">>);
+ _ -> parse_uri_skip_host(Rest, State, Method)
+ end.
+
+parse_uri_path(<< C, Rest/bits >>, State, Method, SoFar) ->
+ case C of
+ $\r -> error_terminate(400, State);
+ $\s -> parse_version(Rest, State, Method, SoFar, <<>>, <<>>);
+ $? -> parse_uri_query(Rest, State, Method, SoFar, <<>>);
+ $# -> parse_uri_fragment(Rest, State, Method, SoFar, <<>>, <<>>);
+ _ -> parse_uri_path(Rest, State, Method, << SoFar/binary, C >>)
+ end.
+
+parse_uri_query(<< C, Rest/bits >>, S, M, P, SoFar) ->
+ case C of
+ $\r -> error_terminate(400, S);
+ $\s -> parse_version(Rest, S, M, P, SoFar, <<>>);
+ $# -> parse_uri_fragment(Rest, S, M, P, SoFar, <<>>);
+ _ -> parse_uri_query(Rest, S, M, P, << SoFar/binary, C >>)
+ end.
+
+parse_uri_fragment(<< C, Rest/bits >>, S, M, P, Q, SoFar) ->
+ case C of
+ $\r -> error_terminate(400, S);
+ $\s -> parse_version(Rest, S, M, P, Q, SoFar);
+ _ -> parse_uri_fragment(Rest, S, M, P, Q, << SoFar/binary, C >>)
+ end.
+
+parse_version(<< "HTTP/1.1\r\n", Rest/bits >>, S, M, P, Q, F) ->
+ parse_header(Rest, S, M, P, Q, F, {1, 1}, []);
+parse_version(<< "HTTP/1.0\r\n", Rest/bits >>, S, M, P, Q, F) ->
+ parse_header(Rest, S, M, P, Q, F, {1, 0}, []);
+parse_version(_, State, _, _, _, _) ->
+ error_terminate(505, State).
+
+wait_header(Buffer, State=#state{socket=Socket, transport=Transport,
+ timeout=Timeout}, M, P, Q, F, V, H) ->
+ case Transport:recv(Socket, 0, Timeout) of
+ {ok, Data} ->
+ parse_header(<< Buffer/binary, Data/binary >>,
+ State, M, P, Q, F, V, H);
+ {error, timeout} ->
+ error_terminate(408, State);
+ {error, _} ->
+ terminate(State)
+ end.
+
+parse_header(<< $\r, $\n, Rest/bits >>, S, M, P, Q, F, V, Headers) ->
+ request(Rest, S, M, P, Q, F, V, lists:reverse(Headers));
+parse_header(Buffer, State=#state{max_header_name_length=MaxLength},
+ M, P, Q, F, V, H) ->
case binary:match(Buffer, <<":">>) of
nomatch when byte_size(Buffer) > MaxLength ->
error_terminate(413, State);
nomatch ->
- wait_header(Buffer, State, Req, fun parse_header/3);
- {Pos, _} ->
- << Name:Pos/binary, _:8, Rest/binary >> = Buffer,
- Name2 = cowboy_bstr:to_lower(Name),
- Rest2 = cowboy_http:whitespace(Rest, fun(D) -> D end),
- parse_header_value(Rest2, State, Req, Name2, <<>>)
+ wait_header(Buffer, State, M, P, Q, F, V, H);
+ {_, _} ->
+ parse_hd_name(Buffer, State, M, P, Q, F, V, H, <<>>)
+ end.
+
+%% I know, this isn't exactly pretty. But this is the most critical
+%% code path and as such needs to be optimized to death.
+%%
+%% ... Sorry for your eyes.
+%%
+%% But let's be honest, that's still pretty readable.
+parse_hd_name(<< C, Rest/bits >>, S, M, P, Q, F, V, H, SoFar) ->
+ case C of
+ $: -> parse_hd_before_value(Rest, S, M, P, Q, F, V, H, SoFar);
+ $\s -> parse_hd_name_ws(Rest, S, M, P, Q, F, V, H, SoFar);
+ $\t -> parse_hd_name_ws(Rest, S, M, P, Q, F, V, H, SoFar);
+ $A -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $a >>);
+ $B -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $b >>);
+ $C -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $c >>);
+ $D -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $d >>);
+ $E -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $e >>);
+ $F -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $f >>);
+ $G -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $g >>);
+ $H -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $h >>);
+ $I -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $i >>);
+ $J -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $j >>);
+ $K -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $k >>);
+ $L -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $l >>);
+ $M -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $m >>);
+ $N -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $n >>);
+ $O -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $o >>);
+ $P -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $p >>);
+ $Q -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $q >>);
+ $R -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $r >>);
+ $S -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $s >>);
+ $T -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $t >>);
+ $U -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $u >>);
+ $V -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $v >>);
+ $W -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $w >>);
+ $X -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $x >>);
+ $Y -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $y >>);
+ $Z -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $z >>);
+ C -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, C >>)
+ end.
+
+parse_hd_name_ws(<< C, Rest/bits >>, S, M, P, Q, F, V, H, Name) ->
+ case C of
+ $\s -> parse_hd_name_ws(Rest, S, M, P, Q, F, V, H, Name);
+ $\t -> parse_hd_name_ws(Rest, S, M, P, Q, F, V, H, Name);
+ $: -> parse_hd_before_value(Rest, S, M, P, Q, F, V, H, Name)
+ end.
+
+wait_hd_before_value(Buffer, State=#state{
+ socket=Socket, transport=Transport, timeout=Timeout},
+ M, P, Q, F, V, H, N) ->
+ case Transport:recv(Socket, 0, Timeout) of
+ {ok, Data} ->
+ parse_hd_before_value(<< Buffer/binary, Data/binary >>,
+ State, M, P, Q, F, V, H, N);
+ {error, timeout} ->
+ error_terminate(408, State);
+ {error, _} ->
+ terminate(State)
end.
-parse_header_value(Buffer, State=#state{max_header_value_length=MaxLength},
- Req, Name, SoFar) ->
- case binary:match(Buffer, <<"\r\n">>) of
- nomatch when byte_size(Buffer) + byte_size(SoFar) > MaxLength ->
+parse_hd_before_value(<< $\s, Rest/bits >>, S, M, P, Q, F, V, H, N) ->
+ parse_hd_before_value(Rest, S, M, P, Q, F, V, H, N);
+parse_hd_before_value(<< $\t, Rest/bits >>, S, M, P, Q, F, V, H, N) ->
+ parse_hd_before_value(Rest, S, M, P, Q, F, V, H, N);
+parse_hd_before_value(Buffer, State=#state{
+ max_header_value_length=MaxLength}, M, P, Q, F, V, H, N) ->
+ case binary:match(Buffer, <<"\n">>) of
+ nomatch when byte_size(Buffer) > MaxLength ->
error_terminate(413, State);
nomatch ->
- wait_header(Buffer, State, Req,
- fun(B, S, R) -> parse_header_value(B, S, R, Name, SoFar) end);
- {Pos, _} when Pos + 2 =:= byte_size(Buffer) ->
- wait_header(Buffer, State, Req,
- fun(B, S, R) -> parse_header_value(B, S, R, Name, SoFar) end);
- {Pos, _} ->
- << Value:Pos/binary, _:16, Rest/binary >> = Buffer,
- case binary:at(Buffer, Pos + 2) of
- C when C =:= $\s; C =:= $\t ->
- parse_header_value(Rest, State, Req, Name,
- << SoFar/binary, Value/binary >>);
- _ ->
- header(Rest, State, Req, Name,
- << SoFar/binary, Value/binary >>)
- end
+ wait_hd_before_value(Buffer, State, M, P, Q, F, V, H, N);
+ {_, _} ->
+ parse_hd_value(Buffer, State, M, P, Q, F, V, H, N, <<>>)
end.
--spec wait_header(binary(), #state{}, cowboy_req:req(), fun()) -> ok.
-wait_header(Buffer, State=#state{socket=Socket, transport=Transport,
- timeout=T}, Req, Fun) ->
- case Transport:recv(Socket, 0, T) of
- {ok, Data} -> Fun(<< Buffer/binary, Data/binary >>, State, Req);
- {error, timeout} -> error_terminate(408, State);
- {error, closed} -> terminate(State)
+%% We completely ignore the first argument which is always
+%% the empty binary. We keep it there because we don't want
+%% to change the other arguments' position and trigger costy
+%% operations for no reasons.
+wait_hd_value(_, State=#state{
+ socket=Socket, transport=Transport, timeout=Timeout},
+ M, P, Q, F, V, H, N, SoFar) ->
+ case Transport:recv(Socket, 0, Timeout) of
+ {ok, Data} ->
+ parse_hd_value(Data, State, M, P, Q, F, V, H, N, SoFar);
+ {error, timeout} ->
+ error_terminate(408, State);
+ {error, _} ->
+ terminate(State)
end.
--spec header(binary(), #state{}, cowboy_req:req(), binary(), binary()) -> ok.
-header(Buffer, State=#state{host_tokens=undefined, transport=Transport},
- Req, <<"host">>, RawHost) ->
- RawHost2 = cowboy_bstr:to_lower(RawHost),
- case catch cowboy_dispatcher:split_host(RawHost2) of
- {HostTokens, Host, undefined} ->
- Port = default_port(Transport:name()),
- parse_header(Buffer, State#state{host_tokens=HostTokens},
- cowboy_req:set_host(Host, Port, RawHost, Req));
- {HostTokens, Host, Port} ->
- parse_header(Buffer, State#state{host_tokens=HostTokens},
- cowboy_req:set_host(Host, Port, RawHost, Req));
- {'EXIT', _Reason} ->
- error_terminate(400, State)
+%% Pushing back as much as we could the retrieval of new data
+%% to check for multilines allows us to avoid a few tests in
+%% the critical path, but forces us to have a special function.
+wait_hd_value_nl(_, State=#state{
+ socket=Socket, transport=Transport, timeout=Timeout},
+ M, P, Q, F, V, Headers, Name, SoFar) ->
+ case Transport:recv(Socket, 0, Timeout) of
+ {ok, << C, Data/bits >>} when C =:= $\s; C =:= $\t ->
+ parse_hd_value(Data, State, M, P, Q, F, V, Headers, Name, SoFar);
+ {ok, Data} ->
+ parse_header(Data, State, M, P, Q, F, V, [{Name, SoFar}|Headers]);
+ {error, timeout} ->
+ error_terminate(408, State);
+ {error, _} ->
+ terminate(State)
+ end.
+
+parse_hd_value(<< $\r, Rest/bits >>, S, M, P, Q, F, V, Headers, Name, SoFar) ->
+ case Rest of
+ << $\n >> ->
+ wait_hd_value_nl(<<>>, S, M, P, Q, F, V, Headers, Name, SoFar);
+ << $\n, C, Rest2/bits >> when C =:= $\s; C =:= $\t ->
+ parse_hd_value(Rest2, S, M, P, Q, F, V, Headers, Name, SoFar);
+ << $\n, Rest2/bits >> ->
+ parse_header(Rest2, S, M, P, Q, F, V, [{Name, SoFar}|Headers])
end;
-%% Ignore Host headers if we already have it.
-header(Buffer, State, Req, <<"host">>, _) ->
- parse_header(Buffer, State, Req);
-header(Buffer, State=#state{req_keepalive=Keepalive,
- max_keepalive=MaxKeepalive}, Req, <<"connection">>, Connection)
- when Keepalive < MaxKeepalive ->
- parse_header(Buffer, State, cowboy_req:set_connection(Connection, Req));
-header(Buffer, State, Req, Name, Value) ->
- parse_header(Buffer, State, cowboy_req:add_header(Name, Value, Req)).
-
-%% The Host header is required in HTTP/1.1 and optional in HTTP/1.0.
-header_end(Buffer, State=#state{host_tokens=undefined, transport=Transport},
- Req) ->
- case cowboy_req:version(Req) of
- {{1, 1}, _} ->
+parse_hd_value(<< C, Rest/bits >>, S, M, P, Q, F, V, H, N, SoFar) ->
+ parse_hd_value(Rest, S, M, P, Q, F, V, H, N, << SoFar/binary, C >>);
+parse_hd_value(<<>>, State=#state{max_header_value_length=MaxLength},
+ _, _, _, _, _, _, _, SoFar) when byte_size(SoFar) > MaxLength ->
+ error_terminate(413, State);
+parse_hd_value(<<>>, S, M, P, Q, F, V, H, N, SoFar) ->
+ wait_hd_value(<<>>, S, M, P, Q, F, V, H, N, SoFar).
+
+request(B, State=#state{transport=Transport}, M, P, Q, F, Version, Headers) ->
+ case lists:keyfind(<<"host">>, 1, Headers) of
+ false when Version =:= {1, 1} ->
error_terminate(400, State);
- {{1, 0}, Req2} ->
- Port = default_port(Transport:name()),
- onrequest(
- cowboy_req:set_buffer(Buffer,
- cowboy_req:set_host(<<>>, Port, <<>>, Req2)),
- State)
- end;
-header_end(Buffer, State, Req) ->
- onrequest(cowboy_req:set_buffer(Buffer, Req), State).
+ false ->
+ request(B, State, M, P, Q, F, Version, Headers,
+ <<>>, default_port(Transport:name()));
+ {_, RawHost} ->
+ case parse_host(RawHost, <<>>) of
+ {Host, undefined} ->
+ request(B, State, M, P, Q, F, Version, Headers,
+ Host, default_port(Transport:name()));
+ {Host, Port} ->
+ request(B, State, M, P, Q, F, Version, Headers,
+ Host, Port)
+ end
+ end.
+
+-spec default_port(atom()) -> 80 | 443.
+default_port(ssl) -> 443;
+default_port(_) -> 80.
+
+%% Another hurtful block of code. :)
+parse_host(<<>>, Acc) ->
+ {Acc, undefined};
+parse_host(<< $:, Rest/bits >>, Acc) ->
+ {Acc, list_to_integer(binary_to_list(Rest))};
+parse_host(<< C, Rest/bits >>, Acc) ->
+ case C of
+ $A -> parse_host(Rest, << Acc/binary, $a >>);
+ $B -> parse_host(Rest, << Acc/binary, $b >>);
+ $C -> parse_host(Rest, << Acc/binary, $c >>);
+ $D -> parse_host(Rest, << Acc/binary, $d >>);
+ $E -> parse_host(Rest, << Acc/binary, $e >>);
+ $F -> parse_host(Rest, << Acc/binary, $f >>);
+ $G -> parse_host(Rest, << Acc/binary, $g >>);
+ $H -> parse_host(Rest, << Acc/binary, $h >>);
+ $I -> parse_host(Rest, << Acc/binary, $i >>);
+ $J -> parse_host(Rest, << Acc/binary, $j >>);
+ $K -> parse_host(Rest, << Acc/binary, $k >>);
+ $L -> parse_host(Rest, << Acc/binary, $l >>);
+ $M -> parse_host(Rest, << Acc/binary, $m >>);
+ $N -> parse_host(Rest, << Acc/binary, $n >>);
+ $O -> parse_host(Rest, << Acc/binary, $o >>);
+ $P -> parse_host(Rest, << Acc/binary, $p >>);
+ $Q -> parse_host(Rest, << Acc/binary, $q >>);
+ $R -> parse_host(Rest, << Acc/binary, $r >>);
+ $S -> parse_host(Rest, << Acc/binary, $s >>);
+ $T -> parse_host(Rest, << Acc/binary, $t >>);
+ $U -> parse_host(Rest, << Acc/binary, $u >>);
+ $V -> parse_host(Rest, << Acc/binary, $v >>);
+ $W -> parse_host(Rest, << Acc/binary, $w >>);
+ $X -> parse_host(Rest, << Acc/binary, $x >>);
+ $Y -> parse_host(Rest, << Acc/binary, $y >>);
+ $Z -> parse_host(Rest, << Acc/binary, $z >>);
+ _ -> parse_host(Rest, << Acc/binary, C >>)
+ end.
+
+%% End of request parsing.
+%%
+%% We create the Req object and start handling the request.
+
+request(Buffer, State=#state{socket=Socket, transport=Transport,
+ req_keepalive=ReqKeepalive, max_keepalive=MaxKeepalive,
+ onresponse=OnResponse, urldecode=URLDecode},
+ Method, Path, Query, Fragment, Version, Headers, Host, Port) ->
+ Req = cowboy_req:new(Socket, Transport, Method, Path, Query, Fragment,
+ Version, Headers, Host, Port, Buffer, ReqKeepalive < MaxKeepalive,
+ OnResponse, URLDecode),
+ onrequest(Req, State, Host, Path).
%% 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(cowboy_req:req(), #state{}) -> ok.
-onrequest(Req, State=#state{onrequest=undefined}) ->
- dispatch(Req, State);
-onrequest(Req, State=#state{onrequest=OnRequest}) ->
+-spec onrequest(cowboy_req:req(), #state{}, binary(), binary()) -> ok.
+onrequest(Req, State=#state{onrequest=undefined}, Host, Path) ->
+ dispatch(Req, State, Host, Path);
+onrequest(Req, State=#state{onrequest=OnRequest}, Host, Path) ->
Req2 = OnRequest(Req),
case cowboy_req:get_resp_state(Req2) of
- waiting -> dispatch(Req2, State);
+ waiting -> dispatch(Req2, State, Host, Path);
_ -> next_request(Req2, State, ok)
end.
--spec dispatch(cowboy_req:req(), #state{}) -> ok.
-dispatch(Req, State=#state{dispatch=Dispatch,
- host_tokens=HostTokens, path_tokens=PathTokens}) ->
- case cowboy_dispatcher:match(HostTokens, PathTokens, Dispatch) of
+-spec dispatch(cowboy_req:req(), #state{}, binary(), binary()) -> ok.
+dispatch(Req, State=#state{dispatch=Dispatch, urldecode={URLDecFun, URLDecArg}},
+ Host, Path) ->
+ case cowboy_dispatcher:match(Dispatch,
+ fun(Bin) -> URLDecFun(Bin, URLDecArg) end, Host, Path) of
{ok, Handler, Opts, Bindings, HostInfo, PathInfo} ->
Req2 = cowboy_req:set_bindings(HostInfo, PathInfo, Bindings, Req),
- handler_init(Req2, State#state{handler={Handler, Opts},
- host_tokens=undefined, path_tokens=undefined});
+ handler_init(Req2, State, Handler, Opts);
{error, notfound, host} ->
error_terminate(400, State);
{error, notfound, path} ->
error_terminate(404, State)
end.
--spec handler_init(cowboy_req:req(), #state{}) -> ok.
-handler_init(Req, State=#state{transport=Transport,
- handler={Handler, Opts}}) ->
+-spec handler_init(cowboy_req:req(), #state{}, module(), any()) -> ok.
+handler_init(Req, State=#state{transport=Transport}, Handler, Opts) ->
try Handler:init({Transport:name(), http}, Req, Opts) of
{ok, Req2, HandlerState} ->
- handler_handle(HandlerState, Req2, State);
+ handler_handle(Req2, State, Handler, HandlerState);
{loop, Req2, HandlerState} ->
- handler_before_loop(HandlerState, Req2, State);
+ handler_before_loop(Req2, State#state{hibernate=false},
+ Handler, HandlerState);
{loop, Req2, HandlerState, hibernate} ->
- handler_before_loop(HandlerState, Req2,
- State#state{hibernate=true});
+ handler_before_loop(Req2, State#state{hibernate=true},
+ Handler, HandlerState);
{loop, Req2, HandlerState, Timeout} ->
- handler_before_loop(HandlerState, Req2,
- State#state{loop_timeout=Timeout});
+ handler_before_loop(Req2, State#state{loop_timeout=Timeout},
+ Handler, HandlerState);
{loop, Req2, HandlerState, Timeout, hibernate} ->
- handler_before_loop(HandlerState, Req2,
- State#state{hibernate=true, loop_timeout=Timeout});
+ handler_before_loop(Req2, State#state{
+ hibernate=true, loop_timeout=Timeout}, Handler, HandlerState);
{shutdown, Req2, HandlerState} ->
- handler_terminate(HandlerState, Req2, State);
+ handler_terminate(Req2, Handler, HandlerState);
%% @todo {upgrade, transport, Module}
{upgrade, protocol, Module} ->
- upgrade_protocol(Req, State, Module)
+ upgrade_protocol(Req, State, Handler, Opts, Module)
catch Class:Reason ->
error_terminate(500, State),
- PLReq = cowboy_req: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()])
+ "** Request was ~p~n"
+ "** Stacktrace: ~p~n~n",
+ [Handler, Class, Reason, Opts,
+ cowboy_req:to_list(Req), erlang:get_stacktrace()])
end.
--spec upgrade_protocol(cowboy_req:req(), #state{}, atom()) -> ok.
-upgrade_protocol(Req, State=#state{listener=ListenerPid,
- handler={Handler, Opts}}, Module) ->
+-spec upgrade_protocol(cowboy_req:req(), #state{}, module(), any(), module())
+ -> ok.
+upgrade_protocol(Req, State=#state{listener=ListenerPid},
+ 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(), cowboy_req:req(), #state{}) -> ok.
-handler_handle(HandlerState, Req, State=#state{handler={Handler, Opts}}) ->
+-spec handler_handle(cowboy_req:req(), #state{}, module(), any()) -> ok.
+handler_handle(Req, State, Handler, HandlerState) ->
try Handler:handle(Req, HandlerState) of
{ok, Req2, HandlerState2} ->
- terminate_request(HandlerState2, Req2, State)
+ terminate_request(Req2, State, Handler, HandlerState2)
catch Class:Reason ->
- PLReq = cowboy_req: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),
+ "** Handler state was ~p~n"
+ "** Request was ~p~n"
+ "** Stacktrace: ~p~n~n",
+ [Handler, Class, Reason, HandlerState,
+ cowboy_req:to_list(Req), erlang:get_stacktrace()]),
+ handler_terminate(Req, Handler, HandlerState),
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(), cowboy_req:req(), #state{}) -> ok.
-handler_before_loop(HandlerState, Req, State=#state{hibernate=true}) ->
+-spec handler_before_loop(cowboy_req:req(), #state{}, module(), any()) -> ok.
+handler_before_loop(Req, State=#state{hibernate=true}, Handler, HandlerState) ->
State2 = handler_loop_timeout(State),
catch erlang:hibernate(?MODULE, handler_loop,
- [HandlerState, Req, State2#state{hibernate=false}]),
+ [Req, State2#state{hibernate=false}, Handler, HandlerState]),
ok;
-handler_before_loop(HandlerState, Req, State) ->
+handler_before_loop(Req, State, Handler, HandlerState) ->
State2 = handler_loop_timeout(State),
- handler_loop(HandlerState, Req, State2).
+ handler_loop(Req, State2, Handler, HandlerState).
%% Almost the same code can be found in cowboy_websocket.
-spec handler_loop_timeout(#state{}) -> #state{}.
@@ -373,59 +540,58 @@ handler_loop_timeout(State=#state{loop_timeout=Timeout,
TRef = erlang:start_timer(Timeout, self(), ?MODULE),
State#state{loop_timeout_ref=TRef}.
--spec handler_loop(any(), cowboy_req:req(), #state{}) -> ok.
-handler_loop(HandlerState, Req, State=#state{loop_timeout_ref=TRef}) ->
+-spec handler_loop(cowboy_req:req(), #state{}, module(), any()) -> ok.
+handler_loop(Req, State=#state{loop_timeout_ref=TRef}, Handler, HandlerState) ->
receive
{timeout, TRef, ?MODULE} ->
- terminate_request(HandlerState, Req, State);
+ terminate_request(Req, State, Handler, HandlerState);
{timeout, OlderTRef, ?MODULE} when is_reference(OlderTRef) ->
- handler_loop(HandlerState, Req, State);
+ handler_loop(Req, State, Handler, HandlerState);
Message ->
- handler_call(HandlerState, Req, State, Message)
+ handler_call(Req, State, Handler, HandlerState, Message)
end.
--spec handler_call(any(), cowboy_req:req(), #state{}, any()) -> ok.
-handler_call(HandlerState, Req, State=#state{handler={Handler, Opts}},
- Message) ->
+-spec handler_call(cowboy_req:req(), #state{}, module(), any(), any()) -> ok.
+handler_call(Req, State, Handler, HandlerState, Message) ->
try Handler:info(Message, Req, HandlerState) of
{ok, Req2, HandlerState2} ->
- terminate_request(HandlerState2, Req2, State);
+ terminate_request(Req2, State, Handler, HandlerState2);
{loop, Req2, HandlerState2} ->
- handler_before_loop(HandlerState2, Req2, State);
+ handler_before_loop(Req2, State, Handler, HandlerState2);
{loop, Req2, HandlerState2, hibernate} ->
- handler_before_loop(HandlerState2, Req2,
- State#state{hibernate=true})
+ handler_before_loop(Req2, State#state{hibernate=true},
+ Handler, HandlerState2)
catch Class:Reason ->
- PLReq = cowboy_req: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),
+ "** Handler state was ~p~n"
+ "** Request was ~p~n"
+ "** Stacktrace: ~p~n~n",
+ [Handler, Class, Reason, HandlerState,
+ cowboy_req:to_list(Req), erlang:get_stacktrace()]),
+ handler_terminate(Req, Handler, HandlerState),
error_terminate(500, State)
end.
--spec handler_terminate(any(), cowboy_req:req(), #state{}) -> ok.
-handler_terminate(HandlerState, Req, #state{handler={Handler, Opts}}) ->
+-spec handler_terminate(cowboy_req:req(), module(), any()) -> ok.
+handler_terminate(Req, Handler, HandlerState) ->
try
Handler:terminate(cowboy_req:lock(Req), HandlerState)
catch Class:Reason ->
- PLReq = cowboy_req: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()])
+ "** Handler state was ~p~n"
+ "** Request was ~p~n"
+ "** Stacktrace: ~p~n~n",
+ [Handler, Class, Reason, HandlerState,
+ cowboy_req:to_list(Req), erlang:get_stacktrace()])
end.
--spec terminate_request(any(), cowboy_req:req(), #state{}) -> ok.
-terminate_request(HandlerState, Req, State) ->
- HandlerRes = handler_terminate(HandlerState, Req, State),
+-spec terminate_request(cowboy_req:req(), #state{}, module(), any()) -> ok.
+terminate_request(Req, State, Handler, HandlerState) ->
+ HandlerRes = handler_terminate(Req, Handler, HandlerState),
next_request(Req, State, HandlerRes).
-spec next_request(cowboy_req:req(), #state{}, any()) -> ok.
@@ -439,8 +605,8 @@ next_request(Req, State=#state{req_keepalive=Keepalive}, HandlerRes) ->
receive {cowboy_req, resp_sent} -> ok after 0 -> ok end,
case {HandlerRes, BodyRes, cowboy_req:get_connection(Req)} of
{ok, ok, keepalive} ->
- ?MODULE:parse_request(Buffer, State#state{handler=undefined,
- req_empty_lines=0, req_keepalive=Keepalive + 1});
+ ?MODULE:parse_request(Buffer, State#state{
+ req_keepalive=Keepalive + 1}, 0);
_Closed ->
terminate(State)
end.
@@ -453,7 +619,8 @@ error_terminate(Code, State=#state{socket=Socket, transport=Transport,
{cowboy_req, resp_sent} -> ok
after 0 ->
_ = cowboy_req:reply(Code, cowboy_req:new(Socket, Transport,
- close, <<"GET">>, {1, 1}, <<>>, <<>>, OnResponse, undefined)),
+ <<"GET">>, <<>>, <<>>, <<>>, {1, 1}, [], <<>>, undefined,
+ <<>>, false, OnResponse, undefined)),
ok
end,
terminate(State).
@@ -462,19 +629,3 @@ error_terminate(Code, State=#state{socket=Socket, transport=Transport,
terminate(#state{socket=Socket, transport=Transport}) ->
Transport:close(Socket),
ok.
-
-%% Internal.
-
--spec version_to_connection(#state{}, cowboy_http:version())
- -> keepalive | close.
-version_to_connection(#state{req_keepalive=Keepalive,
- max_keepalive=MaxKeepalive}, _) when Keepalive >= MaxKeepalive ->
- close;
-version_to_connection(_, {1, 1}) ->
- keepalive;
-version_to_connection(_, _) ->
- close.
-
--spec default_port(atom()) -> 80 | 443.
-default_port(ssl) -> 443;
-default_port(_) -> 80.
diff --git a/src/cowboy_req.erl b/src/cowboy_req.erl
index 9cc7760..10c5e96 100644
--- a/src/cowboy_req.erl
+++ b/src/cowboy_req.erl
@@ -42,7 +42,7 @@
-module(cowboy_req).
%% Request API.
--export([new/9]).
+-export([new/14]).
-export([method/1]).
-export([version/1]).
-export([peer/1]).
@@ -103,10 +103,6 @@
-export([ensure_response/2]).
%% Private setter/getter API.
--export([set_host/4]).
--export([set_connection/2]).
--export([add_header/3]).
--export([set_buffer/2]).
-export([set_bindings/4]).
-export([get_resp_state/1]).
-export([get_buffer/1]).
@@ -172,15 +168,36 @@
%%
%% This function takes care of setting the owner's pid to self().
%% @private
--spec new(inet:socket(), module(), keepalive | close,
- binary(), cowboy_http:version(), binary(), binary(),
- undefined | fun(), undefined | {fun(), atom()})
+%% @todo Fragment.
+-spec new(inet:socket(), module(), binary(), binary(), binary(), binary(),
+ cowboy_http:version(), cowboy_http:headers(), binary(),
+ inet:port_number() | undefined, binary(), boolean(),
+ undefined | cowboy_protocol:onresponse_fun(),
+ undefined | {fun(), atom()})
-> req().
-new(Socket, Transport, Connection, Method, Version, Path, Qs,
+new(Socket, Transport, Method, Path, Query, _Fragment,
+ Version, Headers, Host, Port, Buffer, CanKeepalive,
OnResponse, URLDecode) ->
- #http_req{socket=Socket, transport=Transport, connection=Connection,
- pid=self(), method=Method, version=Version, path=Path, qs=Qs,
- onresponse=OnResponse, urldecode=URLDecode}.
+ Req = #http_req{socket=Socket, transport=Transport, pid=self(),
+ method=Method, path=Path, qs=Query, version=Version,
+ headers=Headers, host=Host, port=Port, buffer=Buffer,
+ onresponse=OnResponse, urldecode=URLDecode},
+ case CanKeepalive of
+ false ->
+ Req#http_req{connection=close};
+ true ->
+ case lists:keymember(<<"connection">>, 1, Headers) of
+ false when Version =:= {1, 1} ->
+ Req; %% keepalive
+ false ->
+ Req#http_req{connection=close};
+ true ->
+ {ok, Tokens, Req2} = parse_header(<<"connection">>, Req),
+ %% @todo Might want to bring this function into cowboy_req.
+ Connection = cowboy_http:connection_to_atom(Tokens),
+ Req2#http_req{connection=Connection}
+ end
+ end.
%% @doc Return the HTTP method of the request.
-spec method(Req) -> {binary(), Req} when Req::req().
@@ -968,31 +985,6 @@ ensure_response(#http_req{socket=Socket, transport=Transport,
%% Private setter/getter API.
%% @private
--spec set_host(binary(), inet:port_number(), binary(), Req)
- -> Req when Req::req().
-set_host(Host, Port, RawHost, Req=#http_req{headers=Headers}) ->
- Req#http_req{host=Host, port=Port, headers=[{<<"host">>, RawHost}|Headers]}.
-
-%% @private
--spec set_connection(binary(), Req) -> Req when Req::req().
-set_connection(RawConnection, Req=#http_req{headers=Headers}) ->
- Req2 = Req#http_req{headers=[{<<"connection">>, RawConnection}|Headers]},
- {ok, ConnTokens, Req3} = parse_header(<<"connection">>, Req2),
- ConnAtom = cowboy_http:connection_to_atom(ConnTokens),
- Req3#http_req{connection=ConnAtom}.
-
-%% @private
--spec add_header(binary(), binary(), Req)
- -> Req when Req::req().
-add_header(Name, Value, Req=#http_req{headers=Headers}) ->
- Req#http_req{headers=[{Name, Value}|Headers]}.
-
-%% @private
--spec set_buffer(binary(), Req) -> Req when Req::req().
-set_buffer(Buffer, Req) ->
- Req#http_req{buffer=Buffer}.
-
-%% @private
-spec set_bindings(cowboy_dispatcher:tokens(), cowboy_dispatcher:tokens(),
cowboy_dispatcher:bindings(), Req) -> Req when Req::req().
set_bindings(HostInfo, PathInfo, Bindings, Req) ->