aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/cowboy.erl4
-rw-r--r--src/cowboy_req.erl25
-rw-r--r--src/cowboy_spdy.erl488
-rw-r--r--src/cowboy_tls.erl3
4 files changed, 2 insertions, 518 deletions
diff --git a/src/cowboy.erl b/src/cowboy.erl
index 67afd7b..d9c14ea 100644
--- a/src/cowboy.erl
+++ b/src/cowboy.erl
@@ -52,8 +52,8 @@ start_tls(Ref, NbAcceptors, TransOpts0, ProtoOpts)
when is_integer(NbAcceptors), NbAcceptors > 0 ->
TransOpts = [
connection_type(ProtoOpts),
- {next_protocols_advertised, [<<"h2">>, <<"spdy/3">>, <<"http/1.1">>]},
- {alpn_preferred_protocols, [<<"h2">>, <<"spdy/3">>, <<"http/1.1">>]}
+ {next_protocols_advertised, [<<"h2">>, <<"http/1.1">>]},
+ {alpn_preferred_protocols, [<<"h2">>, <<"http/1.1">>]}
|TransOpts0],
ranch:start_listener(Ref, NbAcceptors, ranch_ssl, TransOpts, cowboy_tls, ProtoOpts).
diff --git a/src/cowboy_req.erl b/src/cowboy_req.erl
index 16b1fd1..b01a70c 100644
--- a/src/cowboy_req.erl
+++ b/src/cowboy_req.erl
@@ -769,11 +769,6 @@ response_headers(Headers, Req) ->
% %% We stream the response body until we close the connection.
% RespConn = close,
% {RespType, Req2} = if
-% Transport =:= cowboy_spdy ->
-% response(Status, Headers, RespHeaders, [
-% {<<"date">>, cowboy_clock:rfc1123()},
-% {<<"server">>, <<"Cowboy">>}
-% ], stream, Req);
% true ->
% response(Status, Headers, RespHeaders, [
% {<<"connection">>, <<"close">>},
@@ -896,9 +891,6 @@ chunk(Data, #{pid := Pid, streamid := StreamID}) ->
%% If ever made public, need to send nothing if HEAD.
-spec last_chunk(Req) -> Req when Req::req().
-last_chunk(Req=#http_req{socket=Socket, transport=cowboy_spdy}) ->
- _ = cowboy_spdy:stream_close(Socket),
- Req#http_req{resp_state=done};
last_chunk(Req=#http_req{socket=Socket, transport=Transport}) ->
_ = Transport:send(Socket, <<"0\r\n\r\n">>),
Req#http_req{resp_state=done}.
@@ -1028,15 +1020,6 @@ to_list(Req) ->
%-spec chunked_response(cowboy:http_status(), cowboy:http_headers(), Req) ->
% {normal | hook, Req} when Req::req().
%chunked_response(Status, Headers, Req=#http_req{
-% transport=cowboy_spdy, resp_state=waiting,
-% resp_headers=RespHeaders}) ->
-% {RespType, Req2} = response(Status, Headers, RespHeaders, [
-% {<<"date">>, cowboy_clock:rfc1123()},
-% {<<"server">>, <<"Cowboy">>}
-% ], stream, Req),
-% {RespType, Req2#http_req{resp_state=chunks,
-% resp_headers=[], resp_body= <<>>}};
-%chunked_response(Status, Headers, Req=#http_req{
% version=Version, connection=Connection,
% resp_state=RespState, resp_headers=RespHeaders})
% when RespState =:= waiting; RespState =:= waiting_stream ->
@@ -1094,14 +1077,6 @@ response(Status, Headers, RespHeaders, DefaultHeaders, Body, Req=#http_req{
end
end,
ReplyType = case Req2#http_req.resp_state of
- waiting when Transport =:= cowboy_spdy, Body =:= stream ->
- cowboy_spdy:stream_reply(Socket, status(Status2), FullHeaders2),
- ReqPid ! {?MODULE, resp_sent},
- normal;
- waiting when Transport =:= cowboy_spdy ->
- cowboy_spdy:reply(Socket, status(Status2), FullHeaders2, Body),
- ReqPid ! {?MODULE, resp_sent},
- normal;
RespState when RespState =:= waiting; RespState =:= waiting_stream ->
HTTPVer = atom_to_binary(Version, latin1),
StatusLine = << HTTPVer/binary, " ",
diff --git a/src/cowboy_spdy.erl b/src/cowboy_spdy.erl
deleted file mode 100644
index 2628ab5..0000000
--- a/src/cowboy_spdy.erl
+++ /dev/null
@@ -1,488 +0,0 @@
-%% Copyright (c) 2013-2014, Loïc Hoguin <[email protected]>
-%%
-%% 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.
-
--module(cowboy_spdy).
-
-%% API.
--export([start_link/4]).
-
-%% Internal.
--export([init/5]).
--export([system_continue/3]).
--export([system_terminate/4]).
--export([system_code_change/4]).
-
-%% Internal request process.
--export([request_init/10]).
--export([resume/5]).
--export([reply/4]).
--export([stream_reply/3]).
--export([stream_data/2]).
--export([stream_close/1]).
-
-%% Internal transport functions.
--export([name/0]).
--export([messages/0]).
--export([recv/3]).
--export([send/2]).
--export([sendfile/2]).
--export([setopts/2]).
-
--type streamid() :: non_neg_integer().
--type socket() :: {pid(), streamid()}.
-
--record(child, {
- streamid :: streamid(),
- pid :: pid(),
- input = nofin :: fin | nofin,
- in_buffer = <<>> :: binary(),
- is_recv = false :: false | {active, socket(), pid()}
- | {passive, socket(), pid(), non_neg_integer(), reference()},
- output = nofin :: fin | nofin
-}).
-
--record(state, {
- parent = undefined :: pid(),
- socket :: inet:socket(),
- transport :: module(),
- buffer = <<>> :: binary(),
- middlewares :: [module()],
- env :: cowboy_middleware:env(),
- onresponse :: cowboy:onresponse_fun(),
- peer :: {inet:ip_address(), inet:port_number()},
- zdef :: zlib:zstream(),
- zinf :: zlib:zstream(),
- last_streamid = 0 :: streamid(),
- children = [] :: [#child{}]
-}).
-
--type opts() :: [{env, cowboy_middleware:env()}
- | {middlewares, [module()]}
- | {onresponse, cowboy:onresponse_fun()}].
--export_type([opts/0]).
-
-%% API.
-
--spec start_link(any(), inet:socket(), module(), any()) -> {ok, pid()}.
-start_link(Ref, Socket, Transport, Opts) ->
- proc_lib:start_link(?MODULE, init,
- [self(), Ref, Socket, Transport, Opts]).
-
-%% Internal.
-
-%% Faster alternative to proplists:get_value/3.
-get_value(Key, Opts, Default) ->
- case lists:keyfind(Key, 1, Opts) of
- {_, Value} -> Value;
- _ -> Default
- end.
-
--spec init(pid(), ranch:ref(), inet:socket(), module(), opts()) -> ok.
-init(Parent, Ref, Socket, Transport, Opts) ->
- process_flag(trap_exit, true),
- ok = proc_lib:init_ack(Parent, {ok, self()}),
- {ok, Peer} = Transport:peername(Socket),
- Middlewares = get_value(middlewares, Opts, [cowboy_router, cowboy_handler]),
- Env = [{listener, Ref}|get_value(env, Opts, [])],
- OnResponse = get_value(onresponse, Opts, undefined),
- Zdef = cow_spdy:deflate_init(),
- Zinf = cow_spdy:inflate_init(),
- ok = ranch:accept_ack(Ref),
- loop(#state{parent=Parent, socket=Socket, transport=Transport,
- middlewares=Middlewares, env=Env,
- onresponse=OnResponse, peer=Peer, zdef=Zdef, zinf=Zinf}).
-
-loop(State=#state{parent=Parent, socket=Socket, transport=Transport,
- buffer=Buffer, children=Children}) ->
- {OK, Closed, Error} = Transport:messages(),
- Transport:setopts(Socket, [{active, once}]),
- receive
- {OK, Socket, Data} ->
- parse_frame(State, << Buffer/binary, Data/binary >>);
- {Closed, Socket} ->
- terminate(State);
- {Error, Socket, _Reason} ->
- terminate(State);
- {recv, FromSocket = {Pid, StreamID}, FromPid, Length, Timeout}
- when Pid =:= self() ->
- Child = #child{in_buffer=InBuffer, is_recv=false}
- = get_child(StreamID, State),
- if
- Length =:= 0, InBuffer =/= <<>> ->
- FromPid ! {recv, FromSocket, {ok, InBuffer}},
- loop(replace_child(Child#child{in_buffer= <<>>}, State));
- byte_size(InBuffer) >= Length ->
- << Data:Length/binary, Rest/bits >> = InBuffer,
- FromPid ! {recv, FromSocket, {ok, Data}},
- loop(replace_child(Child#child{in_buffer=Rest}, State));
- true ->
- TRef = erlang:send_after(Timeout, self(),
- {recv_timeout, FromSocket}),
- loop(replace_child(Child#child{
- is_recv={passive, FromSocket, FromPid, Length, TRef}},
- State))
- end;
- {recv_timeout, {Pid, StreamID}}
- when Pid =:= self() ->
- Child = #child{is_recv={passive, FromSocket, FromPid, _, _}}
- = get_child(StreamID, State),
- FromPid ! {recv, FromSocket, {error, timeout}},
- loop(replace_child(Child, State));
- {reply, {Pid, StreamID}, Status, Headers}
- when Pid =:= self() ->
- Child = #child{output=nofin} = get_child(StreamID, State),
- syn_reply(State, StreamID, true, Status, Headers),
- loop(replace_child(Child#child{output=fin}, State));
- {reply, {Pid, StreamID}, Status, Headers, Body}
- when Pid =:= self() ->
- Child = #child{output=nofin} = get_child(StreamID, State),
- syn_reply(State, StreamID, false, Status, Headers),
- data(State, StreamID, true, Body),
- loop(replace_child(Child#child{output=fin}, State));
- {stream_reply, {Pid, StreamID}, Status, Headers}
- when Pid =:= self() ->
- #child{output=nofin} = get_child(StreamID, State),
- syn_reply(State, StreamID, false, Status, Headers),
- loop(State);
- {stream_data, {Pid, StreamID}, Data}
- when Pid =:= self() ->
- #child{output=nofin} = get_child(StreamID, State),
- data(State, StreamID, false, Data),
- loop(State);
- {stream_close, {Pid, StreamID}}
- when Pid =:= self() ->
- Child = #child{output=nofin} = get_child(StreamID, State),
- data(State, StreamID, true, <<>>),
- loop(replace_child(Child#child{output=fin}, State));
- {sendfile, {Pid, StreamID}, Filepath}
- when Pid =:= self() ->
- Child = #child{output=nofin} = get_child(StreamID, State),
- data_from_file(State, StreamID, Filepath),
- loop(replace_child(Child#child{output=fin}, State));
- {active, FromSocket = {Pid, StreamID}, FromPid} when Pid =:= self() ->
- Child = #child{in_buffer=InBuffer, is_recv=false}
- = get_child(StreamID, State),
- case InBuffer of
- <<>> ->
- loop(replace_child(Child#child{
- is_recv={active, FromSocket, FromPid}}, State));
- _ ->
- FromPid ! {spdy, FromSocket, InBuffer},
- loop(replace_child(Child#child{in_buffer= <<>>}, State))
- end;
- {passive, FromSocket = {Pid, StreamID}, FromPid} when Pid =:= self() ->
- Child = #child{is_recv=IsRecv} = get_child(StreamID, State),
- %% Make sure we aren't in the middle of a recv call.
- case IsRecv of false -> ok; {active, FromSocket, FromPid} -> ok end,
- loop(replace_child(Child#child{is_recv=false}, State));
- {'EXIT', Parent, Reason} ->
- exit(Reason);
- {'EXIT', Pid, _} ->
- %% @todo Report the error if any.
- loop(delete_child(Pid, State));
- {system, From, Request} ->
- sys:handle_system_msg(Request, From, Parent, ?MODULE, [], State);
- %% Calls from the supervisor module.
- {'$gen_call', {To, Tag}, which_children} ->
- Workers = [{?MODULE, Pid, worker, [?MODULE]}
- || #child{pid=Pid} <- Children],
- To ! {Tag, Workers},
- loop(State);
- {'$gen_call', {To, Tag}, count_children} ->
- NbChildren = length(Children),
- Counts = [{specs, 1}, {active, NbChildren},
- {supervisors, 0}, {workers, NbChildren}],
- To ! {Tag, Counts},
- loop(State);
- {'$gen_call', {To, Tag}, _} ->
- To ! {Tag, {error, ?MODULE}},
- loop(State)
- after 60000 ->
- goaway(State, ok),
- terminate(State)
- end.
-
--spec system_continue(_, _, #state{}) -> ok.
-system_continue(_, _, State) ->
- loop(State).
-
--spec system_terminate(any(), _, _, _) -> no_return().
-system_terminate(Reason, _, _, _) ->
- exit(Reason).
-
--spec system_code_change(Misc, _, _, _) -> {ok, Misc} when Misc::#state{}.
-system_code_change(Misc, _, _, _) ->
- {ok, Misc}.
-
-parse_frame(State=#state{zinf=Zinf}, Data) ->
- case cow_spdy:split(Data) of
- {true, Frame, Rest} ->
- P = cow_spdy:parse(Frame, Zinf),
- case handle_frame(State#state{buffer = Rest}, P) of
- error ->
- terminate(State);
- State2 ->
- parse_frame(State2, Rest)
- end;
- false ->
- loop(State#state{buffer=Data})
- end.
-
-%% FLAG_UNIDIRECTIONAL can only be set by the server.
-handle_frame(State, {syn_stream, StreamID, _, _, true,
- _, _, _, _, _, _, _}) ->
- rst_stream(State, StreamID, protocol_error),
- State;
-%% We do not support Associated-To-Stream-ID.
-handle_frame(State, {syn_stream, StreamID, AssocToStreamID,
- _, _, _, _, _, _, _, _, _}) when AssocToStreamID =/= 0 ->
- rst_stream(State, StreamID, internal_error),
- State;
-%% SYN_STREAM.
-%%
-%% Erlang does not allow us to control the priority of processes
-%% so we ignore that value entirely.
-handle_frame(State=#state{middlewares=Middlewares, env=Env,
- onresponse=OnResponse, peer=Peer},
- {syn_stream, StreamID, _, IsFin, _, _,
- Method, _, Host, Path, Version, Headers}) ->
- Pid = spawn_link(?MODULE, request_init, [
- {self(), StreamID}, Peer, OnResponse,
- Env, Middlewares, Method, Host, Path, Version, Headers
- ]),
- new_child(State, StreamID, Pid, IsFin);
-%% RST_STREAM.
-handle_frame(State, {rst_stream, StreamID, Status}) ->
- error_logger:error_msg("Received RST_STREAM frame ~p ~p",
- [StreamID, Status]),
- %% @todo Stop StreamID.
- State;
-%% PING initiated by the server; ignore, we don't send any.
-handle_frame(State, {ping, PingID}) when PingID rem 2 =:= 0 ->
- error_logger:error_msg("Ignored PING control frame: ~p~n", [PingID]),
- State;
-%% PING initiated by the client; send it back.
-handle_frame(State=#state{socket=Socket, transport=Transport},
- {ping, PingID}) ->
- Transport:send(Socket, cow_spdy:ping(PingID)),
- State;
-%% Data received for a stream.
-handle_frame(State, {data, StreamID, IsFin, Data}) ->
- Child = #child{input=nofin, in_buffer=Buffer, is_recv=IsRecv}
- = get_child(StreamID, State),
- Data2 = << Buffer/binary, Data/binary >>,
- IsFin2 = if IsFin -> fin; true -> nofin end,
- Child2 = case IsRecv of
- {active, FromSocket, FromPid} ->
- FromPid ! {spdy, FromSocket, Data},
- Child#child{input=IsFin2, is_recv=false};
- {passive, FromSocket, FromPid, 0, TRef} ->
- FromPid ! {recv, FromSocket, {ok, Data2}},
- cancel_recv_timeout(StreamID, TRef),
- Child#child{input=IsFin2, in_buffer= <<>>, is_recv=false};
- {passive, FromSocket, FromPid, Length, TRef}
- when byte_size(Data2) >= Length ->
- << Data3:Length/binary, Rest/bits >> = Data2,
- FromPid ! {recv, FromSocket, {ok, Data3}},
- cancel_recv_timeout(StreamID, TRef),
- Child#child{input=IsFin2, in_buffer=Rest, is_recv=false};
- _ ->
- Child#child{input=IsFin2, in_buffer=Data2}
- end,
- replace_child(Child2, State);
-%% General error, can't recover.
-handle_frame(State, {error, badprotocol}) ->
- goaway(State, protocol_error),
- error;
-%% Ignore all other frames for now.
-handle_frame(State, Frame) ->
- error_logger:error_msg("Ignored frame ~p", [Frame]),
- State.
-
-cancel_recv_timeout(StreamID, TRef) ->
- _ = erlang:cancel_timer(TRef),
- receive
- {recv_timeout, {Pid, StreamID}}
- when Pid =:= self() ->
- ok
- after 0 ->
- ok
- end.
-
-%% @todo We must wait for the children to finish here,
-%% but only up to N milliseconds. Then we shutdown.
-terminate(_State) ->
- ok.
-
-syn_reply(#state{socket=Socket, transport=Transport, zdef=Zdef},
- StreamID, IsFin, Status, Headers) ->
- Transport:send(Socket, cow_spdy:syn_reply(Zdef, StreamID, IsFin,
- Status, <<"HTTP/1.1">>, Headers)).
-
-rst_stream(#state{socket=Socket, transport=Transport}, StreamID, Status) ->
- Transport:send(Socket, cow_spdy:rst_stream(StreamID, Status)).
-
-goaway(#state{socket=Socket, transport=Transport, last_streamid=LastStreamID},
- Status) ->
- Transport:send(Socket, cow_spdy:goaway(LastStreamID, Status)).
-
-data(#state{socket=Socket, transport=Transport}, StreamID, IsFin, Data) ->
- Transport:send(Socket, cow_spdy:data(StreamID, IsFin, Data)).
-
-data_from_file(#state{socket=Socket, transport=Transport},
- StreamID, Filepath) ->
- {ok, IoDevice} = file:open(Filepath, [read, binary, raw]),
- data_from_file(Socket, Transport, StreamID, IoDevice).
-
-data_from_file(Socket, Transport, StreamID, IoDevice) ->
- case file:read(IoDevice, 16#1fff) of
- eof ->
- _ = Transport:send(Socket, cow_spdy:data(StreamID, true, <<>>)),
- ok;
- {ok, Data} ->
- case Transport:send(Socket, cow_spdy:data(StreamID, false, Data)) of
- ok ->
- data_from_file(Socket, Transport, StreamID, IoDevice);
- {error, _} ->
- ok
- end
- end.
-
-%% Children.
-
-new_child(State=#state{children=Children}, StreamID, Pid, IsFin) ->
- IsFin2 = if IsFin -> fin; true -> nofin end,
- State#state{last_streamid=StreamID,
- children=[#child{streamid=StreamID,
- pid=Pid, input=IsFin2}|Children]}.
-
-get_child(StreamID, #state{children=Children}) ->
- lists:keyfind(StreamID, #child.streamid, Children).
-
-replace_child(Child=#child{streamid=StreamID},
- State=#state{children=Children}) ->
- Children2 = lists:keyreplace(StreamID, #child.streamid, Children, Child),
- State#state{children=Children2}.
-
-delete_child(Pid, State=#state{children=Children}) ->
- Children2 = lists:keydelete(Pid, #child.pid, Children),
- State#state{children=Children2}.
-
-%% Request process.
-
--spec request_init(socket(), {inet:ip_address(), inet:port_number()},
- cowboy:onresponse_fun(), cowboy_middleware:env(), [module()],
- binary(), binary(), binary(), binary(), [{binary(), binary()}])
- -> ok.
-request_init(FakeSocket, Peer, OnResponse,
- Env, Middlewares, Method, Host, Path, Version, Headers) ->
- {Host2, Port} = cow_http_hd:parse_host(Host),
- {Path2, Qs} = cow_http:parse_fullpath(Path),
- Version2 = cow_http:parse_version(Version),
- Req = cowboy_req:new(FakeSocket, ?MODULE, Peer,
- Method, Path2, Qs, Version2, Headers,
- Host2, Port, <<>>, true, false, OnResponse),
- execute(Req, Env, Middlewares).
-
--spec execute(cowboy_req:req(), cowboy_middleware:env(), [module()])
- -> ok.
-execute(Req, _, []) ->
- cowboy_req:ensure_response(Req, 204);
-execute(Req, Env, [Middleware|Tail]) ->
- case Middleware:execute(Req, Env) of
- {ok, Req2, Env2} ->
- execute(Req2, Env2, Tail);
- {suspend, Module, Function, Args} ->
- erlang:hibernate(?MODULE, resume,
- [Env, Tail, Module, Function, Args]);
- {stop, Req2} ->
- cowboy_req:ensure_response(Req2, 204)
- end.
-
--spec resume(cowboy_middleware:env(), [module()],
- module(), module(), [any()]) -> ok.
-resume(Env, Tail, Module, Function, Args) ->
- case apply(Module, Function, Args) of
- {ok, Req2, Env2} ->
- execute(Req2, Env2, Tail);
- {suspend, Module2, Function2, Args2} ->
- erlang:hibernate(?MODULE, resume,
- [Env, Tail, Module2, Function2, Args2]);
- {stop, Req2} ->
- cowboy_req:ensure_response(Req2, 204)
- end.
-
-%% Reply functions used by cowboy_req.
-
--spec reply(socket(), binary(), cowboy:http_headers(), iodata()) -> ok.
-reply(Socket = {Pid, _}, Status, Headers, Body) ->
- _ = case iolist_size(Body) of
- 0 -> Pid ! {reply, Socket, Status, Headers};
- _ -> Pid ! {reply, Socket, Status, Headers, Body}
- end,
- ok.
-
--spec stream_reply(socket(), binary(), cowboy:http_headers()) -> ok.
-stream_reply(Socket = {Pid, _}, Status, Headers) ->
- _ = Pid ! {stream_reply, Socket, Status, Headers},
- ok.
-
--spec stream_data(socket(), iodata()) -> ok.
-stream_data(Socket = {Pid, _}, Data) ->
- _ = Pid ! {stream_data, Socket, Data},
- ok.
-
--spec stream_close(socket()) -> ok.
-stream_close(Socket = {Pid, _}) ->
- _ = Pid ! {stream_close, Socket},
- ok.
-
-%% Internal transport functions.
-
--spec name() -> spdy.
-name() ->
- spdy.
-
--spec messages() -> {spdy, spdy_closed, spdy_error}.
-messages() ->
- {spdy, spdy_closed, spdy_error}.
-
--spec recv(socket(), non_neg_integer(), timeout())
- -> {ok, binary()} | {error, timeout}.
-recv(Socket = {Pid, _}, Length, Timeout) ->
- _ = Pid ! {recv, Socket, self(), Length, Timeout},
- receive
- {recv, Socket, Ret} ->
- Ret
- end.
-
--spec send(socket(), iodata()) -> ok.
-send(Socket, Data) ->
- stream_data(Socket, Data).
-
-%% We don't wait for the result of the actual sendfile call,
-%% therefore we can't know how much was actually sent.
-%% This isn't a problem as we don't use this value in Cowboy.
--spec sendfile(socket(), file:name_all()) -> {ok, undefined}.
-sendfile(Socket = {Pid, _}, Filepath) ->
- _ = Pid ! {sendfile, Socket, Filepath},
- {ok, undefined}.
-
--spec setopts({pid(), _}, list()) -> ok.
-setopts(Socket = {Pid, _}, [{active, once}]) ->
- _ = Pid ! {active, Socket, self()},
- ok;
-setopts(Socket = {Pid, _}, [{active, false}]) ->
- _ = Pid ! {passive, Socket, self()},
- ok.
diff --git a/src/cowboy_tls.erl b/src/cowboy_tls.erl
index 0ccf733..375b005 100644
--- a/src/cowboy_tls.erl
+++ b/src/cowboy_tls.erl
@@ -29,9 +29,6 @@ init(Parent, Ref, Socket, Transport, Opts) ->
case ssl:negotiated_protocol(Socket) of
{ok, <<"h2">>} ->
init(Parent, Ref, Socket, Transport, Opts, cowboy_http2);
- %% @todo Implement cowboy_spdy and cowboy_http.
- {ok, <<"spdy/3">>} ->
- init(Parent, Ref, Socket, Transport, Opts, cowboy_spdy);
_ -> %% http/1.1 or no protocol negotiated.
init(Parent, Ref, Socket, Transport, Opts, cowboy_http)
end.