umgeher/cowboy
0
Fork 0
mirror of https://github.com/ninenines/cowboy.git synced 2025-07-14 12:20:24 +00:00
Code Issues Wiki Activity
cowboy/src/cowboy_websocket.erl

431 lines
18 KiB
Erlang
Raw Normal View History

Welcome to 2017
2017-01-02 19:36:36 +01:00
%% Copyright (c) 2011-2017, Loïc Hoguin <essen@ninenines.eu>
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02: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.
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
%% Cowboy supports versions 7 through 17 of the Websocket drafts.
%% It also supports RFC6455, the proposed standard for Websocket.
Rename cowboy_http_websocket to cowboy_websocket
2012-08-27 14:00:28 +02:00
-module(cowboy_websocket).
Add sub protocol behaviour
2013-02-15 00:53:40 +00:00
-behaviour(cowboy_sub_protocol).
Add documentation for the public interface. This is probably not perfect yet but it should be better than nothing. We'll improve things with feedback received from the many users.
2011-07-06 17:42:20 +02:00
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
-export([upgrade/4]).
-export([upgrade/5]).
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
-export([takeover/7]).
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
-export([handler_loop/3]).
-type call_result(State) :: {ok, State}
| {ok, State, hibernate}
| {reply, cow_ws:frame() | [cow_ws:frame()], State}
| {reply, cow_ws:frame() | [cow_ws:frame()], State, hibernate}
| {stop, State}.
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
Rename 'shutdown' close reason and tuples to 'stop' The 'shutdown' atom has a specific meaning inside OTP. We are instead going to use 'stop' which is pretty much the equivalent of what we actually do. 'shutdown' is now reserved for future special processes implementation.
2014-11-07 19:22:36 +02:00
-type terminate_reason() :: normal | stop | timeout
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
| remote | {remote, cow_ws:close_code(), binary()}
Improve handler interface and documentation This change simplifies a little more the sub protocols mechanism. Aliases have been removed. The renaming of loop handlers as long polling handlers has been reverted. Plain HTTP handlers now simply do their work in the init/2 callback. There is no specific code for them. Loop handlers now follow the same return value as Websocket, they use ok to continue and shutdown to stop. Terminate reasons for all handler types have been documented. The terminate callback is now appropriately called in all cases (or should be). Behaviors for all handler types have been moved in the module that implement them. This means that cowboy_handler replaces the cowboy_http_handler behavior, and similarly cowboy_loop replaces cowboy_loop_handler, cowboy_websocket replaces cowboy_websocket_handler. Finally cowboy_rest now has the start of a behavior in it and will have the full list of optional callbacks defined once Erlang 18.0 gets released. The guide has been reorganized and should be easier to follow.
2014-09-30 20:12:13 +03:00
| {error, badencoding | badframe | closed | atom()}
| {crash, error | exit | throw, any()}.
-callback init(Req, any())
-> {ok | module(), Req, any()}
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
| {module(), Req, any(), any()}
Improve handler interface and documentation This change simplifies a little more the sub protocols mechanism. Aliases have been removed. The renaming of loop handlers as long polling handlers has been reverted. Plain HTTP handlers now simply do their work in the init/2 callback. There is no specific code for them. Loop handlers now follow the same return value as Websocket, they use ok to continue and shutdown to stop. Terminate reasons for all handler types have been documented. The terminate callback is now appropriately called in all cases (or should be). Behaviors for all handler types have been moved in the module that implement them. This means that cowboy_handler replaces the cowboy_http_handler behavior, and similarly cowboy_loop replaces cowboy_loop_handler, cowboy_websocket replaces cowboy_websocket_handler. Finally cowboy_rest now has the start of a behavior in it and will have the full list of optional callbacks defined once Erlang 18.0 gets released. The guide has been reorganized and should be easier to follow.
2014-09-30 20:12:13 +03:00
when Req::cowboy_req:req().
Fix timer-sent events in the websocket example
2016-08-11 11:06:03 +02:00
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
-callback websocket_init(State)
Allow websocket_init/1 to reply/close/hibernate
2016-08-15 19:21:38 +02:00
-> call_result(State) when State::any().
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
-optional_callbacks([websocket_init/1]).
Fix timer-sent events in the websocket example
2016-08-11 11:06:03 +02:00
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
-callback websocket_handle({text | binary | ping | pong, binary()}, State)
-> call_result(State) when State::any().
-callback websocket_info(any(), State)
-> call_result(State) when State::any().
Add optional callbacks Mostly useful for REST, which has a ton. This is an initial commit, it still needs to be tested, but it's time to sleep.
2015-07-27 23:58:58 +02:00
-callback terminate(any(), cowboy_req:req(), any()) -> ok.
-optional_callbacks([terminate/3]).
Add support for fragmented websocket messages
2012-04-01 18:58:28 -07:00
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
-type opts() :: #{
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
compress => boolean(),
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
idle_timeout => timeout(),
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
req_filter => fun((cowboy_req:req()) -> map())
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
}.
-export_type([opts/0]).
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
-record(state, {
Numerous Dialyzer fixes
2017-01-02 16:47:16 +01:00
socket = undefined :: inet:socket() | undefined,
Put socket and transport into cowboy_websocket's #state{} As part of the work to make cowboy_req:req() opaque.
2012-09-15 21:09:12 +02:00
transport = undefined :: module(),
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
handler :: module(),
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
key = undefined :: undefined | binary(),
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
timeout = infinity :: timeout(),
Add a test for websocket hibernate + timeout and fix this use case The issue was that we were calling erlang:hibernate before a receive .. after .. end call. Erlang hibernates the process before reaching the receive instruction and we therefore couldn't enter the after clause when hibernating. This is now fixed by using erlang:send_after instead and receiving that message instead of using an after clause.
2011-09-22 21:33:56 +02:00
timeout_ref = undefined :: undefined | reference(),
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
compress = false :: boolean(),
Compile the binary match pattern for websockets only once.
2011-06-06 13:48:41 +02:00
messages = undefined :: undefined | {atom(), atom(), atom()},
Add WebSocket drafts 7, 8, 9 and 10 implementation The implementation is only partial for now but should work for all browsers implementing it.
2011-08-23 16:24:02 +02:00
hibernate = false :: boolean(),
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
frag_state = undefined :: cow_ws:frag_state(),
frag_buffer = <<>> :: binary(),
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
utf8_state = 0 :: cow_ws:utf8_state(),
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
extensions = #{} :: map(),
req = #{} :: map()
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
}).
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
%% Stream process.
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
-spec upgrade(Req, Env, module(), any())
-> {ok, Req, Env}
when Req::cowboy_req:req(), Env::cowboy_middleware:env().
upgrade(Req, Env, Handler, HandlerState) ->
upgrade(Req, Env, Handler, HandlerState, #{}).
-spec upgrade(Req, Env, module(), any(), opts())
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
-> {ok, Req, Env}
Add middleware support Middlewares allow customizing the request processing. All existing Cowboy project are incompatible with this commit. You need to change `{dispatch, Dispatch}` in the protocol options to `{env, [{dispatch, Dispatch}]}` to fix your code.
2013-01-03 22:47:51 +01:00
when Req::cowboy_req:req(), Env::cowboy_middleware:env().
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
%% @todo Immediately crash if a response has already been sent.
%% @todo Error out if HTTP/2.
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
upgrade(Req0, Env, Handler, HandlerState, Opts) ->
Timeout = maps:get(idle_timeout, Opts, 60000),
Compress = maps:get(compress, Opts, false),
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
FilteredReq = case maps:get(req_filter, Opts, undefined) of
undefined -> maps:with([method, version, scheme, host, port, path, qs, peer], Req0);
FilterFun -> FilterFun(Req0)
end,
State0 = #state{handler=Handler, timeout=Timeout, compress=Compress, req=FilteredReq},
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
try websocket_upgrade(State0, Req0) of
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
{ok, State, Req} ->
websocket_handshake(State, Req, HandlerState, Env)
Crash on failure, don't report errors When something went wrong in a handler we used to report errors and then terminate the process normally. This doesn't work so well with links which won't detect failure. Now we still catch the error, but throw another one with more details on why it happened, including the Req object information and the stacktrace. Ranch will then print an error message with all this information. Because we crash directly, this also means that we will not hog resources unnecessarily for too long when something bad happens.
2013-08-24 20:36:23 +02:00
catch _:_ ->
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
%% @todo Probably log something here?
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
%% @todo Test that we can have 2 /ws 400 status code in a row on the same connection.
Make reply functions return Req
2016-08-10 17:15:02 +02:00
%% @todo Does this even work?
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
{ok, cowboy_req:reply(400, Req0), Env}
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
end.
Change type #http_req{} to cowboy_req:req() This removes cowboy_static's dependency on http.hrl.
2012-09-15 01:31:51 +02:00
-spec websocket_upgrade(#state{}, Req)
-> {ok, #state{}, Req} when Req::cowboy_req:req().
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
websocket_upgrade(State, Req) ->
Breaking update of the cowboy_req interface Simplify the interface for most cowboy_req functions. They all return a single value except the four body reading functions. The reply functions now only return a Req value. Access functions do not return a Req anymore. Functions that used to cache results do not have a cache anymore. The interface for accessing query string and cookies has therefore been changed. There are now three query string functions: qs/1 provides access to the raw query string value; parse_qs/1 returns the query string as a list of key/values; match_qs/2 returns a map containing the values requested in the second argument, after applying constraints and default value. Similarly, there are two cookie functions: parse_cookies/1 and match_cookies/2. More match functions will be added in future commits. None of the functions return an error tuple anymore. It either works or crashes. Cowboy will attempt to provide an appropriate status code in the response of crashed handlers. As a result, the content decode function has its return value changed to a simple binary, and the body reading functions only return on success.
2014-09-23 16:43:29 +03:00
ConnTokens = cowboy_req:parse_header(<<"connection">>, Req),
Parse Connection header tokens in a case-insensitive manner
2011-10-20 19:04:49 +02:00
true = lists:member(<<"upgrade">>, ConnTokens),
Add 'Upgrade' header parsing Not parsing product tokens, I don't see much point.
2011-12-22 22:09:08 +01:00
%% @todo Should probably send a 426 if the Upgrade header is missing.
Breaking update of the cowboy_req interface Simplify the interface for most cowboy_req functions. They all return a single value except the four body reading functions. The reply functions now only return a Req value. Access functions do not return a Req anymore. Functions that used to cache results do not have a cache anymore. The interface for accessing query string and cookies has therefore been changed. There are now three query string functions: qs/1 provides access to the raw query string value; parse_qs/1 returns the query string as a list of key/values; match_qs/2 returns a map containing the values requested in the second argument, after applying constraints and default value. Similarly, there are two cookie functions: parse_cookies/1 and match_cookies/2. More match functions will be added in future commits. None of the functions return an error tuple anymore. It either works or crashes. Cowboy will attempt to provide an appropriate status code in the response of crashed handlers. As a result, the content decode function has its return value changed to a simple binary, and the body reading functions only return on success.
2014-09-23 16:43:29 +03:00
[<<"websocket">>] = cowboy_req:parse_header(<<"upgrade">>, Req),
Version = cowboy_req:header(<<"sec-websocket-version">>, Req),
Use binary_to_integer instead of to list and back
2016-08-10 17:50:28 +02:00
IntVersion = binary_to_integer(Version),
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
true = (IntVersion =:= 7) orelse (IntVersion =:= 8)
orelse (IntVersion =:= 13),
Breaking update of the cowboy_req interface Simplify the interface for most cowboy_req functions. They all return a single value except the four body reading functions. The reply functions now only return a Req value. Access functions do not return a Req anymore. Functions that used to cache results do not have a cache anymore. The interface for accessing query string and cookies has therefore been changed. There are now three query string functions: qs/1 provides access to the raw query string value; parse_qs/1 returns the query string as a list of key/values; match_qs/2 returns a map containing the values requested in the second argument, after applying constraints and default value. Similarly, there are two cookie functions: parse_cookies/1 and match_cookies/2. More match functions will be added in future commits. None of the functions return an error tuple anymore. It either works or crashes. Cowboy will attempt to provide an appropriate status code in the response of crashed handlers. As a result, the content decode function has its return value changed to a simple binary, and the body reading functions only return on success.
2014-09-23 16:43:29 +03:00
Key = cowboy_req:header(<<"sec-websocket-key">>, Req),
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
false = Key =:= undefined,
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
websocket_extensions(State#state{key=Key}, Req#{websocket_version => IntVersion}).
Add support for the webkit deflate frame extension
2013-04-15 18:36:33 +02:00
-spec websocket_extensions(#state{}, Req)
-> {ok, #state{}, Req} when Req::cowboy_req:req().
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
websocket_extensions(State=#state{compress=Compress}, Req) ->
Fix warnings
2016-03-06 18:09:43 +01:00
%% @todo We want different options for this. For example
%% * compress everything auto
%% * compress only text auto
%% * compress only binary auto
%% * compress nothing auto (but still enabled it)
%% * disable compression
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
case {Compress, cowboy_req:parse_header(<<"sec-websocket-extensions">>, Req)} of
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
{true, Extensions} when Extensions =/= undefined ->
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
websocket_extensions(State, Req, Extensions, []);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
_ ->
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
{ok, State, Req}
Add support for the webkit deflate frame extension
2013-04-15 18:36:33 +02:00
end.
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
websocket_extensions(State, Req, [], []) ->
{ok, State, Req};
websocket_extensions(State, Req, [], [<<", ">>|RespHeader]) ->
{ok, State, cowboy_req:set_resp_header(<<"sec-websocket-extensions">>, lists:reverse(RespHeader), Req)};
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
websocket_extensions(State=#state{extensions=Extensions}, Req=#{pid := Pid},
[{<<"permessage-deflate">>, Params}|Tail], RespHeader) ->
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
%% @todo Make deflate options configurable.
Opts = #{level => best_compression, mem_level => 8, strategy => default},
Update Cowlib to 2.0.1 and fix OTP 20.1+ Websocket compression Unfortunately compression will be disabled for 20.1, 20.1.1 and 20.1.2. In additiona I do not recommend 20.1.3 due to issues inflating some specific sizes.
2017-11-01 15:41:52 +00:00
try cow_ws:negotiate_permessage_deflate(Params, Extensions, Opts#{owner => Pid}) of
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
{ok, RespExt, Extensions2} ->
websocket_extensions(State#state{extensions=Extensions2},
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
Req, Tail, [<<", ">>, RespExt|RespHeader]);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
ignore ->
websocket_extensions(State, Req, Tail, RespHeader)
Update Cowlib to 2.0.1 and fix OTP 20.1+ Websocket compression Unfortunately compression will be disabled for 20.1, 20.1.1 and 20.1.2. In additiona I do not recommend 20.1.3 due to issues inflating some specific sizes.
2017-11-01 15:41:52 +00:00
catch exit:{error, incompatible_zlib_version, _} ->
websocket_extensions(State, Req, Tail, RespHeader)
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
end;
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
websocket_extensions(State=#state{extensions=Extensions}, Req=#{pid := Pid},
[{<<"x-webkit-deflate-frame">>, Params}|Tail], RespHeader) ->
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
%% @todo Make deflate options configurable.
Opts = #{level => best_compression, mem_level => 8, strategy => default},
Update Cowlib to 2.0.1 and fix OTP 20.1+ Websocket compression Unfortunately compression will be disabled for 20.1, 20.1.1 and 20.1.2. In additiona I do not recommend 20.1.3 due to issues inflating some specific sizes.
2017-11-01 15:41:52 +00:00
try cow_ws:negotiate_x_webkit_deflate_frame(Params, Extensions, Opts#{owner => Pid}) of
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
{ok, RespExt, Extensions2} ->
websocket_extensions(State#state{extensions=Extensions2},
Fix Websocket compression The option for enabling Websocket compression has been renamed. Previously it was shared with HTTP compression, now it's specific to Websocket. The new option is named 'websocket_compress'.
2016-08-12 16:56:08 +02:00
Req, Tail, [<<", ">>, RespExt|RespHeader]);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
ignore ->
websocket_extensions(State, Req, Tail, RespHeader)
Update Cowlib to 2.0.1 and fix OTP 20.1+ Websocket compression Unfortunately compression will be disabled for 20.1, 20.1.1 and 20.1.2. In additiona I do not recommend 20.1.3 due to issues inflating some specific sizes.
2017-11-01 15:41:52 +00:00
catch exit:{error, incompatible_zlib_version, _} ->
websocket_extensions(State, Req, Tail, RespHeader)
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
end;
websocket_extensions(State, Req, [_|Tail], RespHeader) ->
websocket_extensions(State, Req, Tail, RespHeader).
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
-spec websocket_handshake(#state{}, Req, any(), Env)
-> {ok, Req, Env}
when Req::cowboy_req:req(), Env::cowboy_middleware:env().
Fix warnings
2016-03-06 18:09:43 +01:00
websocket_handshake(State=#state{key=Key},
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
Req=#{pid := Pid, streamid := StreamID}, HandlerState, Env) ->
Drop R15 support
2014-07-12 14:19:29 +02:00
Challenge = base64:encode(crypto:hash(sha,
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
<< Key/binary, "258EAFA5-E914-47DA-95CA-C5AB0DC85B11" >>)),
Add some todos
2017-10-31 17:15:11 +00:00
%% @todo We don't want date and server headers.
Merge branch 'master' of https://github.com/camshaft/cowboy
2016-08-12 17:01:01 +02:00
Headers = cowboy_req:response_headers(#{
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
<<"connection">> => <<"Upgrade">>,
<<"upgrade">> => <<"websocket">>,
<<"sec-websocket-accept">> => Challenge
Merge branch 'master' of https://github.com/camshaft/cowboy
2016-08-12 17:01:01 +02:00
}, Req),
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
Pid ! {{Pid, StreamID}, {switch_protocol, Headers, ?MODULE, {State, HandlerState}}},
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
{ok, Req, Env}.
%% Connection process.
Fix warnings
2016-03-06 18:09:43 +01:00
%% @todo Keep parent and handle system messages.
-spec takeover(pid(), ranch:ref(), inet:socket(), module(), any(), binary(),
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
{#state{}, any()}) -> ok.
Fix warnings
2016-03-06 18:09:43 +01:00
takeover(_Parent, Ref, Socket, Transport, _Opts, Buffer,
Allow websocket_init/1 to reply/close/hibernate
2016-08-15 19:21:38 +02:00
{State0=#state{handler=Handler}, HandlerState}) ->
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
%% @todo We should have an option to disable this behavior.
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
ranch:remove_connection(Ref),
Allow websocket_init/1 to reply/close/hibernate
2016-08-15 19:21:38 +02:00
State1 = handler_loop_timeout(State0#state{socket=Socket, transport=Transport}),
State = State1#state{key=undefined, messages=Transport:messages()},
case erlang:function_exported(Handler, websocket_init, 1) of
true -> handler_call(State, HandlerState, Buffer, websocket_init, undefined, fun handler_before_loop/3);
false -> handler_before_loop(State, HandlerState, Buffer)
end.
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
-spec handler_before_loop(#state{}, any(), binary())
%% @todo Yeah not env.
-> {ok, cowboy_middleware:env()}.
Put socket and transport into cowboy_websocket's #state{} As part of the work to make cowboy_req:req() opaque.
2012-09-15 21:09:12 +02:00
handler_before_loop(State=#state{
socket=Socket, transport=Transport, hibernate=true},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, SoFar) ->
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
Transport:setopts(Socket, [{active, once}]),
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
proc_lib:hibernate(?MODULE, handler_loop,
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
[State#state{hibernate=false}, HandlerState, SoFar]);
Put socket and transport into cowboy_websocket's #state{} As part of the work to make cowboy_req:req() opaque.
2012-09-15 21:09:12 +02:00
handler_before_loop(State=#state{socket=Socket, transport=Transport},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, SoFar) ->
Add hibernate support for websockets. Return {ok, Req, State, hibernate} or {reply, Data, Req, State, hibernate} to hibernate the websocket process and save up memory and CPU. You should hibernate processes that will receive few messages. So probably most of them.
2011-06-06 18:15:36 +02:00
Transport:setopts(Socket, [{active, once}]),
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_loop(State, HandlerState, SoFar).
Add a test for websocket hibernate + timeout and fix this use case The issue was that we were calling erlang:hibernate before a receive .. after .. end call. Erlang hibernates the process before reaching the receive instruction and we therefore couldn't enter the after clause when hibernating. This is now fixed by using erlang:send_after instead and receiving that message instead of using an after clause.
2011-09-22 21:33:56 +02:00
-spec handler_loop_timeout(#state{}) -> #state{}.
handler_loop_timeout(State=#state{timeout=infinity}) ->
State#state{timeout_ref=undefined};
handler_loop_timeout(State=#state{timeout=Timeout, timeout_ref=PrevRef}) ->
_ = case PrevRef of undefined -> ignore; PrevRef ->
erlang:cancel_timer(PrevRef) end,
use erlang:start_timer/3 instead of erlang:send_after/3 for handling timeouts
2012-04-24 11:38:27 -07:00
TRef = erlang:start_timer(Timeout, self(), ?MODULE),
Add a test for websocket hibernate + timeout and fix this use case The issue was that we were calling erlang:hibernate before a receive .. after .. end call. Erlang hibernates the process before reaching the receive instruction and we therefore couldn't enter the after clause when hibernating. This is now fixed by using erlang:send_after instead and receiving that message instead of using an after clause.
2011-09-22 21:33:56 +02:00
State#state{timeout_ref=TRef}.
Add hibernate support for websockets. Return {ok, Req, State, hibernate} or {reply, Data, Req, State, hibernate} to hibernate the websocket process and save up memory and CPU. You should hibernate processes that will receive few messages. So probably most of them.
2011-06-06 18:15:36 +02:00
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
-spec handler_loop(#state{}, any(), binary())
-> {ok, cowboy_middleware:env()}.
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
handler_loop(State=#state{socket=Socket, messages={OK, Closed, Error},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
timeout_ref=TRef}, HandlerState, SoFar) ->
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
receive
{OK, Socket, Data} ->
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
State2 = handler_loop_timeout(State),
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_data(State2, HandlerState,
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
<< SoFar/binary, Data/binary >>);
{Closed, Socket} ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
terminate(State, HandlerState, {error, closed});
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
{Error, Socket, Reason} ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
terminate(State, HandlerState, {error, Reason});
use erlang:start_timer/3 instead of erlang:send_after/3 for handling timeouts
2012-04-24 11:38:27 -07:00
{timeout, TRef, ?MODULE} ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_close(State, HandlerState, timeout);
use erlang:start_timer/3 instead of erlang:send_after/3 for handling timeouts
2012-04-24 11:38:27 -07:00
{timeout, OlderTRef, ?MODULE} when is_reference(OlderTRef) ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_loop(State, HandlerState, SoFar);
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
Message ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_call(State, HandlerState,
SoFar, websocket_info, Message, fun handler_before_loop/3)
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
end.
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
-spec websocket_data(#state{}, any(), binary())
-> {ok, cowboy_middleware:env()}.
websocket_data(State=#state{frag_state=FragState, extensions=Extensions}, HandlerState, Data) ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
case cow_ws:parse_header(Data, Extensions, FragState) of
%% All frames sent from the client to the server are masked.
{_, _, _, _, undefined, _} ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_close(State, HandlerState, {error, badframe});
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
{Type, FragState2, Rsv, Len, MaskKey, Rest} ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_payload(State#state{frag_state=FragState2}, HandlerState, Type, Len, MaskKey, Rsv, undefined, <<>>, 0, Rest);
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
more ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_before_loop(State, HandlerState, Data);
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
error ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_close(State, HandlerState, {error, badframe})
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
end.
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
websocket_payload(State=#state{frag_state=FragState, utf8_state=Incomplete, extensions=Extensions},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen, Data) ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
case cow_ws:parse_payload(Data, MaskKey, Incomplete, UnmaskedLen, Type, Len, FragState, Extensions, Rsv) of
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
{ok, CloseCode2, Payload, Utf8State, Rest} ->
websocket_dispatch(State#state{utf8_state=Utf8State},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, Type, << Unmasked/binary, Payload/binary >>, CloseCode2, Rest);
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
{ok, Payload, Utf8State, Rest} ->
websocket_dispatch(State#state{utf8_state=Utf8State},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, Type, << Unmasked/binary, Payload/binary >>, CloseCode, Rest);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
{more, CloseCode2, Payload, Utf8State} ->
websocket_payload_loop(State#state{utf8_state=Utf8State},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, Type, Len - byte_size(Data), MaskKey, Rsv, CloseCode2,
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
<< Unmasked/binary, Payload/binary >>, UnmaskedLen + byte_size(Data));
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
{more, Payload, Utf8State} ->
websocket_payload_loop(State#state{utf8_state=Utf8State},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, Type, Len - byte_size(Data), MaskKey, Rsv, CloseCode,
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
<< Unmasked/binary, Payload/binary >>, UnmaskedLen + byte_size(Data));
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
Error = {error, _Reason} ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_close(State, HandlerState, Error)
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
end.
Websocket text frames are now checked for UTF-8 correctness The autobahntestsuite now passes 100% of the tests. We are getting close to fully implementing the Websocket RFC.
2013-01-13 00:10:32 +01:00
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
websocket_payload_loop(State=#state{socket=Socket, transport=Transport,
messages={OK, Closed, Error}, timeout_ref=TRef},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen) ->
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
Transport:setopts(Socket, [{active, once}]),
receive
{OK, Socket, Data} ->
State2 = handler_loop_timeout(State),
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_payload(State2, HandlerState,
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen, Data);
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
{Closed, Socket} ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
terminate(State, HandlerState, {error, closed});
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
{Error, Socket, Reason} ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
terminate(State, HandlerState, {error, Reason});
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
{timeout, TRef, ?MODULE} ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_close(State, HandlerState, timeout);
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
{timeout, OlderTRef, ?MODULE} when is_reference(OlderTRef) ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_payload_loop(State, HandlerState,
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen);
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
Message ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_call(State, HandlerState,
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
<<>>, websocket_info, Message,
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
fun (State2, HandlerState2, _) ->
websocket_payload_loop(State2, HandlerState2,
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Type, Len, MaskKey, Rsv, CloseCode, Unmasked, UnmaskedLen)
Unmask websocket frames on the fly and optimize the code No change in functionality, but this will allow us to validate that text frames are utf8 without having to receive the frame entirely.
2013-01-12 22:31:23 +01:00
end)
end.
Add WebSocket drafts 7, 8, 9 and 10 implementation The implementation is only partial for now but should work for all browsers implementing it.
2011-08-23 16:24:02 +02:00
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
websocket_dispatch(State=#state{socket=Socket, transport=Transport, frag_state=FragState, frag_buffer=SoFar, extensions=Extensions},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState, Type0, Payload0, CloseCode0, RemainingData) ->
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
case cow_ws:make_frame(Type0, Payload0, CloseCode0, FragState) of
%% @todo Allow receiving fragments.
{fragment, nofin, _, Payload} ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_data(State#state{frag_buffer= << SoFar/binary, Payload/binary >>}, HandlerState, RemainingData);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
{fragment, fin, Type, Payload} ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_call(State#state{frag_state=undefined, frag_buffer= <<>>}, HandlerState, RemainingData,
websocket_handle, {Type, << SoFar/binary, Payload/binary >>}, fun websocket_data/3);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
close ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_close(State, HandlerState, remote);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
{close, CloseCode, Payload} ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
websocket_close(State, HandlerState, {remote, CloseCode, Payload});
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
Frame = ping ->
Transport:send(Socket, cow_ws:frame(pong, Extensions)),
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_call(State, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/3);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
Frame = {ping, Payload} ->
Transport:send(Socket, cow_ws:frame({pong, Payload}, Extensions)),
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_call(State, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/3);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
Frame ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_call(State, HandlerState, RemainingData, websocket_handle, Frame, fun websocket_data/3)
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
end.
Add WebSocket drafts 7, 8, 9 and 10 implementation The implementation is only partial for now but should work for all browsers implementing it.
2011-08-23 16:24:02 +02:00
Numerous Dialyzer fixes
2017-01-02 16:47:16 +01:00
-spec handler_call(#state{}, any(), binary(), atom(), any(), fun()) -> no_return().
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
handler_call(State=#state{handler=Handler}, HandlerState,
Crash on failure, don't report errors When something went wrong in a handler we used to report errors and then terminate the process normally. This doesn't work so well with links which won't detect failure. Now we still catch the error, but throw another one with more details on why it happened, including the Req object information and the stacktrace. Ranch will then print an error message with all this information. Because we crash directly, this also means that we will not hog resources unnecessarily for too long when something bad happens.
2013-08-24 20:36:23 +02:00
RemainingData, Callback, Message, NextState) ->
Allow websocket_init/1 to reply/close/hibernate
2016-08-15 19:21:38 +02:00
try case Callback of
websocket_init -> Handler:websocket_init(HandlerState);
_ -> Handler:Callback(Message, HandlerState)
end of
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
{ok, HandlerState2} ->
NextState(State, HandlerState2, RemainingData);
{ok, HandlerState2, hibernate} ->
Send many frames in one TCP send Includes refactoring of the related code to avoid repetition.
2016-08-15 20:04:37 +02:00
NextState(State#state{hibernate=true}, HandlerState2, RemainingData);
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
{reply, Payload, HandlerState2} ->
Allow atom responses in websocket handlers #563
2013-08-13 23:29:16 +04:00
case websocket_send(Payload, State) of
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
ok ->
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
NextState(State, HandlerState2, RemainingData);
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
stop ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
terminate(State, HandlerState2, stop);
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Error = {error, _} ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
terminate(State, HandlerState2, Error)
Check for errors when calling Transport:send in the websocket protocol In some situations, the underlying socket might become "half-open" in which case the websocket will stay in a waiting state indefinitely. The detection of this state requires checking for errors when calling send.
2012-04-08 11:57:30 +02:00
end;
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
{reply, Payload, HandlerState2, hibernate} ->
Allow atom responses in websocket handlers #563
2013-08-13 23:29:16 +04:00
case websocket_send(Payload, State) of
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
ok ->
NextState(State#state{hibernate=true},
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
HandlerState2, RemainingData);
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
stop ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
terminate(State, HandlerState2, stop);
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Error = {error, _} ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
terminate(State, HandlerState2, Error)
Check for errors when calling Transport:send in the websocket protocol In some situations, the underlying socket might become "half-open" in which case the websocket will stay in a waiting state indefinitely. The detection of this state requires checking for errors when calling send.
2012-04-08 11:57:30 +02:00
end;
Remove Req from the Websocket interface After the switch to Websocket, we are no longer in a request/response scenario, therefore a lot of the cowboy_req functions do not apply anymore. Any data required from the request will need to be taken from Req in init/2 and saved in the handler's state.
2016-08-12 19:27:23 +02:00
{stop, HandlerState2} ->
websocket_close(State, HandlerState2, stop)
Send a meaningful error to error_logger on websocket handler crashes. Same as commit 4c4030a792a94d96f8bda5076fcfdc03a590030e but for websockets. See also issue #13 on github.
2011-05-27 12:32:02 +02:00
catch Class:Reason ->
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
websocket_send_close(State, {crash, Class, Reason}),
handler_terminate(State, HandlerState, {crash, Class, Reason}),
Let the stream handler take care of crash handling and logging
2016-08-10 17:45:28 +02:00
erlang:raise(Class, Reason, erlang:get_stacktrace())
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
end.
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
-spec websocket_send(cow_ws:frame(), #state{}) -> ok | stop | {error, atom()}.
Send many frames in one TCP send Includes refactoring of the related code to avoid repetition.
2016-08-15 20:04:37 +02:00
websocket_send(Frames, State) when is_list(Frames) ->
websocket_send_many(Frames, State, []);
Update Cowlib to 1.2.0; adds Websocket permessage-deflate The Websocket text frames should also be less resource intensive to validate now, with a binary concatenation avoided.
2015-03-06 01:56:30 +01:00
websocket_send(Frame, #state{socket=Socket, transport=Transport, extensions=Extensions}) ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Res = Transport:send(Socket, cow_ws:frame(Frame, Extensions)),
Send many frames in one TCP send Includes refactoring of the related code to avoid repetition.
2016-08-15 20:04:37 +02:00
case is_close_frame(Frame) of
true -> stop;
false -> Res
Unify the init and terminate callbacks This set of changes is the first step to simplify the writing of handlers, by removing some extraneous callbacks and making others optional. init/3 is now init/2, its first argument being removed. rest_init/2 and rest_terminate/2 have been removed. websocket_init/3 and websocket_terminate/3 have been removed. terminate/3 is now optional. It is called regardless of the type of handler, including rest and websocket. The return value of init/2 changed. It now returns {Mod, Req, Opts} with Mod being either one of the four handler type or a custom module. It can also return extra timeout and hibernate options. The signature for sub protocols has changed, they now receive these extra timeout and hibernate options. Loop handlers are now implemented in cowboy_long_polling, and will be renamed throughout the project in a future commit.
2014-09-26 15:58:44 +03:00
end.
Send many frames in one TCP send Includes refactoring of the related code to avoid repetition.
2016-08-15 20:04:37 +02:00
websocket_send_many([], #state{socket=Socket, transport=Transport}, Acc) ->
Transport:send(Socket, lists:reverse(Acc));
websocket_send_many([Frame|Tail], State=#state{socket=Socket, transport=Transport,
extensions=Extensions}, Acc0) ->
Acc = [cow_ws:frame(Frame, Extensions)|Acc0],
case is_close_frame(Frame) of
true ->
_ = Transport:send(Socket, lists:reverse(Acc)),
stop;
false ->
websocket_send_many(Tail, State, Acc)
Check for errors when calling Transport:send in the websocket protocol In some situations, the underlying socket might become "half-open" in which case the websocket will stay in a waiting state indefinitely. The detection of this state requires checking for errors when calling send.
2012-04-08 11:57:30 +02:00
end.
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
Send many frames in one TCP send Includes refactoring of the related code to avoid repetition.
2016-08-15 20:04:37 +02:00
is_close_frame(close) -> true;
is_close_frame({close, _}) -> true;
is_close_frame({close, _, _}) -> true;
is_close_frame(_) -> false.
Numerous Dialyzer fixes
2017-01-02 16:47:16 +01:00
-spec websocket_close(#state{}, any(), terminate_reason()) -> no_return().
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
websocket_close(State, HandlerState, Reason) ->
websocket_send_close(State, Reason),
terminate(State, HandlerState, Reason).
websocket_send_close(#state{socket=Socket, transport=Transport,
extensions=Extensions}, Reason) ->
_ = case Reason of
Rename 'shutdown' close reason and tuples to 'stop' The 'shutdown' atom has a specific meaning inside OTP. We are instead going to use 'stop' which is pretty much the equivalent of what we actually do. 'shutdown' is now reserved for future special processes implementation.
2014-11-07 19:22:36 +02:00
Normal when Normal =:= stop; Normal =:= timeout ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Transport:send(Socket, cow_ws:frame({close, 1000, <<>>}, Extensions));
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
{error, badframe} ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Transport:send(Socket, cow_ws:frame({close, 1002, <<>>}, Extensions));
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
{error, badencoding} ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Transport:send(Socket, cow_ws:frame({close, 1007, <<>>}, Extensions));
Improve handler interface and documentation This change simplifies a little more the sub protocols mechanism. Aliases have been removed. The renaming of loop handlers as long polling handlers has been reverted. Plain HTTP handlers now simply do their work in the init/2 callback. There is no specific code for them. Loop handlers now follow the same return value as Websocket, they use ok to continue and shutdown to stop. Terminate reasons for all handler types have been documented. The terminate callback is now appropriately called in all cases (or should be). Behaviors for all handler types have been moved in the module that implement them. This means that cowboy_handler replaces the cowboy_http_handler behavior, and similarly cowboy_loop replaces cowboy_loop_handler, cowboy_websocket replaces cowboy_websocket_handler. Finally cowboy_rest now has the start of a behavior in it and will have the full list of optional callbacks defined once Erlang 18.0 gets released. The guide has been reorganized and should be easier to follow.
2014-09-30 20:12:13 +03:00
{crash, _, _} ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Transport:send(Socket, cow_ws:frame({close, 1011, <<>>}, Extensions));
Improve handler interface and documentation This change simplifies a little more the sub protocols mechanism. Aliases have been removed. The renaming of loop handlers as long polling handlers has been reverted. Plain HTTP handlers now simply do their work in the init/2 callback. There is no specific code for them. Loop handlers now follow the same return value as Websocket, they use ok to continue and shutdown to stop. Terminate reasons for all handler types have been documented. The terminate callback is now appropriately called in all cases (or should be). Behaviors for all handler types have been moved in the module that implement them. This means that cowboy_handler replaces the cowboy_http_handler behavior, and similarly cowboy_loop replaces cowboy_loop_handler, cowboy_websocket replaces cowboy_websocket_handler. Finally cowboy_rest now has the start of a behavior in it and will have the full list of optional callbacks defined once Erlang 18.0 gets released. The guide has been reorganized and should be easier to follow.
2014-09-30 20:12:13 +03:00
remote ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Transport:send(Socket, cow_ws:frame(close, Extensions));
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
{remote, Code, _} ->
Use cow_ws for the Websocket parsing code Updates Cowlib to 1.1.0
2015-02-16 15:48:04 +01:00
Transport:send(Socket, cow_ws:frame({close, Code, <<>>}, Extensions))
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
end,
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
ok.
Initial draft-hixie-thewebsocketprotocol-76 support.
2011-04-14 21:21:17 +02:00
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
-spec terminate(#state{}, any(), terminate_reason()) -> no_return().
terminate(State, HandlerState, Reason) ->
handler_terminate(State, HandlerState, Reason),
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
exit(normal).
Ensure Websocket errors result in a crash log
2017-02-18 20:21:02 +01:00
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
handler_terminate(#state{handler=Handler, req=Req}, HandlerState, Reason) ->
cowboy_handler:terminate(Reason, Req, HandlerState, Handler).
Reference in a new issue Copy permalink