WebSocket module now uses wslay library.

COPYRIGHT.txt

@@ -366,6 +366,11 @@ Copyright: 2011, Khaled Mamou
   2003-2009, Erwin Coumans
 License: BSD-3-clause
 
+Files: ./thirdparty/wslay/
+Comment: Wslay
+Copyright: 2011-2015, Tatsuhiro Tsujikawa
+License: Expat
+
 Files: ./thirdparty/xatlas/
 Comment: xatlas
 Copyright: 2018, Jonathan Young

core/io/stream_peer_tcp.cpp

@@ -217,6 +217,11 @@ Error StreamPeerTCP::read(uint8_t *p_buffer, int p_bytes, int &r_received, bool
 
 			to_read -= read;
 			total_read += read;
+
+			if (!p_block) {
+				r_received = total_read;
+				return OK;
+			}
 		}
 	}
 

modules/websocket/SCsub

@@ -5,7 +5,7 @@ Import('env_modules')
 
 # Thirdparty source files
 
-env_lws = env_modules.Clone()
+env_ws = env_modules.Clone()
 
 if env['builtin_libwebsockets'] and not env["platform"] == "javascript": # already builtin for javascript
     thirdparty_dir = "#thirdparty/libwebsockets/"
@@ -90,4 +90,23 @@ if env['builtin_libwebsockets'] and not env["platform"] == "javascript": # alrea
     env_thirdparty.disable_warnings()
     env_thirdparty.add_source_files(env.modules_sources, thirdparty_sources)
 
-env_lws.add_source_files(env.modules_sources, "*.cpp")
+    wslay_dir = "#thirdparty/wslay/"
+    wslay_sources = [
+        "wslay_net.c",
+        "wslay_event.c",
+        "wslay_queue.c",
+        "wslay_stack.c",
+        "wslay_frame.c",
+    ]
+    wslay_sources = [wslay_dir + s for s in wslay_sources]
+    env_ws.Prepend(CPPPATH=[wslay_dir + "includes/"])
+    env_ws.Append(CPPFLAGS=["-DHAVE_CONFIG_H"])
+    if env["platform"] == "windows" or env["platform"] == "uwp":
+        env_ws.Append(CPPFLAGS=["-DHAVE_WINSOCK2_H"])
+    else:
+        env_ws.Append(CPPFLAGS=["-DHAVE_NETINET_IN_H"])
+    env_wslay = env_ws.Clone()
+    env_wslay.disable_warnings()
+    env_wslay.add_source_files(env.modules_sources, wslay_sources)
+
+env_ws.add_source_files(env.modules_sources, "*.cpp")

modules/websocket/doc_classes/WebSocketClient.xml

@@ -22,7 +22,7 @@
 			<argument index="2" name="gd_mp_api" type="bool" default="false">
 			</argument>
 			<description>
-				Connects to the given URL requesting one of the given [code]protocols[/code] as sub-protocol.
+				Connects to the given URL requesting one of the given [code]protocols[/code] as sub-protocol. If the list empty (default), no sub-protocol will be requested.
 				If [code]true[/code] is passed as [code]gd_mp_api[/code], the client will behave like a network peer for the [MultiplayerAPI], connections to non-Godot servers will not work, and [signal data_received] will not be emitted.
 				If [code]false[/code] is passed instead (default), you must call [PacketPeer] functions ([code]put_packet[/code], [code]get_packet[/code], etc.) on the [WebSocketPeer] returned via [code]get_peer(1)[/code] and not on this object directly (e.g. [code]get_peer(1).put_packet(data)[/code]).
 			</description>

modules/websocket/doc_classes/WebSocketServer.xml

@@ -69,7 +69,7 @@
 			</argument>
 			<description>
 				Starts listening on the given port.
-				You can specify the desired subprotocols via the "protocols" array. If the list empty (default), "binary" will be used.
+				You can specify the desired subprotocols via the "protocols" array. If the list empty (default), no sub-protocol will be requested.
 				If [code]true[/code] is passed as [code]gd_mp_api[/code], the server will behave like a network peer for the [MultiplayerAPI], connections from non-Godot clients will not work, and [signal data_received] will not be emitted.
 				If [code]false[/code] is passed instead (default), you must call [PacketPeer] functions ([code]put_packet[/code], [code]get_packet[/code], etc.), on the [WebSocketPeer] returned via [code]get_peer(id)[/code] to communicate with the peer with given [code]id[/code] (e.g. [code]get_peer(id).get_available_packet_count[/code]).
 			</description>

modules/websocket/register_types.cpp

