Add the port to the url for html5 builds (#35)

Fixes #34

.github/workflows/bob.yml

@@ -0,0 +1,76 @@
+name: Build with bob
+
+on:
+  push:
+  pull_request_target:
+  schedule:
+    # nightly at 05:00 on the 1st and 15th
+    - cron: 0 5 1,15 * *
+
+env:
+  VERSION_FILENAME: 'info.json'
+  BUILD_SERVER: 'https://build.defold.com'
+
+jobs:
+  build_with_bob:
+    strategy:
+      matrix:
+        platform: [armv7-android, x86_64-linux, x86_64-win32, x86-win32, js-web]
+    runs-on: ubuntu-latest
+
+    name: Build
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: '11.0.2'
+
+      - name: Get Defold version
+        run: |
+          TMPVAR=`curl -s http://d.defold.com/stable/${{env.VERSION_FILENAME}} | jq -r '.sha1'`
+          echo "DEFOLD_VERSION=${TMPVAR}" >> $GITHUB_ENV
+          echo "Found version ${TMPVAR}"
+
+      - name: Download bob.jar
+        run: |
+          wget -q http://d.defold.com/archive/stable/${{env.DEFOLD_VERSION}}/bob/bob.jar
+          java -jar bob.jar --version
+
+      - name: Resolve libraries
+        run: java -jar bob.jar resolve --email a@b.com --auth 123456
+      - name: Build
+        run: java -jar bob.jar --platform=${{ matrix.platform }} build --archive --build-server=${{env.BUILD_SERVER}}
+      - name: Bundle
+        run: java -jar bob.jar --platform=${{ matrix.platform }} bundle
+
+  # macOS is not technically needed for building, but we want to test bundling as well, since we're also testing the manifest merging
+  build_with_bob_macos:
+    strategy:
+      matrix:
+        platform: [armv7-darwin, x86_64-darwin]
+    runs-on: macOS-latest
+
+    name: Build
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v1
+        with:
+          java-version: '11.0.2'
+
+      - name: Get Defold version
+        run: |
+          TMPVAR=`curl -s http://d.defold.com/stable/${{env.VERSION_FILENAME}} | jq -r '.sha1'`
+          echo "DEFOLD_VERSION=${TMPVAR}" >> $GITHUB_ENV
+          echo "Found version ${TMPVAR}"
+
+      - name: Download bob.jar
+        run: |
+          wget -q http://d.defold.com/archive/stable/${{env.DEFOLD_VERSION}}/bob/bob.jar
+          java -jar bob.jar --version
+
+      - name: Resolve libraries
+        run: java -jar bob.jar resolve --email a@b.com --auth 123456
+      - name: Build
+        run: java -jar bob.jar --platform=${{ matrix.platform }} build --archive --build-server=${{env.BUILD_SERVER}}
+      - name: Bundle
+        run: java -jar bob.jar --platform=${{ matrix.platform }} bundle

.github/workflows/trigger-site-rebuild.yml

@@ -1,6 +1,9 @@
 name: Trigger site rebuild
 
-on: [push]
+on:
+  push:
+     branches:
+       - 'master'
 
 jobs:
     site-rebuild:

README.md

@@ -1,5 +1,9 @@
+
+
 # Defold websocket extension
 
+[![Build Status](https://github.com/defold/extension-websocket/workflows/Build%20with%20bob/badge.svg)](https://github.com/defold/extension-websocket/actions)
+
 ## Installation
 To use this library in your Defold project, add the following URL to your `game.project` dependencies:
 
@@ -9,4 +13,40 @@ We recommend using a link to a zip file of a [specific release](https://github.c
 
 ## API reference
 
-https://defold.com/extension-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`.
+
+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)
+
+## Credits
+
+This extension makes use of the C library WSlay by @tatsuhiro-t:
+
+* https://github.com/tatsuhiro-t/wslay

docs/index.md

@@ -14,15 +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 " .. 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: '" .. tostring(data.message) .. "'")
+        if data.handshake_response then
+            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
+            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
 

examples/websocket.gui_script

@@ -1,5 +1,4 @@
 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
@@ -73,7 +72,14 @@ local function websocket_callback(self, conn, data)
 		update_gui(self)
 		log("Connected: " .. tostring(conn))
 	elseif data.event == websocket.EVENT_ERROR then
-		log("Error: '" .. data.error .. "'")
+		log("Error: '" .. tostring(data.message) .. "'")
+		if data.handshake_response then
+			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
+			log("Handshake response body: '" .. tostring(data.handshake_response.response) .. "'")
+		end
 	elseif data.event == websocket.EVENT_MESSAGE then
 		log("Receiving: '" .. tostring(data.message) .. "'")
 	end

game.project

@@ -14,4 +14,3 @@ _dependencies = https://github.com/GameAnalytics/defold-openssl/archive/1.0.0.zi
 
 [library]
 include_dirs = websocket
-

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'). If not set, no `Sec-WebSocket-Protocol` header is sent.
+
+          - 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/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

@@ -0,0 +1,42 @@
+#include "websocket.h"
+
+#if defined(__EMSCRIPTEN__)
+
+namespace dmWebsocket
+{
+EM_BOOL Emscripten_WebSocketOnOpen(int eventType, const EmscriptenWebSocketOpenEvent *websocketEvent, void *userData) {
+    DebugLog(1, "WebSocket OnOpen");
+    WebsocketConnection* conn = (WebsocketConnection*)userData;
+    SetState(conn, STATE_CONNECTED);
+    HandleCallback(conn, EVENT_CONNECTED, 0, 0);
+    return EM_TRUE;
+}
+EM_BOOL Emscripten_WebSocketOnError(int eventType, const EmscriptenWebSocketErrorEvent *websocketEvent, void *userData) {
+    DebugLog(1, "WebSocket OnError");
+    WebsocketConnection* conn = (WebsocketConnection*)userData;
+    conn->m_Status = RESULT_ERROR;
+    SetState(conn, STATE_DISCONNECTED);
+    return EM_TRUE;
+}
+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);
+    SetState(conn, STATE_DISCONNECTED);
+    return EM_TRUE;
+}
+EM_BOOL Emscripten_WebSocketOnMessage(int eventType, const EmscriptenWebSocketMessageEvent *websocketEvent, void *userData) {
+    DebugLog(1, "WebSocket OnMessage");
+    WebsocketConnection* conn = (WebsocketConnection*)userData;
+    int length = websocketEvent->numBytes;
+    if (websocketEvent->isText)
+    {
+        length--;
+    }
+    PushMessage(conn, MESSAGE_TYPE_NORMAL, length, websocketEvent->data);
+    return EM_TRUE;
+}
+
+} // namespace
+
+#endif // __EMSCRIPTEN__

