mirror of
https://github.com/defold/extension-websocket.git
synced 2025-06-26 17:47:42 +02:00
Use the Emscripten websocket library instead of POSIX socket emulation (#33)
* Switched to direct javascript websockets * Skip the null termination on text messages when pushing * Moved Emscripten callbacks and some other PR improvements * STATE_CONNECT -> STATE_CREATE * Changed disconnect logic * Review feedback
This commit is contained in:
Björn Ritzl
GitHub
parent
b3afb9a276
commit
efe9115413
@ -14,4 +14,3 @@ _dependencies = https://github.com/GameAnalytics/defold-openssl/archive/1.0.0.zi
|
||||
|
||||
[library]
|
||||
include_dirs = websocket
|
||||
|
||||
|
||||
136
websocket/include/emscripten/websocket.h
Normal file
136
websocket/include/emscripten/websocket.h
Normal file
@ -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
|
||||
448
websocket/lib/web/library_websocket.js
Normal file
448
websocket/lib/web/library_websocket.js
Normal file
@ -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);
|
||||
42
websocket/src/emscripten_callbacks.cpp
Normal file
42
websocket/src/emscripten_callbacks.cpp
Normal file
@ -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__
|
||||
@ -13,6 +13,7 @@
|
||||
|
||||
#if defined(__EMSCRIPTEN__)
|
||||
#include <emscripten/emscripten.h> // for EM_ASM
|
||||
#include <emscripten/websocket.h>
|
||||
#endif
|
||||
|
||||
#if defined(WIN32)
|
||||
@ -53,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";
|
||||
};
|
||||
@ -136,7 +139,7 @@ void DebugPrint(int level, const char* msg, const void* _bytes, uint32_t num_byt
|
||||
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)
|
||||
@ -166,8 +169,6 @@ Result SetStatus(WebsocketConnection* conn, Result status, const char* format, .
|
||||
// ***************************************************************************************************
|
||||
// LUA functions
|
||||
|
||||
|
||||
|
||||
static WebsocketConnection* CreateConnection(const char* url)
|
||||
{
|
||||
WebsocketConnection* conn = new WebsocketConnection;
|
||||
@ -183,7 +184,7 @@ static WebsocketConnection* CreateConnection(const char* url)
|
||||
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;
|
||||
@ -196,6 +197,9 @@ static WebsocketConnection* CreateConnection(const char* url)
|
||||
#if defined(HAVE_WSLAY)
|
||||
conn->m_Ctx = 0;
|
||||
#endif
|
||||
#if defined(__EMSCRIPTEN__)
|
||||
conn->m_WS = 0;
|
||||
#endif
|
||||
|
||||
return conn;
|
||||
}
|
||||
@ -214,10 +218,9 @@ static void DestroyConnection(WebsocketConnection* conn)
|
||||
dmScript::DestroyCallback(conn->m_Callback);
|
||||
|
||||
#if defined(__EMSCRIPTEN__)
|
||||
if (conn->m_Socket != dmSocket::INVALID_SOCKET_HANDLE) {
|
||||
// We would normally do a shutdown() first, but Emscripten returns ENOSYS
|
||||
//dmSocket::Shutdown(conn->m_Socket, dmSocket::SHUTDOWNTYPE_READWRITE);
|
||||
dmSocket::Delete(conn->m_Socket);
|
||||
if (conn->m_WS)
|
||||
{
|
||||
emscripten_websocket_delete(conn->m_WS);
|
||||
}
|
||||
#else
|
||||
if (conn->m_Connection)
|
||||
@ -239,21 +242,32 @@ 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
|
||||
// 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)
|
||||
return i;
|
||||
for (int i = 0; i < g_Websocket.m_Connections.Size(); ++i )
|
||||
{
|
||||
if (g_Websocket.m_Connections[i] == conn)
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
return false;
|
||||
}
|
||||
|
||||
/*#
|
||||
@ -306,8 +320,7 @@ static int LuaDisconnect(lua_State* L)
|
||||
|
||||
WebsocketConnection* conn = (WebsocketConnection*)lua_touserdata(L, 1);
|
||||
|
||||
int i = FindConnection(conn);
|
||||
if (i != -1)
|
||||
if (IsConnectionValid(conn))
|
||||
{
|
||||
CloseConnection(conn);
|
||||
}
|
||||
@ -326,8 +339,7 @@ static int LuaSend(lua_State* L)
|
||||
|
||||
WebsocketConnection* conn = (WebsocketConnection*)lua_touserdata(L, 1);
|
||||
|
||||
int i = FindConnection(conn);
|
||||
if (i == -1)
|
||||
if (!IsConnectionValid(conn))
|
||||
return DM_LUA_ERROR("Invalid connection");
|
||||
|
||||
if (conn->m_State != STATE_CONNECTED)
|
||||
@ -346,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
|
||||
|
||||
dmSocket::Result sr = Send(conn, string, string_length, 0);
|
||||
if (dmSocket::RESULT_OK != sr)
|
||||
EMSCRIPTEN_RESULT result;
|
||||
int write_mode = dmScript::CheckTableNumber(L, 3, "type", DATA_TYPE_BINARY);
|
||||
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");
|
||||
}
|
||||
@ -357,7 +377,7 @@ static int LuaSend(lua_State* L)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void HandleCallback(WebsocketConnection* conn, int event, int msg_offset, int msg_length)
|
||||
void HandleCallback(WebsocketConnection* conn, int event, int msg_offset, int msg_length)
|
||||
{
|
||||
if (!dmScript::IsCallbackValid(conn->m_Callback))
|
||||
return;
|
||||
@ -524,14 +544,6 @@ static dmExtension::Result AppInitialize(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)
|
||||
{
|
||||
@ -561,7 +573,6 @@ static dmExtension::Result Initialize(dmExtension::Params* params)
|
||||
|
||||
static dmExtension::Result AppFinalize(dmExtension::AppParams* params)
|
||||
{
|
||||
|
||||
dmConnectionPool::Shutdown(g_Websocket.m_Pool, dmSocket::SHUTDOWNTYPE_READWRITE);
|
||||
return dmExtension::RESULT_OK;
|
||||
}
|
||||
@ -587,17 +598,13 @@ Result PushMessage(WebsocketConnection* conn, MessageType type, int length, cons
|
||||
msg.m_Length = length;
|
||||
conn->m_Messages.Push(msg);
|
||||
|
||||
// No need to copy itself (html5)
|
||||
if (buffer != (const uint8_t*)conn->m_Buffer)
|
||||
if ((conn->m_BufferSize + length) >= conn->m_BufferCapacity)
|
||||
{
|
||||
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_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;
|
||||
@ -647,23 +654,6 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
|
||||
CLOSE_CONN("Websocket closing for %s (%s)", conn->m_Url.m_Hostname, WSL_ResultToString(r));
|
||||
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)
|
||||
{
|
||||
PushMessage(conn, MESSAGE_TYPE_NORMAL, recv_bytes, (const uint8_t*)conn->m_Buffer);
|
||||
}
|
||||
else
|
||||
{
|
||||
CLOSE_CONN("Websocket failed to receive data %s", dmSocket::ResultToString(sr));
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
|
||||
uint32_t offset = 0;
|
||||
@ -735,9 +725,9 @@ static dmExtension::Result OnUpdate(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);
|
||||
|
||||
dmSocket::SetBlocking(conn->m_Socket, false);
|
||||
#endif
|
||||
SetState(conn, STATE_CONNECTED);
|
||||
HandleCallback(conn, EVENT_CONNECTED, 0, 0);
|
||||
}
|
||||
@ -762,7 +752,7 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
|
||||
|
||||
SetState(conn, STATE_HANDSHAKE_READ);
|
||||
}
|
||||
else if (STATE_CONNECTING == conn->m_State)
|
||||
else if (STATE_CREATE == conn->m_State)
|
||||
{
|
||||
if (CheckConnectTimeout(conn))
|
||||
{
|
||||
@ -771,40 +761,33 @@ static dmExtension::Result OnUpdate(dmExtension::Params* params)
|
||||
}
|
||||
|
||||
#if defined(__EMSCRIPTEN__)
|
||||
conn->m_SSLSocket = dmSSLSocket::INVALID_SOCKET_HANDLE;
|
||||
|
||||
EM_ASM({
|
||||
// https://emscripten.org/docs/porting/networking.html#emulated-posix-tcp-sockets-over-websockets
|
||||
Module["websocket"]["subprotocol"] = $0 ? UTF8ToString($0) : null;
|
||||
}, conn->m_Protocol);
|
||||
|
||||
char uri_buffer[dmURI::MAX_URI_LEN];
|
||||
const char* uri;
|
||||
if (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);
|
||||
uri = uri_buffer;
|
||||
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 {
|
||||
uri = conn->m_Url.m_Hostname;
|
||||
dmSnPrintf(uri_buffer, sizeof(uri_buffer), "%s://%s", conn->m_Url.m_Scheme, conn->m_Url.m_Hostname);
|
||||
}
|
||||
uri = uri_buffer;
|
||||
|
||||
dmSocket::Address address;
|
||||
dmSocket::Result sr = dmSocket::GetHostByName(uri, &address, true, false);
|
||||
if (dmSocket::RESULT_OK != sr) {
|
||||
CLOSE_CONN("Failed to get address from host name '%s': %s", uri, dmSocket::ResultToString(sr));
|
||||
EmscriptenWebSocketCreateAttributes ws_attrs = {
|
||||
uri,
|
||||
conn->m_Protocol,
|
||||
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);
|
||||
if (dmSocket::RESULT_OK != sr) {
|
||||
CLOSE_CONN("Failed to create socket for '%s': %s", conn->m_Url.m_Hostname, dmSocket::ResultToString(sr));
|
||||
continue;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
emscripten_websocket_set_onopen_callback(ws, conn, Emscripten_WebSocketOnOpen);
|
||||
emscripten_websocket_set_onerror_callback(ws, conn, Emscripten_WebSocketOnError);
|
||||
emscripten_websocket_set_onclose_callback(ws, conn, Emscripten_WebSocketOnClose);
|
||||
emscripten_websocket_set_onmessage_callback(ws, conn, Emscripten_WebSocketOnMessage);
|
||||
SetState(conn, STATE_CONNECTING);
|
||||
#else
|
||||
dmSocket::Result sr;
|
||||
int timeout = g_Websocket.m_Timeout;
|
||||
@ -816,9 +799,16 @@ static dmExtension::Result OnUpdate(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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -13,6 +13,10 @@
|
||||
|
||||
#if defined(HAVE_WSLAY)
|
||||
#include <wslay/wslay.h>
|
||||
#endif
|
||||
|
||||
#if defined(__EMSCRIPTEN__)
|
||||
#include "emscripten/websocket.h"
|
||||
#endif
|
||||
|
||||
#include <dmsdk/dlib/connection_pool.h>
|
||||
@ -35,10 +39,12 @@ namespace dmWebsocket
|
||||
|
||||
enum State
|
||||
{
|
||||
STATE_CREATE,
|
||||
STATE_CONNECTING,
|
||||
STATE_HANDSHAKE_WRITE,
|
||||
STATE_HANDSHAKE_READ,
|
||||
STATE_CONNECTED,
|
||||
STATE_DISCONNECTING,
|
||||
STATE_DISCONNECTED,
|
||||
};
|
||||
|
||||
@ -104,6 +110,9 @@ namespace dmWebsocket
|
||||
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;
|
||||
@ -132,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);
|
||||
@ -142,6 +154,9 @@ 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);
|
||||
|
||||
@ -157,6 +172,12 @@ namespace dmWebsocket
|
||||
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;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user