|
|
@@ -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.
|
Loïc Hoguin