@@ -40,6 +40,8 @@
 #include "lws_client.h"
 #include "lws_peer.h"
 #include "lws_server.h"
+#include "wsl_client.h"
+#include "wsl_server.h"
 #endif
 
 void register_websocket_types() {
@@ -67,6 +69,8 @@ void register_websocket_types() {
 	LWSPeer::make_default();
 	LWSClient::make_default();
 	LWSServer::make_default();
+	WSLClient::make_default();
+	WSLServer::make_default();
 #endif
 
 	ClassDB::register_virtual_class<WebSocketMultiplayerPeer>();

modules/websocket/wsl_client.h

+/*************************************************************************/
+/*  wsl_client.h                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef WSLCLIENT_H
+#define WSLCLIENT_H
+
+#ifndef JAVASCRIPT_ENABLED
+
+#include "core/error_list.h"
+#include "core/io/stream_peer_ssl.h"
+#include "core/io/stream_peer_tcp.h"
+#include "websocket_client.h"
+#include "wsl_peer.h"
+#include "wslay/wslay.h"
+
+class WSLClient : public WebSocketClient {
+
+	GDCIIMPL(WSLClient, WebSocketClient);
+
+private:
+	int _in_buf_size;
+	int _in_pkt_size;
+	int _out_buf_size;
+	int _out_pkt_size;
+	wslay_event_context_ptr _ctx;
+	Ref<WSLPeer> _peer;
+	// XXX we could use HTTPClient with some hacking instead...
+	Ref<StreamPeerTCP> _tcp;
+	CharString _request;
+	String _response;
+	String _key;
+	String _host;
+	PoolVector<String> _protocols;
+	Ref<StreamPeer> _connection;
+	int _requested;
+	bool _use_ssl;
+
+	void _do_handshake();
+	bool _verify_headers(String &r_protocol);
+
+public:
+	Error set_buffers(int p_in_buffer, int p_in_packets, int p_out_buffer, int p_out_packets);
+	Error connect_to_host(String p_host, String p_path, uint16_t p_port, bool p_ssl, PoolVector<String> p_protocol = PoolVector<String>());
+	int get_max_packet_size() const;
+	Ref<WebSocketPeer> get_peer(int p_peer_id) const;
+	void disconnect_from_host(int p_code = 1000, String p_reason = "");
+	IP_Address get_connected_host() const;
+	uint16_t get_connected_port() const;
+	virtual ConnectionStatus get_connection_status() const;
+	virtual void poll();
+
+	WSLClient();
+	~WSLClient();
+};
+
+#endif // JAVASCRIPT_ENABLED
+
+#endif // WSLCLIENT_H

modules/websocket/wsl_peer.h

+/*************************************************************************/
+/*  wsl_peer.h                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef WSLPEER_H
+#define WSLPEER_H
+
+#ifndef JAVASCRIPT_ENABLED
+
+#include "core/error_list.h"
+#include "core/io/packet_peer.h"
+#include "core/ring_buffer.h"
+#include "packet_buffer.h"
+#include "websocket_peer.h"
+#include "wslay/wslay.h"
+
+#define WSL_MAX_HEADER_SIZE 4096
+
+class WSLPeer : public WebSocketPeer {
+
+	GDCIIMPL(WSLPeer, WebSocketPeer);
+
+public:
+	struct PeerData {
+		bool polling;
+		bool destroy;
+		bool valid;
+		bool is_server;
+		void *obj;
+		void *peer;
+		Ref<StreamPeer> conn;
+		int id;
+		wslay_event_context_ptr ctx;
+
+		PeerData() {
+			polling = false;
+			destroy = false;
+			valid = false;
+			is_server = false;
+			id = 1;
+			ctx = NULL;
+			obj = NULL;
+			peer = NULL;
+		}
+	};
+
+	static String compute_key_response(String p_key);
+	static String generate_key();
+
+private:
+	static bool _wsl_poll(struct PeerData *p_data);
+	static void _wsl_destroy(struct PeerData **p_data);
+
+	Ref<StreamPeer> _connection;
+	struct PeerData *_data;
+	uint8_t _is_string;
+	// Our packet info is just a boolean (is_string), using uint8_t for it.
+	PacketBuffer<uint8_t> _in_buffer;
+
+	PoolVector<uint8_t> _packet_buffer;
+
+	WriteMode write_mode;
+
+public:
+	int close_code;
+	String close_reason;
+	void poll(); // Used by client and server.
+
+	virtual int get_available_packet_count() const;
+	virtual Error get_packet(const uint8_t **r_buffer, int &r_buffer_size);
+	virtual Error put_packet(const uint8_t *p_buffer, int p_buffer_size);
+	virtual int get_max_packet_size() const { return _packet_buffer.size(); };
+
+	virtual void close_now();
+	virtual void close(int p_code = 1000, String p_reason = "");
+	virtual bool is_connected_to_host() const;
+	virtual IP_Address get_connected_host() const;
+	virtual uint16_t get_connected_port() const;
+
+	virtual WriteMode get_write_mode() const;
+	virtual void set_write_mode(WriteMode p_mode);
+	virtual bool was_string_packet() const;
+
+	void make_context(PeerData *p_data, unsigned int p_in_buf_size, unsigned int p_in_pkt_size, unsigned int p_out_buf_size, unsigned int p_out_pkt_size);
+	Error parse_message(const wslay_event_on_msg_recv_arg *arg);
+	void invalidate();
+
+	WSLPeer();
+	~WSLPeer();
+};
+
+#endif // JAVASCRIPT_ENABLED
+
+#endif // LSWPEER_H

modules/websocket/wsl_server.cpp

+/*************************************************************************/
+/*  lws_server.cpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef JAVASCRIPT_ENABLED
+
+#include "wsl_server.h"
+#include "core/os/os.h"
+#include "core/project_settings.h"
+
+bool WSLServer::PendingPeer::_parse_request(String &r_key) {
+	Vector<String> psa = request.trim_suffix("\r\n\r\n").split("\r\n");
+	int len = psa.size();
+	if (len < 4) {
+		ERR_EXPLAIN("Not enough response headers.");
+		ERR_FAIL_V(false);
+	}
+
+	Vector<String> req = psa[0].split(" ", false);
+	if (req.size() < 2) {
+		ERR_EXPLAIN("Invalid protocol or status code.");
+		ERR_FAIL_V(false);
+	}
+	// Wrong protocol
+	if (req[0] != "GET" || req[2] != "HTTP/1.1") {
+		ERR_EXPLAIN("Invalid method or HTTP version.");
+		ERR_FAIL_V(false);
+	}
+
+	Map<String, String> headers;
+	for (int i = 1; i < len; i++) {
+		Vector<String> header = psa[i].split(":", false, 1);
+		if (header.size() != 2) {
+			ERR_EXPLAIN("Invalid header -> " + psa[i]);
+			ERR_FAIL_V(false);
+		}
+		String name = header[0].to_lower();
+		String value = header[1].strip_edges();
+		if (headers.has(name))
+			headers[name] += "," + value;
+		else
+			headers[name] = value;
+	}
+#define _WLS_CHECK(NAME, VALUE)                                                                      \
+	ERR_EXPLAIN("Missing or invalid header '" + String(NAME) + "'. Expected value '" + VALUE + "'"); \
+	ERR_FAIL_COND_V(!headers.has(NAME) || headers[NAME].to_lower() != VALUE, false);
+#define _WLS_CHECK_EX(NAME)                                \
+	ERR_EXPLAIN("Missing header '" + String(NAME) + "'."); \
+	ERR_FAIL_COND_V(!headers.has(NAME), false);
+	_WLS_CHECK("upgrade", "websocket");
+	_WLS_CHECK("sec-websocket-version", "13");
+	_WLS_CHECK_EX("sec-websocket-key");
+	_WLS_CHECK_EX("connection");
+#undef _WLS_CHECK_EX
+#undef _WLS_CHECK
+	r_key = headers["sec-websocket-key"];
+	return true;
+}
+
+Error WSLServer::PendingPeer::do_handshake() {
+	if (OS::get_singleton()->get_ticks_msec() - time > WSL_SERVER_TIMEOUT)
+		return ERR_TIMEOUT;
+	if (!has_request) {
+		uint8_t byte = 0;
+		int read = 0;
+		while (true) {
+			Error err = connection->get_partial_data(&byte, 1, read);
+			if (err != OK) // Got an error
+				return FAILED;
+			else if (read != 1) // Busy, wait next poll
+				return ERR_BUSY;
+			request += byte;
+
+			if (request.size() > WSL_MAX_HEADER_SIZE) {
+				ERR_EXPLAIN("Response headers too big");
+				ERR_FAIL_V(ERR_OUT_OF_MEMORY);
+			}
+			if (request.ends_with("\r\n\r\n")) {
+				if (!_parse_request(key)) {
+					return FAILED;
+				}
+				String r = "HTTP/1.1 101 Switching Protocols\r\n";
+				r += "Upgrade: websocket\r\n";
+				r += "Connection: Upgrade\r\n";
+				r += "Sec-WebSocket-Accept: " + WSLPeer::compute_key_response(key) + "\r\n";
+				r += "\r\n";
+				response = r.utf8();
+				has_request = true;
+				WARN_PRINTS("Parsed, " + key);
+				break;
+			}
+		}
+	}
+	if (has_request && response_sent < response.size() - 1) {
+		int sent = 0;
+		Error err = connection->put_partial_data((const uint8_t *)response.get_data() + response_sent, response.size() - response_sent - 1, sent);
+		if (err != OK) {
+			return err;
+		}
+		response_sent += sent;
+	}
+	if (response_sent < response.size() - 1)
+		return ERR_BUSY;
+	return OK;
+}
+
+Error WSLServer::listen(int p_port, PoolVector<String> p_protocols, bool gd_mp_api) {
+	ERR_FAIL_COND_V(is_listening(), ERR_ALREADY_IN_USE);
+
+	_is_multiplayer = gd_mp_api;
+	_server->listen(p_port);
+
+	return OK;
+}
+
+void WSLServer::poll() {
+
+	List<int> remove_ids;
+	for (Map<int, Ref<WebSocketPeer> >::Element *E = _peer_map.front(); E; E = E->next()) {
+		Ref<WSLPeer> peer = (WSLPeer *)E->get().ptr();
+		peer->poll();
+		if (!peer->is_connected_to_host()) {
+			_on_disconnect(E->key(), peer->close_code != -1);
+			remove_ids.push_back(E->key());
+		}
+	}
+	for (List<int>::Element *E = remove_ids.front(); E; E = E->next()) {
+		_peer_map.erase(E->get());
+	}
+	remove_ids.clear();
+
+	List<Ref<PendingPeer> > remove_peers;
+	for (List<Ref<PendingPeer> >::Element *E = _pending.front(); E; E = E->next()) {
+		Ref<PendingPeer> ppeer = E->get();
+		Error err = ppeer->do_handshake();
+		if (err == ERR_BUSY) {
+			continue;
+		} else if (err != OK) {
+			remove_peers.push_back(ppeer);
+			continue;
+		}
+		// Creating new peer
+		int32_t id = _gen_unique_id();
+
+		WSLPeer::PeerData *data = memnew(struct WSLPeer::PeerData);
+		data->obj = this;
+		data->conn = ppeer->connection;
+		data->is_server = true;
+		data->id = id;
+
+		Ref<WSLPeer> ws_peer = memnew(WSLPeer);
+		ws_peer->make_context(data, _in_buf_size, _in_pkt_size, _out_buf_size, _out_pkt_size);
+
+		_peer_map[id] = ws_peer;
+		remove_peers.push_back(ppeer);
+		_on_connect(id, "");
+	}
+	for (List<Ref<PendingPeer> >::Element *E = remove_peers.front(); E; E = E->next()) {
+		_pending.erase(E->get());
+	}
+	remove_peers.clear();
+
+	if (!_server->is_listening())
+		return;
+
+	while (_server->is_connection_available()) {
+		Ref<StreamPeer> conn = _server->take_connection();
+		if (is_refusing_new_connections())
+			continue; // Conn will go out-of-scope and be closed.
+
+		Ref<PendingPeer> peer = memnew(PendingPeer);
+		peer->connection = conn;
+		peer->time = OS::get_singleton()->get_ticks_msec();
+		_pending.push_back(peer);
+	}
+}
+
+bool WSLServer::is_listening() const {
+	return _server->is_listening();
+}
+
+int WSLServer::get_max_packet_size() const {
+	return (1 << _out_buf_size) - PROTO_SIZE;
+}
+
+void WSLServer::stop() {
+	_server->stop();
+	for (Map<int, Ref<WebSocketPeer> >::Element *E = _peer_map.front(); E; E = E->next()) {
+		Ref<WSLPeer> peer = (WSLPeer *)E->get().ptr();
+		peer->close_now();
+	}
+	_pending.clear();
+	_peer_map.clear();
+}
+
+bool WSLServer::has_peer(int p_id) const {
+	return _peer_map.has(p_id);
+}
+
+Ref<WebSocketPeer> WSLServer::get_peer(int p_id) const {
+	ERR_FAIL_COND_V(!has_peer(p_id), NULL);
+	return _peer_map[p_id];
+}
+
+IP_Address WSLServer::get_peer_address(int p_peer_id) const {
+	ERR_FAIL_COND_V(!has_peer(p_peer_id), IP_Address());
+
+	return _peer_map[p_peer_id]->get_connected_host();
+}
+
+int WSLServer::get_peer_port(int p_peer_id) const {
+	ERR_FAIL_COND_V(!has_peer(p_peer_id), 0);
+
+	return _peer_map[p_peer_id]->get_connected_port();
+}
+
+void WSLServer::disconnect_peer(int p_peer_id, int p_code, String p_reason) {
+	ERR_FAIL_COND(!has_peer(p_peer_id));
+
+	get_peer(p_peer_id)->close(p_code, p_reason);
+}
+
+Error WSLServer::set_buffers(int p_in_buffer, int p_in_packets, int p_out_buffer, int p_out_packets) {
+	ERR_EXPLAIN("Buffers sizes can only be set before listening or connecting");
+	ERR_FAIL_COND_V(_server->is_listening(), FAILED);
+
+	_in_buf_size = nearest_shift(p_in_buffer - 1) + 10;
+	_in_pkt_size = nearest_shift(p_in_packets - 1);
+	_out_buf_size = nearest_shift(p_out_buffer - 1) + 10;
+	_out_pkt_size = nearest_shift(p_out_packets - 1);
+	return OK;
+}
+
+WSLServer::WSLServer() {
+	_in_buf_size = nearest_shift((int)GLOBAL_GET(WSS_IN_BUF) - 1) + 10;
+	_in_pkt_size = nearest_shift((int)GLOBAL_GET(WSS_IN_PKT) - 1);
+	_out_buf_size = nearest_shift((int)GLOBAL_GET(WSS_OUT_BUF) - 1) + 10;
+	_out_pkt_size = nearest_shift((int)GLOBAL_GET(WSS_OUT_PKT) - 1);
+	_server.instance();
+}
+
+WSLServer::~WSLServer() {
+	stop();
+}
+
+#endif // JAVASCRIPT_ENABLED

modules/websocket/wsl_server.h

+/*************************************************************************/
+/*  wsl_server.h                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef WSLSERVER_H
+#define WSLSERVER_H
+
+#ifndef JAVASCRIPT_ENABLED
+
+#include "websocket_server.h"
+#include "wsl_peer.h"
+
+#include "core/io/stream_peer_tcp.h"
+#include "core/io/tcp_server.h"
+
+#define WSL_SERVER_TIMEOUT 1000
+
+class WSLServer : public WebSocketServer {
+
+	GDCIIMPL(WSLServer, WebSocketServer);
+
+private:
+	class PendingPeer : public Reference {
+
+	private:
+		bool _parse_request(String &r_key);
+
+	public:
+		Ref<StreamPeer> connection;
+
+		int time;
+		String request;
+		String key;
+		bool has_request;
+		CharString response;
+		int response_sent;
+
+		PendingPeer() {
+			time = 0;
+			has_request = false;
+			response_sent = 0;
+		}
+
+		Error do_handshake();
+	};
+
+	int _in_buf_size;
+	int _in_pkt_size;
+	int _out_buf_size;
+	int _out_pkt_size;
+
+	List<Ref<PendingPeer> > _pending;
+	Ref<TCP_Server> _server;
+
+public:
+	Error set_buffers(int p_in_buffer, int p_in_packets, int p_out_buffer, int p_out_packets);
+	Error listen(int p_port, PoolVector<String> p_protocols = PoolVector<String>(), bool gd_mp_api = false);
+	void stop();
+	bool is_listening() const;
+	int get_max_packet_size() const;
+	bool has_peer(int p_id) const;
+	Ref<WebSocketPeer> get_peer(int p_id) const;
+	IP_Address get_peer_address(int p_peer_id) const;
+	int get_peer_port(int p_peer_id) const;
+	void disconnect_peer(int p_peer_id, int p_code = 1000, String p_reason = "");
+	virtual void poll();
+
+	WSLServer();
+	~WSLServer();
+};
+
+#endif // JAVASCRIPT_ENABLED
+
+#endif // WSLSERVER_H

thirdparty/README.md

@@ -262,6 +262,13 @@ changes to ensure they build for Javascript/HTML5. Those
 changes are marked with `// -- GODOT --` comments.
 
 
+## wslay
+
+- Upstream: https://github.com/tatsuhiro-t/wslay
+- Version: 1.1.0
+- License: MIT
+
+
 ## libwebsockets
 
 - Upstream: https://github.com/warmcat/libwebsockets

thirdparty/wslay/COPYING

+The MIT License
+
+Copyright (c) 2011, 2012, 2015 Tatsuhiro Tsujikawa
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

thirdparty/wslay/includes/config.h

+#ifndef CONFIG_H
+#define CONFIG_H
+
+#ifdef BIG_ENDIAN_ENABLED
+#define WORDS_BIGENDIAN
+#endif
+
+#endif /* CONFIG_H */

thirdparty/wslay/includes/wslay/wslayver.h

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef WSLAYVER_H
+#define WSLAYVER_H
+
+/* Version number of wslay release */
+#define WSLAY_VERSION "1.1.0"
+
+#endif /* WSLAYVER_H */

thirdparty/wslay/wslay_event.h

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef WSLAY_EVENT_H
+#define WSLAY_EVENT_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <wslay/wslay.h>
+
+struct wslay_stack;
+struct wslay_queue;
+
+struct wslay_event_byte_chunk {
+  uint8_t *data;
+  size_t data_length;
+};
+
+struct wslay_event_imsg {
+  uint8_t fin;
+  uint8_t rsv;
+  uint8_t opcode;
+  uint32_t utf8state;
+  struct wslay_queue *chunks;
+  size_t msg_length;
+};
+
+enum wslay_event_msg_type {
+  WSLAY_NON_FRAGMENTED,
+  WSLAY_FRAGMENTED
+};
+
+struct wslay_event_omsg {
+  uint8_t fin;
+  uint8_t opcode;
+  uint8_t rsv;
+  enum wslay_event_msg_type type;
+
+  uint8_t *data;
+  size_t data_length;
+
+  union wslay_event_msg_source source;
+  wslay_event_fragmented_msg_callback read_callback;
+};
+
+struct wslay_event_frame_user_data {
+  wslay_event_context_ptr ctx;
+  void *user_data;
+};
+
+enum wslay_event_close_status {
+  WSLAY_CLOSE_RECEIVED = 1 << 0,
+  WSLAY_CLOSE_QUEUED = 1 << 1,
+  WSLAY_CLOSE_SENT = 1 << 2
+};
+
+enum wslay_event_config {
+  WSLAY_CONFIG_NO_BUFFERING = 1 << 0
+};
+
+struct wslay_event_context {
+  /* config status, bitwise OR of enum wslay_event_config values*/
+  uint32_t config;
+  /* maximum message length that can be received */
+  uint64_t max_recv_msg_length;
+  /* 1 if initialized for server, otherwise 0 */
+  uint8_t server;
+  /* bitwise OR of enum wslay_event_close_status values */
+  uint8_t close_status;
+  /* status code in received close control frame */
+  uint16_t status_code_recv;
+  /* status code in sent close control frame */
+  uint16_t status_code_sent;
+  wslay_frame_context_ptr frame_ctx;
+  /* 1 if reading is enabled, otherwise 0. Upon receiving close
+     control frame this value set to 0. If any errors in read
+     operation will also set this value to 0. */
+  uint8_t read_enabled;
+  /* 1 if writing is enabled, otherwise 0 Upon completing sending
+     close control frame, this value set to 0. If any errors in write
+     opration will also set this value to 0. */
+  uint8_t write_enabled;
+  /* imsg buffer to allow interleaved control frame between
+     non-control frames. */
+  struct wslay_event_imsg imsgs[2];
+  /* Pointer to imsgs to indicate current used buffer. */
+  struct wslay_event_imsg *imsg;
+  /* payload length of frame currently being received. */
+  uint64_t ipayloadlen;
+  /* next byte offset of payload currently being received. */
+  uint64_t ipayloadoff;
+  /* error value set by user callback */
+  int error;
+  /* Pointer to the message currently being sent. NULL if no message
+     is currently sent. */
+  struct wslay_event_omsg *omsg;
+  /* Queue for non-control frames */
+  struct wslay_queue/*<wslay_omsg*>*/ *send_queue;
+  /* Queue for control frames */
+  struct wslay_queue/*<wslay_omsg*>*/ *send_ctrl_queue;
+  /* Size of send_queue + size of send_ctrl_queue */
+  size_t queued_msg_count;
+  /* The sum of message length in send_queue */
+  size_t queued_msg_length;
+  /* Buffer used for fragmented messages */
+  uint8_t obuf[4096];
+  uint8_t *obuflimit;
+  uint8_t *obufmark;
+  /* payload length of frame currently being sent. */
+  uint64_t opayloadlen;
+  /* next byte offset of payload currently being sent. */
+  uint64_t opayloadoff;
+  struct wslay_event_callbacks callbacks;
+  struct wslay_event_frame_user_data frame_user_data;
+  void *user_data;
+  uint8_t allowed_rsv_bits;
+};
+
+#endif /* WSLAY_EVENT_H */

thirdparty/wslay/wslay_frame.h

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef WSLAY_FRAME_H
+#define WSLAY_FRAME_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <wslay/wslay.h>
+
+enum wslay_frame_state {
+  PREP_HEADER,
+  SEND_HEADER,
+  SEND_PAYLOAD,
+  RECV_HEADER1,
+  RECV_PAYLOADLEN,
+  RECV_EXT_PAYLOADLEN,
+  RECV_MASKKEY,
+  RECV_PAYLOAD
+};
+
+struct wslay_frame_opcode_memo {
+  uint8_t fin;
+  uint8_t opcode;
+  uint8_t rsv;
+};
+
+struct wslay_frame_context {
+  uint8_t ibuf[4096];
+  uint8_t *ibufmark;
+  uint8_t *ibuflimit;
+  struct wslay_frame_opcode_memo iom;
+  uint64_t ipayloadlen;
+  uint64_t ipayloadoff;
+  uint8_t imask;
+  uint8_t imaskkey[4];
+  enum wslay_frame_state istate;
+  size_t ireqread;
+
+  uint8_t oheader[14];
+  uint8_t *oheadermark;
+  uint8_t *oheaderlimit;
+  uint64_t opayloadlen;
+  uint64_t opayloadoff;
+  uint8_t omask;
+  uint8_t omaskkey[4];
+  enum wslay_frame_state ostate;
+
+  struct wslay_frame_callbacks callbacks;
+  void *user_data;
+};
+
+#endif /* WSLAY_FRAME_H */

thirdparty/wslay/wslay_net.c

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "wslay_net.h"
+
+#ifndef WORDS_BIGENDIAN
+
+uint64_t wslay_byteswap64(uint64_t x)
+{
+  uint64_t u = ntohl(x & 0xffffffffllu);
+  uint64_t l = ntohl(x >> 32);
+  return (u << 32) | l;
+}
+
+#endif /* !WORDS_BIGENDIAN */

thirdparty/wslay/wslay_net.h

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef WSLAY_NET_H
+#define WSLAY_NET_H
+
+#ifdef HAVE_CONFIG_H
+#  include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <wslay/wslay.h>
+
+#ifdef HAVE_ARPA_INET_H
+#  include <arpa/inet.h>
+#endif /* HAVE_ARPA_INET_H */
+#ifdef HAVE_NETINET_IN_H
+#  include <netinet/in.h>
+#endif /* HAVE_NETINET_IN_H */
+/* For Mingw build */
+#ifdef HAVE_WINSOCK2_H
+#  include <winsock2.h>
+#endif /* HAVE_WINSOCK2_H */
+
+#ifdef WORDS_BIGENDIAN
+#  define ntoh64(x) (x)
+#  define hton64(x) (x)
+#else /* !WORDS_BIGENDIAN */
+uint64_t wslay_byteswap64(uint64_t x);
+#  define ntoh64(x) wslay_byteswap64(x)
+#  define hton64(x) wslay_byteswap64(x)
+#endif /* !WORDS_BIGENDIAN */
+
+#endif /* WSLAY_NET_H */

thirdparty/wslay/wslay_queue.c

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "wslay_queue.h"
+
+#include <string.h>
+#include <assert.h>
+
+struct wslay_queue* wslay_queue_new(void)
+{
+  struct wslay_queue *queue = (struct wslay_queue*)malloc
+    (sizeof(struct wslay_queue));
+  if(!queue) {
+    return NULL;
+  }
+  queue->top = queue->tail = NULL;
+  return queue;
+}
+
+void wslay_queue_free(struct wslay_queue *queue)
+{
+  if(!queue) {
+    return;
+  } else {
+    struct wslay_queue_cell *p = queue->top;
+    while(p) {
+      struct wslay_queue_cell *next = p->next;
+      free(p);
+      p = next;
+    }
+    free(queue);
+  }
+}
+
+int wslay_queue_push(struct wslay_queue *queue, void *data)
+{
+  struct wslay_queue_cell *new_cell = (struct wslay_queue_cell*)malloc
+    (sizeof(struct wslay_queue_cell));
+  if(!new_cell) {
+    return WSLAY_ERR_NOMEM;
+  }
+  new_cell->data = data;
+  new_cell->next = NULL;
+  if(queue->tail) {
+    queue->tail->next = new_cell;
+    queue->tail = new_cell;
+
+  } else {
+    queue->top = queue->tail = new_cell;
+  }
+  return 0;
+}
+
+int wslay_queue_push_front(struct wslay_queue *queue, void *data)
+{
+  struct wslay_queue_cell *new_cell = (struct wslay_queue_cell*)malloc
+    (sizeof(struct wslay_queue_cell));
+  if(!new_cell) {
+    return WSLAY_ERR_NOMEM;
+  }
+  new_cell->data = data;
+  new_cell->next = queue->top;
+  queue->top = new_cell;
+  if(!queue->tail) {
+    queue->tail = queue->top;
+  }
+  return 0;
+}
+
+void wslay_queue_pop(struct wslay_queue *queue)
+{
+  struct wslay_queue_cell *top = queue->top;
+  assert(top);
+  queue->top = top->next;
+  if(top == queue->tail) {
+    queue->tail = NULL;
+  }
+  free(top);
+}
+
+void* wslay_queue_top(struct wslay_queue *queue)
+{
+  assert(queue->top);
+  return queue->top->data;
+}
+
+void* wslay_queue_tail(struct wslay_queue *queue)
+{
+  assert(queue->tail);
+  return queue->tail->data;
+}
+
+int wslay_queue_empty(struct wslay_queue *queue)
+{
+  return queue->top == NULL;
+}

thirdparty/wslay/wslay_queue.h

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef WSLAY_QUEUE_H
+#define WSLAY_QUEUE_H
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <wslay/wslay.h>
+
+struct wslay_queue_cell {
+  void *data;
+  struct wslay_queue_cell *next;
+};
+
+struct wslay_queue {
+  struct wslay_queue_cell *top;
+  struct wslay_queue_cell *tail;
+};
+
+struct wslay_queue* wslay_queue_new(void);
+void wslay_queue_free(struct wslay_queue *queue);
+int wslay_queue_push(struct wslay_queue *queue, void *data);
+int wslay_queue_push_front(struct wslay_queue *queue, void *data);
+void wslay_queue_pop(struct wslay_queue *queue);
+void* wslay_queue_top(struct wslay_queue *queue);
+void* wslay_queue_tail(struct wslay_queue *queue);
+int wslay_queue_empty(struct wslay_queue *queue);
+
+#endif /* WSLAY_QUEUE_H */

thirdparty/wslay/wslay_stack.c

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#include "wslay_stack.h"
+
+#include <string.h>
+#include <assert.h>
+
+struct wslay_stack* wslay_stack_new()
+{
+  struct wslay_stack *stack = (struct wslay_stack*)malloc
+    (sizeof(struct wslay_stack));
+  if(!stack) {
+    return NULL;
+  }
+  stack->top = NULL;
+  return stack;
+}
+
+void wslay_stack_free(struct wslay_stack *stack)
+{
+  struct wslay_stack_cell *p;
+  if(!stack) {
+    return;
+  }
+  p = stack->top;
+  while(p) {
+    struct wslay_stack_cell *next = p->next;
+    free(p);
+    p = next;
+  }
+  free(stack);
+}
+
+int wslay_stack_push(struct wslay_stack *stack, void *data)
+{
+  struct wslay_stack_cell *new_cell = (struct wslay_stack_cell*)malloc
+    (sizeof(struct wslay_stack_cell));
+  if(!new_cell) {
+    return WSLAY_ERR_NOMEM;
+  }
+  new_cell->data = data;
+  new_cell->next = stack->top;
+  stack->top = new_cell;
+  return 0;
+}
+
+void wslay_stack_pop(struct wslay_stack *stack)
+{
+  struct wslay_stack_cell *top = stack->top;
+  assert(top);
+  stack->top = top->next;
+  free(top);
+}
+
+void* wslay_stack_top(struct wslay_stack *stack)
+{
+  assert(stack->top);
+  return stack->top->data;
+}
+
+int wslay_stack_empty(struct wslay_stack *stack)
+{
+  return stack->top == NULL;
+}

thirdparty/wslay/wslay_stack.h

+/*
+ * Wslay - The WebSocket Library
+ *
+ * Copyright (c) 2011, 2012 Tatsuhiro Tsujikawa
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+#ifndef WSLAY_STACK_H
+#define WSLAY_STACK_H
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <wslay/wslay.h>
+
+struct wslay_stack_cell {
+  void *data;
+  struct wslay_stack_cell *next;
+};
+
+struct wslay_stack {
+  struct wslay_stack_cell *top;
+};
+
+struct wslay_stack* wslay_stack_new();
+void wslay_stack_free(struct wslay_stack *stack);
+int wslay_stack_push(struct wslay_stack *stack, void *data);
+void wslay_stack_pop(struct wslay_stack *stack);
+void* wslay_stack_top(struct wslay_stack *stack);
+int wslay_stack_empty(struct wslay_stack *stack);
+
+#endif /* WSLAY_STACK_H */