Removed hard length limit for received messages (#51)

* Added WebSocket close code to callback

Also added message and code for HTML5

* Unify disconnect handling for wslay and html5

README.md

@@ -1,5 +1,3 @@
-
-
 # Defold websocket extension
 
 [![Build Status](https://github.com/defold/extension-websocket/workflows/Build%20with%20bob/badge.svg)](https://github.com/defold/extension-websocket/actions)
@@ -17,7 +15,12 @@ https://defold.com/extension-websocket/api/
 
 ## Debugging
 
-In order to make it easier to debug this extension, we provide a `game.project` setting `websocket.debug`.
+In order to make it easier to debug this extension, we provide a `game.project` setting `websocket.debug` (edit `game.project` as text and add):
+
+```
+[websocket]
+debug = level
+```
 
 Set it to:
 
@@ -50,3 +53,7 @@ For command line debugging, there's
 This extension makes use of the C library WSlay by @tatsuhiro-t:
 
 * https://github.com/tatsuhiro-t/wslay
+
+The test server used by the example:
+
+* https://www.lob.com/blog/websocket-org-is-down-here-is-an-alternative

docs/index.md

@@ -14,23 +14,23 @@ Here is how you connect to a websocket and listen to events:
 ```lua
 local function websocket_callback(self, conn, data)
     if data.event == websocket.EVENT_DISCONNECTED then
-        log("Disconnected: " .. tostring(conn))
+        print("Disconnected: " .. tostring(conn))
         self.connection = nil
         update_gui(self)
     elseif data.event == websocket.EVENT_CONNECTED then
         update_gui(self)
-        log("Connected: " .. tostring(conn))
+        print("Connected: " .. tostring(conn))
     elseif data.event == websocket.EVENT_ERROR then
-        log("Error: '" .. tostring(data.message) .. "'")
+        print("Error: '" .. tostring(data.message) .. "'")
         if data.handshake_response then
-            log("Handshake response status: '" .. tostring(data.handshake_response.status) .. "'")
+            print("Handshake response status: '" .. tostring(data.handshake_response.status) .. "'")
             for key, value in pairs(data.handshake_response.headers) do
                 log("Handshake response header: '" .. key .. ": " .. value .. "'")
             end
-            log("Handshake response body: '" .. tostring(data.handshake_response.response) .. "'")
+            print("Handshake response body: '" .. tostring(data.handshake_response.response) .. "'")
         end
     elseif data.event == websocket.EVENT_MESSAGE then
-        log("Receiving: '" .. tostring(data.message) .. "'")
+        print("Receiving: '" .. tostring(data.message) .. "'")
     end
 end
 
@@ -56,10 +56,23 @@ https://github.com/defold/extension-websocket/archive/master.zip
 We recommend using a link to a zip file of a [specific release](https://github.com/defold/extension-websocket/releases).
 
 
+## Configuration
+The following configuration options can be set in the game.project file:
+
+```
+[websocket]
+debug = 1
+socket_timeout = 10000000
+```
+
+* `debug` - Log level where 0 means no logs and higher values shows more logs (currently 1 or 2).
+* `socket_timeout` - Timeout for the underlying socket connection. In microseconds.
+
+
 ## Source code
 
 The source code is available on [GitHub](https://github.com/defold/extension-websocket)
 
 ## API reference
 
-https://defold.com/extension-websocket/api/
+https://defold.com/extension-websocket/api/

examples/websocket.gui_script

@@ -1,4 +1,5 @@
-local URL="://echo.websocket.org"
+local URL = "echo.websocket.events"
+
 local function click_button(node, action)
 	return gui.is_enabled(node) and action.pressed and gui.pick_node(node, action.x, action.y)
 end
@@ -32,12 +33,6 @@ local function log(...)
 	gui.set_text(node, gui.get_text(node) .. "\n" .. text)
 end
 
-local function http_result(self, _, response)
-    print(response.status)
-    --print(response.response)
-    pprint(response.headers)
-end
-
 function init(self)
 	msg.post(".", "acquire_input_focus")
 	msg.post("@render:", "clear_color", { color = vmath.vector4(0.2, 0.4, 0.8, 1.0) })
@@ -48,9 +43,6 @@ function init(self)
 	self.connection_text = gui.get_node("connection_text")
 	self.connection = nil
 	update_gui(self)
-
-	--http.request("https://defold.com", "GET", http_result)
-
 end
 
 function final(self)
@@ -65,7 +57,7 @@ end
 
 local function websocket_callback(self, conn, data)
 	if data.event == websocket.EVENT_DISCONNECTED then
-		log("Disconnected: " .. tostring(conn))
+		log("Disconnected: " .. tostring(conn) .. " Code: " .. data.code .. " Message: " .. tostring(data.message))
 		self.connection = nil
 		update_gui(self)
 	elseif data.event == websocket.EVENT_CONNECTED then
@@ -88,7 +80,7 @@ end
 local function connect(self, scheme)
 	local params = {}
 
-	self.url = scheme .. URL
+	self.url = scheme .. "://" .. URL
 	log("Connecting to " .. self.url)
 	self.connection = websocket.connect(self.url, params, websocket_callback)
 end

websocket/api/api.script_api

@@ -61,6 +61,14 @@
             type: string
             desc: The received data if event is `websocket.EVENT_MESSAGE`. Error message otherwise
 
+          - name: handshake_response
+            type: table
+            desc: Handshake response information (status, headers etc)
+
+          - name: code
+            type: number
+            desc: Status code received from the server if the server closed the connection. Only present if event is `EVENT_DISCONNECTED`.
+
 
     returns:
       - name: connection
@@ -86,7 +94,7 @@
               end
 
               function init(self)
-                self.url = "ws://echo.websocket.org"
+                self.url = "ws://echo.websocket.events"
                 local params = {
                   timeout = 3000,
                   headers = "Sec-WebSocket-Protocol: chat\r\nOrigin: mydomain.com\r\n"

websocket/src/emscripten_callbacks.cpp

@@ -21,8 +21,8 @@ EM_BOOL Emscripten_WebSocketOnError(int eventType, const EmscriptenWebSocketErro
 EM_BOOL Emscripten_WebSocketOnClose(int eventType, const EmscriptenWebSocketCloseEvent *websocketEvent, void *userData) {
     DebugLog(1, "WebSocket OnClose");
     WebsocketConnection* conn = (WebsocketConnection*)userData;
-    PushMessage(conn, MESSAGE_TYPE_CLOSE, 0, 0);
+    int length = strlen(websocketEvent->reason);
-    SetState(conn, STATE_DISCONNECTED);
+    PushMessage(conn, MESSAGE_TYPE_CLOSE, length, (uint8_t*)websocketEvent->reason, websocketEvent->code);
     return EM_TRUE;
 }
 EM_BOOL Emscripten_WebSocketOnMessage(int eventType, const EmscriptenWebSocketMessageEvent *websocketEvent, void *userData) {
@@ -33,7 +33,7 @@ EM_BOOL Emscripten_WebSocketOnMessage(int eventType, const EmscriptenWebSocketMe
     {
         length--;
     }
-    PushMessage(conn, MESSAGE_TYPE_NORMAL, length, websocketEvent->data);
+    PushMessage(conn, MESSAGE_TYPE_NORMAL, length, websocketEvent->data, 0);
     return EM_TRUE;
 }
 

websocket/src/websocket.cpp

@@ -7,7 +7,7 @@
 #include "websocket.h"
 #include "script_util.h"
 #include <dmsdk/dlib/connection_pool.h>
-#include <dmsdk/dlib/dns.h>
+#include <dmsdk/dlib/thread.h>
 #include <dmsdk/dlib/sslsocket.h>
 #include <ctype.h> // isprint et al
 
@@ -31,7 +31,6 @@ struct WebsocketContext
     int                             m_Timeout;
     dmArray<WebsocketConnection*>   m_Connections;
     dmConnectionPool::HPool         m_Pool;
-    dmDNS::HChannel                 m_Channel;
     uint32_t                        m_Initialized:1;
 } g_Websocket;
 
@@ -193,6 +192,7 @@ static WebsocketConnection* CreateConnection(const char* url)
     conn->m_Status = RESULT_OK;
     conn->m_HasHandshakeData = 0;
     conn->m_HandshakeResponse = 0;
+    conn->m_ConnectionThread = 0;
 
 #if defined(HAVE_WSLAY)
     conn->m_Ctx = 0;
@@ -232,6 +232,13 @@ static void DestroyConnection(WebsocketConnection* conn)
 
 
     free((void*)conn->m_Buffer);
+
+    if (conn->m_ConnectionThread)
+    {
+        dmThread::Join(conn->m_ConnectionThread);
+        conn->m_ConnectionThread = 0;
+    }
+
     delete conn;
     DebugLog(2, "DestroyConnection: %p", conn);
 }
@@ -242,10 +249,7 @@ static void CloseConnection(WebsocketConnection* conn)
     // we want it to send this message in the polling
     if (conn->m_State == STATE_CONNECTED) {
 #if defined(HAVE_WSLAY)
-        // close the connection and immediately transition to the DISCONNECTED
-        // state
         WSL_Close(conn->m_Ctx);
-        SetState(conn, STATE_DISCONNECTED);
 #else
         // start disconnecting by closing the WebSocket through the JS API
         // we transition to the DISCONNECTED state when we receive the
@@ -255,6 +259,11 @@ static void CloseConnection(WebsocketConnection* conn)
 #endif
     }
 
+#if defined(HAVE_WSLAY)
+    // close the connection and immediately transition to the DISCONNECTED
+    // state
+    SetState(conn, STATE_DISCONNECTED);
+#endif
 }
 
 static bool IsConnectionValid(WebsocketConnection* conn)
@@ -427,6 +436,12 @@ void HandleCallback(WebsocketConnection* conn, int event, int msg_offset, int ms
         conn->m_HandshakeResponse = 0;
     }
 
+    if (event == EVENT_DISCONNECTED)
+    {
+        lua_pushinteger(L, conn->m_CloseCode);
+        lua_setfield(L, -2, "code");
+    }
+
     dmScript::PCall(L, 3, 0);
 
     dmScript::TeardownCallback(conn->m_Callback);
@@ -518,8 +533,8 @@ static dmExtension::Result AppInitialize(dmExtension::AppParams* params)
     g_Websocket.m_BufferSize = dmConfigFile::GetInt(params->m_ConfigFile, "websocket.buffer_size", 64 * 1024);
     g_Websocket.m_Timeout = dmConfigFile::GetInt(params->m_ConfigFile, "websocket.socket_timeout", 500 * 1000);
     g_Websocket.m_Connections.SetCapacity(4);
-    g_Websocket.m_Channel = 0;
     g_Websocket.m_Pool = 0;
+    g_Websocket.m_Initialized = 0;
 
     dmConnectionPool::Params pool_params;
     pool_params.m_MaxConnections = dmConfigFile::GetInt(params->m_ConfigFile, "websocket.max_connections", 2);
@@ -532,31 +547,10 @@ static dmExtension::Result AppInitialize(dmExtension::AppParams* params)
     if (dmConnectionPool::RESULT_OK != result)
     {
         dmLogError("Failed to create connection pool: %d", result);
+        return dmExtension::RESULT_INIT_ERROR;
     }
 
-// We can do without the channel, it will then fallback to the dmSocket::GetHostname (as opposed to dmDNS::GetHostname)
-#if defined(HAVE_WSLAY)
-    dmDNS::Result dns_result = dmDNS::NewChannel(&g_Websocket.m_Channel);
-
-    if (dmDNS::RESULT_OK != dns_result)
-    {
-        dmLogError("Failed to create connection pool: %d", dns_result);
-    }
-#endif
-
     g_Websocket.m_Initialized = 1;
-    if (!g_Websocket.m_Pool)
-    {
-        if (!g_Websocket.m_Pool)
-        {
-            dmLogInfo("pool is null!");
-            dmConnectionPool::Delete(g_Websocket.m_Pool);
-        }
-
-        dmLogInfo("%s extension not initialized", MODULE_NAME);
-        g_Websocket.m_Initialized = 0;
-    }
-
     return dmExtension::RESULT_OK;
 }
 
@@ -588,7 +582,7 @@ static dmExtension::Result Finalize(dmExtension::Params* params)
     return dmExtension::RESULT_OK;
 }
 
-Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* buffer)
+Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* buffer, uint16_t code)
 {
     if (conn->m_Messages.Full())
         conn->m_Messages.OffsetCapacity(4);
@@ -596,6 +590,7 @@ Result PushMessage(WebsocketConnection* conn, MessageType type, int length, cons
     Message msg;
     msg.m_Type = (uint32_t)type;
     msg.m_Length = length;
+    msg.m_Code = code;
     conn->m_Messages.Push(msg);
 
     if ((conn->m_BufferSize + length) >= conn->m_BufferCapacity)
@@ -622,6 +617,19 @@ static bool CheckConnectTimeout(WebsocketConnection* conn)
     return t >= conn->m_ConnectTimeout;
 }
 
+static void ConnectionWorker(void* _conn)
+{
+    WebsocketConnection* conn = (WebsocketConnection*)_conn;
+    dmSocket::Result sr;
+    dmConnectionPool::Result pool_result = dmConnectionPool::Dial(g_Websocket.m_Pool, conn->m_Url.m_Hostname, conn->m_Url.m_Port, conn->m_SSL, g_Websocket.m_Timeout, &conn->m_Connection, &sr);
+    if (dmConnectionPool::RESULT_OK != pool_result)
+    {
+        CLOSE_CONN("Failed to open connection: %s", dmSocket::ResultToString(sr));
+        return;
+    }
+    SetState(conn, STATE_HANDSHAKE_WRITE);
+}
+
 static dmExtension::Result OnUpdate(dmExtension::Params* params)
 {
     uint32_t size = g_Websocket.m_Connections.Size();
@@ -645,7 +653,7 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
             --size;
             DestroyConnection(conn);
         }
-        else if (STATE_CONNECTED == conn->m_State)
+        else if ((STATE_CONNECTED == conn->m_State) || (STATE_DISCONNECTING == conn->m_State))
         {
 #if defined(HAVE_WSLAY)
             int r = WSL_Poll(conn->m_Ctx);
@@ -657,7 +665,6 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
 #endif
 
             uint32_t offset = 0;
-            bool close_received = false;
             for (uint32_t i = 0; i < conn->m_Messages.Size(); ++i)
             {
                 const Message& msg = conn->m_Messages[i];
@@ -665,24 +672,18 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
                 if (EVENT_DISCONNECTED == msg.m_Type)
                 {
                     conn->m_Status = RESULT_OK;
-                    CloseConnection(conn);
+                    // close the connection and immediately transition to the DISCONNECTED
-
+                    // state
-                    // Put the message at the front of the buffer
+                    SetState(conn, STATE_DISCONNECTED);
-                    conn->m_Messages.SetSize(0);
+                    conn->m_CloseCode = msg.m_Code;
-                    conn->m_BufferSize = 0;
-                    PushMessage(conn, MESSAGE_TYPE_CLOSE, msg.m_Length, (const uint8_t*)conn->m_Buffer+offset);
-                    close_received = true;
                     break;
                 }
 
                 HandleCallback(conn, EVENT_MESSAGE, offset, msg.m_Length);
                 offset += msg.m_Length;
             }
-            if (!close_received) // saving the close message for next step
+            conn->m_Messages.SetSize(0);
-            {
+            conn->m_BufferSize = 0;
-                conn->m_Messages.SetSize(0);
-                conn->m_BufferSize = 0;
-            }
         }
         else if (STATE_HANDSHAKE_READ == conn->m_State)
         {
@@ -739,6 +740,13 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
                 continue;
             }
 
+            if (conn->m_ConnectionThread)
+            {
+                dmThread::Join(conn->m_ConnectionThread);
+                conn->m_ConnectionThread = 0;
+            }
+            conn->m_Socket = dmConnectionPool::GetSocket(g_Websocket.m_Pool, conn->m_Connection);
+            conn->m_SSLSocket = dmConnectionPool::GetSSLSocket(g_Websocket.m_Pool, conn->m_Connection);
             Result result = SendClientHandshake(conn);
             if (RESULT_WOULDBLOCK == result)
             {
@@ -799,28 +807,20 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
             emscripten_websocket_set_onerror_callback(ws, conn, Emscripten_WebSocketOnError);
             emscripten_websocket_set_onclose_callback(ws, conn, Emscripten_WebSocketOnClose);
             emscripten_websocket_set_onmessage_callback(ws, conn, Emscripten_WebSocketOnMessage);
-            SetState(conn, STATE_CONNECTING);
 #else
-            dmSocket::Result sr;
+            conn->m_ConnectionThread = dmThread::New((dmThread::ThreadStart)ConnectionWorker, 0x80000, conn, "WSConnect");
-            int timeout = g_Websocket.m_Timeout;
-            dmConnectionPool::Result pool_result = dmConnectionPool::Dial(g_Websocket.m_Pool, conn->m_Url.m_Hostname, conn->m_Url.m_Port, g_Websocket.m_Channel, conn->m_SSL, timeout, &conn->m_Connection, &sr);
-            if (dmConnectionPool::RESULT_OK != pool_result)
-            {
-                CLOSE_CONN("Failed to open connection: %s", dmSocket::ResultToString(sr));
-                continue;
-            }
-            conn->m_Socket = dmConnectionPool::GetSocket(g_Websocket.m_Pool, conn->m_Connection);
-            conn->m_SSLSocket = dmConnectionPool::GetSSLSocket(g_Websocket.m_Pool, conn->m_Connection);
-            SetState(conn, STATE_HANDSHAKE_WRITE);
 #endif
+            SetState(conn, STATE_CONNECTING);
         }
         else if (STATE_CONNECTING == conn->m_State)
         {
+#if defined(__EMSCRIPTEN__)
             if (CheckConnectTimeout(conn))
             {
                 CLOSE_CONN("Connect sequence timed out");
                 continue;
             }
+#endif
         }
     }
 

websocket/src/websocket.h

@@ -21,9 +21,9 @@
 
 #include <dmsdk/dlib/connection_pool.h>
 #include <dmsdk/dlib/socket.h>
-#include <dmsdk/dlib/dns.h>
 #include <dmsdk/dlib/uri.h>
 #include <dmsdk/dlib/array.h>
+#include <dmsdk/dlib/thread.h>
 
 namespace dmCrypt
 {
@@ -80,6 +80,7 @@ namespace dmWebsocket
 
     struct Message
     {
+        uint16_t m_Code;
         uint32_t m_Length:30;
         uint32_t m_Type:2;
     };
@@ -118,6 +119,7 @@ namespace dmWebsocket
         dmConnectionPool::HConnection   m_Connection;
         dmSocket::Socket                m_Socket;
         dmSSLSocket::Socket             m_SSLSocket;
+        dmThread::Thread                m_ConnectionThread;
         dmArray<Message>                m_Messages; // lengths of the messages in the data buffer
         uint64_t                        m_ConnectTimeout;
         uint8_t                         m_Key[16];
@@ -128,6 +130,7 @@ namespace dmWebsocket
         int                             m_BufferSize;
         uint32_t                        m_BufferCapacity;
         Result                          m_Status;
+        uint16_t                        m_CloseCode;
         uint8_t                         m_SSL:1;
         uint8_t                         m_HasHandshakeData:1;
         uint8_t                         :7;
@@ -158,7 +161,7 @@ namespace dmWebsocket
     void HandleCallback(WebsocketConnection* conn, int event, int msg_offset, int msg_length);
 
     // Messages
-    Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* msg);
+    Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* msg, uint16_t code);
 
 #if defined(HAVE_WSLAY)
     // Wslay callbacks

websocket/src/wslay_callbacks.cpp

@@ -39,11 +39,7 @@ const char* WSL_ResultToString(int err)
 int WSL_Init(wslay_event_context_ptr* ctx, ssize_t buffer_size, void* userctx)
 {
     // Currently only supports client implementation
-    int ret = -1;
+    return wslay_event_context_client_init(ctx, &g_WslCallbacks, userctx);
-    ret = wslay_event_context_client_init(ctx, &g_WslCallbacks, userctx);
-    if (ret == 0)
-        wslay_event_config_set_max_recv_msg_length(*ctx, buffer_size);
-    return ret;
 }
 
 
@@ -124,7 +120,7 @@ void WSL_OnMsgRecvCallback(wslay_event_context_ptr ctx, const struct wslay_event
     WebsocketConnection* conn = (WebsocketConnection*)user_data;
     if (arg->opcode == WSLAY_TEXT_FRAME || arg->opcode == WSLAY_BINARY_FRAME)
     {
-        PushMessage(conn, MESSAGE_TYPE_NORMAL, arg->msg_length, arg->msg);
+        PushMessage(conn, MESSAGE_TYPE_NORMAL, arg->msg_length, arg->msg, 0);
     } else if (arg->opcode == WSLAY_CONNECTION_CLOSE)
     {
         // The first two bytes is the close code
@@ -137,8 +133,9 @@ void WSL_OnMsgRecvCallback(wslay_event_context_ptr ctx, const struct wslay_event
         }
 
         char buffer[1024];
-        len = dmSnPrintf(buffer, sizeof(buffer), "Server closing (%u). Reason: '%s'", wslay_event_get_status_code_received(ctx), reason);
+        uint16_t status_code = wslay_event_get_status_code_received(ctx);
-        PushMessage(conn, MESSAGE_TYPE_CLOSE, len, (const uint8_t*)buffer);
+        len = dmSnPrintf(buffer, sizeof(buffer), "Server closing (%u). Reason: '%s'", status_code, reason);
+        PushMessage(conn, MESSAGE_TYPE_CLOSE, len, (const uint8_t*)buffer, status_code);
 
         if (!wslay_event_get_close_sent(ctx))
         {
@@ -164,4 +161,4 @@ int WSL_GenmaskCallback(wslay_event_context_ptr ctx, uint8_t *buf, size_t len, v
 
 } // namespace
 
-#endif // HAVE_WSLAY
+#endif // HAVE_WSLAY