websocket/src/handshake.cpp

@@ -1,5 +1,7 @@
 #include "websocket.h"
 #include <dmsdk/dlib/socket.h>
+#include <dmsdk/dlib/http_client.h>
+#include <ctype.h> // tolower
 
 namespace dmWebsocket
 {
@@ -39,8 +41,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 +59,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 +120,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 +161,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 +171,65 @@ Result ReceiveHeaders(WebsocketConnection* conn)
 }
 #endif
 
+static void HandleVersion(void* user_data, int major, int minor, int status, const char* status_str)
+{
+    HandshakeResponse* response = (HandshakeResponse*)user_data;
+    response->m_HttpMajor = major;
+    response->m_HttpMinor = minor;
+    response->m_ResponseStatusCode = status;
+}
+
+
+static void HandleHeader(void* user_data, const char* key, const char* value)
+{
+    HandshakeResponse* response = (HandshakeResponse*)user_data;
+    if (response->m_Headers.Remaining() == 0)
+    {
+        response->m_Headers.OffsetCapacity(4);
+    }
+    HttpHeader* new_header = new HttpHeader(key, value);
+
+    response->m_Headers.Push(new_header);
+}
+
+
+static void HandleContent(void* user_data, int offset)
+{
+    HandshakeResponse* response = (HandshakeResponse*)user_data;
+    response->m_BodyOffset = offset;
+}
+
+
+bool ValidateSecretKey(WebsocketConnection* conn, const char* server_key)
+{
+    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", server_key);
+
+    return strcmp(server_key, (const char*)client_key) == 0;
+}
+
+
 #if defined(__EMSCRIPTEN__)
 Result VerifyHeaders(WebsocketConnection* conn)
 {
@@ -165,74 +240,54 @@ Result VerifyHeaders(WebsocketConnection* conn)
 {
     char* r = conn->m_Buffer;
 
-    // According to protocol, the response should start with "HTTP/1.1 <statuscode> <message>"
+    // Find start of payload now because dmHttpClient::ParseHeader is destructive
-    const char* http_version_and_status_protocol = "HTTP/1.1 101";
+    const char* start_of_payload = strstr(conn->m_Buffer, "\r\n\r\n");
-    if (strstr(r, http_version_and_status_protocol) != r) {
+    start_of_payload += 4;
-        return SetStatus(conn, RESULT_HANDSHAKE_FAILED, "Missing: '%s' in header", http_version_and_status_protocol);
-    }
 
-    r = strstr(r, "\r\n") + 2;
+    HandshakeResponse* response = new HandshakeResponse();
-
+    conn->m_HandshakeResponse = response;
-    bool upgraded = false;
+    dmHttpClient::ParseResult parse_result = dmHttpClient::ParseHeader(r, response, true, &HandleVersion, &HandleHeader, &HandleContent);
-    bool valid_key = false;
+    if (parse_result != dmHttpClient::ParseResult::PARSE_RESULT_OK)
-    const char* protocol = "";
-
-    // TODO: Perhaps also support the Sec-WebSocket-Protocol
-
-    // parse the headers in place
-    while (r)
     {
-        // Tokenize the each header line: "Key: Value\r\n"
+        return SetStatus(conn, RESULT_HANDSHAKE_FAILED, "Failed to parse handshake response. 'dmHttpClient::ParseResult=%i'", parse_result);
-        const char* key = r;
-        r = strchr(r, ':');
-        *r = 0;
-        ++r;
-        const char* value = r;
-        while(*value == ' ')
-            ++value;
-        r = strstr(r, "\r\n");
-        *r = 0;
-        r += 2;
-
-        if (strcmp(key, "Connection") == 0 && strcmp(value, "Upgrade") == 0)
-            upgraded = true;
-        else if (strcmp(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;
-
-            memcpy(client_key + client_key_len, RFC_MAGIC, strlen(RFC_MAGIC));
-            client_key_len += strlen(RFC_MAGIC);
-            client_key[client_key_len] = 0;
-
-            uint8_t client_key_sha1[20];
-            dmCrypt::HashSha1(client_key, client_key_len, 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;
-
-            if (strcmp(value, (const char*)client_key) == 0)
-                valid_key = true;
-        }
-
-        if (strcmp(r, "\r\n") == 0)
-            break;
     }
 
-    if (!upgraded)
+    if (response->m_ResponseStatusCode != 101) {
+        return SetStatus(conn, RESULT_HANDSHAKE_FAILED, "Wrong response status: %i", response->m_ResponseStatusCode);
+    }
+
+    HttpHeader *connection_header, *upgrade_header, *websocket_secret_header;
+    connection_header = response->GetHeader("Connection");
+    upgrade_header = response->GetHeader("Upgrade");
+    websocket_secret_header = response->GetHeader("Sec-WebSocket-Accept");
+    bool connection = connection_header && dmStrCaseCmp(connection_header->m_Value, "Upgrade") == 0;
+    bool upgrade  = upgrade_header && dmStrCaseCmp(upgrade_header->m_Value, "websocket") == 0;
+    bool valid_key = websocket_secret_header && ValidateSecretKey(conn, websocket_secret_header->m_Value);
+
+    // Send error to lua?
+    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;
-        dmLogError("Response:\n\"%s\"\n", conn->m_Buffer);
+    if(!ok)
+    {
+        return RESULT_HANDSHAKE_FAILED;
     }
 
-    return (upgraded && valid_key) ? RESULT_OK : RESULT_HANDSHAKE_FAILED;
+    delete conn->m_HandshakeResponse;
+    conn->m_HandshakeResponse = 0;
+
+    // The response might contain both the headers, but also (if successful) the first batch of data
+    uint32_t size = conn->m_BufferSize - (start_of_payload - conn->m_Buffer);
+    conn->m_BufferSize = size;
+    memmove(conn->m_Buffer, start_of_payload, size);
+    conn->m_Buffer[size] = 0;
+    conn->m_HasHandshakeData = conn->m_BufferSize != 0 ? 1 : 0;
+    return RESULT_OK;
 }
 #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,21 @@
 #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
+#include <emscripten/websocket.h>
+#endif
+
+#if defined(WIN32)
+#include <malloc.h>
+#define alloca _alloca
 #endif
 
 namespace dmWebsocket {
 
+int g_DebugWebSocket = 0;
 
 struct WebsocketContext
 {
@@ -28,9 +36,6 @@ struct WebsocketContext
 } g_Websocket;
 
 
-static void HandleCallback(WebsocketConnection* conn, int event);
-
-
 #define STRING_CASE(_X) case _X: return #_X;
 
 const char* ResultToString(Result err)
@@ -49,10 +54,12 @@ const char* ResultToString(Result err)
 const char* StateToString(State err)
 {
     switch(err) {
+        STRING_CASE(STATE_CREATE);
         STRING_CASE(STATE_CONNECTING);
         STRING_CASE(STATE_HANDSHAKE_WRITE);
         STRING_CASE(STATE_HANDSHAKE_READ);
         STRING_CASE(STATE_CONNECTED);
+        STRING_CASE(STATE_DISCONNECTING);
         STRING_CASE(STATE_DISCONNECTED);
         default: return "Unknown error";
     };
@@ -60,21 +67,85 @@ 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__); \
     CloseConnection(conn);
 
 
-static void SetState(WebsocketConnection* conn, State state)
+void SetState(WebsocketConnection* conn, State state)
 {
     State prev_state = conn->m_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;
 }
@@ -96,23 +169,37 @@ Result SetStatus(WebsocketConnection* conn, Result status, const char* format, .
 // ***************************************************************************************************
 // LUA functions
 
-
-
 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);
 
     if (strcmp(conn->m_Url.m_Scheme, "https") == 0)
         strcpy(conn->m_Url.m_Scheme, "wss");
 
     conn->m_SSL = strcmp(conn->m_Url.m_Scheme, "wss") == 0 ? 1 : 0;
-    conn->m_State = STATE_CONNECTING;
+    conn->m_State = STATE_CREATE;
+
+    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_HandshakeResponse = 0;
+
+#if defined(HAVE_WSLAY)
+    conn->m_Ctx = 0;
+#endif
+#if defined(__EMSCRIPTEN__)
+    conn->m_WS = 0;
+#endif
 
     return conn;
 }
@@ -124,47 +211,63 @@ 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);
 
 #if defined(__EMSCRIPTEN__)
-    if (conn->m_Socket != dmSocket::INVALID_SOCKET_HANDLE) {
+    if (conn->m_WS)
-        // We would normally do a shutdown() first, but Emscripten returns ENOSYS
+    {
-        //dmSocket::Shutdown(conn->m_Socket, dmSocket::SHUTDOWNTYPE_READWRITE);
+        emscripten_websocket_delete(conn->m_WS);
-        dmSocket::Delete(conn->m_Socket);
     }
 #else
     if (conn->m_Connection)
-        dmConnectionPool::Return(g_Websocket.m_Pool, conn->m_Connection);
+        dmConnectionPool::Close(g_Websocket.m_Pool, conn->m_Connection);
 #endif
 
+    if (conn->m_HandshakeResponse)
+        delete conn->m_HandshakeResponse;
+
+
     free((void*)conn->m_Buffer);
-    free((void*)conn);
+    delete conn;
+    DebugLog(2, "DestroyConnection: %p", conn);
 }
 
 
 static void CloseConnection(WebsocketConnection* conn)
 {
-    State prev_state = conn->m_State;
-
     // 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
+        // Emscripten callback that the connection has closed
+        emscripten_websocket_close(conn->m_WS, 1000, "CloseConnection");
+        SetState(conn, STATE_DISCONNECTING);
 #endif
     }
 
-    SetState(conn, STATE_DISCONNECTED);
 }
 
-static int FindConnection(WebsocketConnection* conn)
+static bool IsConnectionValid(WebsocketConnection* conn)
 {
-    for (int i = 0; i < g_Websocket.m_Connections.Size(); ++i )
+    if (conn)
     {
-        if (g_Websocket.m_Connections[i] == conn)
+        for (int i = 0; i < g_Websocket.m_Connections.Size(); ++i )
-            return i;
+        {
+            if (g_Websocket.m_Connections[i] == conn)
+                return true;
+        }
     }
-    return -1;
+    return false;
 }
 
 /*#
@@ -178,13 +281,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);
 
@@ -208,8 +320,7 @@ static int LuaDisconnect(lua_State* L)
 
     WebsocketConnection* conn = (WebsocketConnection*)lua_touserdata(L, 1);
 
-    int i = FindConnection(conn);
+    if (IsConnectionValid(conn))
-    if (i != -1)
     {
         CloseConnection(conn);
     }
@@ -228,8 +339,7 @@ static int LuaSend(lua_State* L)
 
     WebsocketConnection* conn = (WebsocketConnection*)lua_touserdata(L, 1);
 
-    int i = FindConnection(conn);
+    if (!IsConnectionValid(conn))
-    if (i == -1)
         return DM_LUA_ERROR("Invalid connection");
 
     if (conn->m_State != STATE_CONNECTED)
@@ -239,7 +349,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;
@@ -248,9 +358,17 @@ static int LuaSend(lua_State* L)
 
     wslay_event_queue_msg(conn->m_Ctx, &msg); // it makes a copy of the data
 #else
-
+    EMSCRIPTEN_RESULT result;
-    dmSocket::Result sr = Send(conn, string, string_length, 0);
+    int write_mode = dmScript::CheckTableNumber(L, 3, "type", DATA_TYPE_BINARY);
-    if (dmSocket::RESULT_OK != sr)
+    if (write_mode == DATA_TYPE_BINARY)
+    {
+        result = emscripten_websocket_send_binary(conn->m_WS, (void*)string, string_length);
+    }
+    else
+    {
+        result = emscripten_websocket_send_utf8_text(conn->m_WS, string);
+    }
+    if (result)
     {
         CLOSE_CONN("Failed to send on websocket");
     }
@@ -259,7 +377,7 @@ static int LuaSend(lua_State* L)
     return 0;
 }
 
-static void HandleCallback(WebsocketConnection* conn, int event)
+void HandleCallback(WebsocketConnection* conn, int event, int msg_offset, int msg_length)
 {
     if (!dmScript::IsCallbackValid(conn->m_Callback))
         return;
@@ -280,13 +398,33 @@ 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");
+
-    }
+    if(conn->m_HandshakeResponse)
-    else if (EVENT_MESSAGE == event) {
+    {
-        lua_pushlstring(L, conn->m_Buffer, conn->m_BufferSize);
+        HandshakeResponse* response = conn->m_HandshakeResponse;
-        lua_setfield(L, -2, "message");
+
+        lua_newtable(L);
+
+        lua_pushnumber(L, response->m_ResponseStatusCode);
+        lua_setfield(L, -2, "status");
+
+        lua_pushstring(L, &conn->m_Buffer[response->m_BodyOffset]);
+        lua_setfield(L, -2, "response");
+
+        lua_newtable(L);
+        for (uint32_t i = 0; i < response->m_Headers.Size(); ++i)
+        {
+            lua_pushstring(L, response->m_Headers[i]->m_Value);
+            lua_setfield(L, -2, response->m_Headers[i]->m_Key);
+        }
+        lua_setfield(L, -2, "headers");
+
+        lua_setfield(L, -2, "handshake_response");
+
+        delete conn->m_HandshakeResponse;
+        conn->m_HandshakeResponse = 0;
     }
 
     dmScript::PCall(L, 3, 0);
@@ -295,6 +433,42 @@ static void HandleCallback(WebsocketConnection* conn, int event)
 }
 
 
+HttpHeader::HttpHeader(const char* key, const char* value)
+{
+    m_Key = strdup(key);
+    m_Value = strdup(value);
+}
+
+HttpHeader::~HttpHeader()
+{
+    free((void*)m_Key);
+    free((void*)m_Value);
+    m_Key = 0;
+    m_Value = 0;
+}
+
+HttpHeader* HandshakeResponse::GetHeader(const char* header_key)
+{
+    for(uint32_t i = 0; i < m_Headers.Size(); ++i)
+    {
+        if (dmStrCaseCmp(m_Headers[i]->m_Key, header_key) == 0)
+        {
+            return m_Headers[i];
+        }
+    }
+
+    return 0;
+}
+
+HandshakeResponse::~HandshakeResponse()
+{
+    for(uint32_t i = 0; i < m_Headers.Size(); ++i)
+    {
+        delete m_Headers[i];
+    }
+}
+
+
 // ***************************************************************************************************
 // Life cycle functions
 
@@ -315,13 +489,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 +513,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 +525,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);
@@ -356,14 +544,6 @@ static dmExtension::Result WebsocketAppInitialize(dmExtension::AppParams* params
     }
 #endif
 
-#if defined(__EMSCRIPTEN__)
-    // avoid mixed content warning if trying to access wss resource from http page
-    // If not using this, we get EHOSTUNREACH
-    EM_ASM({
-        Module["websocket"].url = window["location"]["protocol"].replace("http", "ws") + "//";
-    });
-#endif
-
     g_Websocket.m_Initialized = 1;
     if (!g_Websocket.m_Pool)
     {
@@ -380,7 +560,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 +571,58 @@ 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)
 {
+    while (!g_Websocket.m_Connections.Empty())
+    {
+        WebsocketConnection* conn = g_Websocket.m_Connections.Back();
+        g_Websocket.m_Connections.Pop();
+        DestroyConnection(conn);
+    }
     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);
+
+    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 +634,11 @@ 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);
+            HandleCallback(conn, EVENT_DISCONNECTED, 0, conn->m_BufferSize);
 
             g_Websocket.m_Connections.EraseSwap(i);
             --i;
@@ -434,42 +654,44 @@ 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);
-            if( sr == dmSocket::RESULT_WOULDBLOCK )
-            {
-                continue;
-            }
-
-            if (dmSocket::RESULT_OK == sr)
-            {
-                conn->m_BufferSize += recv_bytes;
-                conn->m_Buffer[conn->m_BufferCapacity-1] = 0;
-                conn->m_HasMessage = 1;
-            }
-            else
-            {
-                CLOSE_CONN("Websocket failed to receive data %s", dmSocket::ResultToString(sr));
-                continue;
-            }
 #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 +704,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)
             {
@@ -502,17 +725,20 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
             dmSocket::SetReceiveTimeout(conn->m_Socket, 1000);
             if (conn->m_SSLSocket)
                 dmSSLSocket::SetReceiveTimeout(conn->m_SSLSocket, 1000);
-#endif
+
             dmSocket::SetBlocking(conn->m_Socket, false);
-
+#endif
-            conn->m_Buffer[0] = 0;
-            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)
             {
@@ -526,38 +752,54 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
 
             SetState(conn, STATE_HANDSHAKE_READ);
         }
-        else if (STATE_CONNECTING == conn->m_State)
+        else if (STATE_CREATE == conn->m_State)
         {
-#if defined(__EMSCRIPTEN__)
+            if (CheckConnectTimeout(conn))
-            conn->m_SSLSocket = dmSSLSocket::INVALID_SOCKET_HANDLE;
+            {
+                CLOSE_CONN("Connect sequence timed out");
+                continue;
+            }
 
+#if defined(__EMSCRIPTEN__)
             char uri_buffer[dmURI::MAX_URI_LEN];
             const char* uri;
-            if (conn->m_Url.m_Path[0] != '\0') {
+            bool no_path = conn->m_Url.m_Path[0] == '\0';
-                dmSnPrintf(uri_buffer, sizeof(uri_buffer), "%s%s", conn->m_Url.m_Hostname, conn->m_Url.m_Path);
+            bool no_port = conn->m_Url.m_Port == -1;
-                uri = uri_buffer;
+            if (no_path && no_port)
-            } else {
+            {
-                uri = conn->m_Url.m_Hostname;
+                dmSnPrintf(uri_buffer, sizeof(uri_buffer), "%s://%s", conn->m_Url.m_Scheme, conn->m_Url.m_Hostname);
             }
+            else if (no_port)
+            {
+                dmSnPrintf(uri_buffer, sizeof(uri_buffer), "%s://%s%s", conn->m_Url.m_Scheme, conn->m_Url.m_Hostname, conn->m_Url.m_Path);
+            }
+            else if (no_path)
+            {
+                dmSnPrintf(uri_buffer, sizeof(uri_buffer), "%s://%s:%d", conn->m_Url.m_Scheme, conn->m_Url.m_Hostname, conn->m_Url.m_Port);
+            }
+            else {
+                dmSnPrintf(uri_buffer, sizeof(uri_buffer), "%s://%s:%d%s", conn->m_Url.m_Scheme, conn->m_Url.m_Hostname, conn->m_Url.m_Port, conn->m_Url.m_Path);
+            }
+            uri = uri_buffer;
 
-            dmSocket::Address address;
+            EmscriptenWebSocketCreateAttributes ws_attrs = {
-            dmSocket::Result sr = dmSocket::GetHostByName(uri, &address, true, false);
+                uri,
-            if (dmSocket::RESULT_OK != sr) {
+                conn->m_Protocol,
-                CLOSE_CONN("Failed to get address from host name '%s': %s", uri, dmSocket::ResultToString(sr));
+                EM_TRUE
+            };
+            EMSCRIPTEN_WEBSOCKET_T ws = emscripten_websocket_new(&ws_attrs);
+            if (ws < 0)
+            {
+                CLOSE_CONN("Failed to connect to '%s:%d': %d", conn->m_Url.m_Hostname, (int)conn->m_Url.m_Port, ws);
                 continue;
             }
+            conn->m_WS = ws;
 
-            sr = dmSocket::New(address.m_family, dmSocket::TYPE_STREAM, dmSocket::PROTOCOL_TCP, &conn->m_Socket);
+            emscripten_websocket_set_onopen_callback(ws, conn, Emscripten_WebSocketOnOpen);
-            if (dmSocket::RESULT_OK != sr) {
+            emscripten_websocket_set_onerror_callback(ws, conn, Emscripten_WebSocketOnError);
-                CLOSE_CONN("Failed to create socket for '%s': %s", conn->m_Url.m_Hostname, dmSocket::ResultToString(sr));
+            emscripten_websocket_set_onclose_callback(ws, conn, Emscripten_WebSocketOnClose);
-                continue;
+            emscripten_websocket_set_onmessage_callback(ws, conn, Emscripten_WebSocketOnMessage);
-            }
+            SetState(conn, STATE_CONNECTING);
-
-            sr = dmSocket::Connect(conn->m_Socket, address, conn->m_Url.m_Port);
-            if (dmSocket::RESULT_OK != sr) {
-                CLOSE_CONN("Failed to connect to '%s:%d': %s", conn->m_Url.m_Hostname, (int)conn->m_Url.m_Port, dmSocket::ResultToString(sr));
-                continue;
-            }
 #else
             dmSocket::Result sr;
             int timeout = g_Websocket.m_Timeout;
@@ -569,9 +811,16 @@ static dmExtension::Result WebsocketOnUpdate(dmExtension::Params* params)
             }
             conn->m_Socket = dmConnectionPool::GetSocket(g_Websocket.m_Pool, conn->m_Connection);
             conn->m_SSLSocket = dmConnectionPool::GetSSLSocket(g_Websocket.m_Pool, conn->m_Connection);
-#endif
-
             SetState(conn, STATE_HANDSHAKE_WRITE);
+#endif
+        }
+        else if (STATE_CONNECTING == conn->m_State)
+        {
+            if (CheckConnectTimeout(conn))
+            {
+                CLOSE_CONN("Connect sequence timed out");
+                continue;
+            }
         }
     }
 
@@ -580,6 +829,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

@@ -13,12 +13,17 @@
 
 #if defined(HAVE_WSLAY)
     #include <wslay/wslay.h>
+    #endif
+
+#if defined(__EMSCRIPTEN__)
+#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>
 
 namespace dmCrypt
 {
@@ -34,10 +39,12 @@ namespace dmWebsocket
 
     enum State
     {
+        STATE_CREATE,
         STATE_CONNECTING,
         STATE_HANDSHAKE_WRITE,
         STATE_HANDSHAKE_READ,
         STATE_CONNECTED,
+        STATE_DISCONNECTING,
         STATE_DISCONNECTED,
     };
 
@@ -59,24 +66,72 @@ 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 HttpHeader
+    {
+        const char* m_Key;
+        const char* m_Value;
+        HttpHeader(const char* key, const char* value);
+        ~HttpHeader();
+    };
+
+    struct HandshakeResponse
+    {
+        int m_HttpMajor;
+        int m_HttpMinor;
+        int m_ResponseStatusCode;
+        int m_BodyOffset;
+        dmArray<HttpHeader*> m_Headers;
+
+        ~HandshakeResponse();
+        HttpHeader* GetHeader(const char* header);
+    };
+
+
     struct WebsocketConnection
     {
         dmScript::LuaCallbackInfo*      m_Callback;
 #if defined(HAVE_WSLAY)
         wslay_event_context_ptr         m_Ctx;
+#endif
+#if defined(__EMSCRIPTEN__)
+        EMSCRIPTEN_WEBSOCKET_T          m_WS;
 #endif
         dmURI::Parts                    m_Url;
         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                         :7;
+        HandshakeResponse*              m_HandshakeResponse;
     };
 
     // Set error message
@@ -86,6 +141,9 @@ namespace dmWebsocket
     Result SetStatus(WebsocketConnection* conn, Result status, const char* fmt, ...);
 #endif
 
+    // Set socket state
+    void SetState(WebsocketConnection* conn, State state);
+
     // Communication
     dmSocket::Result Send(WebsocketConnection* conn, const char* buffer, int length, int* out_sent_bytes);
     dmSocket::Result Receive(WebsocketConnection* conn, void* buffer, int length, int* received_bytes);
@@ -96,33 +154,41 @@ namespace dmWebsocket
     Result ReceiveHeaders(WebsocketConnection* conn);
     Result VerifyHeaders(WebsocketConnection* conn);
 
+    // Callback to Lua
+    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);
+
 #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);
     int     WSL_GenmaskCallback(wslay_event_context_ptr ctx, uint8_t *buf, size_t len, void *user_data);
     const char* WSL_ResultToString(int err);
 #endif
+#if defined(__EMSCRIPTEN__)
+    EM_BOOL Emscripten_WebSocketOnOpen(int eventType, const EmscriptenWebSocketOpenEvent *websocketEvent, void *userData);
+    EM_BOOL Emscripten_WebSocketOnError(int eventType, const EmscriptenWebSocketErrorEvent *websocketEvent, void *userData);
+    EM_BOOL Emscripten_WebSocketOnClose(int eventType, const EmscriptenWebSocketCloseEvent *websocketEvent, void *userData);
+    EM_BOOL Emscripten_WebSocketOnMessage(int eventType, const EmscriptenWebSocketMessageEvent *websocketEvent, void *userData);
+#endif
 
     // Random numbers (PCG)
     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);
+
     }
 }