forked from cory/tildefriends
Cory McWilliams
5d5ff121f9
git-svn-id: https://www.unprompted.com/svn/projects/tildefriends/trunk@4144 ed5197a5-7fde-0310-b194-c3ffbd925b24
1122 lines
35 KiB
C
1122 lines
35 KiB
C
#include "socket.js.h"
|
|
|
|
#include "mem.h"
|
|
#include "task.h"
|
|
#include "tls.h"
|
|
#include "tlscontext.js.h"
|
|
#include "util.js.h"
|
|
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <uv.h>
|
|
|
|
#include "quickjs-libc.h"
|
|
|
|
typedef int promiseid_t;
|
|
typedef struct _socket_t socket_t;
|
|
|
|
static JSClassID _classId;
|
|
static int _count;
|
|
static int _open_count;
|
|
static tf_tls_context_t* _defaultTlsContext;
|
|
|
|
static socket_t** _sockets;
|
|
static int _sockets_count;
|
|
|
|
typedef enum _socket_direction_t {
|
|
kUndetermined,
|
|
kAccept,
|
|
kConnect,
|
|
} socket_direction_t;
|
|
|
|
typedef struct _socket_t {
|
|
tf_task_t* _task;
|
|
uv_tcp_t _socket;
|
|
tf_tls_session_t* _tls;
|
|
promiseid_t _startTlsPromise;
|
|
promiseid_t _closePromise;
|
|
bool _connected;
|
|
bool _noDelay;
|
|
bool _reading;
|
|
bool _listening;
|
|
char _peerName[256];
|
|
socket_direction_t _direction;
|
|
JSValue _object;
|
|
JSValue _onConnect;
|
|
JSValue _onRead;
|
|
JSValue _onError;
|
|
JSValue _info;
|
|
uint64_t created_ms;
|
|
} socket_t;
|
|
|
|
static JSValue _socket_create(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static void _socket_finalizer(JSRuntime *runtime, JSValue value);
|
|
|
|
static JSValue _socket_startTls(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_stopTls(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_bind(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_connect(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_listen(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_accept(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_close(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_shutdown(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_read(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_onError(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_write(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_isConnected(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_getPeerName(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_getPeerCertificate(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_getNoDelay(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_setNoDelay(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _socket_setInfo(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
static JSValue _sockets_get(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv);
|
|
|
|
static void _socket_onClose(uv_handle_t* handle);
|
|
static void _socket_onShutdown(uv_shutdown_t* request, int status);
|
|
static void _socket_onResolvedForBind(uv_getaddrinfo_t* resolver, int status, struct addrinfo* result);
|
|
static void _socket_onResolvedForConnect(uv_getaddrinfo_t* resolver, int status, struct addrinfo* result);
|
|
static void _socket_onConnect(uv_connect_t* request, int status);
|
|
static void _socket_onNewConnection(uv_stream_t* server, int status);
|
|
static void _socket_allocateBuffer(uv_handle_t* handle, size_t suggestedSize, uv_buf_t* buffer);
|
|
static void _socket_onRead(uv_stream_t* stream, ssize_t readSize, const uv_buf_t* buffer);
|
|
static void _socket_onWrite(uv_write_t* request, int status);
|
|
static void _socket_onTlsShutdown(uv_write_t* request, int status);
|
|
|
|
static void _socket_notifyDataRead(socket_t* socket, const char* data, size_t length);
|
|
static int _socket_writeBytes(socket_t* socket, promiseid_t promise, int (*callback)(socket_t* socket, promiseid_t promise, const char*, size_t), JSValue value, int* outLength);
|
|
static int _socket_writeInternal(socket_t* socket, promiseid_t promise, const char* data, size_t length);
|
|
static void _socket_processTlsShutdown(socket_t* socket, promiseid_t promise);
|
|
static void _socket_shutdownInternal(socket_t* socket, promiseid_t promise);
|
|
static bool _socket_processSomeOutgoingTls(socket_t* socket, promiseid_t promise, uv_write_cb callback);
|
|
static void _socket_processOutgoingTls(socket_t* socket);
|
|
static void _socket_reportTlsErrors(socket_t* socket);
|
|
static void _socket_reportError(socket_t* socket, const char* error);
|
|
|
|
static void _socket_set_handler(socket_t* socket, JSValue* handler, JSValue new_value)
|
|
{
|
|
JSContext* context = tf_task_get_context(socket->_task);
|
|
|
|
JSValue old_handler = *handler;
|
|
|
|
if (JS_IsUndefined(old_handler) && !JS_IsUndefined(new_value))
|
|
{
|
|
JS_DupValue(context, socket->_object);
|
|
}
|
|
|
|
*handler = JS_DupValue(context, new_value);
|
|
|
|
JS_FreeValue(context, old_handler);
|
|
|
|
if (!JS_IsUndefined(old_handler) && JS_IsUndefined(new_value))
|
|
{
|
|
JS_FreeValue(context, socket->_object);
|
|
}
|
|
}
|
|
|
|
static void _socket_gc_mark(JSRuntime* runtime, JSValueConst value, JS_MarkFunc mark_func)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(value, _classId);
|
|
if (socket)
|
|
{
|
|
JS_MarkValue(runtime, socket->_onConnect, mark_func);
|
|
JS_MarkValue(runtime, socket->_onRead, mark_func);
|
|
JS_MarkValue(runtime, socket->_onError, mark_func);
|
|
JS_MarkValue(runtime, socket->_info, mark_func);
|
|
}
|
|
}
|
|
|
|
JSValue tf_socket_register(JSContext* context)
|
|
{
|
|
JS_NewClassID(&_classId);
|
|
JSClassDef def = {
|
|
.class_name = "Socket",
|
|
.finalizer = &_socket_finalizer,
|
|
.gc_mark = _socket_gc_mark,
|
|
};
|
|
if (JS_NewClass(JS_GetRuntime(context), _classId, &def) != 0)
|
|
{
|
|
fprintf(stderr, "Failed to register Socket.\n");
|
|
}
|
|
|
|
JSValue global = JS_GetGlobalObject(context);
|
|
JS_SetPropertyStr(context, global, "getSockets", JS_NewCFunction(context, _sockets_get, "getSockets", 0));
|
|
JS_FreeValue(context, global);
|
|
return JS_NewCFunction2(context, _socket_create, "Socket", 0, JS_CFUNC_constructor, 0);
|
|
}
|
|
|
|
int tf_socket_get_count()
|
|
{
|
|
return _count;
|
|
}
|
|
|
|
int tf_socket_get_open_count()
|
|
{
|
|
return _open_count;
|
|
}
|
|
|
|
typedef struct _socket_resolve_data_t {
|
|
uv_getaddrinfo_t resolver;
|
|
socket_t* socket;
|
|
promiseid_t promise;
|
|
} socket_resolve_data_t;
|
|
|
|
socket_t* _socket_create_internal(JSContext* context)
|
|
{
|
|
socket_t* socket = tf_malloc(sizeof(socket_t));
|
|
memset(socket, 0, sizeof(*socket));
|
|
_sockets = tf_realloc(_sockets, sizeof(socket_t*) * (_sockets_count + 1));
|
|
_sockets[_sockets_count++] = socket;
|
|
|
|
socket->_closePromise = -1;
|
|
socket->_startTlsPromise = -1;
|
|
|
|
++_count;
|
|
JSValue object = JS_NewObjectClass(context, _classId);
|
|
socket->_task = tf_task_get(context);
|
|
socket->_object = object;
|
|
JS_SetOpaque(object, socket);
|
|
|
|
socket->created_ms = uv_now(tf_task_get_loop(socket->_task));
|
|
|
|
socket->_onRead = JS_UNDEFINED;
|
|
socket->_onError = JS_UNDEFINED;
|
|
socket->_onConnect = JS_UNDEFINED;
|
|
|
|
JS_SetPropertyStr(context, object, "bind", JS_NewCFunction(context, _socket_bind, "bind", 2));
|
|
JS_SetPropertyStr(context, object, "connect", JS_NewCFunction(context, _socket_connect, "connect", 2));
|
|
JS_SetPropertyStr(context, object, "listen", JS_NewCFunction(context, _socket_listen, "listen", 2));
|
|
JS_SetPropertyStr(context, object, "accept", JS_NewCFunction(context, _socket_accept, "accept", 0));
|
|
JS_SetPropertyStr(context, object, "startTls", JS_NewCFunction(context, _socket_startTls, "startTls", 0));
|
|
JS_SetPropertyStr(context, object, "stopTls", JS_NewCFunction(context, _socket_stopTls, "stopTls", 0));
|
|
JS_SetPropertyStr(context, object, "shutdown", JS_NewCFunction(context, _socket_shutdown, "shutdown", 0));
|
|
JS_SetPropertyStr(context, object, "close", JS_NewCFunction(context, _socket_close, "close", 0));
|
|
JS_SetPropertyStr(context, object, "read", JS_NewCFunction(context, _socket_read, "read", 0));
|
|
JS_SetPropertyStr(context, object, "onError", JS_NewCFunction(context, _socket_onError, "onError", 1));
|
|
JS_SetPropertyStr(context, object, "write", JS_NewCFunction(context, _socket_write, "write", 1));
|
|
|
|
JSAtom atom = JS_NewAtom(context, "isConnected");
|
|
JS_DefinePropertyGetSet(context, object, atom, JS_NewCFunction(context, _socket_isConnected, "isConnected", 0), JS_NULL, 0);
|
|
JS_FreeAtom(context, atom);
|
|
|
|
atom = JS_NewAtom(context, "peerName");
|
|
JS_DefinePropertyGetSet(context, object, atom, JS_NewCFunction(context, _socket_getPeerName, "peerName", 0), JS_NULL, 0);
|
|
JS_FreeAtom(context, atom);
|
|
|
|
atom = JS_NewAtom(context, "peerCertificate");
|
|
JS_DefinePropertyGetSet(context, object, atom, JS_NewCFunction(context, _socket_getPeerCertificate, "peerCertificate", 0), JS_NULL, 0);
|
|
JS_FreeAtom(context, atom);
|
|
|
|
atom = JS_NewAtom(context, "noDelay");
|
|
JSValue get_no_delay = JS_NewCFunction(context, _socket_getNoDelay, "getNoDelay", 0);
|
|
JSValue set_no_delay = JS_NewCFunction(context, _socket_setNoDelay, "setNoDelay", 1);
|
|
JS_DefinePropertyGetSet(context, object, atom, get_no_delay, set_no_delay, 0);
|
|
JS_FreeAtom(context, atom);
|
|
|
|
atom = JS_NewAtom(context, "info");
|
|
JSValue set_info = JS_NewCFunction(context, _socket_setInfo, "setInfo", 1);
|
|
JS_DefinePropertyGetSet(context, object, atom, JS_UNDEFINED, set_info, 0);
|
|
JS_FreeAtom(context, atom);
|
|
|
|
++_open_count;
|
|
uv_tcp_init(tf_task_get_loop(socket->_task), &socket->_socket);
|
|
socket->_socket.data = socket;
|
|
|
|
return socket;
|
|
}
|
|
|
|
JSValue _socket_create(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
return _socket_create_internal(context)->_object;
|
|
}
|
|
|
|
void _socket_close_internal(socket_t* socket)
|
|
{
|
|
_socket_set_handler(socket, &socket->_onRead, JS_UNDEFINED);
|
|
_socket_set_handler(socket, &socket->_onError, JS_UNDEFINED);
|
|
_socket_set_handler(socket, &socket->_onConnect, JS_UNDEFINED);
|
|
if (socket->_tls)
|
|
{
|
|
tf_tls_session_destroy(socket->_tls);
|
|
socket->_tls = NULL;
|
|
}
|
|
if (socket->_socket.data &&
|
|
!uv_is_closing((uv_handle_t*)&socket->_socket))
|
|
{
|
|
uv_close((uv_handle_t*)&socket->_socket, _socket_onClose);
|
|
}
|
|
|
|
if (!socket->_socket.data &&
|
|
JS_IsUndefined(socket->_object))
|
|
{
|
|
--_count;
|
|
for (int i = 0; i < _sockets_count; i++)
|
|
{
|
|
if (_sockets[i] == socket)
|
|
{
|
|
_sockets[i] = _sockets[_sockets_count - 1];
|
|
--_sockets_count;
|
|
_sockets = tf_realloc(_sockets, sizeof(socket_t*) * _sockets_count);
|
|
break;
|
|
}
|
|
}
|
|
tf_free(socket);
|
|
}
|
|
}
|
|
|
|
void _socket_finalizer(JSRuntime *runtime, JSValue value)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(value, _classId);
|
|
socket->_object = JS_UNDEFINED;
|
|
_socket_close_internal(socket);
|
|
}
|
|
|
|
void _socket_reportError(socket_t* socket, const char* error)
|
|
{
|
|
JSContext* context = tf_task_get_context(socket->_task);
|
|
JSValue ref = JS_DupValue(context, socket->_object);
|
|
if (JS_IsFunction(context, socket-> _onError))
|
|
{
|
|
JSValue exception = JS_ThrowInternalError(context, "%s", error);
|
|
JSValue cb_ref = JS_DupValue(context, socket->_onError);
|
|
JSValue result = JS_Call(context, socket->_onError, socket->_object, 1, &exception);
|
|
JS_FreeValue(context, cb_ref);
|
|
tf_util_report_error(context, result);
|
|
JS_FreeValue(context, exception);
|
|
JS_FreeValue(context, result);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Socket::reportError: %s\n", error);
|
|
}
|
|
JS_FreeValue(context, ref);
|
|
}
|
|
|
|
void _socket_reportTlsErrors(socket_t* socket)
|
|
{
|
|
char buffer[4096];
|
|
while (socket->_tls && tf_tls_session_get_error(socket->_tls, buffer, sizeof(buffer)))
|
|
{
|
|
_socket_reportError(socket, buffer);
|
|
}
|
|
}
|
|
|
|
JSValue _socket_startTls(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
if (!socket->_tls)
|
|
{
|
|
tf_tls_context_t* context = 0;
|
|
|
|
if (argc > 0 && JS_IsObject(argv[0]))
|
|
{
|
|
context = tf_tls_context_get(argv[0]);
|
|
}
|
|
else
|
|
{
|
|
if (!_defaultTlsContext)
|
|
{
|
|
_defaultTlsContext = tf_tls_context_create();
|
|
}
|
|
context = _defaultTlsContext;
|
|
}
|
|
|
|
if (context)
|
|
{
|
|
socket->_tls = tf_tls_context_create_session(context);
|
|
}
|
|
|
|
if (socket->_tls)
|
|
{
|
|
tf_tls_session_set_hostname(socket->_tls, socket->_peerName);
|
|
if (socket->_direction == kAccept)
|
|
{
|
|
tf_tls_session_start_accept(socket->_tls);
|
|
}
|
|
else if (socket->_direction == kConnect)
|
|
{
|
|
tf_tls_session_start_connect(socket->_tls);
|
|
}
|
|
JSValue result = tf_task_allocate_promise(socket->_task, &socket->_startTlsPromise);
|
|
_socket_processOutgoingTls(socket);
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
return JS_ThrowInternalError(tf_task_get_context(socket->_task), "Failed to get TLS context");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return JS_ThrowInternalError(tf_task_get_context(socket->_task), "startTls with TLS already started");
|
|
}
|
|
}
|
|
|
|
JSValue _socket_stopTls(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
if (socket->_tls)
|
|
{
|
|
_socket_processOutgoingTls(socket);
|
|
tf_tls_session_destroy(socket->_tls);
|
|
socket->_tls = NULL;
|
|
}
|
|
else
|
|
{
|
|
JS_ThrowInternalError(tf_task_get_context(socket->_task), "stopTls with TLS already stopped");
|
|
}
|
|
return JS_NULL;
|
|
}
|
|
|
|
bool _socket_processSomeOutgoingTls(socket_t* socket, promiseid_t promise, uv_write_cb callback)
|
|
{
|
|
if (!socket->_socket.data)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
char buffer[65536];
|
|
int result = tf_tls_session_read_encrypted(socket->_tls, buffer, sizeof(buffer));
|
|
if (result > 0)
|
|
{
|
|
char* request_buffer = tf_malloc(sizeof(uv_write_t) + result);
|
|
uv_write_t* request = (uv_write_t*)request_buffer;
|
|
memset(request, 0, sizeof(*request));
|
|
request->data = (void*)(intptr_t)(promise);
|
|
char* rawBuffer = request_buffer + sizeof(uv_write_t);
|
|
memcpy(rawBuffer, buffer, result);
|
|
|
|
uv_buf_t writeBuffer =
|
|
{
|
|
.base = rawBuffer,
|
|
.len = result,
|
|
};
|
|
|
|
int writeResult = uv_write(request, (uv_stream_t*)&socket->_socket, &writeBuffer, 1, callback);
|
|
if (writeResult != 0)
|
|
{
|
|
tf_free(request_buffer);
|
|
char error[256];
|
|
snprintf(error, sizeof(error), "uv_write: %s", uv_strerror(writeResult));
|
|
_socket_reportError(socket, error);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_socket_reportTlsErrors(socket);
|
|
}
|
|
return result > 0;
|
|
}
|
|
|
|
void _socket_processOutgoingTls(socket_t* socket)
|
|
{
|
|
while (_socket_processSomeOutgoingTls(socket, -1, _socket_onWrite))
|
|
{
|
|
}
|
|
}
|
|
|
|
JSValue _socket_bind(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
const char* node = JS_ToCString(tf_task_get_context(socket->_task), argv[0]);
|
|
const char* port = JS_ToCString(tf_task_get_context(socket->_task), argv[1]);
|
|
|
|
socket_resolve_data_t* data = tf_malloc(sizeof(socket_resolve_data_t));
|
|
memset(data, 0, sizeof(*data));
|
|
struct addrinfo hints = {
|
|
.ai_family = PF_INET,
|
|
.ai_socktype = SOCK_STREAM,
|
|
.ai_protocol = IPPROTO_TCP,
|
|
.ai_flags = 0,
|
|
};
|
|
data->resolver.data = data;
|
|
data->socket = socket;
|
|
JSValue promise = tf_task_allocate_promise(socket->_task, &data->promise);
|
|
int result = uv_getaddrinfo(tf_task_get_loop(socket->_task), &data->resolver, _socket_onResolvedForBind, node, port, &hints);
|
|
if (result != 0)
|
|
{
|
|
tf_task_reject_promise(socket->_task, data->promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), "uv_getaddrinfo: %s", uv_strerror(result)));
|
|
tf_free(data);
|
|
}
|
|
return promise;
|
|
}
|
|
|
|
void _socket_onResolvedForBind(uv_getaddrinfo_t* resolver, int status, struct addrinfo* result)
|
|
{
|
|
socket_resolve_data_t* data = (socket_resolve_data_t*)resolver->data;
|
|
if (status != 0)
|
|
{
|
|
tf_task_reject_promise(data->socket->_task, data->promise, JS_ThrowInternalError(tf_task_get_context(data->socket->_task), "uv_getaddrinfo: %s", uv_strerror(status)));
|
|
}
|
|
else
|
|
{
|
|
int bindResult = uv_tcp_bind(&data->socket->_socket, result->ai_addr, 0);
|
|
if (bindResult != 0)
|
|
{
|
|
tf_task_reject_promise(data->socket->_task, data->promise, JS_ThrowInternalError(tf_task_get_context(data->socket->_task), "uv_tcp_bind: %s", uv_strerror(bindResult)));
|
|
}
|
|
else
|
|
{
|
|
tf_task_resolve_promise(data->socket->_task, data->promise, JS_UNDEFINED);
|
|
}
|
|
}
|
|
tf_free(data);
|
|
}
|
|
|
|
JSValue _socket_connect(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
socket->_direction = kConnect;
|
|
const char* node = JS_ToCString(context, argv[0]);
|
|
const char* port = JS_ToCString(context, argv[1]);
|
|
|
|
snprintf(socket->_peerName, sizeof(socket->_peerName), "%s", node);
|
|
|
|
socket_resolve_data_t* data = tf_malloc(sizeof(socket_resolve_data_t));
|
|
memset(data, 0, sizeof(*data));
|
|
struct addrinfo hints = {
|
|
.ai_family = PF_INET,
|
|
.ai_socktype = SOCK_STREAM,
|
|
.ai_protocol = IPPROTO_TCP,
|
|
};
|
|
data->resolver.data = data;
|
|
data->socket = socket;
|
|
JSValue promise = tf_task_allocate_promise(socket->_task, &data->promise);
|
|
int result = uv_getaddrinfo(tf_task_get_loop(socket->_task), &data->resolver, _socket_onResolvedForConnect, node, port, &hints);
|
|
if (result != 0)
|
|
{
|
|
char error[256];
|
|
snprintf(error, sizeof(error), "uv_getaddrinfo: %s", uv_strerror(result));
|
|
tf_task_reject_promise(socket->_task, data->promise, JS_ThrowInternalError(context, "%s", error));
|
|
_socket_close_internal(socket);
|
|
tf_free(data);
|
|
}
|
|
|
|
JS_FreeCString(context, node);
|
|
JS_FreeCString(context, port);
|
|
return promise;
|
|
}
|
|
|
|
void _socket_onResolvedForConnect(uv_getaddrinfo_t* resolver, int status, struct addrinfo* result)
|
|
{
|
|
socket_resolve_data_t* data = resolver->data;
|
|
if (status != 0)
|
|
{
|
|
char error[256];
|
|
snprintf(error, sizeof(error), "uv_getaddrinfo: %s", uv_strerror(status));
|
|
tf_task_reject_promise(data->socket->_task, data->promise, JS_ThrowInternalError(tf_task_get_context(data->socket->_task), "%s", error));
|
|
_socket_close_internal(data->socket);
|
|
}
|
|
else
|
|
{
|
|
uv_connect_t* request = tf_malloc(sizeof(uv_connect_t));
|
|
memset(request, 0, sizeof(*request));
|
|
request->data = (void*)(intptr_t)data->promise;
|
|
int connectResult = uv_tcp_connect(request, &data->socket->_socket, result->ai_addr, _socket_onConnect);
|
|
if (connectResult != 0)
|
|
{
|
|
char error[256];
|
|
snprintf(error, sizeof(error), "uv_tcp_connect: %s", uv_strerror(connectResult));
|
|
tf_task_reject_promise(data->socket->_task, data->promise, JS_ThrowInternalError(tf_task_get_context(data->socket->_task), "%s", error));
|
|
_socket_close_internal(data->socket);
|
|
tf_free(request);
|
|
}
|
|
}
|
|
uv_freeaddrinfo(result);
|
|
tf_free(data);
|
|
}
|
|
|
|
void _socket_onConnect(uv_connect_t* request, int status)
|
|
{
|
|
promiseid_t promise = (intptr_t)request->data;
|
|
if (promise != -1)
|
|
{
|
|
socket_t* socket = request->handle->data;
|
|
if (status == 0)
|
|
{
|
|
socket->_connected = true;
|
|
tf_task_resolve_promise(socket->_task, promise, JS_NewInt32(tf_task_get_context(socket->_task), status));
|
|
}
|
|
else
|
|
{
|
|
char error[256];
|
|
snprintf(error, sizeof(error), "uv_tcp_connect: %s", uv_strerror(status));
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), "%s", error));
|
|
_socket_close_internal(socket);
|
|
}
|
|
}
|
|
tf_free(request);
|
|
}
|
|
|
|
JSValue _socket_listen(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
socket->_listening = true;
|
|
int backlog = 16;
|
|
JS_ToInt32(context, &backlog, argv[0]);
|
|
if (JS_IsUndefined(socket->_onConnect))
|
|
{
|
|
_socket_set_handler(socket, &socket->_onConnect, argv[1]);
|
|
int result = uv_listen((uv_stream_t*)&socket->_socket, backlog, _socket_onNewConnection);
|
|
if (result != 0)
|
|
{
|
|
return JS_ThrowInternalError(context, "uv_listen: %s", uv_strerror(result));
|
|
}
|
|
return JS_NewInt32(context, result);
|
|
}
|
|
else
|
|
{
|
|
return JS_ThrowInternalError(context, "listen: Already listening.");
|
|
}
|
|
}
|
|
|
|
void _socket_onNewConnection(uv_stream_t* server, int status)
|
|
{
|
|
socket_t* socket = server->data;
|
|
JSContext* context = tf_task_get_context(socket->_task);
|
|
JSValue ref = JS_DupValue(context, socket->_object);
|
|
if (!JS_IsUndefined(socket->_onConnect))
|
|
{
|
|
JSValue cb_ref = JS_DupValue(context, socket->_onConnect);
|
|
JSValue result = JS_Call(context, socket->_onConnect, socket->_object, 0, NULL);
|
|
JS_FreeValue(context, cb_ref);
|
|
tf_util_report_error(context, result);
|
|
JS_FreeValue(context, result);
|
|
}
|
|
JS_FreeValue(context, ref);
|
|
}
|
|
|
|
JSValue _socket_accept(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
|
|
socket_t* client = _socket_create_internal(context);
|
|
client->_direction = kAccept;
|
|
promiseid_t promise;
|
|
JSValue ref = JS_DupValue(context, client->_object);
|
|
JSValue result = tf_task_allocate_promise(socket->_task, &promise);
|
|
int status = uv_accept((uv_stream_t*)&socket->_socket, (uv_stream_t*)&client->_socket);
|
|
if (status == 0)
|
|
{
|
|
struct sockaddr_in name = { 0 };
|
|
int namelen = (int)sizeof(name);
|
|
if (uv_tcp_getpeername(&client->_socket, (struct sockaddr*)&name, &namelen) == 0)
|
|
{
|
|
uv_ip_name((const struct sockaddr*)&name, client->_peerName, sizeof(client->_peerName));
|
|
}
|
|
client->_connected = true;
|
|
tf_task_resolve_promise(socket->_task, promise, client->_object);
|
|
JS_FreeValue(context, client->_object);
|
|
}
|
|
else
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(context, "uv_accept: %s", uv_strerror(status)));
|
|
}
|
|
JS_FreeValue(context, ref);
|
|
return result;
|
|
}
|
|
|
|
JSValue _socket_close(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
if (socket->_closePromise == -1 &&
|
|
socket->_socket.data &&
|
|
!uv_is_closing((uv_handle_t*)&socket->_socket))
|
|
{
|
|
JSValue result = tf_task_allocate_promise(socket->_task, &socket->_closePromise);
|
|
_socket_close_internal(socket);
|
|
return result;
|
|
}
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue _socket_shutdown(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
promiseid_t promise = -1;
|
|
JSValue result = tf_task_allocate_promise(socket->_task, &promise);
|
|
if (socket->_tls)
|
|
{
|
|
_socket_processTlsShutdown(socket, promise);
|
|
}
|
|
else
|
|
{
|
|
_socket_shutdownInternal(socket, promise);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void _socket_shutdownInternal(socket_t* socket, promiseid_t promise)
|
|
{
|
|
uv_shutdown_t* request = tf_malloc(sizeof(uv_shutdown_t));
|
|
memset(request, 0, sizeof(*request));
|
|
request->data = (void*)(intptr_t)promise;
|
|
int result = uv_shutdown(request, (uv_stream_t*)&socket->_socket, _socket_onShutdown);
|
|
if (result != 0)
|
|
{
|
|
char error[256];
|
|
snprintf(error, sizeof(error), "uv_shutdown: %s", uv_strerror(result));
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), "%s", error));
|
|
tf_free(request);
|
|
}
|
|
}
|
|
|
|
void _socket_processTlsShutdown(socket_t* socket, promiseid_t promise)
|
|
{
|
|
if (!socket->_tls)
|
|
{
|
|
_socket_shutdownInternal(socket, promise);
|
|
}
|
|
else
|
|
{
|
|
tf_tls_session_shutdown(socket->_tls);
|
|
if (!_socket_processSomeOutgoingTls(socket, promise, _socket_onTlsShutdown))
|
|
{
|
|
_socket_shutdownInternal(socket, promise);
|
|
}
|
|
}
|
|
}
|
|
|
|
void _socket_onTlsShutdown(uv_write_t* request, int status)
|
|
{
|
|
socket_t* socket = request->handle->data;
|
|
promiseid_t promise = (intptr_t)request->data;
|
|
_socket_processTlsShutdown(socket, promise);
|
|
tf_free(request);
|
|
}
|
|
|
|
JSValue _socket_onError(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
_socket_set_handler(socket, &socket->_onError, argv[0]);
|
|
return JS_NULL;
|
|
}
|
|
|
|
JSValue _socket_read(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
JSValue ref = JS_DupValue(context, socket->_object);
|
|
_socket_set_handler(socket, &socket->_onRead, argv[0]);
|
|
|
|
promiseid_t promise = -1;
|
|
JSValue read_result = tf_task_allocate_promise(socket->_task, &promise);
|
|
if (!socket->_reading && socket->_socket.data)
|
|
{
|
|
int result = uv_read_start((uv_stream_t*)&socket->_socket, _socket_allocateBuffer, _socket_onRead);
|
|
if (result != 0)
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(context, "uv_read_start: %s", uv_strerror(result)));
|
|
}
|
|
else
|
|
{
|
|
socket->_reading = true;
|
|
tf_task_resolve_promise(socket->_task, promise, JS_UNDEFINED);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tf_task_resolve_promise(socket->_task, promise, JS_UNDEFINED);
|
|
}
|
|
JS_FreeValue(context, ref);
|
|
return read_result;
|
|
}
|
|
|
|
void _socket_allocateBuffer(uv_handle_t* handle, size_t suggestedSize, uv_buf_t* buf)
|
|
{
|
|
*buf = uv_buf_init(tf_malloc(suggestedSize), suggestedSize);
|
|
}
|
|
|
|
void _socket_onRead(uv_stream_t* stream, ssize_t readSize, const uv_buf_t* buffer)
|
|
{
|
|
socket_t* socket = stream->data;
|
|
JSContext* context = tf_task_get_context(socket->_task);
|
|
JSValue ref = JS_DupValue(context, socket->_object);
|
|
if (readSize <= 0)
|
|
{
|
|
socket->_connected = false;
|
|
if (!JS_IsUndefined(socket->_onRead))
|
|
{
|
|
JSValue args[] = { JS_UNDEFINED };
|
|
JSValue cb_ref = JS_DupValue(context, socket->_onRead);
|
|
JSValue result = JS_Call(context, socket->_onRead, socket->_object, 1, args);
|
|
JS_FreeValue(context, cb_ref);
|
|
tf_util_report_error(context, result);
|
|
JS_FreeValue(context, result);
|
|
}
|
|
_socket_close_internal(socket);
|
|
}
|
|
else
|
|
{
|
|
if (socket->_tls)
|
|
{
|
|
_socket_reportTlsErrors(socket);
|
|
tf_tls_session_write_encrypted(socket->_tls, buffer->base, readSize);
|
|
if (socket->_startTlsPromise != -1)
|
|
{
|
|
tf_tls_handshake_t result = tf_tls_session_handshake(socket->_tls);
|
|
if (result == k_tls_handshake_done)
|
|
{
|
|
promiseid_t promise = socket->_startTlsPromise;
|
|
socket->_startTlsPromise = -1;
|
|
tf_task_resolve_promise(socket->_task, promise, JS_UNDEFINED);
|
|
}
|
|
else if (result == k_tls_handshake_failed)
|
|
{
|
|
promiseid_t promise = socket->_startTlsPromise;
|
|
socket->_startTlsPromise = -1;
|
|
char buffer[8192];
|
|
if (tf_tls_session_get_error(socket->_tls, buffer, sizeof(buffer)))
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(context, "%s", buffer));
|
|
}
|
|
else
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_UNDEFINED);
|
|
}
|
|
}
|
|
}
|
|
|
|
while (socket->_tls)
|
|
{
|
|
char plain[8192];
|
|
int result = tf_tls_session_read_plain(socket->_tls, plain, sizeof(plain));
|
|
if (result > 0)
|
|
{
|
|
_socket_notifyDataRead(socket, plain, result);
|
|
}
|
|
else if (result == k_tls_read_failed)
|
|
{
|
|
_socket_reportTlsErrors(socket);
|
|
_socket_close_internal(socket);
|
|
break;
|
|
}
|
|
else if (result == k_tls_read_zero)
|
|
{
|
|
if (!JS_IsUndefined(socket->_onRead))
|
|
{
|
|
JSValue args[] = { JS_UNDEFINED };
|
|
JSValue cb_ref = JS_DupValue(context, socket->_onRead);
|
|
JSValue result = JS_Call(context, socket->_onRead, socket->_object, 1, args);
|
|
JS_FreeValue(context, cb_ref);
|
|
tf_util_report_error(context, result);
|
|
JS_FreeValue(context, result);
|
|
}
|
|
_socket_close_internal(socket);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (socket->_tls)
|
|
{
|
|
_socket_processOutgoingTls(socket);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_socket_notifyDataRead(socket, buffer->base, readSize);
|
|
}
|
|
}
|
|
tf_free(buffer->base);
|
|
JS_FreeValue(context, ref);
|
|
}
|
|
|
|
static JSValue _newUint8Array(JSContext* context, const void* data, size_t length)
|
|
{
|
|
JSValue arrayBuffer = JS_NewArrayBufferCopy(context, (const uint8_t*)data, length);
|
|
JSValue global = JS_GetGlobalObject(context);
|
|
JSValue constructor = JS_GetPropertyStr(context, global, "Uint8Array");
|
|
JSValue typedArray = JS_CallConstructor(context, constructor, 1, &arrayBuffer);
|
|
JS_FreeValue(context, constructor);
|
|
JS_FreeValue(context, global);
|
|
JS_FreeValue(context, arrayBuffer);
|
|
return typedArray;
|
|
}
|
|
|
|
void _socket_notifyDataRead(socket_t* socket, const char* data, size_t length)
|
|
{
|
|
if (data && length > 0)
|
|
{
|
|
JSContext* context = tf_task_get_context(socket->_task);
|
|
JSValue ref = JS_DupValue(context, socket->_object);
|
|
JSValue typedArray = _newUint8Array(context, data, length);
|
|
JSValue args[] = { typedArray };
|
|
if (!JS_IsUndefined(socket->_onRead))
|
|
{
|
|
JSValue cb_ref = JS_DupValue(context, socket->_onRead);
|
|
JSValue result = JS_Call(context, socket->_onRead, socket->_object, 1, args);
|
|
JS_FreeValue(context, cb_ref);
|
|
tf_util_report_error(context, result);
|
|
JS_FreeValue(context, result);
|
|
}
|
|
JS_FreeValue(context, typedArray);
|
|
JS_FreeValue(context, ref);
|
|
}
|
|
}
|
|
|
|
int _socket_writeBytes(socket_t* socket, promiseid_t promise, int (*callback)(socket_t* socket, promiseid_t promise, const char*, size_t), JSValue value, int* outLength)
|
|
{
|
|
int result = -1;
|
|
size_t length;
|
|
uint8_t* array = NULL;
|
|
JSContext* context = tf_task_get_context(socket->_task);
|
|
if (JS_IsString(value))
|
|
{
|
|
const char* stringValue = JS_ToCStringLen(context, &length, value);
|
|
result = callback(socket, promise, stringValue, length);
|
|
JS_FreeCString(context, stringValue);
|
|
}
|
|
else if ((array = tf_util_try_get_array_buffer(context, &length, value)) != 0)
|
|
{
|
|
result = callback(socket, promise, (const char*)array, length);
|
|
}
|
|
else
|
|
{
|
|
size_t offset;
|
|
size_t element_size;
|
|
JSValue buffer = tf_util_try_get_typed_array_buffer(context, value, &offset, &length, &element_size);
|
|
if (!JS_IsException(buffer))
|
|
{
|
|
size_t size;
|
|
if ((array = tf_util_try_get_array_buffer(context, &size, buffer)) != 0)
|
|
{
|
|
result = callback(socket, promise, (const char*)array, length);
|
|
}
|
|
}
|
|
JS_FreeValue(context, buffer);
|
|
}
|
|
|
|
if (outLength)
|
|
{
|
|
*outLength = (int)length;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int _socket_writeInternal(socket_t* socket, promiseid_t promise, const char* data, size_t length)
|
|
{
|
|
if (!socket->_socket.data)
|
|
{
|
|
return UV_ENOTCONN;
|
|
}
|
|
|
|
char* rawBuffer = tf_malloc(sizeof(uv_write_t) + length);
|
|
uv_write_t* request = (uv_write_t*)rawBuffer;
|
|
memcpy(rawBuffer + sizeof(uv_write_t), data, length);
|
|
|
|
uv_buf_t buffer =
|
|
{
|
|
.base = rawBuffer + sizeof(uv_write_t),
|
|
.len = length,
|
|
};
|
|
|
|
request->data = (void*)(intptr_t)promise;
|
|
int result = uv_write(request, (uv_stream_t*)&socket->_socket, &buffer, 1, _socket_onWrite);
|
|
if (result != 0)
|
|
{
|
|
tf_free(rawBuffer);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static int _socket_write_tls(socket_t* socket, promiseid_t promise, const char* data, size_t size)
|
|
{
|
|
return tf_tls_session_write_plain(socket->_tls, data, size);
|
|
}
|
|
|
|
JSValue _socket_write(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
promiseid_t promise = -1;
|
|
JSValue write_result = tf_task_allocate_promise(socket->_task, &promise);
|
|
JSValue ref = JS_DupValue(context, socket->_object);
|
|
if (!JS_IsUndefined(argv[0]))
|
|
{
|
|
if (socket->_tls)
|
|
{
|
|
_socket_reportTlsErrors(socket);
|
|
int length = 0;
|
|
int result = _socket_writeBytes(socket, -1, _socket_write_tls, argv[0], &length);
|
|
char buffer[8192];
|
|
if (result <= 0 && tf_tls_session_get_error(socket->_tls, buffer, sizeof(buffer)))
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(context, "%s", buffer));
|
|
}
|
|
else if (result < length)
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_NewInt32(context, result));
|
|
}
|
|
else
|
|
{
|
|
tf_task_resolve_promise(socket->_task, promise, JS_NewInt32(context, result));
|
|
}
|
|
_socket_processOutgoingTls(socket);
|
|
}
|
|
else
|
|
{
|
|
int length;
|
|
int result = _socket_writeBytes(socket, promise, _socket_writeInternal, argv[0], &length);
|
|
|
|
if (result != 0)
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(context, "uv_write: %s", uv_strerror(result)));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_NewInt32(context, -2));
|
|
}
|
|
JS_FreeValue(context, ref);
|
|
return write_result;
|
|
}
|
|
|
|
void _socket_onWrite(uv_write_t* request, int status)
|
|
{
|
|
socket_t* socket = request->handle->data;
|
|
promiseid_t promise = (intptr_t)request->data;
|
|
if (promise != -1)
|
|
{
|
|
if (status == 0)
|
|
{
|
|
tf_task_resolve_promise(socket->_task, promise, JS_NewInt32(tf_task_get_context(socket->_task), status));
|
|
}
|
|
else
|
|
{
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), "uv_write: %s", uv_strerror(status)));
|
|
}
|
|
}
|
|
tf_free(request);
|
|
}
|
|
|
|
JSValue _socket_isConnected(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
return socket->_connected ? JS_TRUE : JS_FALSE;
|
|
}
|
|
|
|
void _socket_onClose(uv_handle_t* handle)
|
|
{
|
|
--_open_count;
|
|
socket_t* socket = handle->data;
|
|
handle->data = NULL;
|
|
if (socket->_closePromise != -1)
|
|
{
|
|
promiseid_t promise = socket->_closePromise;
|
|
socket->_closePromise = -1;
|
|
socket->_connected = false;
|
|
tf_task_resolve_promise(socket->_task, promise, JS_UNDEFINED);
|
|
}
|
|
if (socket->_startTlsPromise != -1)
|
|
{
|
|
promiseid_t promise = socket->_startTlsPromise;
|
|
socket->_startTlsPromise = -1;
|
|
socket->_connected = false;
|
|
tf_task_resolve_promise(socket->_task, promise, JS_UNDEFINED);
|
|
}
|
|
_socket_close_internal(socket);
|
|
}
|
|
|
|
void _socket_onShutdown(uv_shutdown_t* request, int status)
|
|
{
|
|
socket_t* socket = request->handle->data;
|
|
promiseid_t promise = (intptr_t)request->data;
|
|
if (status == 0)
|
|
{
|
|
tf_task_resolve_promise(socket->_task, promise, JS_UNDEFINED);
|
|
}
|
|
else
|
|
{
|
|
char error[256];
|
|
snprintf(error, sizeof(error), "uv_shutdown: %s", uv_strerror(status));
|
|
tf_task_reject_promise(socket->_task, promise, JS_ThrowInternalError(tf_task_get_context(socket->_task), "%s", error));
|
|
}
|
|
tf_free(request);
|
|
}
|
|
|
|
JSValue _socket_getPeerName(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
struct sockaddr_in6 addr;
|
|
int nameLength = sizeof(addr);
|
|
if (uv_tcp_getpeername(&socket->_socket, (struct sockaddr*)&addr, &nameLength) == 0)
|
|
{
|
|
char name[1024];
|
|
if ((size_t)nameLength > sizeof(struct sockaddr_in))
|
|
{
|
|
if (uv_ip6_name(&addr, name, sizeof(name)) == 0)
|
|
{
|
|
return JS_NewString(context, name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (uv_ip4_name((struct sockaddr_in*)&addr, name, sizeof(name)) == 0)
|
|
{
|
|
return JS_NewString(context, name);
|
|
}
|
|
}
|
|
}
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue _socket_getPeerCertificate(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
if (socket->_tls)
|
|
{
|
|
char buffer[128 * 1024];
|
|
int result = tf_tls_session_get_peer_certificate(socket->_tls, buffer, sizeof(buffer));
|
|
if (result > 0)
|
|
{
|
|
return _newUint8Array(tf_task_get_context(socket->_task), buffer, sizeof(buffer));
|
|
}
|
|
}
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue _socket_getNoDelay(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
return JS_NewBool(context, socket->_noDelay);
|
|
}
|
|
|
|
JSValue _socket_setNoDelay(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
int result = JS_ToBool(context, argv[0]);
|
|
socket->_noDelay = result > 0;
|
|
uv_tcp_nodelay(&socket->_socket, result > 0 ? 1 : 0);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue _socket_setInfo(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
socket_t* socket = JS_GetOpaque(this_val, _classId);
|
|
JSValue old = socket->_info;
|
|
socket->_info = JS_DupValue(context, argv[0]);
|
|
JS_FreeValue(context, old);
|
|
return JS_UNDEFINED;
|
|
}
|
|
|
|
JSValue _sockets_get(JSContext* context, JSValueConst this_val, int argc, JSValueConst* argv)
|
|
{
|
|
JSValue array = JS_NewArray(context);
|
|
for (int i = 0; i < _sockets_count; i++)
|
|
{
|
|
socket_t* s = _sockets[i];
|
|
JSValue entry = JS_NewObject(context);
|
|
JS_SetPropertyStr(context, entry, "peer", JS_NewString(context, s->_peerName));
|
|
JS_SetPropertyStr(context, entry, "listening", JS_NewBool(context, s->_listening));
|
|
JS_SetPropertyStr(context, entry, "connected", JS_NewBool(context, s->_connected));
|
|
JS_SetPropertyStr(context, entry, "tls", JS_NewBool(context, s->_tls != NULL));
|
|
JS_SetPropertyStr(context, entry, "age_seconds", JS_NewFloat64(context, (uv_now(tf_task_get_loop(s->_task)) - s->created_ms) / 1000.f));
|
|
JS_SetPropertyStr(context, entry, "info", JS_DupValue(context, s->_info));
|
|
JS_SetPropertyUint32(context, array, i, entry);
|
|
}
|
|
return array;
|
|
}
|