Merge remote-tracking branch 'upstream/master'

Author: Doridian

README.md

@@ -37,6 +37,23 @@ require("gwsockets")
   GWSockets.addVerifyPath( "/etc/ssl/certs" )
   ```
 
+* If you would like to enable the `permessage-deflate` extension which allows you to send and receive compressed messages, you can enable it with the following functions:
+
+  ```LUA
+  -- Do note this will only be enabled if the websocket server supports permessage-deflate and enables it during handshake.
+  WEBSOCKET:setMessageCompression(true)
+  ```
+
+* You can also disable context takeover during compression, which will prevent re-using the same compression context over multiple messages.
+  This will decrease the memory usage at the cost of a worse compression ratio.
+
+  ```LUA
+  WEBSOCKET:setDisableContextTakeover(true)
+  ```
+
+ *WARNING:* Enabling compression over encrypted connections (`WSS://`) may make you vulnerable to [CRIME](https://en.wikipedia.org/wiki/CRIME)/[BREACH](https://en.wikipedia.org/wiki/BREACH) attacks.
+            Make sure you know what you are doing, or avoid sending sensitive information over websocket messages.
+
 * Next add any cookies or headers you would like to send with the initial request (Optional)
 
   ```LUA
@@ -67,9 +84,13 @@ require("gwsockets")
 * Lastly open the connection
 
   ```LUA
-  WEBSOCKET:open()
+  WEBSOCKET:open( shouldClearQueue = true )
   ```
 
+  *NOTE:* By default, opening a connection will clear the queued messages. This is due to the fact there
+  is no way of knowing what's in the queue, and what has been received by the remote. If you would like to
+  disable this, you may use `open(false)`.
+  
 * Once the socket has been opened you can send messages using the `write` function
 
   ```LUA

src/GLua.cpp

@@ -168,14 +168,17 @@ LUA_FUNCTION(socketOpen)
 	{
 		LUA->ThrowError("Cannot open socket that is already connected");
 	}
+
+	const bool shouldClearQueue = LUA->IsType(2, Type::BOOL) ? LUA->GetBool(2) : true;
+	
 	//As soon as the socket starts connecting we want to keep a reference to the table so that it does not
 	//get garbage collected, so that the callbacks can be called.
 	if (socketTableReferences.find(socket) == socketTableReferences.end())
 	{
 		LUA->Push(1);
 		socketTableReferences[socket] = LUA->ReferenceCreate();
 	}
-	socket->open();
+	socket->open(shouldClearQueue);
 	return 0;
 }
 
@@ -218,6 +221,34 @@ LUA_FUNCTION(socketSetHeader)
 	return 0;
 }
 
+LUA_FUNCTION(socketSetMessageCompression)
+{
+	GWSocket* socket = getCppObject<GWSocket>(LUA);
+	if (socket->state != STATE_DISCONNECTED)
+	{
+		LUA->ThrowError("Cannot set message compression for an already connected websocket");
+	}
+
+	LUA->CheckType(2, Type::BOOL);
+	socket->setPerMessageDeflate(LUA->GetBool(2));
+
+	return 0;
+}
+
+LUA_FUNCTION(socketSetDisableContextTakeover)
+{
+	GWSocket* socket = getCppObject<GWSocket>(LUA);
+	if (socket->state != STATE_DISCONNECTED)
+	{
+		LUA->ThrowError("Cannot set compression takeover for an already connected websocket");
+	}
+
+	LUA->CheckType(2, Type::BOOL);
+	socket->setDisableContextTakeover(LUA->GetBool(2));
+
+	return 0;
+}
+
 LUA_FUNCTION(socketIsConnected)
 {
 	GWSocket* socket = getCppObject<GWSocket>(LUA);
@@ -421,6 +452,10 @@ GMOD_MODULE_OPEN()
 	LUA->SetField(-2, "setCookie");
 	LUA->PushCFunction(socketSetHeader);
 	LUA->SetField(-2, "setHeader");
+	LUA->PushCFunction(socketSetMessageCompression);
+	LUA->SetField(-2, "setMessageCompression");
+	LUA->PushCFunction(socketSetDisableContextTakeover);
+	LUA->SetField(-2, "setDisableContextTakeover");
 	LUA->PushCFunction(socketIsConnected);
 	LUA->SetField(-2, "isConnected");
 	LUA->PushCFunction(socketClearQueue);

src/GWSocket.cpp

@@ -211,14 +211,20 @@ void GWSocket::hostResolvedStep(const boost::system::error_code &ec, tcp::resolv
 	}
 }
 
