1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
#include "root.h"
#include "headers.h"
#include "ScriptExecutionContext.h"
#include "webcore/WebSocket.h"
#include <uws/src/App.h>
extern "C" void Bun__startLoop(us_loop_t* loop);
namespace WebCore {
template<bool SSL, bool isServer>
static void registerHTTPContextForWebSocket(ScriptExecutionContext* script, us_socket_context_t* ctx, us_loop_t* loop)
{
if constexpr (!isServer) {
if constexpr (SSL) {
Bun__WebSocketHTTPSClient__register(script->jsGlobalObject(), loop, ctx);
} else {
Bun__WebSocketHTTPClient__register(script->jsGlobalObject(), loop, ctx);
}
} else {
RELEASE_ASSERT_NOT_REACHED();
}
}
us_socket_context_t* ScriptExecutionContext::webSocketContextSSL()
{
if (!m_ssl_client_websockets_ctx) {
us_loop_t* loop = (us_loop_t*)uWS::Loop::get();
us_socket_context_options_t opts;
memset(&opts, 0, sizeof(us_socket_context_options_t));
this->m_ssl_client_websockets_ctx = us_create_socket_context(1, loop, sizeof(size_t), opts);
void** ptr = reinterpret_cast<void**>(us_socket_context_ext(1, m_ssl_client_websockets_ctx));
*ptr = this;
registerHTTPContextForWebSocket<true, false>(this, m_ssl_client_websockets_ctx, loop);
}
return m_ssl_client_websockets_ctx;
}
us_socket_context_t* ScriptExecutionContext::webSocketContextNoSSL()
{
if (!m_client_websockets_ctx) {
us_loop_t* loop = (us_loop_t*)uWS::Loop::get();
us_socket_context_options_t opts;
memset(&opts, 0, sizeof(us_socket_context_options_t));
this->m_client_websockets_ctx = us_create_socket_context(0, loop, sizeof(size_t), opts);
void** ptr = reinterpret_cast<void**>(us_socket_context_ext(0, m_client_websockets_ctx));
*ptr = this;
registerHTTPContextForWebSocket<false, false>(this, m_client_websockets_ctx, loop);
}
return m_client_websockets_ctx;
}
template<bool SSL>
static uWS::WebSocketContext<SSL, false, WebCore::WebSocket*>* registerWebSocketClientContext(ScriptExecutionContext* script, us_socket_context_t* parent)
{
uWS::Loop* loop = uWS::Loop::get();
uWS::WebSocketContext<SSL, false, WebCore::WebSocket*>* ctx = uWS::WebSocketContext<SSL, false, WebCore::WebSocket*>::createClient(loop, parent);
auto* opts = ctx->getExt();
/* Maximum message size we can receive */
static unsigned int maxPayloadLength = 128 * 1024 * 1024;
/* 2 minutes timeout is good */
static unsigned short idleTimeout = 120;
/* 64kb backpressure is probably good */
static unsigned int maxBackpressure = 128 * 1024 * 1024;
static bool closeOnBackpressureLimit = false;
/* This one depends on kernel timeouts and is a bad default */
static bool resetIdleTimeoutOnSend = false;
/* A good default, esp. for newcomers */
static bool sendPingsAutomatically = true;
/* Maximum socket lifetime in seconds before forced closure (defaults to disabled) */
static unsigned short maxLifetime = 0;
opts->maxPayloadLength = maxPayloadLength;
opts->maxBackpressure = maxBackpressure;
opts->closeOnBackpressureLimit = closeOnBackpressureLimit;
opts->resetIdleTimeoutOnSend = resetIdleTimeoutOnSend;
opts->sendPingsAutomatically = sendPingsAutomatically;
// opts->compression = compression;
// TODO:
opts->compression = uWS::CompressOptions::DISABLED;
opts->openHandler = [](uWS::WebSocket<SSL, false, WebCore::WebSocket*>* ws) {
WebCore::WebSocket* webSocket = *ws->getUserData();
webSocket->didConnect();
};
opts->messageHandler = [](uWS::WebSocket<SSL, false, WebCore::WebSocket*>* ws, std::string_view input, uWS::OpCode opCode) {
WebCore::WebSocket* webSocket = *ws->getUserData();
if (opCode == uWS::OpCode::BINARY) {
webSocket->didReceiveBinaryData({ const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(input.data())), input.length() });
} else {
webSocket->didReceiveMessage(WTF::String::fromUTF8(input.data(), input.length()));
}
};
// pts->drainHandler = [](uWS::WebSocket<SSL, false, WebCore::WebSocket>* ws, std::string_view input, uWS::OpCode opCode) {
// WebCore::WebSocket* webSocket = *ws->getUserData();
// webSocket->didReceiveData(input.data(), input.length());
// };
opts->closeHandler = [](uWS::WebSocket<SSL, false, WebCore::WebSocket*>* ws, int code, std::string_view message) {
WebCore::WebSocket* webSocket = *ws->getUserData();
webSocket->didClose(
ws->getBufferedAmount(),
code,
WTF::String::fromUTF8(
message.data(),
message.length()));
};
return ctx;
}
uWS::WebSocketContext<false, false, WebSocket*>* ScriptExecutionContext::connectedWebSocketKindClient()
{
return registerWebSocketClientContext<false>(this, webSocketContextNoSSL());
}
uWS::WebSocketContext<true, false, WebSocket*>* ScriptExecutionContext::connectedWebSocketKindClientSSL()
{
return registerWebSocketClientContext<true>(this, webSocketContextSSL());
}
}
|
