Merge pull request #21 from defold/issue-18-error-message-fix

Issue 18: Documentation fix

README.md

@@ -10,3 +10,33 @@ We recommend using a link to a zip file of a [specific release](https://github.c
 ## API reference
 
 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`.
+
+Set it to:
+
+* `0` to disable debugging (i.e. no debug output).
+* `1` to display state changes.
+* `2` to display the messages sent and received.
+
+## External resources
+
+To verify that your websocket server works, you can test it with some tools.
+
+* [websocat](https://github.com/vi/websocat)
+
+Or, you can test your server on this web page:
+
+* https://www.websocket.org/echo.html
+
+To monitor all the packets sent to/from the client/server, you can use e.g.
+
+* [Wireshark](https://www.wireshark.org)
+
+For command line debugging, there's
+
+* tcpdump: `sudo tcpdump -X -s0 -ilo0 port 8080 ` (example for local ws:// connection)
+
+* tcpdump: `sudo tcpdump -X -s0 host echo.websocket.org` (Monitors packets to/from echo.websocket.org)

docs/index.md

@@ -14,15 +14,16 @@ 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
-        print("disconnected " .. conn)
+        log("Disconnected: " .. tostring(conn))
         self.connection = nil
+        update_gui(self)
     elseif data.event == websocket.EVENT_CONNECTED then
-        print("Connected " .. conn)
+        update_gui(self)
-        -- self.connection = conn
+        log("Connected: " .. tostring(conn))
     elseif data.event == websocket.EVENT_ERROR then
-        print("Error:", data.error)
+        log("Error: '" .. data.error .. "'")
     elseif data.event == websocket.EVENT_MESSAGE then
-        print("Receiving: '" .. tostring(data.message) .. "'")
+        log("Receiving: '" .. tostring(data.message) .. "'")
     end
 end
 

websocket/api/api.script_api

@@ -17,6 +17,17 @@
         type: table
         desc: optional parameters as properties. The following parameters can be set
         members:
+          - name: timeout
+            type: number
+            desc: Timeout for the connection sequence (milliseconds). Not used on HTML5. (Default is 3000)
+
+          - name: protocol
+            type: string
+            desc: the protocol to use (e.g. 'chat'). (Default is 'binary')
+
+          - name: headers
+            type: string
+            desc: list of http headers. Each pair is separated with "\r\n". Not used on HTML5.
 
       - name: callback
         type: function
@@ -48,11 +59,7 @@
 
           - name: message
             type: string
-            desc: The received data. Only valid if event is `websocket.EVENT_MESSAGE`
+            desc: The received data if event is `websocket.EVENT_MESSAGE`. Error message otherwise
-
-          - name: error
-            type: string
-            desc: The error string. Only valid if event is `websocket.EVENT_ERROR`
 
 
     returns:
@@ -65,21 +72,25 @@
             ```lua
               local function websocket_callback(self, conn, data)
                 if data.event == websocket.EVENT_DISCONNECTED then
-                  print("disconnected " .. conn)
+                  log("Disconnected: " .. tostring(conn))
                   self.connection = nil
+                  update_gui(self)
                 elseif data.event == websocket.EVENT_CONNECTED then
-                  print("Connected " .. conn)
+                  update_gui(self)
-                  -- self.connection = conn
+                  log("Connected: " .. tostring(conn))
                 elseif data.event == websocket.EVENT_ERROR then
-                  print("Error:", data.error)
+                  log("Error: '" .. data.message .. "'")
                 elseif data.event == websocket.EVENT_MESSAGE then
-                  print("Receiving: '" .. tostring(data.message) .. "'")
+                  log("Receiving: '" .. tostring(data.message) .. "'")
                 end
               end
 
               function init(self)
                 self.url = "ws://echo.websocket.org"
-                local params = {}
+                local params = {
+                  timeout = 3000,
+                  headers = "Sec-WebSocket-Protocol: chat\r\nOrigin: mydomain.com\r\n"
+                }
                 self.connection = websocket.connect(self.url, params, websocket_callback)
               end
 
@@ -112,6 +123,17 @@
       - name: message
         type: string
         desc: the message to send
+      - name: options
+        type: table
+        desc: options for this particular message. May be `nil`
+        members:
+        - name: type
+          type: number
+          desc: The data type of the message
+
+             - `websocket.DATA_TYPE_BINARY` (default)
+
+             - `websocket.DATA_TYPE_TEXT`
 
     examples:
       - desc: |-

websocket/src/handshake.cpp

@@ -1,5 +1,6 @@
 #include "websocket.h"
 #include <dmsdk/dlib/socket.h>
+#include <ctype.h> // tolower
 
 namespace dmWebsocket
 {
@@ -39,8 +40,12 @@ static Result SendClientHandshakeHeaders(WebsocketConnection* conn)
         dmSnPrintf(port, sizeof(port), ":%d", conn->m_Url.m_Port);
 
     dmSocket::Result sr;
-    WS_SENDALL("GET /");
+    WS_SENDALL("GET ");
-    WS_SENDALL(conn->m_Url.m_Path);
+    if (conn->m_Url.m_Path[0] == '\0') {
+        WS_SENDALL("/"); // Default to / for empty path
+    } else {
+        WS_SENDALL(conn->m_Url.m_Path);
+    }
     WS_SENDALL(" HTTP/1.1\r\n");
     WS_SENDALL("Host: ");
     WS_SENDALL(conn->m_Url.m_Hostname);
@@ -53,9 +58,23 @@ static Result SendClientHandshakeHeaders(WebsocketConnection* conn)
     WS_SENDALL("\r\n");
     WS_SENDALL("Sec-WebSocket-Version: 13\r\n");
 
-    // Add custom protocols
+    if (conn->m_CustomHeaders)
+    {
+        WS_SENDALL(conn->m_CustomHeaders);
+        // make sure we ended with '\r\n'
+        int len = strlen(conn->m_CustomHeaders);
+        bool ended_with_sentinel = len >= 2 && conn->m_CustomHeaders[len - 2] == '\r' && conn->m_CustomHeaders[len - 1] == '\n';
+        if (!ended_with_sentinel)
+        {
+            WS_SENDALL("\r\n");
+        }
+    }
 
-    // Add custom headers
+    if (conn->m_Protocol) {
+        WS_SENDALL("Sec-WebSocket-Protocol: ");
+        WS_SENDALL(conn->m_Protocol);
+        WS_SENDALL("\r\n");
+    }
 
     WS_SENDALL("\r\n");
 
@@ -100,17 +119,12 @@ Result ReceiveHeaders(WebsocketConnection* conn)
 #else
 Result ReceiveHeaders(WebsocketConnection* conn)
 {
-    dmSocket::Selector selector;
+    dmSocket::Result sr = WaitForSocket(conn, dmSocket::SELECTOR_KIND_READ, SOCKET_WAIT_TIMEOUT);
-    dmSocket::SelectorZero(&selector);
-    dmSocket::SelectorSet(&selector, dmSocket::SELECTOR_KIND_READ, conn->m_Socket);
-
-    dmSocket::Result sr = dmSocket::Select(&selector, 200*1000);
-
     if (dmSocket::RESULT_OK != sr)
     {
         if (dmSocket::RESULT_WOULDBLOCK)
         {
-            dmLogWarning("Waiting for socket to be available for reading");
+            DebugLog(2, "Waiting for socket to be available for reading");
             return RESULT_WOULDBLOCK;
         }
 
@@ -146,7 +160,8 @@ Result ReceiveHeaders(WebsocketConnection* conn)
     conn->m_Buffer[conn->m_BufferSize] = '\0';
 
     // Check if the end of the response has arrived
-    if (conn->m_BufferSize >= 4 && strcmp(conn->m_Buffer + conn->m_BufferSize - 4, "\r\n\r\n") == 0)
+    const char* endtag = strstr(conn->m_Buffer, "\r\n\r\n");
+    if (endtag != 0)
     {
         return RESULT_OK;
     }
@@ -155,6 +170,20 @@ Result ReceiveHeaders(WebsocketConnection* conn)
 }
 #endif
 
+static int dmStriCmp(const char* s1, const char* s2)
+{
+    for (;;)
+    {
+        if (!*s1 || !*s2 || tolower((unsigned char) *s1) != tolower((unsigned char) *s2))
+        {
+            return (unsigned char) *s1 - (unsigned char) *s2;
+        }
+        s1++;
+        s2++;
+    }
+}
+
+
 #if defined(__EMSCRIPTEN__)
 Result VerifyHeaders(WebsocketConnection* conn)
 {
@@ -171,16 +200,16 @@ Result VerifyHeaders(WebsocketConnection* conn)
         return SetStatus(conn, RESULT_HANDSHAKE_FAILED, "Missing: '%s' in header", http_version_and_status_protocol);
     }
 
+    const char* endtag = strstr(conn->m_Buffer, "\r\n\r\n");
+
     r = strstr(r, "\r\n") + 2;
 
-    bool upgraded = false;
+    bool connection = false;
+    bool upgrade = false;
     bool valid_key = false;
-    const char* protocol = "";
-
-    // TODO: Perhaps also support the Sec-WebSocket-Protocol
 
     // parse the headers in place
-    while (r)
+    while (r < endtag)
     {
         // Tokenize the each header line: "Key: Value\r\n"
         const char* key = r;
@@ -194,45 +223,65 @@ Result VerifyHeaders(WebsocketConnection* conn)
         *r = 0;
         r += 2;
 
-        if (strcmp(key, "Connection") == 0 && strcmp(value, "Upgrade") == 0)
+        // Page 18 in https://tools.ietf.org/html/rfc6455#section-11.3.3
-            upgraded = true;
+        if (dmStriCmp(key, "Connection") == 0 && dmStriCmp(value, "Upgrade") == 0)
-        else if (strcmp(key, "Sec-WebSocket-Accept") == 0)
+            connection = true;
+        else if (dmStriCmp(key, "Upgrade") == 0 && dmStriCmp(value, "websocket") == 0)
+            upgrade = true;
+        else if (dmStriCmp(key, "Sec-WebSocket-Accept") == 0)
         {
-
             uint8_t client_key[32 + 40];
             uint32_t client_key_len = sizeof(client_key);
             dmCrypt::Base64Encode(conn->m_Key, sizeof(conn->m_Key), client_key, &client_key_len);
             client_key[client_key_len] = 0;
 
+            DebugLog(2, "Secret key (base64): %s", client_key);
+
             memcpy(client_key + client_key_len, RFC_MAGIC, strlen(RFC_MAGIC));
             client_key_len += strlen(RFC_MAGIC);
             client_key[client_key_len] = 0;
 
+            DebugLog(2, "Secret key + RFC_MAGIC: %s", client_key);
+
             uint8_t client_key_sha1[20];
             dmCrypt::HashSha1(client_key, client_key_len, client_key_sha1);
 
+            DebugPrint(2, "Hashed key (sha1):", client_key_sha1, sizeof(client_key_sha1));
+
             client_key_len = sizeof(client_key);
             dmCrypt::Base64Encode(client_key_sha1, sizeof(client_key_sha1), client_key, &client_key_len);
             client_key[client_key_len] = 0;
 
+            DebugLog(2, "Client key (base64): %s", client_key);
+
+            DebugLog(2, "Server key (base64): %s", value);
+
             if (strcmp(value, (const char*)client_key) == 0)
                 valid_key = true;
         }
-
-        if (strcmp(r, "\r\n") == 0)
-            break;
     }
 
-    if (!upgraded)
+    // The response might contain both the headers, but also (if successful) the first batch of data
+    endtag += 4;
+    uint32_t size = conn->m_BufferSize - (endtag - conn->m_Buffer);
+    conn->m_BufferSize = size;
+    memmove(conn->m_Buffer, endtag, size);
+    conn->m_Buffer[size] = 0;
+    conn->m_HasHandshakeData = conn->m_BufferSize != 0 ? 1 : 0;
+
+    if (!connection)
+        dmLogError("Failed to find the Connection keyword in the response headers");
+    if (!upgrade)
         dmLogError("Failed to find the Upgrade keyword in the response headers");
     if (!valid_key)
         dmLogError("Failed to find valid key in the response headers");
 
-    if (!(upgraded && valid_key)) {
+    bool ok = connection && upgrade && valid_key;
+    if (!ok) {
         dmLogError("Response:\n\"%s\"\n", conn->m_Buffer);
     }
 
-    return (upgraded && valid_key) ? RESULT_OK : RESULT_HANDSHAKE_FAILED;
+    return ok ? RESULT_OK : RESULT_HANDSHAKE_FAILED;
 }
 #endif
 

websocket/src/script_util.cpp

@@ -1,8 +1,8 @@
 #include "script_util.h"
 
-namespace dmWebsocket {
+namespace dmScript {
 
-bool luaL_checkbool(lua_State *L, int numArg)
+bool CheckBool(lua_State *L, int numArg)
 {
     bool b = false;
     if (lua_isboolean(L, numArg))
@@ -16,17 +16,17 @@ bool luaL_checkbool(lua_State *L, int numArg)
     return b;
 }
 
-bool luaL_checkboold(lua_State *L, int numArg, int def)
+bool CheckBoold(lua_State *L, int numArg, int def)
 {
     int type = lua_type(L, numArg);
     if (type != LUA_TNONE && type != LUA_TNIL)
     {
-        return luaL_checkbool(L, numArg);
+        return CheckBool(L, numArg);
     }
     return def;
 }
 
-lua_Number luaL_checknumberd(lua_State *L, int numArg, lua_Number def)
+lua_Number CheckNumberd(lua_State *L, int numArg, lua_Number def)
 {
     int type = lua_type(L, numArg);
     if (type != LUA_TNONE && type != LUA_TNIL)
@@ -36,7 +36,7 @@ lua_Number luaL_checknumberd(lua_State *L, int numArg, lua_Number def)
     return def;
 }
 
-char* luaL_checkstringd(lua_State *L, int numArg, const char* def)
+char* CheckStringd(lua_State *L, int numArg, const char* def)
 {
     int type = lua_type(L, numArg);
     if (type != LUA_TNONE && type != LUA_TNIL)
@@ -46,7 +46,7 @@ char* luaL_checkstringd(lua_State *L, int numArg, const char* def)
     return (char*)def;
 }
 
-lua_Number luaL_checktable_number(lua_State *L, int numArg, const char* field, lua_Number def)
+lua_Number CheckTableNumber(lua_State *L, int numArg, const char* field, lua_Number def)
 {
     lua_Number result = def;
     if(lua_istable(L, numArg))
@@ -61,7 +61,7 @@ lua_Number luaL_checktable_number(lua_State *L, int numArg, const char* field, l
     return result;
 }
 
-char* luaL_checktable_string(lua_State *L, int numArg, const char* field, char* def)
+char* CheckTableString(lua_State *L, int numArg, const char* field, char* def)
 {
     char* result = def;
     if(lua_istable(L, numArg))

websocket/src/script_util.h

@@ -2,11 +2,11 @@
 
 #include <dmsdk/sdk.h>
 
-namespace dmWebsocket {
+namespace dmScript {
-    bool        luaL_checkbool(lua_State *L, int numArg);
+    bool        CheckBool(lua_State *L, int numArg);
-    bool        luaL_checkboold(lua_State *L, int numArg, int def);
+    bool        CheckBoold(lua_State *L, int numArg, int def);
-    lua_Number  luaL_checknumberd(lua_State *L, int numArg, lua_Number def);
+    lua_Number  CheckNumberd(lua_State *L, int numArg, lua_Number def);
-    char*       luaL_checkstringd(lua_State *L, int numArg, const char* def);
+    char*       CheckStringd(lua_State *L, int numArg, const char* def);
-    lua_Number  luaL_checktable_number(lua_State *L, int numArg, const char* field, lua_Number def);
+    lua_Number  CheckTableNumber(lua_State *L, int numArg, const char* field, lua_Number def);
-    char*       luaL_checktable_string(lua_State *L, int numArg, const char* field, char* def);
+    char*       CheckTableString(lua_State *L, int numArg, const char* field, char* def);
 } // namespace

websocket/src/socket.cpp

@@ -42,15 +42,24 @@ dmSocket::Result Send(WebsocketConnection* conn, const char* buffer, int length,
     }
     if (out_sent_bytes)
         *out_sent_bytes = total_sent_bytes;
+
+    DebugPrint(2, "Sent buffer:", buffer, length);
     return dmSocket::RESULT_OK;
 }
 
 dmSocket::Result Receive(WebsocketConnection* conn, void* buffer, int length, int* received_bytes)
 {
+    dmSocket::Result sr;
     if (conn->m_SSLSocket)
-        return dmSSLSocket::Receive(conn->m_SSLSocket, buffer, length, received_bytes);
+        sr = dmSSLSocket::Receive(conn->m_SSLSocket, buffer, length, received_bytes);
     else
-        return dmSocket::Receive(conn->m_Socket, buffer, length, received_bytes);
+        sr = dmSocket::Receive(conn->m_Socket, buffer, length, received_bytes);
+
+    int num_bytes = received_bytes ? (uint32_t)*received_bytes : 0;
+    if (sr == dmSocket::RESULT_OK && num_bytes > 0)
+        DebugPrint(2, "Received bytes:", buffer, num_bytes);
+
+    return sr;
 }
 
 } // namespace

websocket/src/websocket.cpp

@@ -9,13 +9,20 @@
 #include <dmsdk/dlib/connection_pool.h>
 #include <dmsdk/dlib/dns.h>
 #include <dmsdk/dlib/sslsocket.h>
+#include <ctype.h> // isprint et al
 
 #if defined(__EMSCRIPTEN__)
 #include <emscripten/emscripten.h> // for EM_ASM
 #endif
 
+#if defined(WIN32)
+#include <malloc.h>
+#define alloca _alloca
+#endif
+
 namespace dmWebsocket {
 
+int g_DebugWebSocket = 0;
 
 struct WebsocketContext
 {
@@ -60,8 +67,72 @@ const char* StateToString(State err)
 
 #undef STRING_CASE
 
-#define WS_DEBUG(...)
+void DebugLog(int level, const char* fmt, ...)
-//#define WS_DEBUG(...) dmLogWarning(__VA_ARGS__);
+{
+    if (level > g_DebugWebSocket)
+        return;
+
+    size_t buffer_size = 4096;
+    char* buffer = (char*)alloca(buffer_size);
+    va_list lst;
+    va_start(lst, fmt);
+
+    buffer_size = vsnprintf(buffer, buffer_size, fmt, lst);
+    dmLogWarning("%s", buffer);
+    va_end(lst);
+}
+
+void DebugPrint(int level, const char* msg, const void* _bytes, uint32_t num_bytes)
+{
+    if (level > g_DebugWebSocket)
+        return;
+
+    char buffer[1024];
+    char submessage[128];
+    uint32_t sublength = 0;
+
+    uint32_t len = dmSnPrintf(buffer, sizeof(buffer), "%s '", msg);
+
+    const uint8_t* bytes = (const uint8_t*)_bytes;
+    for (uint32_t i = 0; i < num_bytes; ++i)
+    {
+        if (len + 2 >= sizeof(buffer))
+        {
+            dmLogWarning("%s", buffer);
+            buffer[0] = 0;
+            len = 0;
+        }
+
+        sublength = 0;
+
+        int c = bytes[i];
+        if (isprint(c))
+            sublength = dmSnPrintf(submessage, sizeof(submessage), "%c", c);
+        else if (c == '\r')
+            sublength = dmSnPrintf(submessage, sizeof(submessage), "\\r");
+        else if (c == '\n')
+            sublength = dmSnPrintf(submessage, sizeof(submessage), "\\n");
+        else if (c == '\t')
+            sublength = dmSnPrintf(submessage, sizeof(submessage), "\\t");
+        else
+            sublength = dmSnPrintf(submessage, sizeof(submessage), "\\%02x", c);
+        dmStrlCat(buffer, submessage, sizeof(buffer));
+        len += sublength;
+    }
+
+    if (len + 2 >= sizeof(buffer))
+    {
+        dmLogWarning("%s", buffer);
+        buffer[0] = 0;
+        len = 0;
+    }
+
+    sublength = dmSnPrintf(submessage, sizeof(submessage), "' %u bytes", num_bytes);
+    dmStrlCat(buffer, submessage, sizeof(buffer));
+    len += sublength;
+    dmLogWarning("%s", buffer);
+}
+
 
 #define CLOSE_CONN(...) \
     SetStatus(conn, RESULT_ERROR, __VA_ARGS__); \
@@ -74,7 +145,7 @@ static void SetState(WebsocketConnection* conn, State state)
     if (prev_state != state)
     {
         conn->m_State = state;
-        WS_DEBUG("%s -> %s", StateToString(prev_state), StateToString(conn->m_State));
+        DebugLog(1, "%s -> %s", StateToString(prev_state), StateToString(conn->m_State));
     }
 }
 
@@ -89,6 +160,8 @@ Result SetStatus(WebsocketConnection* conn, Result status, const char* format, .
         conn->m_BufferSize = vsnprintf(conn->m_Buffer, conn->m_BufferCapacity, format, lst);
         va_end(lst);
         conn->m_Status = status;
+
+        DebugLog(1, "STATUS: '%s'  len: %u", conn->m_Buffer, conn->m_BufferSize);
     }
     return status;
 }
@@ -100,10 +173,12 @@ Result SetStatus(WebsocketConnection* conn, Result status, const char* format, .
 
 static WebsocketConnection* CreateConnection(const char* url)
 {
-    WebsocketConnection* conn = (WebsocketConnection*)malloc(sizeof(WebsocketConnection));
+    WebsocketConnection* conn = new WebsocketConnection;
-    memset(conn, 0, sizeof(WebsocketConnection));
     conn->m_BufferCapacity = g_Websocket.m_BufferSize;
     conn->m_Buffer = (char*)malloc(conn->m_BufferCapacity);
+    conn->m_Buffer[0] = 0;
+    conn->m_BufferSize = 0;
+    conn->m_ConnectTimeout = 0;
 
     dmURI::Parts uri;
     dmURI::Parse(url, &conn->m_Url);
@@ -114,6 +189,18 @@ static WebsocketConnection* CreateConnection(const char* url)
     conn->m_SSL = strcmp(conn->m_Url.m_Scheme, "wss") == 0 ? 1 : 0;
     conn->m_State = STATE_CONNECTING;
 
+    conn->m_Callback = 0;
+    conn->m_Connection = 0;
+    conn->m_Socket = 0;
+    conn->m_SSLSocket = 0;
+    conn->m_Status = RESULT_OK;
+    conn->m_HasHandshakeData = 0;
+    conn->m_WasConnected = 0;
+
+#if defined(HAVE_WSLAY)
+    conn->m_Ctx = 0;
+#endif
+
     return conn;
 }
 
@@ -124,6 +211,9 @@ static void DestroyConnection(WebsocketConnection* conn)
         WSL_Exit(conn->m_Ctx);
 #endif
 
+    free((void*)conn->m_CustomHeaders);
+    free((void*)conn->m_Protocol);
+
     if (conn->m_Callback)
         dmScript::DestroyCallback(conn->m_Callback);
 
@@ -138,8 +228,10 @@ static void DestroyConnection(WebsocketConnection* conn)
         dmConnectionPool::Return(g_Websocket.m_Pool, conn->m_Connection);
 #endif
 
+
     free((void*)conn->m_Buffer);
-    free((void*)conn);
+    delete conn;
+    DebugLog(2, "DestroyConnection: %p", conn);
 }
 
 
@@ -178,13 +270,22 @@ static int LuaConnect(lua_State* L)
         return DM_LUA_ERROR("The web socket module isn't initialized");
 
     const char* url = luaL_checkstring(L, 1);
+    lua_Number timeout = dmScript::CheckTableNumber(L, 2, "timeout", 3000);
+    const char* custom_headers = dmScript::CheckTableString(L, 2, "headers", 0);
+    const char* protocol = dmScript::CheckTableString(L, 2, "protocol", 0);
 
-    // long playedTime = luaL_checktable_number(L, 2, "playedTime", -1);
+    if (custom_headers != 0)
-    // long progressValue = luaL_checktable_number(L, 2, "progressValue", -1);
+    {
-    // char *description = luaL_checktable_string(L, 2, "description", NULL);
+        if (strstr(custom_headers, "\r\n\r\n") != 0)
-    // char *coverImage = luaL_checktable_string(L, 2, "coverImage", NULL);
+        {
+            return DM_LUA_ERROR("The header field must not contain double '\\r\\n\\r\\n': '%s'", custom_headers);
+        }
+    }
 
     WebsocketConnection* conn = CreateConnection(url);
+    conn->m_ConnectTimeout = dmTime::GetTime() + timeout * 1000;
+    conn->m_CustomHeaders = custom_headers ? strdup(custom_headers) : 0;
+    conn->m_Protocol = protocol ? strdup(protocol) : 0;
 
     conn->m_Callback = dmScript::CreateCallback(L, 3);
 
@@ -239,7 +340,7 @@ static int LuaSend(lua_State* L)
     const char* string = luaL_checklstring(L, 2, &string_length);
 
 #if defined(HAVE_WSLAY)
-    int write_mode = WSLAY_BINARY_FRAME; // WSLAY_TEXT_FRAME
+    int write_mode = dmScript::CheckTableNumber(L, 3, "type", WSLAY_BINARY_FRAME);
 
     struct wslay_event_msg msg;
     msg.opcode = write_mode;
@@ -259,7 +360,7 @@ static int LuaSend(lua_State* L)
     return 0;
 }
 
-static void HandleCallback(WebsocketConnection* conn, int event)
+static void HandleCallback(WebsocketConnection* conn, int event, int msg_offset, int msg_length)
 {
     if (!dmScript::IsCallbackValid(conn->m_Callback))
         return;
@@ -280,14 +381,8 @@ static void HandleCallback(WebsocketConnection* conn, int event)
     lua_pushinteger(L, event);
     lua_setfield(L, -2, "event");
 
-    if (EVENT_ERROR == event) {
+    lua_pushlstring(L, conn->m_Buffer + msg_offset, msg_length);
-        lua_pushlstring(L, conn->m_Buffer, conn->m_BufferSize);
+    lua_setfield(L, -2, "message");
-        lua_setfield(L, -2, "error");
-    }
-    else if (EVENT_MESSAGE == event) {
-        lua_pushlstring(L, conn->m_Buffer, conn->m_BufferSize);
-        lua_setfield(L, -2, "message");
-    }
 
     dmScript::PCall(L, 3, 0);
 
@@ -315,13 +410,23 @@ static void LuaInit(lua_State* L)
     luaL_register(L, MODULE_NAME, Websocket_module_methods);
 
 #define SETCONSTANT(_X) \
-            lua_pushnumber(L, (lua_Number) _X); \
+        lua_pushnumber(L, (lua_Number) _X); \
-            lua_setfield(L, -2, #_X);
+        lua_setfield(L, -2, #_X);
 
-        SETCONSTANT(EVENT_CONNECTED);
+    SETCONSTANT(EVENT_CONNECTED);
-        SETCONSTANT(EVENT_DISCONNECTED);
+    SETCONSTANT(EVENT_DISCONNECTED);
-        SETCONSTANT(EVENT_MESSAGE);
+    SETCONSTANT(EVENT_MESSAGE);
-        SETCONSTANT(EVENT_ERROR);
+    SETCONSTANT(EVENT_ERROR);
+
+#if defined(HAVE_WSLAY)
+    lua_pushnumber(L, (lua_Number) WSLAY_BINARY_FRAME);
+    lua_setfield(L, -2, "DATA_TYPE_BINARY");
+    lua_pushnumber(L, (lua_Number) WSLAY_TEXT_FRAME);
+    lua_setfield(L, -2, "DATA_TYPE_TEXT");
+#else
+    SETCONSTANT(DATA_TYPE_BINARY);
+    SETCONSTANT(DATA_TYPE_TEXT);
+#endif
 
 #undef SETCONSTANT
 
@@ -329,7 +434,7 @@ static void LuaInit(lua_State* L)
     assert(top == lua_gettop(L));
 }
 
-static dmExtension::Result WebsocketAppInitialize(dmExtension::AppParams* params)
+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);
@@ -341,6 +446,10 @@ static dmExtension::Result WebsocketAppInitialize(dmExtension::AppParams* params
     pool_params.m_MaxConnections = dmConfigFile::GetInt(params->m_ConfigFile, "websocket.max_connections", 2);
     dmConnectionPool::Result result = dmConnectionPool::New(&pool_params, &g_Websocket.m_Pool);
 
+    g_DebugWebSocket = dmConfigFile::GetInt(params->m_ConfigFile, "websocket.debug", 0);
+    if (g_DebugWebSocket)
+        dmLogInfo("dmWebSocket::g_DebugWebSocket == %d", g_DebugWebSocket);
+
     if (dmConnectionPool::RESULT_OK != result)
     {
         dmLogError("Failed to create connection pool: %d", result);
@@ -380,7 +489,7 @@ static dmExtension::Result WebsocketAppInitialize(dmExtension::AppParams* params
     return dmExtension::RESULT_OK;
 }
 
-static dmExtension::Result WebsocketInitialize(dmExtension::Params* params)
+static dmExtension::Result Initialize(dmExtension::Params* params)
 {
     if (!g_Websocket.m_Initialized)
         return dmExtension::RESULT_OK;
@@ -391,19 +500,57 @@ static dmExtension::Result WebsocketInitialize(dmExtension::Params* params)
     return dmExtension::RESULT_OK;
 }
 
-static dmExtension::Result WebsocketAppFinalize(dmExtension::AppParams* params)
+static dmExtension::Result AppFinalize(dmExtension::AppParams* params)
 {
 
     dmConnectionPool::Shutdown(g_Websocket.m_Pool, dmSocket::SHUTDOWNTYPE_READWRITE);
     return dmExtension::RESULT_OK;
 }
 
-static dmExtension::Result WebsocketFinalize(dmExtension::Params* params)
+static dmExtension::Result Finalize(dmExtension::Params* params)
 {
     return dmExtension::RESULT_OK;
 }
 
-static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
+Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* buffer)
+{
+    if (conn->m_Messages.Full())
+        conn->m_Messages.OffsetCapacity(4);
+
+    Message msg;
+    msg.m_Type = (uint32_t)type;
+    msg.m_Length = length;
+    conn->m_Messages.Push(msg);
+
+    // No need to copy itself (html5)
+    if (buffer != (const uint8_t*)conn->m_Buffer)
+    {
+        if ((conn->m_BufferSize + length) >= conn->m_BufferCapacity)
+        {
+            conn->m_BufferCapacity = conn->m_BufferSize + length + 1;
+            conn->m_Buffer = (char*)realloc(conn->m_Buffer, conn->m_BufferCapacity);
+        }
+        // append to the end of the buffer
+        memcpy(conn->m_Buffer + conn->m_BufferSize, buffer, length);
+    }
+
+    conn->m_BufferSize += length;
+    conn->m_Buffer[conn->m_BufferCapacity-1] = 0;
+
+    // Instead of printing from the incoming buffer, we print from our own, to make sure it looks ok
+    DebugPrint(2, __FUNCTION__, conn->m_Buffer+conn->m_BufferSize-length, length);
+
+    return dmWebsocket::RESULT_OK;
+}
+
+// has the connect procedure taken too long?
+static bool CheckConnectTimeout(WebsocketConnection* conn)
+{
+    uint64_t t = dmTime::GetTime();
+    return t >= conn->m_ConnectTimeout;
+}
+
+static dmExtension::Result OnUpdate(dmExtension::Params* params)
 {
     uint32_t size = g_Websocket.m_Connections.Size();
 
@@ -415,10 +562,14 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
         {
             if (RESULT_OK != conn->m_Status)
             {
-                HandleCallback(conn, EVENT_ERROR);
+                HandleCallback(conn, EVENT_ERROR, 0, conn->m_BufferSize);
+                conn->m_BufferSize = 0;
             }
 
-            HandleCallback(conn, EVENT_DISCONNECTED);
+            if (conn->m_WasConnected)
+            {
+                HandleCallback(conn, EVENT_DISCONNECTED, 0, conn->m_BufferSize);
+            }
 
             g_Websocket.m_Connections.EraseSwap(i);
             --i;
@@ -434,12 +585,6 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
                 CLOSE_CONN("Websocket closing for %s (%s)", conn->m_Url.m_Hostname, WSL_ResultToString(r));
                 continue;
             }
-            r = WSL_WantsExit(conn->m_Ctx);
-            if (0 != r)
-            {
-                CLOSE_CONN("Websocket received close event for %s", conn->m_Url.m_Hostname);
-                continue;
-            }
 #else
             int recv_bytes = 0;
             dmSocket::Result sr = Receive(conn, conn->m_Buffer, conn->m_BufferCapacity-1, &recv_bytes);
@@ -450,9 +595,7 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
 
             if (dmSocket::RESULT_OK == sr)
             {
-                conn->m_BufferSize += recv_bytes;
+                PushMessage(conn, MESSAGE_TYPE_NORMAL, recv_bytes, (const uint8_t*)conn->m_Buffer);
-                conn->m_Buffer[conn->m_BufferCapacity-1] = 0;
-                conn->m_HasMessage = 1;
             }
             else
             {
@@ -461,15 +604,42 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
             }
 #endif
 
-            if (conn->m_HasMessage)
+            uint32_t offset = 0;
+            bool close_received = false;
+            for (uint32_t i = 0; i < conn->m_Messages.Size(); ++i)
             {
-                HandleCallback(conn, EVENT_MESSAGE);
+                const Message& msg = conn->m_Messages[i];
-                conn->m_HasMessage = 0;
+
+                if (EVENT_DISCONNECTED == msg.m_Type)
+                {
+                    conn->m_Status = RESULT_OK;
+                    CloseConnection(conn);
+
+                    // Put the message at the front of the buffer
+                    conn->m_Messages.SetSize(0);
+                    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;
             }
         }
         else if (STATE_HANDSHAKE_READ == conn->m_State)
         {
+            if (CheckConnectTimeout(conn))
+            {
+                CLOSE_CONN("Connect sequence timed out");
+                continue;
+            }
+
             Result result = ReceiveHeaders(conn);
             if (RESULT_WOULDBLOCK == result)
             {
@@ -482,6 +652,7 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
                 continue;
             }
 
+            // Verifies headers, and also stages any initial sent data
             result = VerifyHeaders(conn);
             if (RESULT_OK != result)
             {
@@ -505,14 +676,18 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
 #endif
             dmSocket::SetBlocking(conn->m_Socket, false);
 
-            conn->m_Buffer[0] = 0;
+            conn->m_WasConnected = 1;
-            conn->m_BufferSize = 0;
-
             SetState(conn, STATE_CONNECTED);
-            HandleCallback(conn, EVENT_CONNECTED);
+            HandleCallback(conn, EVENT_CONNECTED, 0, 0);
         }
         else if (STATE_HANDSHAKE_WRITE == conn->m_State)
         {
+            if (CheckConnectTimeout(conn))
+            {
+                CLOSE_CONN("Connect sequence timed out");
+                continue;
+            }
+
             Result result = SendClientHandshake(conn);
             if (RESULT_WOULDBLOCK == result)
             {
@@ -528,9 +703,22 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
         }
         else if (STATE_CONNECTING == conn->m_State)
         {
+            if (CheckConnectTimeout(conn))
+            {
+                CLOSE_CONN("Connect sequence timed out");
+                continue;
+            }
+
 #if defined(__EMSCRIPTEN__)
             conn->m_SSLSocket = dmSSLSocket::INVALID_SOCKET_HANDLE;
 
+            if (conn->m_Protocol) {
+                EM_ASM({
+                    // https://emscripten.org/docs/porting/networking.html#emulated-posix-tcp-sockets-over-websockets
+                    Module["websocket"]["subprotocol"] = UTF8ToString($0);
+                }, conn->m_Protocol);
+            }
+
             char uri_buffer[dmURI::MAX_URI_LEN];
             const char* uri;
             if (conn->m_Url.m_Path[0] != '\0') {
@@ -580,6 +768,6 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
 
 } // dmWebsocket
 
-DM_DECLARE_EXTENSION(Websocket, LIB_NAME, dmWebsocket::WebsocketAppInitialize, dmWebsocket::WebsocketAppFinalize, dmWebsocket::WebsocketInitialize, dmWebsocket::WebsocketOnUpdate, 0, dmWebsocket::WebsocketFinalize)
+DM_DECLARE_EXTENSION(Websocket, LIB_NAME, dmWebsocket::AppInitialize, dmWebsocket::AppFinalize, dmWebsocket::Initialize, dmWebsocket::OnUpdate, 0, dmWebsocket::Finalize)
 
 #undef CLOSE_CONN

websocket/src/websocket.h

@@ -19,6 +19,7 @@
 #include <dmsdk/dlib/socket.h>
 #include <dmsdk/dlib/dns.h>
 #include <dmsdk/dlib/uri.h>
+#include <dmsdk/dlib/array.h>
 
 namespace dmCrypt
 {
@@ -59,6 +60,24 @@ namespace dmWebsocket
         EVENT_ERROR,
     };
 
+    enum MessageType
+    {
+        MESSAGE_TYPE_NORMAL = 0,
+        MESSAGE_TYPE_CLOSE  = 1,
+    };
+
+    enum DataType
+    {
+        DATA_TYPE_BINARY = 0,
+        DATA_TYPE_TEXT   = 1,
+    };
+
+    struct Message
+    {
+        uint32_t m_Length:30;
+        uint32_t m_Type:2;
+    };
+
     struct WebsocketConnection
     {
         dmScript::LuaCallbackInfo*      m_Callback;
@@ -69,14 +88,20 @@ namespace dmWebsocket
         dmConnectionPool::HConnection   m_Connection;
         dmSocket::Socket                m_Socket;
         dmSSLSocket::Socket             m_SSLSocket;
+        dmArray<Message>                m_Messages; // lengths of the messages in the data buffer
+        uint64_t                        m_ConnectTimeout;
         uint8_t                         m_Key[16];
+        const char*                     m_Protocol;
+        const char*                     m_CustomHeaders;
         State                           m_State;
-        uint32_t                        m_SSL:1;
-        uint32_t                        m_HasMessage:1;
         char*                           m_Buffer;
         int                             m_BufferSize;
         uint32_t                        m_BufferCapacity;
         Result                          m_Status;
+        uint8_t                         m_SSL:1;
+        uint8_t                         m_HasHandshakeData:1;
+        uint8_t                         m_WasConnected:1;
+        uint8_t                         :6;
     };
 
     // Set error message
@@ -96,13 +121,15 @@ namespace dmWebsocket
     Result ReceiveHeaders(WebsocketConnection* conn);
     Result VerifyHeaders(WebsocketConnection* conn);
 
+    // Messages
+    Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* msg);
+
 #if defined(HAVE_WSLAY)
     // Wslay callbacks
     int     WSL_Init(wslay_event_context_ptr* ctx, ssize_t buffer_size, void* userctx);
     void    WSL_Exit(wslay_event_context_ptr ctx);
     int     WSL_Close(wslay_event_context_ptr ctx);
     int     WSL_Poll(wslay_event_context_ptr ctx);
-    int     WSL_WantsExit(wslay_event_context_ptr ctx);
     ssize_t WSL_RecvCallback(wslay_event_context_ptr ctx, uint8_t *buf, size_t len, int flags, void *user_data);
     ssize_t WSL_SendCallback(wslay_event_context_ptr ctx, const uint8_t *data, size_t len, int flags, void *user_data);
     void    WSL_OnMsgRecvCallback(wslay_event_context_ptr ctx, const struct wslay_event_on_msg_recv_arg *arg, void *user_data);
@@ -114,6 +141,15 @@ namespace dmWebsocket
     typedef struct { uint64_t state;  uint64_t inc; } pcg32_random_t;
     void pcg32_srandom_r(pcg32_random_t* rng, uint64_t initstate, uint64_t initseq);
     uint32_t pcg32_random_r(pcg32_random_t* rng);
+
+    // If level <= dmWebSocket::g_DebugWebSocket, then it outputs the message
+#ifdef __GNUC__
+    void DebugLog(int level, const char* fmt, ...) __attribute__ ((format (printf, 2, 3)));
+#else
+    void DebugLog(int level, const char* fmt, ...);
+#endif
+
+    void DebugPrint(int level, const char* msg, const void* _bytes, uint32_t num_bytes);
 }
 
 

websocket/src/wslay_callbacks.cpp

@@ -54,8 +54,8 @@ void WSL_Exit(wslay_event_context_ptr ctx)
 
 int WSL_Close(wslay_event_context_ptr ctx)
 {
-    const char* reason = "Client wants to close";
+    const char* reason = "";
-    wslay_event_queue_close(ctx, 0, (const uint8_t*)reason, strlen(reason));
+    wslay_event_queue_close(ctx, WSLAY_CODE_NORMAL_CLOSURE, (const uint8_t*)reason, 0);
     return 0;
 }
 
@@ -68,24 +68,25 @@ int WSL_Poll(wslay_event_context_ptr ctx)
     return r;
 }
 
-int WSL_WantsExit(wslay_event_context_ptr ctx)
-{
-    if ((wslay_event_get_close_sent(ctx) && wslay_event_get_close_received(ctx))) {
-        return 1;
-    }
-    return 0;
-}
-
 ssize_t WSL_RecvCallback(wslay_event_context_ptr ctx, uint8_t *buf, size_t len, int flags, void *user_data)
 {
     WebsocketConnection* conn = (WebsocketConnection*)user_data;
 
     int r = -1; // received bytes if >=0, error if < 0
 
+    if (conn->m_HasHandshakeData)
+    {
+        r = conn->m_BufferSize;
+        memcpy(buf, conn->m_Buffer, r);
+        conn->m_BufferSize = 0;
+        conn->m_HasHandshakeData = 0;
+        return r;
+    }
+
     dmSocket::Result socket_result = Receive(conn, buf, len, &r);
 
     if (dmSocket::RESULT_OK == socket_result && r == 0)
-        socket_result = dmSocket::RESULT_WOULDBLOCK;
+        socket_result = dmSocket::RESULT_CONNABORTED;
 
     if (dmSocket::RESULT_OK != socket_result)
     {
@@ -117,20 +118,35 @@ ssize_t WSL_SendCallback(wslay_event_context_ptr ctx, const uint8_t *data, size_
     return (ssize_t)sent_bytes;
 }
 
+// Might be called multiple times for a connection receiving multiple events
 void WSL_OnMsgRecvCallback(wslay_event_context_ptr ctx, const struct wslay_event_on_msg_recv_arg *arg, void *user_data)
 {
     WebsocketConnection* conn = (WebsocketConnection*)user_data;
     if (arg->opcode == WSLAY_TEXT_FRAME || arg->opcode == WSLAY_BINARY_FRAME)
     {
-        if (arg->msg_length >= conn->m_BufferCapacity)
+        PushMessage(conn, MESSAGE_TYPE_NORMAL, arg->msg_length, arg->msg);
-            conn->m_Buffer = (char*)realloc(conn->m_Buffer, arg->msg_length + 1);
-        memcpy(conn->m_Buffer, arg->msg, arg->msg_length);
-        conn->m_BufferSize = arg->msg_length;
-        conn->m_HasMessage = 1;
-
     } else if (arg->opcode == WSLAY_CONNECTION_CLOSE)
     {
-        // TODO: Store the reason
+        // The first two bytes is the close code
+        const uint8_t* reason = (const uint8_t*)"";
+        size_t len = arg->msg_length;
+        if (arg->msg_length > 2)
+        {
+            reason = arg->msg + 2;
+            len -= 2;
+        }
+
+        char buffer[1024];
+        len = dmSnPrintf(buffer, sizeof(buffer), "Server closing (%u). Reason: '%s'", wslay_event_get_status_code_received(ctx), reason);
+        PushMessage(conn, MESSAGE_TYPE_CLOSE, len, (const uint8_t*)buffer);
+
+        if (!wslay_event_get_close_sent(ctx))
+        {
+            wslay_event_queue_close(ctx, arg->status_code, (const uint8_t*)buffer, len);
+        }
+
+        DebugLog(1, "%s", buffer);
+
     }
 }