-void GWSocket::open()
+void GWSocket::open(bool shouldClearQueue)
 {
 	auto expected = STATE_DISCONNECTED;
 	if (!this->state.compare_exchange_strong(expected, STATE_CONNECTING))
 	{
 		return;
 	}
-	this->clearQueue();
+
+	// Clear the queue if it was requested.
+	if (shouldClearQueue)
+	{
+		this->clearQueue();
+	}
+	
 	// Look up the domain name
 	this->resolver.async_resolve(host, std::to_string(port), boost::bind(&GWSocket::hostResolvedStep, this, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
 }
@@ -327,4 +333,14 @@ bool GWSocket::setHeader(std::string key, std::string value)
 	}
 	this->headers[key] = value;
 	return true;
-}
+}
+
+void GWSocket::setPerMessageDeflate(bool value)
+{
+	perMessageDeflate = value;
+}
+
+void GWSocket::setDisableContextTakeover(bool value)
+{
+	disableContextTakeover = value;
+}

src/GWSocket.h

@@ -63,13 +63,16 @@ class GWSocket
 	GWSocket(std::string host, unsigned short port, std::string path) : host(host), port(port), path(path) { };
 	virtual ~GWSocket() { };
 
-	void open();
+	void open(bool shouldClearQueue = true);
 	void onDisconnected(const boost::system::error_code & ec);
 	bool close();
 	bool closeNow();
 	void write(std::string message);
 	bool setCookie(std::string key, std::string value);
 	bool setHeader(std::string key, std::string value);
+	void setPerMessageDeflate(bool value);
+	void setDisableContextTakeover(bool value);
+
 	BlockingQueue<GWSocketMessageIn> messageQueue;
 	bool isConnected() { return state == STATE_CONNECTED; };
 	bool canBeDeleted() { return state == STATE_DISCONNECTED; };
@@ -78,6 +81,8 @@ class GWSocket
 	std::string host;
 	unsigned int port;
 	std::atomic<SocketState> state{ STATE_DISCONNECTED };
+	bool perMessageDeflate;
+	bool disableContextTakeover;
 
 	static std::unique_ptr<boost::asio::io_context> ioc; //Needs to be initialized on module load
 protected:

src/SSLWebSocket.h

@@ -28,7 +28,7 @@ class SSLWebSocket : public GWSocket
 	void closeSocket();
 	void sslHandshakeComplete(const boost::system::error_code& ec, std::string host, std::string path, std::function<void(websocket::request_type&)> decorator);
 	bool verifyCertificate(bool preverified, boost::asio::ssl::verify_context& ctx);
-	std::atomic<websocket::stream<ssl::stream<tcp::socket>>*> ws{ nullptr };
+	std::atomic<websocket::stream<ssl::stream<tcp::socket>, true>*> ws{ nullptr };
 	//This is not an atomic function, it only ensures visibility.
 	//Callers have to make sure that atomicity is not required/ensured otherwise
 	void resetWS()
@@ -38,8 +38,18 @@ class SSLWebSocket : public GWSocket
 		{
 			delete stream;
 		}
-		ws = new websocket::stream<ssl::stream<tcp::socket>>(*ioc, *sslContext);
+
+		auto newWS = new websocket::stream<ssl::stream<tcp::socket>, true>(*ioc, *sslContext);
+
+		// Set permessage-deflate options for message compression if requested.
+		websocket::permessage_deflate opts;
+		opts.client_enable = perMessageDeflate;
+		opts.client_no_context_takeover = disableContextTakeover;
+		newWS->set_option(opts);
+
+		ws = newWS;
 	}
+
 	websocket::stream<ssl::stream<tcp::socket>>* getWS()
 	{
 		return this->ws.load();

src/WebSocket.h

@@ -32,8 +32,18 @@ class WebSocket : public GWSocket
 		{
 			delete stream;
 		}
-		ws = new websocket::stream<tcp::socket>(*ioc);
+
+		auto newWS = new websocket::stream<tcp::socket, true>(*ioc);
+
+		// Set permessage-deflate options for message compression if requested.
+		websocket::permessage_deflate opts;
+		opts.client_enable = perMessageDeflate;
+		opts.client_no_context_takeover = disableContextTakeover;
+		newWS->set_option(opts);
+
+		ws = newWS;
 	}
+
 	websocket::stream<tcp::socket>* getWS()
 	{
 		return this->ws.load();

version.txt

@@ -1 +1 @@
-1.2.0
+1.3.0