aboutsummaryrefslogtreecommitdiffstats
path: root/src/cowboy_websocket.erl
diff options
context:
space:
mode:
Diffstat (limited to 'src/cowboy_websocket.erl')
-rw-r--r--src/cowboy_websocket.erl565
1 files changed, 122 insertions, 443 deletions
diff --git a/src/cowboy_websocket.erl b/src/cowboy_websocket.erl
index cdd0365..681470f 100644
--- a/src/cowboy_websocket.erl
+++ b/src/cowboy_websocket.erl
@@ -20,21 +20,8 @@
-export([upgrade/6]).
-export([handler_loop/4]).
--type close_code() :: 1000..4999.
--export_type([close_code/0]).
-
--type frame() :: close | ping | pong
- | {text | binary | close | ping | pong, iodata()}
- | {close, close_code(), iodata()}.
--export_type([frame/0]).
-
--type opcode() :: 0 | 1 | 2 | 8 | 9 | 10.
--type mask_key() :: 0..16#ffffffff.
--type frag_state() :: undefined
- | {nofin, opcode(), binary()} | {fin, opcode(), binary()}.
--type rsv() :: << _:3 >>.
--type terminate_reason() :: normal | shutdown | timeout
- | remote | {remote, close_code(), binary()}
+-type terminate_reason() :: normal | stop | timeout
+ | remote | {remote, cow_ws:close_code(), binary()}
| {error, badencoding | badframe | closed | atom()}
| {crash, error | exit | throw, any()}.
@@ -47,16 +34,16 @@
-callback websocket_handle({text | binary | ping | pong, binary()}, Req, State)
-> {ok, Req, State}
| {ok, Req, State, hibernate}
- | {reply, frame() | [frame()], Req, State}
- | {reply, frame() | [frame()], Req, State, hibernate}
- | {shutdown, Req, State}
+ | {reply, cow_ws:frame() | [cow_ws:frame()], Req, State}
+ | {reply, cow_ws:frame() | [cow_ws:frame()], Req, State, hibernate}
+ | {stop, Req, State}
when Req::cowboy_req:req(), State::any().
-callback websocket_info(any(), Req, State)
-> {ok, Req, State}
| {ok, Req, State, hibernate}
- | {reply, frame() | [frame()], Req, State}
- | {reply, frame() | [frame()], Req, State, hibernate}
- | {shutdown, Req, State}
+ | {reply, cow_ws:frame() | [cow_ws:frame()], Req, State}
+ | {reply, cow_ws:frame() | [cow_ws:frame()], Req, State, hibernate}
+ | {stop, Req, State}
when Req::cowboy_req:req(), State::any().
%% @todo optional -callback terminate(terminate_reason(), cowboy_req:req(), state()) -> ok.
@@ -70,11 +57,11 @@
timeout_ref = undefined :: undefined | reference(),
messages = undefined :: undefined | {atom(), atom(), atom()},
hibernate = false :: boolean(),
- frag_state = undefined :: frag_state(),
+ frag_state = undefined :: cow_ws:frag_state(),
+ frag_buffer = <<>> :: binary(),
utf8_state = <<>> :: binary(),
- deflate_frame = false :: boolean(),
- inflate_state :: undefined | port(),
- deflate_state :: undefined | port()
+ recv_extensions = #{} :: map(),
+ send_extensions = #{} :: map()
}).
-spec upgrade(Req, Env, module(), any(), timeout(), run | hibernate)
@@ -135,9 +122,8 @@ websocket_extensions(State, Req) ->
% the zlib headers.
ok = zlib:deflateInit(Deflate, best_compression, deflated, -15, 8, default),
{ok, State#state{
- deflate_frame = true,
- inflate_state = Inflate,
- deflate_state = Deflate
+ recv_extensions = #{deflate_frame => Inflate},
+ send_extensions = #{deflate_frame => Deflate}
}, cowboy_req:set_meta(websocket_compress, true, Req)};
_ ->
{ok, State, cowboy_req:set_meta(websocket_compress, false, Req)}
@@ -149,16 +135,16 @@ websocket_extensions(State, Req) ->
| {suspend, module(), atom(), [any()]}
when Req::cowboy_req:req().
websocket_handshake(State=#state{
- transport=Transport, key=Key, deflate_frame=DeflateFrame},
+ transport=Transport, key=Key, recv_extensions=Extensions},
Req, HandlerState) ->
Challenge = base64:encode(crypto:hash(sha,
<< Key/binary, "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" >>)),
- Extensions = case DeflateFrame of
- false -> [];
- true -> [{<<"sec-websocket-extensions">>, <<"x-webkit-deflate-frame">>}]
+ ExtHeader = case Extensions of
+ #{deflate_frame := _} -> [{<<"sec-websocket-extensions">>, <<"x-webkit-deflate-frame">>}];
+ _ -> []
end,
Req2 = cowboy_req:upgrade_reply(101, [{<<"upgrade">>, <<"websocket">>},
- {<<"sec-websocket-accept">>, Challenge}|Extensions], Req),
+ {<<"sec-websocket-accept">>, Challenge}|ExtHeader], Req),
%% Flush the resp_sent message before moving on.
receive {cowboy_req, resp_sent} -> ok after 0 -> ok end,
State2 = handler_loop_timeout(State),
@@ -213,299 +199,59 @@ handler_loop(State=#state{socket=Socket, messages={OK, Closed, Error},
SoFar, websocket_info, Message, fun handler_before_loop/4)
end.
-%% All frames passing through this function are considered valid,
-%% with the only exception of text and close frames with a payload
-%% which may still contain errors.
-spec websocket_data(#state{}, Req, any(), binary())
-> {ok, Req, cowboy_middleware:env()}
| {suspend, module(), atom(), [any()]}
when Req::cowboy_req:req().
-%% RSV bits MUST be 0 unless an extension is negotiated
-%% that defines meanings for non-zero values.
-websocket_data(State, Req, HandlerState, << _:1, Rsv:3, _/bits >>)
- when Rsv =/= 0, State#state.deflate_frame =:= false ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% Invalid opcode. Note that these opcodes may be used by extensions.
-websocket_data(State, Req, HandlerState, << _:4, Opcode:4, _/bits >>)
- when Opcode > 2, Opcode =/= 8, Opcode =/= 9, Opcode =/= 10 ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% Control frames MUST NOT be fragmented.
-websocket_data(State, Req, HandlerState, << 0:1, _:3, Opcode:4, _/bits >>)
- when Opcode >= 8 ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% A frame MUST NOT use the zero opcode unless fragmentation was initiated.
-websocket_data(State=#state{frag_state=undefined}, Req, HandlerState,
- << _:4, 0:4, _/bits >>) ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% Non-control opcode when expecting control message or next fragment.
-websocket_data(State=#state{frag_state={nofin, _, _}}, Req, HandlerState,
- << _:4, Opcode:4, _/bits >>)
- when Opcode =/= 0, Opcode < 8 ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% Close control frame length MUST be 0 or >= 2.
-websocket_data(State, Req, HandlerState, << _:4, 8:4, _:1, 1:7, _/bits >>) ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% Close control frame with incomplete close code. Need more data.
-websocket_data(State, Req, HandlerState,
- Data = << _:4, 8:4, 1:1, Len:7, _/bits >>)
- when Len > 1, byte_size(Data) < 8 ->
- handler_before_loop(State, Req, HandlerState, Data);
-%% 7 bits payload length.
-websocket_data(State, Req, HandlerState, << Fin:1, Rsv:3/bits, Opcode:4, 1:1,
- Len:7, MaskKey:32, Rest/bits >>)
- when Len < 126 ->
- websocket_data(State, Req, HandlerState,
- Opcode, Len, MaskKey, Rest, Rsv, Fin);
-%% 16 bits payload length.
-websocket_data(State, Req, HandlerState, << Fin:1, Rsv:3/bits, Opcode:4, 1:1,
- 126:7, Len:16, MaskKey:32, Rest/bits >>)
- when Len > 125, Opcode < 8 ->
- websocket_data(State, Req, HandlerState,
- Opcode, Len, MaskKey, Rest, Rsv, Fin);
-%% 63 bits payload length.
-websocket_data(State, Req, HandlerState, << Fin:1, Rsv:3/bits, Opcode:4, 1:1,
- 127:7, 0:1, Len:63, MaskKey:32, Rest/bits >>)
- when Len > 16#ffff, Opcode < 8 ->
- websocket_data(State, Req, HandlerState,
- Opcode, Len, MaskKey, Rest, Rsv, Fin);
-%% When payload length is over 63 bits, the most significant bit MUST be 0.
-websocket_data(State, Req, HandlerState, << _:8, 1:1, 127:7, 1:1, _:7, _/bits >>) ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% All frames sent from the client to the server are masked.
-websocket_data(State, Req, HandlerState, << _:8, 0:1, _/bits >>) ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% For the next two clauses, it can be one of the following:
-%%
-%% * The minimal number of bytes MUST be used to encode the length
-%% * All control frames MUST have a payload length of 125 bytes or less
-websocket_data(State, Req, HandlerState, << _:9, 126:7, _:48, _/bits >>) ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-websocket_data(State, Req, HandlerState, << _:9, 127:7, _:96, _/bits >>) ->
- websocket_close(State, Req, HandlerState, {error, badframe});
-%% Need more data.
-websocket_data(State, Req, HandlerState, Data) ->
- handler_before_loop(State, Req, HandlerState, Data).
-
-%% Initialize or update fragmentation state.
--spec websocket_data(#state{}, Req, any(),
- opcode(), non_neg_integer(), mask_key(), binary(), rsv(), 0 | 1)
- -> {ok, Req, cowboy_middleware:env()}
- | {suspend, module(), atom(), [any()]}
- when Req::cowboy_req:req().
-%% The opcode is only included in the first frame fragment.
-websocket_data(State=#state{frag_state=undefined}, Req, HandlerState,
- Opcode, Len, MaskKey, Data, Rsv, 0) ->
- websocket_payload(State#state{frag_state={nofin, Opcode, <<>>}},
- Req, HandlerState, 0, Len, MaskKey, <<>>, 0, Data, Rsv);
-%% Subsequent frame fragments.
-websocket_data(State=#state{frag_state={nofin, _, _}}, Req, HandlerState,
- 0, Len, MaskKey, Data, Rsv, 0) ->
- websocket_payload(State, Req, HandlerState,
- 0, Len, MaskKey, <<>>, 0, Data, Rsv);
-%% Final frame fragment.
-websocket_data(State=#state{frag_state={nofin, Opcode, SoFar}},
- Req, HandlerState, 0, Len, MaskKey, Data, Rsv, 1) ->
- websocket_payload(State#state{frag_state={fin, Opcode, SoFar}},
- Req, HandlerState, 0, Len, MaskKey, <<>>, 0, Data, Rsv);
-%% Unfragmented frame.
-websocket_data(State, Req, HandlerState, Opcode, Len, MaskKey, Data, Rsv, 1) ->
- websocket_payload(State, Req, HandlerState,
- Opcode, Len, MaskKey, <<>>, 0, Data, Rsv).
-
--spec websocket_payload(#state{}, Req, any(),
- opcode(), non_neg_integer(), mask_key(), binary(), non_neg_integer(),
- binary(), rsv())
- -> {ok, Req, cowboy_middleware:env()}
- | {suspend, module(), atom(), [any()]}
- when Req::cowboy_req:req().
-%% Close control frames with a payload MUST contain a valid close code.
-websocket_payload(State, Req, HandlerState,
- Opcode=8, Len, MaskKey, <<>>, 0,
- << MaskedCode:2/binary, Rest/bits >>, Rsv) ->
- Unmasked = << Code:16 >> = websocket_unmask(MaskedCode, MaskKey, <<>>),
- if Code < 1000; Code =:= 1004; Code =:= 1005; Code =:= 1006;
- (Code > 1011) and (Code < 3000); Code > 4999 ->
+websocket_data(State=#state{frag_state=FragState, recv_extensions=Extensions}, Req, HandlerState, Data) ->
+ case cow_ws:parse_header(Data, Extensions, FragState) of
+ %% All frames sent from the client to the server are masked.
+ {_, _, _, _, undefined, _} ->
websocket_close(State, Req, HandlerState, {error, badframe});
- true ->
- websocket_payload(State, Req, HandlerState,
- Opcode, Len - 2, MaskKey, Unmasked, byte_size(MaskedCode),
- Rest, Rsv)
- end;
-%% Text frames and close control frames MUST have a payload that is valid UTF-8.
-websocket_payload(State=#state{utf8_state=Incomplete},
- Req, HandlerState, Opcode, Len, MaskKey, Unmasked, UnmaskedLen,
- Data, Rsv)
- when (byte_size(Data) < Len) andalso ((Opcode =:= 1) orelse
- ((Opcode =:= 8) andalso (Unmasked =/= <<>>))) ->
- Unmasked2 = websocket_unmask(Data,
- rotate_mask_key(MaskKey, UnmaskedLen), <<>>),
- {Unmasked3, State2} = websocket_inflate_frame(Unmasked2, Rsv, false, State),
- case is_utf8(<< Incomplete/binary, Unmasked3/binary >>) of
- false ->
- websocket_close(State2, Req, HandlerState, {error, badencoding});
- Utf8State ->
- websocket_payload_loop(State2#state{utf8_state=Utf8State},
- Req, HandlerState, Opcode, Len - byte_size(Data), MaskKey,
- << Unmasked/binary, Unmasked3/binary >>,
- UnmaskedLen + byte_size(Data), Rsv)
- end;
-websocket_payload(State=#state{utf8_state=Incomplete},
- Req, HandlerState, Opcode, Len, MaskKey, Unmasked, UnmaskedLen,
- Data, Rsv)
- when Opcode =:= 1; (Opcode =:= 8) and (Unmasked =/= <<>>) ->
- << End:Len/binary, Rest/bits >> = Data,
- Unmasked2 = websocket_unmask(End,
- rotate_mask_key(MaskKey, UnmaskedLen), <<>>),
- {Unmasked3, State2} = websocket_inflate_frame(Unmasked2, Rsv, true, State),
- case is_utf8(<< Incomplete/binary, Unmasked3/binary >>) of
- <<>> ->
- websocket_dispatch(State2#state{utf8_state= <<>>},
- Req, HandlerState, Rest, Opcode,
- << Unmasked/binary, Unmasked3/binary >>);
- _ ->
- websocket_close(State2, Req, HandlerState, {error, badencoding})
- end;
-%% Fragmented text frames may cut payload in the middle of UTF-8 codepoints.
-websocket_payload(State=#state{frag_state={_, 1, _}, utf8_state=Incomplete},
- Req, HandlerState, Opcode=0, Len, MaskKey, Unmasked, UnmaskedLen,
- Data, Rsv)
- when byte_size(Data) < Len ->
- Unmasked2 = websocket_unmask(Data,
- rotate_mask_key(MaskKey, UnmaskedLen), <<>>),
- {Unmasked3, State2} = websocket_inflate_frame(Unmasked2, Rsv, false, State),
- case is_utf8(<< Incomplete/binary, Unmasked3/binary >>) of
- false ->
- websocket_close(State2, Req, HandlerState, {error, badencoding});
- Utf8State ->
- websocket_payload_loop(State2#state{utf8_state=Utf8State},
- Req, HandlerState, Opcode, Len - byte_size(Data), MaskKey,
- << Unmasked/binary, Unmasked3/binary >>,
- UnmaskedLen + byte_size(Data), Rsv)
- end;
-websocket_payload(State=#state{frag_state={Fin, 1, _}, utf8_state=Incomplete},
- Req, HandlerState, Opcode=0, Len, MaskKey, Unmasked, UnmaskedLen,
- Data, Rsv) ->
- << End:Len/binary, Rest/bits >> = Data,
- Unmasked2 = websocket_unmask(End,
- rotate_mask_key(MaskKey, UnmaskedLen), <<>>),
- {Unmasked3, State2} = websocket_inflate_frame(Unmasked2, Rsv, Fin =:= fin, State),
- case is_utf8(<< Incomplete/binary, Unmasked3/binary >>) of
- <<>> ->
- websocket_dispatch(State2#state{utf8_state= <<>>},
- Req, HandlerState, Rest, Opcode,
- << Unmasked/binary, Unmasked3/binary >>);
- Utf8State when is_binary(Utf8State), Fin =:= nofin ->
- websocket_dispatch(State2#state{utf8_state=Utf8State},
- Req, HandlerState, Rest, Opcode,
- << Unmasked/binary, Unmasked3/binary >>);
- _ ->
- websocket_close(State, Req, HandlerState, {error, badencoding})
- end;
-%% Other frames have a binary payload.
-websocket_payload(State, Req, HandlerState,
- Opcode, Len, MaskKey, Unmasked, UnmaskedLen, Data, Rsv)
- when byte_size(Data) < Len ->
- Unmasked2 = websocket_unmask(Data,
- rotate_mask_key(MaskKey, UnmaskedLen), <<>>),
- {Unmasked3, State2} = websocket_inflate_frame(Unmasked2, Rsv, false, State),
- websocket_payload_loop(State2, Req, HandlerState,
- Opcode, Len - byte_size(Data), MaskKey,
- << Unmasked/binary, Unmasked3/binary >>, UnmaskedLen + byte_size(Data),
- Rsv);
-websocket_payload(State, Req, HandlerState,
- Opcode, Len, MaskKey, Unmasked, UnmaskedLen, Data, Rsv) ->
- << End:Len/binary, Rest/bits >> = Data,
- Unmasked2 = websocket_unmask(End,
- rotate_mask_key(MaskKey, UnmaskedLen), <<>>),
- {Unmasked3, State2} = websocket_inflate_frame(Unmasked2, Rsv, true, State),
- websocket_dispatch(State2, Req, HandlerState, Rest, Opcode,
- << Unmasked/binary, Unmasked3/binary >>).
-
--spec websocket_inflate_frame(binary(), rsv(), boolean(), #state{}) ->
- {binary(), #state{}}.
-websocket_inflate_frame(Data, << Rsv1:1, _:2 >>, _,
- #state{deflate_frame = DeflateFrame} = State)
- when DeflateFrame =:= false orelse Rsv1 =:= 0 ->
- {Data, State};
-websocket_inflate_frame(Data, << 1:1, _:2 >>, false, State) ->
- Result = zlib:inflate(State#state.inflate_state, Data),
- {iolist_to_binary(Result), State};
-websocket_inflate_frame(Data, << 1:1, _:2 >>, true, State) ->
- Result = zlib:inflate(State#state.inflate_state,
- << Data/binary, 0:8, 0:8, 255:8, 255:8 >>),
- {iolist_to_binary(Result), State}.
-
--spec websocket_unmask(B, mask_key(), B) -> B when B::binary().
-websocket_unmask(<<>>, _, Unmasked) ->
- Unmasked;
-websocket_unmask(<< O:32, Rest/bits >>, MaskKey, Acc) ->
- T = O bxor MaskKey,
- websocket_unmask(Rest, MaskKey, << Acc/binary, T:32 >>);
-websocket_unmask(<< O:24 >>, MaskKey, Acc) ->
- << MaskKey2:24, _:8 >> = << MaskKey:32 >>,
- T = O bxor MaskKey2,
- << Acc/binary, T:24 >>;
-websocket_unmask(<< O:16 >>, MaskKey, Acc) ->
- << MaskKey2:16, _:16 >> = << MaskKey:32 >>,
- T = O bxor MaskKey2,
- << Acc/binary, T:16 >>;
-websocket_unmask(<< O:8 >>, MaskKey, Acc) ->
- << MaskKey2:8, _:24 >> = << MaskKey:32 >>,
- T = O bxor MaskKey2,
- << Acc/binary, T:8 >>.
+ %% No payload.
+ {Type, FragState2, _, 0, _, Rest} ->
+ websocket_dispatch(State#state{frag_state=FragState2}, Req, HandlerState, Type, <<>>, undefined, Rest);
+ {Type, FragState2, Rsv, Len, MaskKey, Rest} ->
+ websocket_payload(State#state{frag_state=FragState2}, Req, HandlerState, Type, Len, MaskKey, Rsv, Rest);
+ more ->
+ handler_before_loop(State, Req, HandlerState, Data);
+ error ->
+ websocket_close(State, Req, HandlerState, {error, badframe})
+ end.
-%% Because we unmask on the fly we need to continue from the right mask byte.
--spec rotate_mask_key(mask_key(), non_neg_integer()) -> mask_key().
-rotate_mask_key(MaskKey, UnmaskedLen) ->
- Left = UnmaskedLen rem 4,
- Right = 4 - Left,
- (MaskKey bsl (Left * 8)) + (MaskKey bsr (Right * 8)).
+websocket_payload(State, Req, HandlerState, Type = close, Len, MaskKey, Rsv, Data) ->
+ case cow_ws:parse_close_code(Data, MaskKey) of
+ {ok, CloseCode, Rest} ->
+ websocket_payload(State, Req, HandlerState, Type, Len - 2, MaskKey, Rsv, CloseCode, <<>>, 2, Rest);
+ error ->
+ websocket_close(State, Req, HandlerState, {error, badframe})
+ end;
+websocket_payload(State, Req, HandlerState, Type, Len, MaskKey, Rsv, Data) ->
+ websocket_payload(State, Req, HandlerState, Type, Len, MaskKey, Rsv, undefined, <<>>, 0, Data).
-%% Returns <<>> if the argument is valid UTF-8, false if not,
-%% or the incomplete part of the argument if we need more data.
--spec is_utf8(binary()) -> false | binary().
-is_utf8(Valid = <<>>) ->
- Valid;
-is_utf8(<< _/utf8, Rest/bits >>) ->
- is_utf8(Rest);
-%% 2 bytes. Codepages C0 and C1 are invalid; fail early.
-is_utf8(<< 2#1100000:7, _/bits >>) ->
- false;
-is_utf8(Incomplete = << 2#110:3, _:5 >>) ->
- Incomplete;
-%% 3 bytes.
-is_utf8(Incomplete = << 2#1110:4, _:4 >>) ->
- Incomplete;
-is_utf8(Incomplete = << 2#1110:4, _:4, 2#10:2, _:6 >>) ->
- Incomplete;
-%% 4 bytes. Codepage F4 may have invalid values greater than 0x10FFFF.
-is_utf8(<< 2#11110100:8, 2#10:2, High:6, _/bits >>) when High >= 2#10000 ->
- false;
-is_utf8(Incomplete = << 2#11110:5, _:3 >>) ->
- Incomplete;
-is_utf8(Incomplete = << 2#11110:5, _:3, 2#10:2, _:6 >>) ->
- Incomplete;
-is_utf8(Incomplete = << 2#11110:5, _:3, 2#10:2, _:6, 2#10:2, _:6 >>) ->
- Incomplete;
-%% Invalid.
-is_utf8(_) ->
- false.
+websocket_payload(State=#state{frag_state=FragState, utf8_state=Incomplete, recv_extensions=Extensions},
+ Req, HandlerState, Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen, Data) ->
+ case cow_ws:parse_payload(Data, MaskKey, Incomplete, UnmaskedLen, Type, Len, FragState, Extensions, Rsv) of
+ {ok, Payload, Utf8State, Rest} ->
+ websocket_dispatch(State#state{utf8_state=Utf8State},
+ Req, HandlerState, Type, << Unmasked/binary, Payload/binary >>, CloseCode, Rest);
+ {more, Payload, Utf8State} ->
+ websocket_payload_loop(State#state{utf8_state=Utf8State},
+ Req, HandlerState, Type, Len - byte_size(Data), MaskKey, Rsv, CloseCode,
+ << Unmasked/binary, Payload/binary >>, UnmaskedLen + byte_size(Data));
+ error ->
+ websocket_close(State, Req, HandlerState, {error, badencoding})
+ end.
--spec websocket_payload_loop(#state{}, Req, any(),
- opcode(), non_neg_integer(), mask_key(), binary(),
- non_neg_integer(), rsv())
- -> {ok, Req, cowboy_middleware:env()}
- | {suspend, module(), atom(), [any()]}
- when Req::cowboy_req:req().
websocket_payload_loop(State=#state{socket=Socket, transport=Transport,
messages={OK, Closed, Error}, timeout_ref=TRef},
- Req, HandlerState, Opcode, Len, MaskKey, Unmasked, UnmaskedLen, Rsv) ->
+ Req, HandlerState, Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen) ->
Transport:setopts(Socket, [{active, once}]),
receive
{OK, Socket, Data} ->
State2 = handler_loop_timeout(State),
websocket_payload(State2, Req, HandlerState,
- Opcode, Len, MaskKey, Unmasked, UnmaskedLen, Data, Rsv);
+ Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen, Data);
{Closed, Socket} ->
handler_terminate(State, Req, HandlerState, {error, closed});
{Error, Socket, Reason} ->
@@ -514,53 +260,46 @@ websocket_payload_loop(State=#state{socket=Socket, transport=Transport,
websocket_close(State, Req, HandlerState, timeout);
{timeout, OlderTRef, ?MODULE} when is_reference(OlderTRef) ->
websocket_payload_loop(State, Req, HandlerState,
- Opcode, Len, MaskKey, Unmasked, UnmaskedLen, Rsv);
+ Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen);
Message ->
handler_call(State, Req, HandlerState,
<<>>, websocket_info, Message,
fun (State2, Req2, HandlerState2, _) ->
websocket_payload_loop(State2, Req2, HandlerState2,
- Opcode, Len, MaskKey, Unmasked, UnmaskedLen, Rsv)
+ Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen)
end)
end.
--spec websocket_dispatch(#state{}, Req, any(), binary(), opcode(), binary())
- -> {ok, Req, cowboy_middleware:env()}
- | {suspend, module(), atom(), [any()]}
- when Req::cowboy_req:req().
%% Continuation frame.
-websocket_dispatch(State=#state{frag_state={nofin, Opcode, SoFar}},
- Req, HandlerState, RemainingData, 0, Payload) ->
- websocket_data(State#state{frag_state={nofin, Opcode,
- << SoFar/binary, Payload/binary >>}}, Req, HandlerState, RemainingData);
+websocket_dispatch(State=#state{frag_state={nofin, _}, frag_buffer=SoFar},
+ Req, HandlerState, fragment, Payload, _, RemainingData) ->
+ websocket_data(State#state{frag_buffer= << SoFar/binary, Payload/binary >>}, Req, HandlerState, RemainingData);
%% Last continuation frame.
-websocket_dispatch(State=#state{frag_state={fin, Opcode, SoFar}},
- Req, HandlerState, RemainingData, 0, Payload) ->
- websocket_dispatch(State#state{frag_state=undefined}, Req, HandlerState,
- RemainingData, Opcode, << SoFar/binary, Payload/binary >>);
+websocket_dispatch(State=#state{frag_state={fin, Type}, frag_buffer=SoFar},
+ Req, HandlerState, fragment, Payload, CloseCode, RemainingData) ->
+ websocket_dispatch(State#state{frag_state=undefined, frag_buffer= <<>>}, Req, HandlerState,
+ Type, << SoFar/binary, Payload/binary >>, CloseCode, RemainingData);
%% Text frame.
-websocket_dispatch(State, Req, HandlerState, RemainingData, 1, Payload) ->
+websocket_dispatch(State, Req, HandlerState, text, Payload, _, RemainingData) ->
handler_call(State, Req, HandlerState, RemainingData,
websocket_handle, {text, Payload}, fun websocket_data/4);
%% Binary frame.
-websocket_dispatch(State, Req, HandlerState, RemainingData, 2, Payload) ->
+websocket_dispatch(State, Req, HandlerState, binary, Payload, _, RemainingData) ->
handler_call(State, Req, HandlerState, RemainingData,
websocket_handle, {binary, Payload}, fun websocket_data/4);
%% Close control frame.
-websocket_dispatch(State, Req, HandlerState, _RemainingData, 8, <<>>) ->
+websocket_dispatch(State, Req, HandlerState, close, _, undefined, _) ->
websocket_close(State, Req, HandlerState, remote);
-websocket_dispatch(State, Req, HandlerState, _RemainingData, 8,
- << Code:16, Payload/bits >>) ->
+websocket_dispatch(State, Req, HandlerState, close, Payload, Code, _) ->
websocket_close(State, Req, HandlerState, {remote, Code, Payload});
%% Ping control frame. Send a pong back and forward the ping to the handler.
-websocket_dispatch(State=#state{socket=Socket, transport=Transport},
- Req, HandlerState, RemainingData, 9, Payload) ->
- Len = payload_length_to_binary(byte_size(Payload)),
- Transport:send(Socket, << 1:1, 0:3, 10:4, 0:1, Len/bits, Payload/binary >>),
+websocket_dispatch(State=#state{socket=Socket, transport=Transport, send_extensions=Extensions},
+ Req, HandlerState, ping, Payload, _, RemainingData) ->
+ Transport:send(Socket, cow_ws:frame({pong, Payload}, Extensions)),
handler_call(State, Req, HandlerState, RemainingData,
websocket_handle, {ping, Payload}, fun websocket_data/4);
%% Pong control frame.
-websocket_dispatch(State, Req, HandlerState, RemainingData, 10, Payload) ->
+websocket_dispatch(State, Req, HandlerState, pong, Payload, _, RemainingData) ->
handler_call(State, Req, HandlerState, RemainingData,
websocket_handle, {pong, Payload}, fun websocket_data/4).
@@ -579,45 +318,45 @@ handler_call(State=#state{handler=Handler}, Req, HandlerState,
{reply, Payload, Req2, HandlerState2}
when is_list(Payload) ->
case websocket_send_many(Payload, State) of
- {ok, State2} ->
- NextState(State2, Req2, HandlerState2, RemainingData);
- {shutdown, State2} ->
- handler_terminate(State2, Req2, HandlerState2, shutdown);
- {{error, _} = Error, State2} ->
- handler_terminate(State2, Req2, HandlerState2, Error)
+ ok ->
+ NextState(State, Req2, HandlerState2, RemainingData);
+ stop ->
+ handler_terminate(State, Req2, HandlerState2, stop);
+ Error = {error, _} ->
+ handler_terminate(State, Req2, HandlerState2, Error)
end;
{reply, Payload, Req2, HandlerState2, hibernate}
when is_list(Payload) ->
case websocket_send_many(Payload, State) of
- {ok, State2} ->
- NextState(State2#state{hibernate=true},
+ ok ->
+ NextState(State#state{hibernate=true},
Req2, HandlerState2, RemainingData);
- {shutdown, State2} ->
- handler_terminate(State2, Req2, HandlerState2, shutdown);
- {{error, _} = Error, State2} ->
- handler_terminate(State2, Req2, HandlerState2, Error)
+ stop ->
+ handler_terminate(State, Req2, HandlerState2, stop);
+ Error = {error, _} ->
+ handler_terminate(State, Req2, HandlerState2, Error)
end;
{reply, Payload, Req2, HandlerState2} ->
case websocket_send(Payload, State) of
- {ok, State2} ->
- NextState(State2, Req2, HandlerState2, RemainingData);
- {shutdown, State2} ->
- handler_terminate(State2, Req2, HandlerState2, shutdown);
- {{error, _} = Error, State2} ->
- handler_terminate(State2, Req2, HandlerState2, Error)
+ ok ->
+ NextState(State, Req2, HandlerState2, RemainingData);
+ stop ->
+ handler_terminate(State, Req2, HandlerState2, stop);
+ Error = {error, _} ->
+ handler_terminate(State, Req2, HandlerState2, Error)
end;
{reply, Payload, Req2, HandlerState2, hibernate} ->
case websocket_send(Payload, State) of
- {ok, State2} ->
- NextState(State2#state{hibernate=true},
+ ok ->
+ NextState(State#state{hibernate=true},
Req2, HandlerState2, RemainingData);
- {shutdown, State2} ->
- handler_terminate(State2, Req2, HandlerState2, shutdown);
- {{error, _} = Error, State2} ->
- handler_terminate(State2, Req2, HandlerState2, Error)
+ stop ->
+ handler_terminate(State, Req2, HandlerState2, stop);
+ Error = {error, _} ->
+ handler_terminate(State, Req2, HandlerState2, Error)
end;
- {shutdown, Req2, HandlerState2} ->
- websocket_close(State, Req2, HandlerState2, shutdown)
+ {stop, Req2, HandlerState2} ->
+ websocket_close(State, Req2, HandlerState2, stop)
catch Class:Reason ->
_ = websocket_close(State, Req, HandlerState, {crash, Class, Reason}),
erlang:Class([
@@ -630,104 +369,44 @@ handler_call(State=#state{handler=Handler}, Req, HandlerState,
])
end.
-websocket_opcode(text) -> 1;
-websocket_opcode(binary) -> 2;
-websocket_opcode(close) -> 8;
-websocket_opcode(ping) -> 9;
-websocket_opcode(pong) -> 10.
-
--spec websocket_deflate_frame(opcode(), binary(), #state{}) ->
- {binary(), rsv(), #state{}}.
-websocket_deflate_frame(Opcode, Payload,
- State=#state{deflate_frame = DeflateFrame})
- when DeflateFrame =:= false orelse Opcode >= 8 ->
- {Payload, << 0:3 >>, State};
-websocket_deflate_frame(_, Payload, State=#state{deflate_state = Deflate}) ->
- Deflated = iolist_to_binary(zlib:deflate(Deflate, Payload, sync)),
- DeflatedBodyLength = erlang:size(Deflated) - 4,
- Deflated1 = case Deflated of
- << Body:DeflatedBodyLength/binary, 0:8, 0:8, 255:8, 255:8 >> -> Body;
- _ -> Deflated
- end,
- {Deflated1, << 1:1, 0:2 >>, State}.
-
--spec websocket_send(frame(), #state{})
--> {ok, #state{}} | {shutdown, #state{}} | {{error, atom()}, #state{}}.
-websocket_send(Type, State=#state{socket=Socket, transport=Transport})
- when Type =:= close ->
- Opcode = websocket_opcode(Type),
- case Transport:send(Socket, << 1:1, 0:3, Opcode:4, 0:8 >>) of
- ok -> {shutdown, State};
- Error -> {Error, State}
- end;
-websocket_send(Type, State=#state{socket=Socket, transport=Transport})
- when Type =:= ping; Type =:= pong ->
- Opcode = websocket_opcode(Type),
- {Transport:send(Socket, << 1:1, 0:3, Opcode:4, 0:8 >>), State};
-websocket_send({close, Payload}, State) ->
- websocket_send({close, 1000, Payload}, State);
-websocket_send({Type = close, StatusCode, Payload}, State=#state{
- socket=Socket, transport=Transport}) ->
- Opcode = websocket_opcode(Type),
- Len = 2 + iolist_size(Payload),
- %% Control packets must not be > 125 in length.
- true = Len =< 125,
- BinLen = payload_length_to_binary(Len),
- Transport:send(Socket,
- [<< 1:1, 0:3, Opcode:4, 0:1, BinLen/bits, StatusCode:16 >>, Payload]),
- {shutdown, State};
-websocket_send({Type, Payload0}, State=#state{socket=Socket, transport=Transport}) ->
- Opcode = websocket_opcode(Type),
- {Payload, Rsv, State2} = websocket_deflate_frame(Opcode, iolist_to_binary(Payload0), State),
- Len = iolist_size(Payload),
- %% Control packets must not be > 125 in length.
- true = if Type =:= ping; Type =:= pong ->
- Len =< 125;
- true ->
- true
- end,
- BinLen = payload_length_to_binary(Len),
- {Transport:send(Socket,
- [<< 1:1, Rsv/bits, Opcode:4, 0:1, BinLen/bits >>, Payload]), State2}.
-
--spec payload_length_to_binary(0..16#7fffffffffffffff)
- -> << _:7 >> | << _:23 >> | << _:71 >>.
-payload_length_to_binary(N) ->
- case N of
- N when N =< 125 -> << N:7 >>;
- N when N =< 16#ffff -> << 126:7, N:16 >>;
- N when N =< 16#7fffffffffffffff -> << 127:7, N:64 >>
+-spec websocket_send(cow_ws:frame(), #state{}) -> ok | stop | {error, atom()}.
+websocket_send(Frame, #state{socket=Socket, transport=Transport, send_extensions=Extensions}) ->
+ Res = Transport:send(Socket, cow_ws:frame(Frame, Extensions)),
+ case Frame of
+ close -> stop;
+ {close, _} -> stop;
+ {close, _, _} -> stop;
+ _ -> Res
end.
--spec websocket_send_many([frame()], #state{})
- -> {ok, #state{}} | {shutdown, #state{}} | {{error, atom()}, #state{}}.
-websocket_send_many([], State) ->
- {ok, State};
+-spec websocket_send_many([cow_ws:frame()], #state{}) -> ok | stop | {error, atom()}.
+websocket_send_many([], _) ->
+ ok;
websocket_send_many([Frame|Tail], State) ->
case websocket_send(Frame, State) of
- {ok, State2} -> websocket_send_many(Tail, State2);
- {shutdown, State2} -> {shutdown, State2};
- {Error, State2} -> {Error, State2}
+ ok -> websocket_send_many(Tail, State);
+ stop -> stop;
+ Error -> Error
end.
-spec websocket_close(#state{}, Req, any(), terminate_reason())
-> {ok, Req, cowboy_middleware:env()}
when Req::cowboy_req:req().
-websocket_close(State=#state{socket=Socket, transport=Transport},
+websocket_close(State=#state{socket=Socket, transport=Transport, send_extensions=Extensions},
Req, HandlerState, Reason) ->
case Reason of
- Normal when Normal =:= shutdown; Normal =:= timeout ->
- Transport:send(Socket, << 1:1, 0:3, 8:4, 0:1, 2:7, 1000:16 >>);
+ Normal when Normal =:= stop; Normal =:= timeout ->
+ Transport:send(Socket, cow_ws:frame({close, 1000, <<>>}, Extensions));
{error, badframe} ->
- Transport:send(Socket, << 1:1, 0:3, 8:4, 0:1, 2:7, 1002:16 >>);
+ Transport:send(Socket, cow_ws:frame({close, 1002, <<>>}, Extensions));
{error, badencoding} ->
- Transport:send(Socket, << 1:1, 0:3, 8:4, 0:1, 2:7, 1007:16 >>);
+ Transport:send(Socket, cow_ws:frame({close, 1007, <<>>}, Extensions));
{crash, _, _} ->
- Transport:send(Socket, << 1:1, 0:3, 8:4, 0:1, 2:7, 1011:16 >>);
+ Transport:send(Socket, cow_ws:frame({close, 1011, <<>>}, Extensions));
remote ->
- Transport:send(Socket, << 1:1, 0:3, 8:4, 0:8 >>);
+ Transport:send(Socket, cow_ws:frame(close, Extensions));
{remote, Code, _} ->
- Transport:send(Socket, << 1:1, 0:3, 8:4, 0:1, 2:7, Code:16 >>)
+ Transport:send(Socket, cow_ws:frame({close, Code, <<>>}, Extensions))
end,
handler_terminate(State, Req, HandlerState, Reason).