umgeher/cowboy
0
Fork 0
mirror of https://github.com/ninenines/cowboy.git synced 2025-07-14 20:30:23 +00:00
Code Issues Wiki Activity
cowboy/test/ws_SUITE.erl

756 lines
32 KiB
Erlang
Raw Normal View History

Refresh copyright lines
2024-01-25 11:22:54 +01:00
%% Copyright (c) 2011-2024, Loïc Hoguin <essen@ninenines.eu>
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
%%
%% 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(ws_SUITE).
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
-compile(export_all).
Add nowarn_export_all to all test suites
2017-11-29 16:57:10 +01:00
-compile(nowarn_export_all).
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
Add rfc7230 test suite and update others to recent Gun This is a large commit. The rfc7230 test suite adds many tests from the RFC7230 document. Gun has been updated quite a bit recently, which broke the Cowboy suites. This is now fixed with this commit. A new hook onfirstrequest has been added. It was very useful during debugging of the test suites. The initial process code has changed a little; more changes are expected with the switch to maps for options.
2015-05-05 19:59:37 +03:00
-import(ct_helper, [config/2]).
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
-import(ct_helper, [doc/1]).
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
%% ct.
all() ->
Don't run long test suites by default The examples test suite is only useful once in a while in order to know whether examples were broken, for example before issuing a release. The new ws_autobahn test suite isolates the autobahn test suite so that it can be ignored by default. It's only useful to run it when working on the Websocket code or before issuing a release.
2018-11-20 13:23:59 +01:00
[{group, ws}].
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
groups() ->
Don't run long test suites by default The examples test suite is only useful once in a while in order to know whether examples were broken, for example before issuing a release. The new ws_autobahn test suite isolates the autobahn test suite so that it can be ignored by default. It's only useful to run it when working on the Websocket code or before issuing a release.
2018-11-20 13:23:59 +01:00
[{ws, [parallel], ct_helper:all(?MODULE)}].
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
Don't run long test suites by default The examples test suite is only useful once in a while in order to know whether examples were broken, for example before issuing a release. The new ws_autobahn test suite isolates the autobahn test suite so that it can be ignored by default. It's only useful to run it when working on the Websocket code or before issuing a release.
2018-11-20 13:23:59 +01:00
init_per_group(Name, Config) ->
Initial commit with connection/streams Breaking changes with previous commit. This is a very large change, and I am giving up on making a single commit that fixes everything. More commits will follow slowly adding back features, introducing new tests and fixing the documentation. This change contains most of the work toward unifying the interface for handling both HTTP/1.1 and HTTP/2. HTTP/1.1 connections are now no longer 1 process per connection; instead by default 1 process per request is also created. This has a number of pros and cons. Because it has cons, we also allow users to use a lower-level API that acts on "streams" (requests/responses) directly at the connection process-level. If performance is a concern, one can always write a stream handler. The performance in this case will be even greater than with Cowboy 1, although all the special handlers are unavailable. When switching to Websocket, after the handler returns from init/2, Cowboy stops the stream and the Websocket protocol takes over the connection process. Websocket then calls websocket_init/2 for any additional initialization such as timers, because the process is different in init/2 and websocket_*/* functions. This however would allow us to use websocket_init/2 for sending messages on connect, instead of sending ourselves a message and be subject to races. Note that websocket_init/2 is optional. This is all a big change and while most of the tests pass, some functionality currently doesn't. SPDY is broken and will be removed soon in favor of HTTP/2. Automatic compression is currently disabled. The cowboy_req interface probably still have a few functions that need to be updated. The docs and examples do not refer the current functionality anymore. Everything will be fixed over time. Feedback is more than welcome. Open a ticket!
2016-02-10 17:28:32 +01:00
cowboy_test:init_http(Name, #{
Allow passing options to sub protocols Before this commit we had an issue where configuring a Websocket connection was simply not possible without doing magic, adding callbacks or extra return values. The init/2 function only allowed setting hibernate and timeout options. After this commit, when switching to a different type of handler you can either return {module, Req, State} or {module, Req, State, Opts} where Opts is any value (as far as the sub protocol interface is concerned) and is ultimately checked by the custom handlers. A large protocol like Websocket would accept only a map there, with many different options, while a small interface like loop handlers would allow passing hibernate and nothing else. For Websocket, hibernate must be set from the websocket_init/1 callback, because init/2 executes in a separate process. Sub protocols now have two callbacks: one with the Opts value, one without. The loop handler code was largely reworked and simplified. It does not need to manage a timeout or read from the socket anymore, it's the job of the protocol code. A lot of unnecessary stuff was therefore removed. Websocket compression must now be enabled from the handler options instead of per listener. This means that a project can have two separate Websocket handlers with different options. Compression is still disabled by default, and the idle_timeout value was changed from inifnity to 60000 (60 seconds), as that's safer and is also a good value for mobile devices.
2017-02-18 18:26:20 +01:00
env => #{dispatch => init_dispatch()}
Initial commit with connection/streams Breaking changes with previous commit. This is a very large change, and I am giving up on making a single commit that fixes everything. More commits will follow slowly adding back features, introducing new tests and fixing the documentation. This change contains most of the work toward unifying the interface for handling both HTTP/1.1 and HTTP/2. HTTP/1.1 connections are now no longer 1 process per connection; instead by default 1 process per request is also created. This has a number of pros and cons. Because it has cons, we also allow users to use a lower-level API that acts on "streams" (requests/responses) directly at the connection process-level. If performance is a concern, one can always write a stream handler. The performance in this case will be even greater than with Cowboy 1, although all the special handlers are unavailable. When switching to Websocket, after the handler returns from init/2, Cowboy stops the stream and the Websocket protocol takes over the connection process. Websocket then calls websocket_init/2 for any additional initialization such as timers, because the process is different in init/2 and websocket_*/* functions. This however would allow us to use websocket_init/2 for sending messages on connect, instead of sending ourselves a message and be subject to races. Note that websocket_init/2 is optional. This is all a big change and while most of the tests pass, some functionality currently doesn't. SPDY is broken and will be removed soon in favor of HTTP/2. Automatic compression is currently disabled. The cowboy_req interface probably still have a few functions that need to be updated. The docs and examples do not refer the current functionality anymore. Everything will be fixed over time. Feedback is more than welcome. Open a ticket!
2016-02-10 17:28:32 +01:00
}, Config).
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
end_per_group(Listener, _Config) ->
Move listener initialization to cowboy_test
2014-04-22 22:50:45 +02:00
cowboy:stop_listener(Listener).
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
%% Dispatch configuration.
init_dispatch() ->
New routing Ultimately few things change, it's mostly just a nicer syntax and slightly different expectations. The name of the value `dispatch` did not change, because the previous dispatch values will now fail if the code is not updated to using `cowboy_router:compile/1`. No constraints have been implemented in this commit.
2013-01-28 16:53:09 +01:00
cowboy_router:compile([
{"localhost", [
Reorganize the websocket test suite We now have the suite specific modules in the data folder. Compilation is performed by the Makefile instead of ct_run.
2013-04-22 15:55:22 +02:00
{"/ws_echo", ws_echo, []},
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
{"/ws_echo_timer", ws_echo_timer, []},
Allow websocket_init/1 to reply/close/hibernate
2016-08-15 19:21:38 +02:00
{"/ws_init", ws_init_h, []},
Reorganize the websocket test suite We now have the suite specific modules in the data folder. Compilation is performed by the Makefile instead of ct_run.
2013-04-22 15:55:22 +02:00
{"/ws_init_shutdown", ws_init_shutdown, []},
{"/ws_send_many", ws_send_many, [
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
{sequence, [
{text, <<"one">>},
{text, <<"two">>},
{text, <<"seven!">>}]}
]},
Reorganize the websocket test suite We now have the suite specific modules in the data folder. Compilation is performed by the Makefile instead of ct_run.
2013-04-22 15:55:22 +02:00
{"/ws_send_close", ws_send_many, [
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
{sequence, [
{text, <<"send">>},
close,
{text, <<"won't be received">>}]}
]},
Reorganize the websocket test suite We now have the suite specific modules in the data folder. Compilation is performed by the Makefile instead of ct_run.
2013-04-22 15:55:22 +02:00
{"/ws_send_close_payload", ws_send_many, [
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
{sequence, [
{text, <<"send">>},
Add {close, StatusCode, Payload} and fix {close, Payload}
2012-12-08 19:11:56 +01:00
{close, 1001, <<"some text!">>},
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
{text, <<"won't be received">>}]}
]},
Merge branch 'master' of https://github.com/camshaft/cowboy
2016-08-12 17:01:01 +02:00
{"/ws_subprotocol", ws_subprotocol, []},
Introduce the req_filter Websocket option This option allows customizing the compacting of the Req object when using Websocket. By default it will keep most public fields excluding headers of course, since those can be large.
2017-05-28 19:04:16 +02:00
{"/terminate", ws_terminate_h, []},
Reorganize the websocket test suite We now have the suite specific modules in the data folder. Compilation is performed by the Makefile instead of ct_run.
2013-04-22 15:55:22 +02:00
{"/ws_timeout_hibernate", ws_timeout_hibernate, []},
Add max_frame_size option for websocket handlers Option allows to limit a frame by size before decoding its payload. LH: I have added a test for when the limit is reached on a nofin fragmented frame (the last commit addressed that case but it had no test). I have fixed formatting and other, and changed the default value to infinity since it might otherwise be incompatible with existing code. I also added documentation and a bunch of other minor changes.
2017-08-25 12:08:26 +03:00
{"/ws_timeout_cancel", ws_timeout_cancel, []},
Add deflate options for Websocket compression They allow the server to configure what it is willing to accept for both the negotiated configuration (takeover and window bits) and the other zlib options (level, mem_level and strategy). This can be used to reduce the memory and/or CPU footprint of the compressed data, which comes with a cost in compression ratio.
2018-11-12 18:12:44 +01:00
{"/ws_max_frame_size", ws_max_frame_size, []},
Add Websocket option validate_utf8 This allows disabling the UTF-8 validation check for text and close frames.
2019-10-05 17:32:50 +02:00
{"/ws_deflate_opts", ws_deflate_opts_h, []},
Confirm Websocket pong frames are received by handlers
2024-01-16 12:20:38 +01:00
{"/ws_dont_validate_utf8", ws_dont_validate_utf8_h, []},
{"/ws_ping", ws_ping_h, []}
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
]}
New routing Ultimately few things change, it's mostly just a nicer syntax and slightly different expectations. The name of the value `dispatch` did not change, because the previous dispatch values will now fail if the code is not updated to using `cowboy_router:compile/1`. No constraints have been implemented in this commit.
2013-01-28 16:53:09 +01:00
]).
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
%% Tests.
Add a Websocket test with 3000 connections To ensure the connections are not limited by max_connections.
2018-04-17 18:54:47 +02:00
unlimited_connections(Config) ->
doc("Websocket connections are not limited. The connections "
"are removed from the count after the handshake completes."),
Disable ws_SUITE:unlimited_connections on Windows
2020-04-02 17:36:03 +02:00
case os:type() of
{win32, _} ->
{skip, "Tests that use too many sockets are disabled on Windows "
"to prevent intermittent failures."};
{unix, _} ->
case list_to_integer(os:cmd("printf `ulimit -n`")) of
Limit when Limit > 6100 ->
do_unlimited_connections(Config);
_ ->
{skip, "`ulimit -n` reports a limit too low for this test."}
end
Skip ws_SUITE:unlimited_connections when ulimit -n is too low
2020-04-02 16:23:36 +02:00
end.
do_unlimited_connections(Config) ->
Add a Websocket test with 3000 connections To ensure the connections are not limited by max_connections.
2018-04-17 18:54:47 +02:00
_ = [begin
spawn_link(fun() -> do_connect_and_loop(Config) end),
timer:sleep(1)
end || _ <- lists:seq(1, 3000)],
timer:sleep(1000),
%% We have at least 3000 client and 3000 server sockets.
true = length(erlang:ports()) > 6000,
%% Ranch thinks we have no connections.
0 = ranch_server:count_connections(ws),
ok.
do_connect_and_loop(Config) ->
{ok, Socket, _} = do_handshake("/ws_echo", Config),
do_loop(Socket).
do_loop(Socket) ->
%% Masked text hello echoed back clear by the server.
Mask = 16#37fa213d,
MaskedHello = do_mask(<<"Hello">>, Mask, <<>>),
ok = gen_tcp:send(Socket, << 1:1, 0:3, 1:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 0:3, 1:4, 0:1, 5:7, "Hello" >>} = gen_tcp:recv(Socket, 0, 6000),
timer:sleep(1000),
do_loop(Socket).
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
ws0(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Websocket version 0 (hixie-76 draft) is no longer supported."),
{ok, Socket} = gen_tcp:connect("localhost", config(port, Config), [binary, {active, false}]),
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
ok = gen_tcp:send(Socket,
Reorganize the websocket test suite We now have the suite specific modules in the data folder. Compilation is performed by the Makefile instead of ct_run.
2013-04-22 15:55:22 +02:00
"GET /ws_echo_timer HTTP/1.1\r\n"
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
"Host: localhost\r\n"
"Connection: Upgrade\r\n"
"Upgrade: WebSocket\r\n"
"Origin: http://localhost\r\n"
"Sec-Websocket-Key1: Y\" 4 1Lj!957b8@0H756!i\r\n"
"Sec-Websocket-Key2: 1711 M;4\\74 80<6\r\n"
"\r\n"),
{ok, Handshake} = gen_tcp:recv(Socket, 0, 6000),
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, {http_response, {1, 1}, 400, _}, _} = erlang:decode_packet(http, Handshake, []),
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
ok.
Test Websocket protocol version 7 A bit late but at least removes a todo.
2017-02-05 11:27:54 +01:00
ws7(Config) ->
doc("Websocket version 7 (draft) is supported."),
{ok, Socket} = gen_tcp:connect("localhost", config(port, Config), [binary, {active, false}]),
ok = gen_tcp:send(Socket, [
"GET /ws_echo_timer HTTP/1.1\r\n"
"Host: localhost\r\n"
"Connection: Upgrade\r\n"
"Upgrade: websocket\r\n"
"Sec-WebSocket-Origin: http://localhost\r\n"
"Sec-WebSocket-Version: 7\r\n"
"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
"\r\n"]),
{ok, Handshake} = gen_tcp:recv(Socket, 0, 6000),
{ok, {http_response, {1, 1}, 101, _}, Rest} = erlang:decode_packet(http, Handshake, []),
[Headers, <<>>] = do_decode_headers(erlang:decode_packet(httph, Rest, []), []),
{_, "Upgrade"} = lists:keyfind('Connection', 1, Headers),
{_, "websocket"} = lists:keyfind('Upgrade', 1, Headers),
{_, "s3pPLMBiTxaQ9kYGzzhZRbK+xOo="} = lists:keyfind("sec-websocket-accept", 1, Headers),
do_ws_version(Socket).
Allow websocket handlers to reply more than one frame Instead of returning {text, Data}, you can now return [{text, Data}, {text, Data2}, ...].
2012-10-11 21:46:43 +02:00
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
ws8(Config) ->
doc("Websocket version 8 (draft) is supported."),
{ok, Socket} = gen_tcp:connect("localhost", config(port, Config), [binary, {active, false}]),
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
ok = gen_tcp:send(Socket, [
Reorganize the websocket test suite We now have the suite specific modules in the data folder. Compilation is performed by the Makefile instead of ct_run.
2013-04-22 15:55:22 +02:00
"GET /ws_echo_timer HTTP/1.1\r\n"
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
"Host: localhost\r\n"
"Connection: Upgrade\r\n"
"Upgrade: websocket\r\n"
"Sec-WebSocket-Origin: http://localhost\r\n"
"Sec-WebSocket-Version: 8\r\n"
"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
"\r\n"]),
{ok, Handshake} = gen_tcp:recv(Socket, 0, 6000),
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, {http_response, {1, 1}, 101, _}, Rest} = erlang:decode_packet(http, Handshake, []),
[Headers, <<>>] = do_decode_headers(erlang:decode_packet(httph, Rest, []), []),
{_, "Upgrade"} = lists:keyfind('Connection', 1, Headers),
{_, "websocket"} = lists:keyfind('Upgrade', 1, Headers),
{_, "s3pPLMBiTxaQ9kYGzzhZRbK+xOo="} = lists:keyfind("sec-websocket-accept", 1, Headers),
do_ws_version(Socket).
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
ws13(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Websocket version 13 (RFC) is supported."),
{ok, Socket, _} = do_handshake("/ws_echo_timer", Config),
do_ws_version(Socket).
do_ws_version(Socket) ->
%% Masked text hello echoed back clear by the server.
Mask = 16#37fa213d,
MaskedHello = do_mask(<<"Hello">>, Mask, <<>>),
ok = gen_tcp:send(Socket, << 1:1, 0:3, 1:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 0:3, 1:4, 0:1, 5:7, "Hello" >>} = gen_tcp:recv(Socket, 0, 6000),
%% Empty binary frame echoed back.
All frames sent from client to server MUST be masked Good in theory, but implementations may vary. If something stops working after this commit we might need some tweaks to support existing clients. Please try it and give feedback.
2013-01-12 16:04:35 +01:00
ok = gen_tcp:send(Socket, << 1:1, 0:3, 2:4, 1:1, 0:7, 0:32 >>),
Add ct tests for binary websocket frames
2011-12-22 20:19:05 +01:00
{ok, << 1:1, 0:3, 2:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
%% Masked binary hello echoed back clear by the server.
ok = gen_tcp:send(Socket, << 1:1, 0:3, 2:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 0:3, 2:4, 0:1, 5:7, "Hello" >>} = gen_tcp:recv(Socket, 0, 6000),
%% Frames sent on timer by the handler.
{ok, << 1:1, 0:3, 1:4, 0:1, 14:7, "websocket_init" >>} = gen_tcp:recv(Socket, 0, 6000),
{ok, << 1:1, 0:3, 1:4, 0:1, 16:7, "websocket_handle" >>} = gen_tcp:recv(Socket, 0, 6000),
{ok, << 1:1, 0:3, 1:4, 0:1, 16:7, "websocket_handle" >>} = gen_tcp:recv(Socket, 0, 6000),
{ok, << 1:1, 0:3, 1:4, 0:1, 16:7, "websocket_handle" >>} = gen_tcp:recv(Socket, 0, 6000),
%% Client-initiated ping/pong.
ok = gen_tcp:send(Socket, << 1:1, 0:3, 9:4, 1:1, 0:7, 0:32 >>),
{ok, << 1:1, 0:3, 10:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
%% Client-initiated close.
ok = gen_tcp:send(Socket, << 1:1, 0:3, 8:4, 1:1, 0:7, 0:32 >>),
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
{ok, << 1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
Add support for the webkit deflate frame extension
2013-04-15 18:36:33 +02:00
ok.
Add test to ensure max_frame_size works for decompressed data
2025-01-22 14:34:33 +01:00
ws_deflate_max_frame_size_close(Config) ->
doc("Server closes connection when decompressed frame size exceeds max_frame_size option"),
%% max_frame_size is set to 8 bytes in ws_max_frame_size.
{ok, Socket, Headers} = do_handshake("/ws_max_frame_size",
"Sec-WebSocket-Extensions: permessage-deflate\r\n", Config),
{_, "permessage-deflate"} = lists:keyfind("sec-websocket-extensions", 1, Headers),
Mask = 16#11223344,
Z = zlib:open(),
zlib:deflateInit(Z, best_compression, deflated, -15, 8, default),
CompressedData0 = iolist_to_binary(zlib:deflate(Z, <<0:800>>, sync)),
CompressedData = binary:part(CompressedData0, 0, byte_size(CompressedData0) - 4),
MaskedData = do_mask(CompressedData, Mask, <<>>),
Len = byte_size(MaskedData),
true = Len < 8,
ok = gen_tcp:send(Socket, << 1:1, 1:1, 0:2, 1:4, 1:1, Len:7, Mask:32, MaskedData/binary >>),
{ok, << 1:1, 0:3, 8:4, 0:1, 2:7, 1009:16 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
Add deflate options for Websocket compression They allow the server to configure what it is willing to accept for both the negotiated configuration (takeover and window bits) and the other zlib options (level, mem_level and strategy). This can be used to reduce the memory and/or CPU footprint of the compressed data, which comes with a cost in compression ratio.
2018-11-12 18:12:44 +01:00
ws_deflate_opts_client_context_takeover(Config) ->
doc("Handler is configured with client context takeover enabled."),
{ok, _, Headers1} = do_handshake("/ws_deflate_opts?client_context_takeover",
"Sec-WebSocket-Extensions: permessage-deflate\r\n", Config),
{_, "permessage-deflate"}
= lists:keyfind("sec-websocket-extensions", 1, Headers1),
{ok, _, Headers2} = do_handshake("/ws_deflate_opts?client_context_takeover",
"Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover\r\n", Config),
{_, "permessage-deflate; client_no_context_takeover"}
= lists:keyfind("sec-websocket-extensions", 1, Headers2),
ok.
ws_deflate_opts_client_no_context_takeover(Config) ->
doc("Handler is configured with client context takeover disabled."),
{ok, _, Headers1} = do_handshake("/ws_deflate_opts?client_no_context_takeover",
"Sec-WebSocket-Extensions: permessage-deflate\r\n", Config),
{_, "permessage-deflate; client_no_context_takeover"}
= lists:keyfind("sec-websocket-extensions", 1, Headers1),
{ok, _, Headers2} = do_handshake("/ws_deflate_opts?client_no_context_takeover",
"Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover\r\n", Config),
{_, "permessage-deflate; client_no_context_takeover"}
= lists:keyfind("sec-websocket-extensions", 1, Headers2),
ok.
%% We must send client_max_window_bits to indicate we support it.
ws_deflate_opts_client_max_window_bits(Config) ->
doc("Handler is configured with client max window bits."),
{ok, _, Headers} = do_handshake("/ws_deflate_opts?client_max_window_bits",
"Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits\r\n", Config),
{_, "permessage-deflate; client_max_window_bits=9"}
= lists:keyfind("sec-websocket-extensions", 1, Headers),
ok.
ws_deflate_opts_client_max_window_bits_override(Config) ->
doc("Handler is configured with client max window bits."),
{ok, _, Headers1} = do_handshake("/ws_deflate_opts?client_max_window_bits",
"Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits=8\r\n", Config),
{_, "permessage-deflate; client_max_window_bits=8"}
= lists:keyfind("sec-websocket-extensions", 1, Headers1),
{ok, _, Headers2} = do_handshake("/ws_deflate_opts?client_max_window_bits",
"Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits=12\r\n", Config),
{_, "permessage-deflate; client_max_window_bits=9"}
= lists:keyfind("sec-websocket-extensions", 1, Headers2),
ok.
ws_deflate_opts_server_context_takeover(Config) ->
doc("Handler is configured with server context takeover enabled."),
{ok, _, Headers1} = do_handshake("/ws_deflate_opts?server_context_takeover",
"Sec-WebSocket-Extensions: permessage-deflate\r\n", Config),
{_, "permessage-deflate"}
= lists:keyfind("sec-websocket-extensions", 1, Headers1),
{ok, _, Headers2} = do_handshake("/ws_deflate_opts?server_context_takeover",
"Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover\r\n", Config),
{_, "permessage-deflate; server_no_context_takeover"}
= lists:keyfind("sec-websocket-extensions", 1, Headers2),
ok.
ws_deflate_opts_server_no_context_takeover(Config) ->
doc("Handler is configured with server context takeover disabled."),
{ok, _, Headers1} = do_handshake("/ws_deflate_opts?server_no_context_takeover",
"Sec-WebSocket-Extensions: permessage-deflate\r\n", Config),
{_, "permessage-deflate; server_no_context_takeover"}
= lists:keyfind("sec-websocket-extensions", 1, Headers1),
{ok, _, Headers2} = do_handshake("/ws_deflate_opts?server_no_context_takeover",
"Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover\r\n", Config),
{_, "permessage-deflate; server_no_context_takeover"}
= lists:keyfind("sec-websocket-extensions", 1, Headers2),
ok.
ws_deflate_opts_server_max_window_bits(Config) ->
doc("Handler is configured with server max window bits."),
{ok, _, Headers} = do_handshake("/ws_deflate_opts?server_max_window_bits",
"Sec-WebSocket-Extensions: permessage-deflate\r\n", Config),
{_, "permessage-deflate; server_max_window_bits=9"}
= lists:keyfind("sec-websocket-extensions", 1, Headers),
ok.
ws_deflate_opts_server_max_window_bits_override(Config) ->
doc("Handler is configured with server max window bits."),
{ok, _, Headers1} = do_handshake("/ws_deflate_opts?server_max_window_bits",
"Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=8\r\n", Config),
{_, "permessage-deflate; server_max_window_bits=8"}
= lists:keyfind("sec-websocket-extensions", 1, Headers1),
{ok, _, Headers2} = do_handshake("/ws_deflate_opts?server_max_window_bits",
"Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=12\r\n", Config),
{_, "permessage-deflate; server_max_window_bits=9"}
= lists:keyfind("sec-websocket-extensions", 1, Headers2),
ok.
ws_deflate_opts_zlevel(Config) ->
doc("Handler is configured with zlib level."),
do_ws_deflate_opts_z("/ws_deflate_opts?level", Config).
ws_deflate_opts_zmemlevel(Config) ->
doc("Handler is configured with zlib mem_level."),
do_ws_deflate_opts_z("/ws_deflate_opts?mem_level", Config).
ws_deflate_opts_zstrategy(Config) ->
doc("Handler is configured with zlib strategy."),
do_ws_deflate_opts_z("/ws_deflate_opts?strategy", Config).
do_ws_deflate_opts_z(Path, Config) ->
{ok, Socket, Headers} = do_handshake(Path,
"Sec-WebSocket-Extensions: permessage-deflate\r\n", Config),
{_, "permessage-deflate"} = lists:keyfind("sec-websocket-extensions", 1, Headers),
%% Send and receive a compressed "Hello" frame.
Mask = 16#11223344,
CompressedHello = << 242, 72, 205, 201, 201, 7, 0 >>,
MaskedHello = do_mask(CompressedHello, Mask, <<>>),
ok = gen_tcp:send(Socket, << 1:1, 1:1, 0:2, 1:4, 1:1, 7:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 1:1, 0:2, 1:4, 0:1, 7:7, CompressedHello/binary >>} = gen_tcp:recv(Socket, 0, 6000),
%% Client-initiated close.
ok = gen_tcp:send(Socket, << 1:1, 0:3, 8:4, 1:1, 0:7, 0:32 >>),
{ok, << 1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
Add Websocket option validate_utf8 This allows disabling the UTF-8 validation check for text and close frames.
2019-10-05 17:32:50 +02:00
ok.
ws_dont_validate_utf8(Config) ->
doc("Handler is configured with UTF-8 validation disabled."),
{ok, Socket, _} = do_handshake("/ws_dont_validate_utf8", Config),
%% Send an invalid UTF-8 text frame and receive it back.
Mask = 16#37fa213d,
MaskedInvalid = do_mask(<<255, 255, 255, 255>>, Mask, <<>>),
ok = gen_tcp:send(Socket, <<1:1, 0:3, 1:4, 1:1, 4:7, Mask:32, MaskedInvalid/binary>>),
{ok, <<1:1, 0:3, 1:4, 0:1, 4:7, 255, 255, 255, 255>>} = gen_tcp:recv(Socket, 0, 6000),
Add deflate options for Websocket compression They allow the server to configure what it is willing to accept for both the negotiated configuration (takeover and window bits) and the other zlib options (level, mem_level and strategy). This can be used to reduce the memory and/or CPU footprint of the compressed data, which comes with a cost in compression ratio.
2018-11-12 18:12:44 +01:00
ok.
Don't discard data following a Websocket upgrade request While the protocol does not allow sending data before receiving a successful Websocket upgrade response, we do not want to discard that data if it does come in.
2019-10-05 13:04:21 +02:00
ws_first_frame_with_handshake(Config) ->
doc("Client sends the first frame immediately with the handshake. "
"This is invalid according to the protocol but we still want "
"to accept it if the handshake is successful."),
Mask = 16#37fa213d,
MaskedHello = do_mask(<<"Hello">>, Mask, <<>>),
{ok, Socket, _} = do_handshake("/ws_echo", "",
<<1:1, 0:3, 1:4, 1:1, 5:7, Mask:32, MaskedHello/binary>>,
Config),
{ok, <<1:1, 0:3, 1:4, 0:1, 5:7, "Hello">>} = gen_tcp:recv(Socket, 0, 6000),
ok.
Ensure HTTP/1.1 Websocket resets the trap_exit flag While we are identified as a supervisor in the tree, we no longer manage children processes at that point, so do not need to trap exit signals. Users can still enable trap_exit if they prefer to.
2024-01-08 11:44:34 +01:00
%% @todo Move these tests to ws_handler_SUITE.
Allow websocket_init/1 to reply/close/hibernate
2016-08-15 19:21:38 +02:00
ws_init_return_ok(Config) ->
doc("Handler does nothing."),
{ok, Socket, _} = do_handshake("/ws_init?ok", Config),
%% The handler does nothing; nothing should happen here.
{error, timeout} = gen_tcp:recv(Socket, 0, 1000),
ok.
ws_init_return_ok_hibernate(Config) ->
doc("Handler does nothing; hibernates."),
{ok, Socket, _} = do_handshake("/ws_init?ok_hibernate", Config),
%% The handler does nothing; nothing should happen here.
{error, timeout} = gen_tcp:recv(Socket, 0, 1000),
ok.
ws_init_return_reply(Config) ->
doc("Handler sends a text frame just after the handshake."),
{ok, Socket, _} = do_handshake("/ws_init?reply", Config),
{ok, << 1:1, 0:3, 1:4, 0:1, 5:7, "Hello" >>} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_init_return_reply_hibernate(Config) ->
doc("Handler sends a text frame just after the handshake and then hibernates."),
{ok, Socket, _} = do_handshake("/ws_init?reply_hibernate", Config),
{ok, << 1:1, 0:3, 1:4, 0:1, 5:7, "Hello" >>} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_init_return_reply_close(Config) ->
doc("Handler closes immediately after the handshake."),
{ok, Socket, _} = do_handshake("/ws_init?reply_close", Config),
{ok, << 1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_init_return_reply_close_hibernate(Config) ->
doc("Handler closes immediately after the handshake, then attempts to hibernate."),
{ok, Socket, _} = do_handshake("/ws_init?reply_close_hibernate", Config),
{ok, << 1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_init_return_reply_many(Config) ->
doc("Handler sends many frames just after the handshake."),
{ok, Socket, _} = do_handshake("/ws_init?reply_many", Config),
%% We catch all frames at once and check them directly.
{ok, <<
1:1, 0:3, 1:4, 0:1, 5:7, "Hello",
1:1, 0:3, 2:4, 0:1, 5:7, "World" >>} = gen_tcp:recv(Socket, 14, 6000),
ok.
ws_init_return_reply_many_hibernate(Config) ->
doc("Handler sends many frames just after the handshake and then hibernates."),
{ok, Socket, _} = do_handshake("/ws_init?reply_many_hibernate", Config),
%% We catch all frames at once and check them directly.
{ok, <<
1:1, 0:3, 1:4, 0:1, 5:7, "Hello",
1:1, 0:3, 2:4, 0:1, 5:7, "World" >>} = gen_tcp:recv(Socket, 14, 6000),
ok.
ws_init_return_reply_many_close(Config) ->
doc("Handler sends many frames including a close frame just after the handshake."),
{ok, Socket, _} = do_handshake("/ws_init?reply_many_close", Config),
%% We catch all frames at once and check them directly.
{ok, <<
1:1, 0:3, 1:4, 0:1, 5:7, "Hello",
1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 9, 6000),
ok.
ws_init_return_reply_many_close_hibernate(Config) ->
doc("Handler sends many frames including a close frame just after the handshake and then hibernates."),
{ok, Socket, _} = do_handshake("/ws_init?reply_many_close_hibernate", Config),
%% We catch all frames at once and check them directly.
{ok, <<
1:1, 0:3, 1:4, 0:1, 5:7, "Hello",
1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 9, 6000),
ok.
ws_init_shutdown_before_handshake(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Handler stops before Websocket handshake."),
{ok, Socket} = gen_tcp:connect("localhost", config(port, Config), [binary, {active, false}]),
Add support for the webkit deflate frame extension
2013-04-15 18:36:33 +02:00
ok = gen_tcp:send(Socket, [
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
"GET /ws_init_shutdown HTTP/1.1\r\n"
Add failing tests for the websocket deflate support
2013-07-02 13:44:28 +02:00
"Host: localhost\r\n"
"Connection: Upgrade\r\n"
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
"Origin: http://localhost\r\n"
"Sec-WebSocket-Version: 13\r\n"
Add failing tests for the websocket deflate support
2013-07-02 13:44:28 +02:00
"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
"Upgrade: websocket\r\n"
"\r\n"]),
{ok, Handshake} = gen_tcp:recv(Socket, 0, 6000),
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, {http_response, {1, 1}, 403, _}, _Rest} = erlang:decode_packet(http, Handshake, []),
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
ok.
Add max_frame_size option for websocket handlers Option allows to limit a frame by size before decoding its payload. LH: I have added a test for when the limit is reached on a nofin fragmented frame (the last commit addressed that case but it had no test). I have fixed formatting and other, and changed the default value to infinity since it might otherwise be incompatible with existing code. I also added documentation and a bunch of other minor changes.
2017-08-25 12:08:26 +03:00
ws_max_frame_size_close(Config) ->
doc("Server closes connection when frame size exceeds max_frame_size option"),
%% max_frame_size is set to 8 bytes in ws_max_frame_size.
{ok, Socket, _} = do_handshake("/ws_max_frame_size", Config),
Mask = 16#11223344,
MaskedHello = do_mask(<<"HelloHello">>, Mask, <<>>),
ok = gen_tcp:send(Socket, << 1:1, 0:3, 2:4, 1:1, 10:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 0:3, 8:4, 0:1, 2:7, 1009:16 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_max_frame_size_final_fragment_close(Config) ->
doc("Server closes connection when final fragmented frame "
"exceeds max_frame_size option"),
%% max_frame_size is set to 8 bytes in ws_max_frame_size.
{ok, Socket, _} = do_handshake("/ws_max_frame_size", Config),
Mask = 16#11223344,
MaskedHello = do_mask(<<"Hello">>, Mask, <<>>),
ok = gen_tcp:send(Socket, << 0:1, 0:3, 2:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
ok = gen_tcp:send(Socket, << 1:1, 0:3, 0:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 0:3, 8:4, 0:1, 2:7, 1009:16 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_max_frame_size_intermediate_fragment_close(Config) ->
doc("Server closes connection when intermediate fragmented frame "
"exceeds max_frame_size option"),
%% max_frame_size is set to 8 bytes in ws_max_frame_size.
{ok, Socket, _} = do_handshake("/ws_max_frame_size", Config),
Mask = 16#11223344,
MaskedHello = do_mask(<<"Hello">>, Mask, <<>>),
ok = gen_tcp:send(Socket, << 0:1, 0:3, 2:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
ok = gen_tcp:send(Socket, << 0:1, 0:3, 0:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
ok = gen_tcp:send(Socket, << 1:1, 0:3, 0:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 0:3, 8:4, 0:1, 2:7, 1009:16 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
Confirm Websocket pong frames are received by handlers
2024-01-16 12:20:38 +01:00
ws_ping(Config) ->
doc("Server initiated pings can receive a pong in response."),
{ok, Socket, _} = do_handshake("/ws_ping", Config),
%% Receive a server-sent ping.
{ok, << 1:1, 0:3, 9:4, 0:1, 0:7 >>} = gen_tcp:recv(Socket, 0, 6000),
%% Send a pong back with a 0 mask.
ok = gen_tcp:send(Socket, << 1:1, 0:3, 10:4, 1:1, 0:7, 0:32 >>),
%% Receive a text frame as a result.
{ok, << 1:1, 0:3, 1:4, 0:1, 4:7, "OK!!" >>} = gen_tcp:recv(Socket, 0, 6000),
ok.
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
ws_send_close(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Server-initiated close frame ends the connection."),
{ok, Socket, _} = do_handshake("/ws_send_close", Config),
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
%% We catch all frames at once and check them directly.
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, <<
1:1, 0:3, 1:4, 0:1, 4:7, "send",
1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 8, 6000),
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_send_close_payload(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Server-initiated close frame with payload ends the connection."),
{ok, Socket, _} = do_handshake("/ws_send_close_payload", Config),
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
%% We catch all frames at once and check them directly.
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, <<
1:1, 0:3, 1:4, 0:1, 4:7, "send",
1:1, 0:3, 8:4, 0:1, 12:7, 1001:16, "some text!" >>} = gen_tcp:recv(Socket, 20, 6000),
Add more frame types available in websocket replies We can now reply empty close, ping and pong frames, or close frames with a payload. This means that we can send a frame and then close the connection in a single operation. If a close packet is sent, the connection is closed immediately, even if there was frames that remained to be sent. Cowboy will silently drop any extra frames in the list given as a reply.
2012-12-02 21:37:24 +01:00
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
Allow websocket handlers to reply more than one frame Instead of returning {text, Data}, you can now return [{text, Data}, {text, Data2}, ...].
2012-10-11 21:46:43 +02:00
ws_send_many(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Server sends many frames in a single reply."),
{ok, Socket, _} = do_handshake("/ws_send_many", Config),
Fix a test that worked intermittently
2012-11-27 17:31:54 +01:00
%% We catch all frames at once and check them directly.
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, <<
1:1, 0:3, 1:4, 0:1, 3:7, "one",
Fix a test that worked intermittently
2012-11-27 17:31:54 +01:00
1:1, 0:3, 1:4, 0:1, 3:7, "two",
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
1:1, 0:3, 1:4, 0:1, 6:7, "seven!" >>} = gen_tcp:recv(Socket, 18, 6000),
ok.
ws_single_bytes(Config) ->
doc("Client sends a text frame one byte at a time."),
{ok, Socket, _} = do_handshake("/ws_echo", Config),
%% We sleep between sends to make sure only one byte is sent.
ok = gen_tcp:send(Socket, << 16#81 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#85 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#37 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#fa >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#21 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#3d >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#7f >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#9f >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#4d >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#51 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#58 >>),
{ok, << 1:1, 0:3, 1:4, 0:1, 5:7, "Hello" >>} = gen_tcp:recv(Socket, 0, 6000),
Allow websocket handlers to reply more than one frame Instead of returning {text, Data}, you can now return [{text, Data}, {text, Data2}, ...].
2012-10-11 21:46:43 +02:00
ok.
Merge branch 'master' of https://github.com/camshaft/cowboy
2016-08-12 17:01:01 +02:00
ws_subprotocol(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Websocket sub-protocol negotiation."),
{ok, _, Headers} = do_handshake("/ws_subprotocol",
"Sec-WebSocket-Protocol: foo, bar\r\n", Config),
{_, "foo"} = lists:keyfind("sec-websocket-protocol", 1, Headers),
Merge branch 'master' of https://github.com/camshaft/cowboy
2016-08-12 17:01:01 +02:00
ok.
Introduce the req_filter Websocket option This option allows customizing the compacting of the Req object when using Websocket. By default it will keep most public fields excluding headers of course, since those can be large.
2017-05-28 19:04:16 +02:00
ws_terminate(Config) ->
doc("The Req object is kept in a more compact form by default."),
{ok, Socket, _} = do_handshake("/terminate",
"x-test-pid: " ++ pid_to_list(self()) ++ "\r\n", Config),
%% Send a close frame.
ok = gen_tcp:send(Socket, << 1:1, 0:3, 8:4, 1:1, 0:7, 0:32 >>),
{ok, << 1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
%% Confirm terminate/3 was called with a compacted Req.
receive {terminate, _, Req} ->
true = maps:is_key(path, Req),
false = maps:is_key(headers, Req),
ok
after 1000 ->
error(timeout)
end.
ws_terminate_fun(Config) ->
doc("A function can be given to filter the Req object."),
{ok, Socket, _} = do_handshake("/terminate?req_filter",
"x-test-pid: " ++ pid_to_list(self()) ++ "\r\n", Config),
%% Send a close frame.
ok = gen_tcp:send(Socket, << 1:1, 0:3, 8:4, 1:1, 0:7, 0:32 >>),
{ok, << 1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
%% Confirm terminate/3 was called with a compacted Req.
receive {terminate, _, Req} ->
filtered = Req,
ok
after 1000 ->
error(timeout)
end.
Add support for fragmented websocket messages
2012-04-01 18:58:28 -07:00
ws_text_fragments(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Client sends fragmented text frames."),
{ok, Socket, _} = do_handshake("/ws_echo", Config),
%% Send two "Hello" over two fragments and two sends.
Mask = 16#37fa213d,
MaskedHello = do_mask(<<"Hello">>, Mask, <<>>),
ok = gen_tcp:send(Socket, << 0:1, 0:3, 1:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
ok = gen_tcp:send(Socket, << 1:1, 0:3, 0:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 0:3, 1:4, 0:1, 10:7, "HelloHello" >>} = gen_tcp:recv(Socket, 0, 6000),
%% Send three "Hello" over three fragments and one send.
Add support for fragmented websocket messages
2012-04-01 18:58:28 -07:00
ok = gen_tcp:send(Socket, [
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
<< 0:1, 0:3, 1:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>,
Add max_frame_size option for websocket handlers Option allows to limit a frame by size before decoding its payload. LH: I have added a test for when the limit is reached on a nofin fragmented frame (the last commit addressed that case but it had no test). I have fixed formatting and other, and changed the default value to infinity since it might otherwise be incompatible with existing code. I also added documentation and a bunch of other minor changes.
2017-08-25 12:08:26 +03:00
<< 0:1, 0:3, 0:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>,
<< 1:1, 0:3, 0:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>]),
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, << 1:1, 0:3, 1:4, 0:1, 15:7, "HelloHelloHello" >>} = gen_tcp:recv(Socket, 0, 6000),
Add support for fragmented websocket messages
2012-04-01 18:58:28 -07:00
ok.
Allow websocket handlers to reply more than one frame Instead of returning {text, Data}, you can now return [{text, Data}, {text, Data2}, ...].
2012-10-11 21:46:43 +02:00
ws_timeout_hibernate(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Server-initiated close on timeout with hibernating process."),
{ok, Socket, _} = do_handshake("/ws_timeout_hibernate", Config),
Improve websocket close handling We now always send a failure reason (bad protocol, bad encoding, etc.) unless the closure was initiated by the client and it didn't send a close code. We now check that the close frames have a payload that is valid UTF-8, unless they don't have a payload at all. We now do not crash the process anymore when bad opcodes are sent, or when the opcode 0 is sent before fragmentation was initiated. Overall this makes us closer to full compliance with the RFC.
2013-01-14 16:20:33 +01:00
{ok, << 1:1, 0:3, 8:4, 0:1, 2:7, 1000:16 >>} = gen_tcp:recv(Socket, 0, 6000),
Allow websocket handlers to reply more than one frame Instead of returning {text, Data}, you can now return [{text, Data}, {text, Data2}, ...].
2012-10-11 21:46:43 +02:00
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
ws_timeout_no_cancel(Config) ->
doc("Server-initiated timeout is not influenced by reception of Erlang messages."),
{ok, Socket, _} = do_handshake("/ws_timeout_cancel", Config),
Improve websocket close handling We now always send a failure reason (bad protocol, bad encoding, etc.) unless the closure was initiated by the client and it didn't send a close code. We now check that the close frames have a payload that is valid UTF-8, unless they don't have a payload at all. We now do not crash the process anymore when bad opcodes are sent, or when the opcode 0 is sent before fragmentation was initiated. Overall this makes us closer to full compliance with the RFC.
2013-01-14 16:20:33 +01:00
{ok, << 1:1, 0:3, 8:4, 0:1, 2:7, 1000:16 >>} = gen_tcp:recv(Socket, 0, 6000),
Cancel timer only on websocket_data receives or sends This commit prevents erlang messages from keeping a websocket connection alive. Previously, the timer was canceled upon any activity. Now, the timeout is only canceled when actual data is sent from the client. The handler_loop_timeout/1 function is called from websocket_data/4 instead of handler_before_loop/4. It is also called after every successful reply in handler_call/4.
2012-12-19 11:34:44 -08:00
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_timeout_reset(Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
doc("Server-initiated timeout is reset when client sends more data."),
{ok, Socket, _} = do_handshake("/ws_timeout_cancel", Config),
%% Send and receive back a frame a few times.
Mask = 16#37fa213d,
MaskedHello = do_mask(<<"Hello">>, Mask, <<>>),
Remove support for Websocket hixie76 draft It was only used by Safari 5.0.1 and possibly 5.1. Their market share is dropping as we speak. It was also insecure (disabled in Firefox for that reason). This will allow us to make much more efficient and cleaner code for the rest of the Websocket versions we support (drafts 7 to 17 + RFC), which are pretty much all versions seen in the wild excluding the one we're removing here.
2013-01-10 21:58:38 +01:00
[begin
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
ok = gen_tcp:send(Socket, << 1:1, 0:3, 1:4, 1:1, 5:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 0:3, 1:4, 0:1, 5:7, "Hello" >>} = gen_tcp:recv(Socket, 0, 6000),
timer:sleep(500)
Remove support for Websocket hixie76 draft It was only used by Safari 5.0.1 and possibly 5.1. Their market share is dropping as we speak. It was also insecure (disabled in Firefox for that reason). This will allow us to make much more efficient and cleaner code for the rest of the Websocket versions we support (drafts 7 to 17 + RFC), which are pretty much all versions seen in the wild excluding the one we're removing here.
2013-01-10 21:58:38 +01:00
end || _ <- [1, 2, 3, 4]],
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
%% Timeout will occur after we stop sending data.
Improve websocket close handling We now always send a failure reason (bad protocol, bad encoding, etc.) unless the closure was initiated by the client and it didn't send a close code. We now check that the close frames have a payload that is valid UTF-8, unless they don't have a payload at all. We now do not crash the process anymore when bad opcodes are sent, or when the opcode 0 is sent before fragmentation was initiated. Overall this makes us closer to full compliance with the RFC.
2013-01-14 16:20:33 +01:00
{ok, << 1:1, 0:3, 8:4, 0:1, 2:7, 1000:16 >>} = gen_tcp:recv(Socket, 0, 6000),
Cancel timer only on websocket_data receives or sends This commit prevents erlang messages from keeping a websocket connection alive. Previously, the timer was canceled upon any activity. Now, the timeout is only canceled when actual data is sent from the client. The handler_loop_timeout/1 function is called from websocket_data/4 instead of handler_before_loop/4. It is also called after every successful reply in handler_call/4.
2012-12-19 11:34:44 -08:00
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
ws_webkit_deflate(Config) ->
doc("x-webkit-deflate-frame compression."),
{ok, Socket, Headers} = do_handshake("/ws_echo",
"Sec-WebSocket-Extensions: x-webkit-deflate-frame\r\n", Config),
{_, "x-webkit-deflate-frame"} = lists:keyfind("sec-websocket-extensions", 1, Headers),
%% Send and receive a compressed "Hello" frame.
Mask = 16#11223344,
CompressedHello = << 242, 72, 205, 201, 201, 7, 0 >>,
MaskedHello = do_mask(CompressedHello, Mask, <<>>),
ok = gen_tcp:send(Socket, << 1:1, 1:1, 0:2, 1:4, 1:1, 7:7, Mask:32, MaskedHello/binary >>),
{ok, << 1:1, 1:1, 0:2, 1:4, 0:1, 7:7, CompressedHello/binary >>} = gen_tcp:recv(Socket, 0, 6000),
%% Client-initiated close.
ok = gen_tcp:send(Socket, << 1:1, 0:3, 8:4, 1:1, 0:7, 0:32 >>),
{ok, << 1:1, 0:3, 8:4, 0:8 >>} = gen_tcp:recv(Socket, 0, 6000),
{error, closed} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_webkit_deflate_fragments(Config) ->
doc("Client sends an x-webkit-deflate-frame compressed and fragmented text frame."),
{ok, Socket, Headers} = do_handshake("/ws_echo",
"Sec-WebSocket-Extensions: x-webkit-deflate-frame\r\n", Config),
{_, "x-webkit-deflate-frame"} = lists:keyfind("sec-websocket-extensions", 1, Headers),
%% Send a compressed "Hello" over two fragments and two sends.
Mask = 16#11223344,
CompressedHello = << 242, 72, 205, 201, 201, 7, 0 >>,
MaskedHello1 = do_mask(binary:part(CompressedHello, 0, 4), Mask, <<>>),
MaskedHello2 = do_mask(binary:part(CompressedHello, 4, 3), Mask, <<>>),
ok = gen_tcp:send(Socket, << 0:1, 1:1, 0:2, 1:4, 1:1, 4:7, Mask:32, MaskedHello1/binary >>),
ok = gen_tcp:send(Socket, << 1:1, 1:1, 0:2, 0:4, 1:1, 3:7, Mask:32, MaskedHello2/binary >>),
{ok, << 1:1, 1:1, 0:2, 1:4, 0:1, 7:7, CompressedHello/binary >>} = gen_tcp:recv(Socket, 0, 6000),
ok.
ws_webkit_deflate_single_bytes(Config) ->
doc("Client sends an x-webkit-deflate-frame compressed text frame one byte at a time."),
{ok, Socket, Headers} = do_handshake("/ws_echo",
"Sec-WebSocket-Extensions: x-webkit-deflate-frame\r\n", Config),
{_, "x-webkit-deflate-frame"} = lists:keyfind("sec-websocket-extensions", 1, Headers),
%% We sleep between sends to make sure only one byte is sent.
Mask = 16#11223344,
CompressedHello = << 242, 72, 205, 201, 201, 7, 0 >>,
MaskedHello = do_mask(CompressedHello, Mask, <<>>),
ok = gen_tcp:send(Socket, << 16#c1 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#87 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#11 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#22 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#33 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, << 16#44 >>), timer:sleep(100),
ok = gen_tcp:send(Socket, [binary:at(MaskedHello, 0)]), timer:sleep(100),
ok = gen_tcp:send(Socket, [binary:at(MaskedHello, 1)]), timer:sleep(100),
ok = gen_tcp:send(Socket, [binary:at(MaskedHello, 2)]), timer:sleep(100),
ok = gen_tcp:send(Socket, [binary:at(MaskedHello, 3)]), timer:sleep(100),
ok = gen_tcp:send(Socket, [binary:at(MaskedHello, 4)]), timer:sleep(100),
ok = gen_tcp:send(Socket, [binary:at(MaskedHello, 5)]), timer:sleep(100),
ok = gen_tcp:send(Socket, [binary:at(MaskedHello, 6)]),
{ok, << 1:1, 1:1, 0:2, 1:4, 0:1, 7:7, CompressedHello/binary >>} = gen_tcp:recv(Socket, 0, 6000),
ok.
Allow websocket handlers to reply more than one frame Instead of returning {text, Data}, you can now return [{text, Data}, {text, Data2}, ...].
2012-10-11 21:46:43 +02:00
%% Internal.
Add support for fragmented websocket messages
2012-04-01 18:58:28 -07:00
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
do_handshake(Path, Config) ->
Don't discard data following a Websocket upgrade request While the protocol does not allow sending data before receiving a successful Websocket upgrade response, we do not want to discard that data if it does come in.
2019-10-05 13:04:21 +02:00
do_handshake(Path, "", "", Config).
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
do_handshake(Path, ExtraHeaders, Config) ->
Don't discard data following a Websocket upgrade request While the protocol does not allow sending data before receiving a successful Websocket upgrade response, we do not want to discard that data if it does come in.
2019-10-05 13:04:21 +02:00
do_handshake(Path, ExtraHeaders, "", Config).
do_handshake(Path, ExtraHeaders, ExtraData, Config) ->
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, Socket} = gen_tcp:connect("localhost", config(port, Config),
[binary, {active, false}]),
ok = gen_tcp:send(Socket, [
"GET ", Path, " HTTP/1.1\r\n"
"Host: localhost\r\n"
"Connection: Upgrade\r\n"
"Origin: http://localhost\r\n"
"Sec-WebSocket-Version: 13\r\n"
"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
"Upgrade: websocket\r\n",
ExtraHeaders,
Don't discard data following a Websocket upgrade request While the protocol does not allow sending data before receiving a successful Websocket upgrade response, we do not want to discard that data if it does come in.
2019-10-05 13:04:21 +02:00
"\r\n",
ExtraData]),
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{ok, Handshake} = gen_tcp:recv(Socket, 0, 6000),
{ok, {http_response, {1, 1}, 101, _}, Rest} = erlang:decode_packet(http, Handshake, []),
Don't discard data following a Websocket upgrade request While the protocol does not allow sending data before receiving a successful Websocket upgrade response, we do not want to discard that data if it does come in.
2019-10-05 13:04:21 +02:00
[Headers, Data] = do_decode_headers(erlang:decode_packet(httph, Rest, []), []),
%% Queue extra data back, if any. We don't want to receive it yet.
case Data of
<<>> -> ok;
_ -> gen_tcp:unrecv(Socket, Data)
end,
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
{_, "Upgrade"} = lists:keyfind('Connection', 1, Headers),
{_, "websocket"} = lists:keyfind('Upgrade', 1, Headers),
{_, "s3pPLMBiTxaQ9kYGzzhZRbK+xOo="} = lists:keyfind("sec-websocket-accept", 1, Headers),
{ok, Socket, Headers}.
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
do_decode_headers({ok, http_eoh, Rest}, Acc) ->
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
[Acc, Rest];
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
do_decode_headers({ok, {http_header, _I, Key, _R, Value}, Rest}, Acc) ->
Move the websocket tests in a separate suite
2011-12-22 20:06:58 +01:00
F = fun(S) when is_atom(S) -> S; (S) -> string:to_lower(S) end,
Modernize the Websocket test suite
2016-08-15 18:06:16 +02:00
do_decode_headers(erlang:decode_packet(httph, Rest, []), [{F(Key), Value}|Acc]).
Add failing tests for the websocket deflate support
2013-07-02 13:44:28 +02:00
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
do_mask(<<>>, _, Acc) ->
Acc;
do_mask(<< O:32, Rest/bits >>, MaskKey, Acc) ->
Add failing tests for the websocket deflate support
2013-07-02 13:44:28 +02:00
T = O bxor MaskKey,
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
do_mask(Rest, MaskKey, << Acc/binary, T:32 >>);
do_mask(<< O:24 >>, MaskKey, Acc) ->
Add failing tests for the websocket deflate support
2013-07-02 13:44:28 +02:00
<< MaskKey2:24, _:8 >> = << MaskKey:32 >>,
T = O bxor MaskKey2,
<< Acc/binary, T:24 >>;
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
do_mask(<< O:16 >>, MaskKey, Acc) ->
Add failing tests for the websocket deflate support
2013-07-02 13:44:28 +02:00
<< MaskKey2:16, _:16 >> = << MaskKey:32 >>,
T = O bxor MaskKey2,
<< Acc/binary, T:16 >>;
Enable Autobahn Test Suite by default Includes a variety of small changes that are a first step to improving the test system heavily.
2014-04-20 22:20:54 +02:00
do_mask(<< O:8 >>, MaskKey, Acc) ->
Add failing tests for the websocket deflate support
2013-07-02 13:44:28 +02:00
<< MaskKey2:8, _:24 >> = << MaskKey:32 >>,
T = O bxor MaskKey2,
<< Acc/binary, T:8 >>.
Reference in a new issue Copy permalink