.gitignore

@@ -11,6 +11,4 @@ Thumbs.db
 builtins
 lws_source
 lws_build
-*.profraw
-*.der
-/.editor_settings
+*.profraw

README.md

@@ -1,3 +1,5 @@
+
+
 # Defold websocket extension
 
 [![Build Status](https://github.com/defold/extension-websocket/workflows/Build%20with%20bob/badge.svg)](https://github.com/defold/extension-websocket/actions)
@@ -11,18 +13,11 @@ We recommend using a link to a zip file of a [specific release](https://github.c
 
 ## API reference
 
-https://defold.com/extension-websocket/
-
-https://defold.com/extension-websocket/websocket_api/
+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` (edit `game.project` as text and add):
-
-```
-[websocket]
-debug = level
-```
+In order to make it easier to debug this extension, we provide a `game.project` setting `websocket.debug`.
 
 Set it to:
 
@@ -55,7 +50,3 @@ 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
-        print("Disconnected: " .. tostring(conn))
+        log("Disconnected: " .. tostring(conn))
         self.connection = nil
         update_gui(self)
     elseif data.event == websocket.EVENT_CONNECTED then
         update_gui(self)
-        print("Connected: " .. tostring(conn))
+        log("Connected: " .. tostring(conn))
     elseif data.event == websocket.EVENT_ERROR then
-        print("Error: '" .. tostring(data.message) .. "'")
+        log("Error: '" .. tostring(data.message) .. "'")
         if data.handshake_response then
-            print("Handshake response status: '" .. tostring(data.handshake_response.status) .. "'")
+            log("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
-            print("Handshake response body: '" .. tostring(data.handshake_response.response) .. "'")
+            log("Handshake response body: '" .. tostring(data.handshake_response.response) .. "'")
         end
     elseif data.event == websocket.EVENT_MESSAGE then
-        print("Receiving: '" .. tostring(data.message) .. "'")
+        log("Receiving: '" .. tostring(data.message) .. "'")
     end
 end
 
@@ -56,19 +56,10 @@ 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/

examples/websocket.gui_script

@@ -1,5 +1,4 @@
-local URL = "echo.websocket.events"
-
+local URL="://echo.websocket.org"
 local function click_button(node, action)
 	return gui.is_enabled(node) and action.pressed and gui.pick_node(node, action.x, action.y)
 end
@@ -33,6 +32,12 @@ 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) })
@@ -43,6 +48,9 @@ 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)
@@ -57,7 +65,7 @@ end
 
 local function websocket_callback(self, conn, data)
 	if data.event == websocket.EVENT_DISCONNECTED then
-		log("Disconnected: " .. tostring(conn) .. " Code: " .. data.code .. " Message: " .. tostring(data.message))
+		log("Disconnected: " .. tostring(conn))
 		self.connection = nil
 		update_gui(self)
 	elseif data.event == websocket.EVENT_CONNECTED then
@@ -80,7 +88,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,14 +61,6 @@
             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
@@ -94,7 +86,7 @@
               end
 
               function init(self)
-                self.url = "ws://echo.websocket.events"
+                self.url = "ws://echo.websocket.org"
                 local params = {
                   timeout = 3000,
                   headers = "Sec-WebSocket-Protocol: chat\r\nOrigin: mydomain.com\r\n"

websocket/ext.manifest

@@ -6,7 +6,3 @@ platforms:
         context:
             includes:   ["upload/websocket/include/wslay"]
             defines:    ["HAVE_CONFIG_H"]
-
-    web:
-        context:
-            linkFlags:  ["-lwebsocket.js"]

websocket/include/emscripten/websocket.h

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2018 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <memory.h>
+
+#include <emscripten/emscripten.h>
+#include <emscripten/html5.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define EMSCRIPTEN_WEBSOCKET_T int
+
+// Returns the WebSocket.readyState field into readyState. readyState must not be a null pointer.
+EMSCRIPTEN_RESULT emscripten_websocket_get_ready_state(EMSCRIPTEN_WEBSOCKET_T socket, unsigned short *readyState);
+
+// Returns the WebSocket.bufferedAmount field into bufferedAmount. bufferedAmount must not be a null pointer.
+EMSCRIPTEN_RESULT emscripten_websocket_get_buffered_amount(EMSCRIPTEN_WEBSOCKET_T socket, unsigned long long *bufferedAmount);
+
+// Writes the WebSocket.url field as a UTF-8 string to the memory area pointed by url. The memory area must contain at least urlLength bytes of free space. If this memory area cannot
+// fit the url string, it will be truncated. Call emscripten_websocket_get_url_length() to determine how large memory area will be required to store the url.
+// url must not be a null pointer.
+EMSCRIPTEN_RESULT emscripten_websocket_get_url(EMSCRIPTEN_WEBSOCKET_T socket, char *url, int urlLength);
+// Returns the byte length needed to store WebSocket.url string in Wasm heap. This length can be passed to emscripten_websocket_get_url as it includes the null byte in the count.
+// urlLength must not be a null pointer.
+EMSCRIPTEN_RESULT emscripten_websocket_get_url_length(EMSCRIPTEN_WEBSOCKET_T socket, int *urlLength);
+
+// Similar to emscripten_websocket_get_url(), but returns WebSocket.extensions field instead.
+EMSCRIPTEN_RESULT emscripten_websocket_get_extensions(EMSCRIPTEN_WEBSOCKET_T socket, char *extensions, int extensionsLength);
+EMSCRIPTEN_RESULT emscripten_websocket_get_extensions_length(EMSCRIPTEN_WEBSOCKET_T socket, int *extensionsLength);
+
+// Similar to emscripten_websocket_get_url(), but returns WebSocket.protocol field instead.
+EMSCRIPTEN_RESULT emscripten_websocket_get_protocol(EMSCRIPTEN_WEBSOCKET_T socket, char *protocol, int protocolLength);
+EMSCRIPTEN_RESULT emscripten_websocket_get_protocol_length(EMSCRIPTEN_WEBSOCKET_T socket, int *protocolLength);
+
+typedef struct EmscriptenWebSocketOpenEvent {
+  EMSCRIPTEN_WEBSOCKET_T socket;
+} EmscriptenWebSocketOpenEvent;
+
+typedef EM_BOOL (*em_websocket_open_callback_func)(int eventType, const EmscriptenWebSocketOpenEvent *websocketEvent, void *userData);
+EMSCRIPTEN_RESULT emscripten_websocket_set_onopen_callback_on_thread(EMSCRIPTEN_WEBSOCKET_T socket, void *userData, em_websocket_open_callback_func callback, pthread_t targetThread);
+
+typedef struct EmscriptenWebSocketMessageEvent {
+  EMSCRIPTEN_WEBSOCKET_T socket;
+  uint8_t *data;
+  uint32_t numBytes;
+  EM_BOOL isText;
+} EmscriptenWebSocketMessageEvent;
+
+typedef EM_BOOL (*em_websocket_message_callback_func)(int eventType, const EmscriptenWebSocketMessageEvent *websocketEvent, void *userData);
+EMSCRIPTEN_RESULT emscripten_websocket_set_onmessage_callback_on_thread(EMSCRIPTEN_WEBSOCKET_T socket, void *userData, em_websocket_message_callback_func callback, pthread_t targetThread);
+
+typedef struct EmscriptenWebSocketErrorEvent {
+  EMSCRIPTEN_WEBSOCKET_T socket;
+} EmscriptenWebSocketErrorEvent;
+
+typedef EM_BOOL (*em_websocket_error_callback_func)(int eventType, const EmscriptenWebSocketErrorEvent *websocketEvent, void *userData);
+EMSCRIPTEN_RESULT emscripten_websocket_set_onerror_callback_on_thread(EMSCRIPTEN_WEBSOCKET_T socket, void *userData, em_websocket_error_callback_func callback, pthread_t targetThread);
+
+typedef struct EmscriptenWebSocketCloseEvent {
+  EMSCRIPTEN_WEBSOCKET_T socket;
+  EM_BOOL wasClean;
+  unsigned short code;
+  char reason[512]; // WebSockets spec enforces this can be max 123 characters, so as UTF-8 at most 123*4 bytes < 512.
+} EmscriptenWebSocketCloseEvent;
+
+typedef EM_BOOL (*em_websocket_close_callback_func)(int eventType, const EmscriptenWebSocketCloseEvent *websocketEvent, void *userData);
+EMSCRIPTEN_RESULT emscripten_websocket_set_onclose_callback_on_thread(EMSCRIPTEN_WEBSOCKET_T socket, void *userData, em_websocket_close_callback_func callback, pthread_t targetThread);
+
+#define emscripten_websocket_set_onopen_callback(socket, userData, callback)    emscripten_websocket_set_onopen_callback_on_thread(   (socket), (userData), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
+#define emscripten_websocket_set_onerror_callback(socket, userData, callback)   emscripten_websocket_set_onerror_callback_on_thread(  (socket), (userData), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
+#define emscripten_websocket_set_onclose_callback(socket, userData, callback)   emscripten_websocket_set_onclose_callback_on_thread(  (socket), (userData), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
+#define emscripten_websocket_set_onmessage_callback(socket, userData, callback) emscripten_websocket_set_onmessage_callback_on_thread((socket), (userData), (callback), EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD)
+
+typedef struct EmscriptenWebSocketCreateAttributes {
+  // The target URL to connect to. This string can point to a stack local variable, the string is read immediately at a call to emscripten_websocket_new().
+  const char *url;
+  // A comma-separated list of protocol strings. Set to e.g. "binary,base64" to create a WebSocket connection with two supported protocols "binary" and "base64".
+  // Be careful to avoid leading and trailing spaces, e.g. "binary, base64" may not be interpreted properly.
+  // This string can point to a stack local variable, the string is read immediately at a call to emscripten_websocket_new().
+  const char *protocols;
+
+  // If true, the created socket will reside on the main browser thread. If false, the created socket is bound to the calling thread.
+  // If you want to share the created EMSCRIPTEN_WEBSOCKET_T structure across multiple threads, or are running your own main loop in the
+  // pthread that you create the socket, set createOnMainThread to true. If the created WebSocket only needs to be accessible on the thread
+  // that created it, and the creating thread is an event based thread (meaning it regularly yields back to the browser event loop), then
+  // it is more efficient to set this to false.
+  EM_BOOL createOnMainThread;
+} EmscriptenWebSocketCreateAttributes;
+
+//extern void emscripten_websocket_init_create_attributes(EmscriptenWebSocketCreateAttributes *attributes);
+#define emscripten_websocket_init_create_attributes(attributes) do { memset((attributes), 0, sizeof(EmscriptenWebSocketCreateAttributes)); } while(0)
+
+// Returns true if WebSockets are supported by the current browser
+EM_BOOL emscripten_websocket_is_supported(void);
+
+// Creates a new WebSocket and connects it to the given remote host.
+// If the return value of this function is > 0, the function has succeeded and the return value represents a handle to the WebSocket object.
+// If the return value of this function is < 0, then the function has failed, and the return value can be interpreted as a EMSCRIPTEN_RESULT code
+// representing the cause of the failure. If the function returns 0, then the call has failed with an unknown reason (build with -s WEBSOCKET_DEBUG=1 for more information)
+EMSCRIPTEN_WEBSOCKET_T emscripten_websocket_new(EmscriptenWebSocketCreateAttributes *createAttributes);
+
+// Sends the given string of null-delimited UTF8 encoded text data to the connected server.
+EMSCRIPTEN_RESULT emscripten_websocket_send_utf8_text(EMSCRIPTEN_WEBSOCKET_T socket, const char *textData);
+
+// Sends the given block of raw memory data out to the connected server.
+EMSCRIPTEN_RESULT emscripten_websocket_send_binary(EMSCRIPTEN_WEBSOCKET_T socket, void *binaryData, uint32_t dataLength);
+
+// Closes the specified WebSocket. N.B.: the meaning of "closing" a WebSocket means "eager read/lazy write"-closing the socket. That is, all still
+// pending untransferred outbound bytes will continue to transfer out, but after calling close on the socket, any pending bytes still in the process
+// of being received will never be available. See https://html.spec.whatwg.org/multipage/web-sockets.html#dom-websocket-sclose
+// After calling close(), it is no longer possible to send() on the WebSocket to send more bytes.
+EMSCRIPTEN_RESULT emscripten_websocket_close(EMSCRIPTEN_WEBSOCKET_T socket, unsigned short code, const char *reason);
+
+// Releases the given WebSocket object and all associated allocated memory for garbage collection. This effectively frees the socket handle, after calling
+// this function the given handle no longer exists.
+EMSCRIPTEN_RESULT emscripten_websocket_delete(EMSCRIPTEN_WEBSOCKET_T socket);
+
+// This function close()s and releases all created WebSocket connections for the current thread. You can call this at application exit time to enforce
+// teardown of all active sockets, although it is optional. When a pthread terminates, it will call this function to delete all active connections bound to
+// that specific pthread (sockets created with createOnMainThread=false). Any WebSockets created by a pthread with createOnMainThread=true will remain alive
+// even after the pthread quits, although be warned that if the target thread that was registered to handle events for a given WebSocket quits, then those
+// events will stop from being delivered altogether.
+void emscripten_websocket_deinitialize(void);
+
+#ifdef __cplusplus
+} // ~extern "C"
+#endif

websocket/lib/web/library_websocket.js

@@ -0,0 +1,448 @@
+/**
+ * @license
+ * Copyright 2018 The Emscripten Authors
+ * SPDX-License-Identifier: MIT
+ */
+
+var LibraryWebSocket = {
+  $WS: {
+    sockets: [null],
+    socketEvent: null
+  },
+
+  emscripten_websocket_get_ready_state__deps: ['$WS'],
+  emscripten_websocket_get_ready_state__proxy: 'sync',
+  emscripten_websocket_get_ready_state__sig: 'iii',
+  emscripten_websocket_get_ready_state: function(socketId, readyState) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_get_ready_state(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+    {{{ makeSetValue('readyState', '0', 'socket.readyState', 'i16') }}};
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_get_buffered_amount__deps: ['$WS'],
+  emscripten_websocket_get_buffered_amount__proxy: 'sync',
+  emscripten_websocket_get_buffered_amount__sig: 'iii',
+  emscripten_websocket_get_buffered_amount: function(socketId, bufferedAmount) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_get_buffered_amount(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+    {{{ makeSetValue('bufferedAmount', '0', 'socket.bufferedAmount', 'i64') }}};
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_get_extensions__deps: ['$WS'],
+  emscripten_websocket_get_extensions__proxy: 'sync',
+  emscripten_websocket_get_extensions__sig: 'iiii',
+  emscripten_websocket_get_extensions: function(socketId, extensions, extensionsLength) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_get_extensions(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+    if (!extensions) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
+    stringToUTF8(socket.extensions, extensions, extensionsLength);
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_get_extensions_length__deps: ['$WS'],
+  emscripten_websocket_get_extensions_length__proxy: 'sync',
+  emscripten_websocket_get_extensions_length__sig: 'iii',
+  emscripten_websocket_get_extensions_length: function(socketId, extensionsLength) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_get_extensions_length(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+    if (!extensionsLength) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
+    {{{ makeSetValue('extensionsLength', '0', 'lengthBytesUTF8(socket.extensions)+1', 'i32') }}};
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_get_protocol__deps: ['$WS'],
+  emscripten_websocket_get_protocol__proxy: 'sync',
+  emscripten_websocket_get_protocol__sig: 'iiii',
+  emscripten_websocket_get_protocol: function(socketId, protocol, protocolLength) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_get_protocol(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+    if (!protocol) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
+    stringToUTF8(socket.protocol, protocol, protocolLength);
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_get_protocol_length__deps: ['$WS'],
+  emscripten_websocket_get_protocol_length__proxy: 'sync',
+  emscripten_websocket_get_protocol_length__sig: 'iii',
+  emscripten_websocket_get_protocol_length: function(socketId, protocolLength) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_get_protocol_length(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+    if (!protocolLength) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
+    {{{ makeSetValue('protocolLength', '0', 'lengthBytesUTF8(socket.protocol)+1', 'i32') }}};
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_get_url__deps: ['$WS'],
+  emscripten_websocket_get_url__proxy: 'sync',
+  emscripten_websocket_get_url__sig: 'iiii',
+  emscripten_websocket_get_url: function(socketId, url, urlLength) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_get_url(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+    if (!url) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
+    stringToUTF8(socket.url, url, urlLength);
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_get_url_length__deps: ['$WS'],
+  emscripten_websocket_get_url_length__proxy: 'sync',
+  emscripten_websocket_get_url_length__sig: 'iii',
+  emscripten_websocket_get_url_length: function(socketId, urlLength) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_get_url_length(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+    if (!urlLength) return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
+    {{{ makeSetValue('urlLength', '0', 'lengthBytesUTF8(socket.url)+1', 'i32') }}};
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_set_onopen_callback_on_thread__deps: ['$WS'],
+  emscripten_websocket_set_onopen_callback_on_thread__proxy: 'sync',
+  emscripten_websocket_set_onopen_callback_on_thread__sig: 'iiiii',
+  emscripten_websocket_set_onopen_callback_on_thread: function(socketId, userData, callbackFunc, thread) {
+// TODO:
+//    if (thread == {{{ cDefine('EM_CALLBACK_THREAD_CONTEXT_CALLING_THREAD') }}} ||
+//      (thread == _pthread_self()) return emscripten_websocket_set_onopen_callback_on_calling_thread(socketId, userData, callbackFunc);
+
+    if (!WS.socketEvent) WS.socketEvent = _malloc(1024); // TODO: sizeof(EmscriptenWebSocketCloseEvent), which is the largest event struct
+
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_set_onopen_callback(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_set_onopen_callback(socketId='+socketId+',userData='+userData+',callbackFunc='+callbackFunc+')');
+#endif
+    socket.onopen = function(e) {
+#if WEBSOCKET_DEBUG
+      console.error('websocket event "open": socketId='+socketId+',userData='+userData+',callbackFunc='+callbackFunc+')');
+#endif
+      HEAPU32[WS.socketEvent>>2] = socketId;
+      {{{ makeDynCall('iiii', 'callbackFunc') }}}(0/*TODO*/, WS.socketEvent, userData);
+    }
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_set_onerror_callback_on_thread__deps: ['$WS'],
+  emscripten_websocket_set_onerror_callback_on_thread__proxy: 'sync',
+  emscripten_websocket_set_onerror_callback_on_thread__sig: 'iiiii',
+  emscripten_websocket_set_onerror_callback_on_thread: function(socketId, userData, callbackFunc, thread) {
+    if (!WS.socketEvent) WS.socketEvent = _malloc(1024); // TODO: sizeof(EmscriptenWebSocketCloseEvent), which is the largest event struct
+
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_set_onerror_callback(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_set_onerror_callback(socketId='+socketId+',userData='+userData+',callbackFunc='+callbackFunc+')');
+#endif
+    socket.onerror = function(e) {
+#if WEBSOCKET_DEBUG
+      console.error('websocket event "error": socketId='+socketId+',userData='+userData+',callbackFunc='+callbackFunc+')');
+#endif
+      HEAPU32[WS.socketEvent>>2] = socketId;
+      {{{ makeDynCall('iiii', 'callbackFunc') }}}(0/*TODO*/, WS.socketEvent, userData);
+    }
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_set_onclose_callback_on_thread__deps: ['$WS'],
+  emscripten_websocket_set_onclose_callback_on_thread__proxy: 'sync',
+  emscripten_websocket_set_onclose_callback_on_thread__sig: 'iiiii',
+  emscripten_websocket_set_onclose_callback_on_thread: function(socketId, userData, callbackFunc, thread) {
+    if (!WS.socketEvent) WS.socketEvent = _malloc(1024); // TODO: sizeof(EmscriptenWebSocketCloseEvent), which is the largest event struct
+
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_set_onclose_callback(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_set_onclose_callback(socketId='+socketId+',userData='+userData+',callbackFunc='+callbackFunc+')');
+#endif
+    socket.onclose = function(e) {
+#if WEBSOCKET_DEBUG
+      console.error('websocket event "close": socketId='+socketId+',userData='+userData+',callbackFunc='+callbackFunc+')');
+#endif
+      HEAPU32[WS.socketEvent>>2] = socketId;
+      HEAPU32[(WS.socketEvent+4)>>2] = e.wasClean;
+      HEAPU32[(WS.socketEvent+8)>>2] = e.code;
+      stringToUTF8(e.reason, HEAPU32[(WS.socketEvent+10)>>2], 512);
+      {{{ makeDynCall('iiii', 'callbackFunc') }}}(0/*TODO*/, WS.socketEvent, userData);
+    }
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_set_onmessage_callback_on_thread__deps: ['$WS'],
+  emscripten_websocket_set_onmessage_callback_on_thread__proxy: 'sync',
+  emscripten_websocket_set_onmessage_callback_on_thread__sig: 'iiiii',
+  emscripten_websocket_set_onmessage_callback_on_thread: function(socketId, userData, callbackFunc, thread) {
+    if (!WS.socketEvent) WS.socketEvent = _malloc(1024); // TODO: sizeof(EmscriptenWebSocketCloseEvent), which is the largest event struct
+
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_set_onmessage_callback(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_set_onmessage_callback(socketId='+socketId+',userData='+userData+',callbackFunc='+callbackFunc+')');
+#endif
+    socket.onmessage = function(e) {
+#if WEBSOCKET_DEBUG == 2
+      console.error('websocket event "message": socketId='+socketId+',userData='+userData+',callbackFunc='+callbackFunc+')');
+#endif
+      HEAPU32[WS.socketEvent>>2] = socketId;
+      if (typeof e.data === 'string') {
+        var len = lengthBytesUTF8(e.data)+1;
+        var buf = _malloc(len);
+        stringToUTF8(e.data, buf, len);
+#if WEBSOCKET_DEBUG
+        var s = (e.data.length < 256) ? e.data : (e.data.substr(0, 256) + ' (' + (e.data.length-256) + ' more characters)');
+        console.error('WebSocket onmessage, received data: "' + e.data + '", ' + e.data.length + ' chars, ' + len + ' bytes encoded as UTF-8: "' + s + '"');
+#endif
+        HEAPU32[(WS.socketEvent+12)>>2] = 1; // text data
+      } else {
+        var len = e.data.byteLength;
+        var buf = _malloc(len);
+        HEAP8.set(new Uint8Array(e.data), buf);
+#if WEBSOCKET_DEBUG
+        var s = 'WebSocket onmessage, received data: ' + len + ' bytes of binary:';
+        for(var i = 0; i < Math.min(len, 256); ++i) s += ' ' + HEAPU8[buf+i].toString(16);
+        s += ', "';
+        for(var i = 0; i < Math.min(len, 256); ++i) s += (HEAPU8[buf+i] >= 32 && HEAPU8[buf+i] <= 127) ? String.fromCharCode(HEAPU8[buf+i]) : '\uFFFD';
+        s += '"';
+        if (len > 256) s + ' ... (' + (len - 256) + ' more bytes)';
+
+        console.error(s);
+#endif
+        HEAPU32[(WS.socketEvent+12)>>2] = 0; // binary data
+      }
+      HEAPU32[(WS.socketEvent+4)>>2] = buf;
+      HEAPU32[(WS.socketEvent+8)>>2] = len;
+      {{{ makeDynCall('iiii', 'callbackFunc') }}}(0/*TODO*/, WS.socketEvent, userData);
+      _free(buf);
+    }
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_new__deps: ['$WS'],
+  emscripten_websocket_new__proxy: 'sync',
+  emscripten_websocket_new__sig: 'ii',
+  emscripten_websocket_new: function(createAttributes) {
+    if (typeof WebSocket === 'undefined') {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_new(): WebSocket API is not supported by current browser)');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_NOT_SUPPORTED') }}};
+    }
+    if (!createAttributes) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_new(): Missing required "createAttributes" function parameter!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_PARAM') }}};
+    }
+
+    var createAttrs = createAttributes>>2;
+    var url = UTF8ToString(HEAP32[createAttrs]);
+    var protocols = HEAP32[createAttrs+1];
+    // TODO: Add support for createOnMainThread==false; currently all WebSocket connections are created on the main thread.
+    // var createOnMainThread = HEAP32[createAttrs+2];
+
+    var socket = protocols ? new WebSocket(url, UTF8ToString(protocols).split(',')) : new WebSocket(url);
+    // We always marshal received WebSocket data back to Wasm, so enable receiving the data as arraybuffers for easy marshalling.
+    socket.binaryType = 'arraybuffer';
+    // TODO: While strictly not necessary, this ID would be good to be unique across all threads to avoid confusion.
+    var socketId = WS.sockets.length;
+    WS.sockets[socketId] = socket;
+
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_new(url='+url+', protocols=' + (protocols?UTF8ToString(protocols).split(','):'null') + '): created socket ID ' + socketId + ')');
+#endif
+    return socketId;
+  },
+
+  emscripten_websocket_send_utf8_text__deps: ['$WS'],
+  emscripten_websocket_send_utf8_text__proxy: 'sync',
+  emscripten_websocket_send_utf8_text__sig: 'iii',
+  emscripten_websocket_send_utf8_text: function(socketId, textData) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_send_utf8_text(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+    var str = UTF8ToString(textData);
+#if WEBSOCKET_DEBUG == 2
+    console.error('emscripten_websocket_send_utf8_text(socketId='+socketId+',textData='+ str.length + ' chars, "' + str +'")');
+#else
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_send_utf8_text(socketId='+socketId+',textData='+ str.length + ' chars, "' + ((str.length > 8) ? (str.substring(0,8) + '...') : str) + '")');
+#endif
+#endif
+    socket.send(str);
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_send_binary__deps: ['$WS'],
+  emscripten_websocket_send_binary__proxy: 'sync',
+  emscripten_websocket_send_binary__sig: 'iiii',
+  emscripten_websocket_send_binary: function(socketId, binaryData, dataLength) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_send_binary(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+#if WEBSOCKET_DEBUG
+    var s = 'data: ' + dataLength + ' bytes of binary:';
+    for(var i = 0; i < Math.min(dataLength, 256); ++i) s += ' '+ HEAPU8[binaryData+i].toString(16);
+    s += ', "';
+    for(var i = 0; i < Math.min(dataLength, 256); ++i) s += (HEAPU8[binaryData+i] >= 32 && HEAPU8[binaryData+i] <= 127) ? String.fromCharCode(HEAPU8[binaryData+i]) : '\uFFFD';
+    s += '"';
+    if (dataLength > 256) s + ' ... (' + (dataLength - 256) + ' more bytes)';
+
+    console.error('emscripten_websocket_send_binary(socketId='+socketId+',binaryData='+binaryData+ ',dataLength='+dataLength+'), ' + s);
+#endif
+#if USE_PTHREADS
+    // TODO: This is temporary to cast a shared Uint8Array to a non-shared Uint8Array. This could be removed if WebSocket API is improved
+    // to allow passing in views to SharedArrayBuffers
+    socket.send(new Uint8Array({{{ makeHEAPView('U8', 'binaryData', 'binaryData+dataLength') }}}));
+#else
+    socket.send({{{ makeHEAPView('U8', 'binaryData', 'binaryData+dataLength') }}});
+#endif
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_close__deps: ['$WS'],
+  emscripten_websocket_close__proxy: 'sync',
+  emscripten_websocket_close__sig: 'iiii',
+  emscripten_websocket_close: function(socketId, code, reason) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_close(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+    var reasonStr = reason ? UTF8ToString(reason) : undefined;
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_close(socketId='+socketId+',code='+code+',reason='+reasonStr+')');
+#endif
+    // According to WebSocket specification, only close codes that are recognized have integer values
+    // 1000-4999, with 3000-3999 and 4000-4999 denoting user-specified close codes:
+    // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+    // Therefore be careful to call the .close() function with exact number and types of parameters.
+    // Coerce code==0 to undefined, since Wasm->JS call can only marshal integers, and 0 is not allowed.
+    if (reason) socket.close(code || undefined, UTF8ToString(reason));
+    else if (code) socket.close(code);
+    else socket.close();
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_delete__deps: ['$WS'],
+  emscripten_websocket_delete__proxy: 'sync',
+  emscripten_websocket_delete__sig: 'ii',
+  emscripten_websocket_delete: function(socketId) {
+    var socket = WS.sockets[socketId];
+    if (!socket) {
+#if WEBSOCKET_DEBUG
+      console.error('emscripten_websocket_delete(): Invalid socket ID ' + socketId + ' specified!');
+#endif
+      return {{{ cDefine('EMSCRIPTEN_RESULT_INVALID_TARGET') }}};
+    }
+
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_delete(socketId='+socketId+')');
+#endif
+    socket.onopen = socket.onerror = socket.onclose = socket.onmessage = null;
+    delete WS.sockets[socket];
+    return {{{ cDefine('EMSCRIPTEN_RESULT_SUCCESS') }}};
+  },
+
+  emscripten_websocket_is_supported__proxy: 'sync',
+  emscripten_websocket_is_supported__sig: 'i',
+  emscripten_websocket_is_supported: function() {
+    return typeof WebSocket !== 'undefined';
+  },
+
+  emscripten_websocket_deinitialize__deps: ['$WS'],
+  emscripten_websocket_deinitialize__proxy: 'sync',
+  emscripten_websocket_deinitialize__sig: 'v',
+  emscripten_websocket_deinitialize__deps: ['emscripten_websocket_delete'],
+  emscripten_websocket_deinitialize: function() {
+#if WEBSOCKET_DEBUG
+    console.error('emscripten_websocket_deinitialize()');
+#endif
+    for(var i in WS.sockets) {
+      var socket = WS.sockets[i];
+      if (socket) {
+        socket.close();
+        _emscripten_websocket_delete(i);
+      }
+    }
+    WS.sockets = [];
+  }
+}
+
+mergeInto(LibraryManager.library, LibraryWebSocket);

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;
-    int length = strlen(websocketEvent->reason);
-    PushMessage(conn, MESSAGE_TYPE_CLOSE, length, (uint8_t*)websocketEvent->reason, websocketEvent->code);
+    PushMessage(conn, MESSAGE_TYPE_CLOSE, 0, 0);
+    SetState(conn, STATE_DISCONNECTED);
     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, 0);
+    PushMessage(conn, MESSAGE_TYPE_NORMAL, length, websocketEvent->data);
     return EM_TRUE;
 }
 

websocket/src/websocket.cpp

@@ -7,6 +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,6 +32,7 @@ struct WebsocketContext
     int                             m_Timeout;
     dmArray<WebsocketConnection*>   m_Connections;
     dmConnectionPool::HPool         m_Pool;
+    dmDNS::HChannel                 m_Channel;
     uint32_t                        m_Initialized:1;
 } g_Websocket;
 
@@ -249,7 +251,10 @@ 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
@@ -259,11 +264,6 @@ 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)
@@ -436,12 +436,6 @@ 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);
@@ -533,6 +527,7 @@ 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;
 
@@ -550,6 +545,16 @@ static dmExtension::Result AppInitialize(dmExtension::AppParams* params)
         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 DNS channel: %d", dns_result);
+    }
+#endif
+
     g_Websocket.m_Initialized = 1;
     return dmExtension::RESULT_OK;
 }
@@ -582,7 +587,7 @@ static dmExtension::Result Finalize(dmExtension::Params* params)
     return dmExtension::RESULT_OK;
 }
 
-Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* buffer, uint16_t code)
+Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* buffer)
 {
     if (conn->m_Messages.Full())
         conn->m_Messages.OffsetCapacity(4);
@@ -590,7 +595,6 @@ 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)
@@ -621,7 +625,7 @@ 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);
+    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, g_Websocket.m_Timeout, &conn->m_Connection, &sr);
     if (dmConnectionPool::RESULT_OK != pool_result)
     {
         CLOSE_CONN("Failed to open connection: %s", dmSocket::ResultToString(sr));
@@ -653,7 +657,7 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
             --size;
             DestroyConnection(conn);
         }
-        else if ((STATE_CONNECTED == conn->m_State) || (STATE_DISCONNECTING == conn->m_State))
+        else if (STATE_CONNECTED == conn->m_State)
         {
 #if defined(HAVE_WSLAY)
             int r = WSL_Poll(conn->m_Ctx);
@@ -665,6 +669,7 @@ 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];
@@ -672,18 +677,24 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
                 if (EVENT_DISCONNECTED == msg.m_Type)
                 {
                     conn->m_Status = RESULT_OK;
-                    // close the connection and immediately transition to the DISCONNECTED
-                    // state
-                    SetState(conn, STATE_DISCONNECTED);
-                    conn->m_CloseCode = msg.m_Code;
+                    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;
             }
-            conn->m_Messages.SetSize(0);
-            conn->m_BufferSize = 0;
+            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)
         {
@@ -808,7 +819,7 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
             emscripten_websocket_set_onclose_callback(ws, conn, Emscripten_WebSocketOnClose);
             emscripten_websocket_set_onmessage_callback(ws, conn, Emscripten_WebSocketOnMessage);
 #else
-            conn->m_ConnectionThread = dmThread::New((dmThread::ThreadStart)ConnectionWorker, 0x80000, conn, "WSConnect");
+            conn->m_ConnectionThread = dmThread::New((dmThread::ThreadStart)ConnectionWorker, 0x80000, conn, "WebSocketConnectionThread");
 #endif
             SetState(conn, STATE_CONNECTING);
         }

websocket/src/websocket.h

@@ -16,11 +16,12 @@
     #endif
 
 #if defined(__EMSCRIPTEN__)
-#include <emscripten/websocket.h> 
+#include "emscripten/websocket.h"
 #endif
 
 #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>
@@ -80,7 +81,6 @@ namespace dmWebsocket
 
     struct Message
     {
-        uint16_t m_Code;
         uint32_t m_Length:30;
         uint32_t m_Type:2;
     };
@@ -130,7 +130,6 @@ 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;
@@ -161,7 +160,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, uint16_t code);
+    Result PushMessage(WebsocketConnection* conn, MessageType type, int length, const uint8_t* msg);
 
 #if defined(HAVE_WSLAY)
     // Wslay callbacks

websocket/src/wslay_callbacks.cpp

@@ -39,7 +39,11 @@ 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
-    return wslay_event_context_client_init(ctx, &g_WslCallbacks, userctx);
+    int ret = -1;
+    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;
 }
 
 
@@ -120,7 +124,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, 0);
+        PushMessage(conn, MESSAGE_TYPE_NORMAL, arg->msg_length, arg->msg);
     } else if (arg->opcode == WSLAY_CONNECTION_CLOSE)
     {
         // The first two bytes is the close code
@@ -133,9 +137,8 @@ void WSL_OnMsgRecvCallback(wslay_event_context_ptr ctx, const struct wslay_event
         }
 
         char buffer[1024];
-        uint16_t status_code = wslay_event_get_status_code_received(ctx);
-        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);
+        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))
         {
@@ -161,4 +164,4 @@ int WSL_GenmaskCallback(wslay_event_context_ptr ctx, uint8_t *buf, size_t len, v
 
 } // namespace
 
-#endif // HAVE_WSLAY
+#endif // HAVE_WSLAY