kapitan/IXWebSocket
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

(websocket server) Handle programmer error when the server callback is not registered properly (fix #227)

Browse Source
This commit is contained in:
Benjamin Sergeant 2020-08-06 04:40:32 -07:00
parent b15c4189f5
commit 12f36b61ff
5 changed files with 123 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
docs/CHANGELOG.md
View File

@ -2,6 +2,10 @@
All changes to this project will be documented in this file. All changes to this project will be documented in this file.
## [10.1.6] - 2020-08-06
(websocket server) Handle programmer error when the server callback is not registered properly (fix #227)
## [10.1.5] - 2020-08-02 ## [10.1.5] - 2020-08-02
(ws) Add a new ws sub-command, push_server. This command runs a server which sends many messages in a loop to a websocket client. We can receive above 200,000 messages per second (cf #235). (ws) Add a new ws sub-command, push_server. This command runs a server which sends many messages in a loop to a websocket client. We can receive above 200,000 messages per second (cf #235).

5
ixwebsocket/IXWebSocket.cpp
View File

@ -405,6 +405,11 @@ namespace ix
_onMessageCallback = callback; _onMessageCallback = callback;
} }
bool WebSocket::isOnMessageCallbackRegistered() const
{
return _onMessageCallback != nullptr;
}
void WebSocket::setTrafficTrackerCallback(const OnTrafficTrackerCallback& callback) void WebSocket::setTrafficTrackerCallback(const OnTrafficTrackerCallback& callback)
{ {
_onTrafficTrackerCallback = callback; _onTrafficTrackerCallback = callback;

1
ixwebsocket/IXWebSocket.h
View File

@ -84,6 +84,7 @@ namespace ix
const std::string& reason = WebSocketCloseConstants::kNormalClosureMessage); const std::string& reason = WebSocketCloseConstants::kNormalClosureMessage);
void setOnMessageCallback(const OnMessageCallback& callback); void setOnMessageCallback(const OnMessageCallback& callback);
bool isOnMessageCallbackRegistered() const;
static void setTrafficTrackerCallback(const OnTrafficTrackerCallback& callback); static void setTrafficTrackerCallback(const OnTrafficTrackerCallback& callback);
static void resetTrafficTrackerCallback(); static void resetTrafficTrackerCallback();

9
ixwebsocket/IXWebSocketServer.cpp
View File

@ -86,6 +86,15 @@ namespace ix
if (_onConnectionCallback) if (_onConnectionCallback)
{ {
_onConnectionCallback(webSocket, connectionState, std::move(connectionInfo)); _onConnectionCallback(webSocket, connectionState, std::move(connectionInfo));
if (!webSocket->isOnMessageCallbackRegistered())
{
logError("WebSocketServer Application developer error: Server callback improperly "
"registerered.");
logError("Missing call to setOnMessageCallback inside setOnConnectionCallback.");
connectionState->setTerminated();
return;
}
} }
else if (_onClientMessageCallback) else if (_onClientMessageCallback)
{ {

224
test/compatibility/cpp/libwebsockets/devnull_client.cpp
View File

@ -36,154 +36,136 @@
* *
*/ */
#include <libwebsockets.h>
#include <string.h>
#include <signal.h>
#include <atomic> #include <atomic>
#include <thread>
#include <iostream> #include <iostream>
#include <libwebsockets.h>
#include <signal.h>
#include <string.h>
#include <thread>
static int interrupted; static int interrupted;
static struct lws *client_wsi; static struct lws* client_wsi;
std::atomic<uint64_t> receivedCount(0); std::atomic<uint64_t> receivedCount(0);
static int static int callback_dumb_increment(
callback_dumb_increment(struct lws *wsi, enum lws_callback_reasons reason, struct lws* wsi, enum lws_callback_reasons reason, void* user, void* in, size_t len)
void *user, void *in, size_t len)
{ {
switch (reason) { switch (reason)
{
/* because we are protocols[0] ... */ /* because we are protocols[0] ... */
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR: case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
lwsl_err("CLIENT_CONNECTION_ERROR: %s\n", lwsl_err("CLIENT_CONNECTION_ERROR: %s\n", in ? (char*) in : "(null)");
in ? (char *)in : "(null)"); client_wsi = NULL;
client_wsi = NULL; break;
break;
case LWS_CALLBACK_CLIENT_ESTABLISHED: case LWS_CALLBACK_CLIENT_ESTABLISHED: lwsl_user("%s: established\n", __func__); break;
lwsl_user("%s: established\n", __func__);
break;
case LWS_CALLBACK_CLIENT_RECEIVE: case LWS_CALLBACK_CLIENT_RECEIVE: receivedCount++; break;
receivedCount++;
break;
case LWS_CALLBACK_CLIENT_CLOSED: case LWS_CALLBACK_CLIENT_CLOSED: client_wsi = NULL; break;
client_wsi = NULL;
break;
default: default: break;
break; }
}
return lws_callback_http_dummy(wsi, reason, user, in, len); return lws_callback_http_dummy(wsi, reason, user, in, len);
} }
static const struct lws_protocols protocols[] = { static const struct lws_protocols protocols[] = {{
"dumb-increment-protocol",
callback_dumb_increment,
0,
0,
},
{NULL, NULL, 0, 0}};
static void sigint_handler(int sig)
{
interrupted = 1;
}
int main(int argc, const char** argv)
{
uint64_t receivedCountTotal(0);
uint64_t receivedCountPerSecs(0);
auto timer = [&receivedCountTotal, &receivedCountPerSecs] {
while (!interrupted)
{ {
"dumb-increment-protocol", std::cerr << "messages received: " << receivedCountPerSecs << " per second "
callback_dumb_increment, << receivedCountTotal << " total" << std::endl;
0,
0,
},
{ NULL, NULL, 0, 0 }
};
static void receivedCountPerSecs = receivedCount - receivedCountTotal;
sigint_handler(int sig) receivedCountTotal += receivedCountPerSecs;
{
interrupted = 1;
}
int main(int argc, const char **argv) auto duration = std::chrono::seconds(1);
{ std::this_thread::sleep_for(duration);
uint64_t receivedCountTotal(0);
uint64_t receivedCountPerSecs(0);
auto timer = [&receivedCountTotal, &receivedCountPerSecs] {
while (!interrupted)
{
std::cerr << "messages received: "
<< receivedCountPerSecs
<< " per second "
<< receivedCountTotal
<< " total"
<< std::endl;
receivedCountPerSecs = receivedCount - receivedCountTotal;
receivedCountTotal += receivedCountPerSecs;
auto duration = std::chrono::seconds(1);
std::this_thread::sleep_for(duration);
}
};
std::thread t1(timer);
struct lws_context_creation_info info;
struct lws_client_connect_info i;
struct lws_context *context;
const char *p;
int n = 0, logs = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE
/* for LLL_ verbosity above NOTICE to be built into lws, lws
* must have been configured with -DCMAKE_BUILD_TYPE=DEBUG
* instead of =RELEASE */
/* | LLL_INFO */ /* | LLL_PARSER */ /* | LLL_HEADER */
/* | LLL_EXT */ /* | LLL_CLIENT */ /* | LLL_LATENCY */
/* | LLL_DEBUG */;
signal(SIGINT, sigint_handler);
if ((p = lws_cmdline_option(argc, argv, "-d")))
logs = atoi(p);
lws_set_log_level(logs, NULL);
lwsl_user("LWS minimal ws client rx [-d <logs>] [--h2]\n");
memset(&info, 0, sizeof info); /* otherwise uninitialized garbage */
info.port = CONTEXT_PORT_NO_LISTEN; /* we do not run any server */
info.protocols = protocols;
info.timeout_secs = 10;
/*
* since we know this lws context is only ever going to be used with
* one client wsis / fds / sockets at a time, let lws know it doesn't
* have to use the default allocations for fd tables up to ulimit -n.
* It will just allocate for 1 internal and 1 (+ 1 http2 nwsi) that we
* will use.
*/
info.fd_limit_per_thread = 1 + 1 + 1;
context = lws_create_context(&info);
if (!context) {
lwsl_err("lws init failed\n");
return 1;
} }
};
memset(&i, 0, sizeof i); /* otherwise uninitialized garbage */ std::thread t1(timer);
i.context = context;
i.port = 8008;
i.address = "127.0.0.1";
i.path = "/";
i.host = i.address;
i.origin = i.address;
i.protocol = protocols[0].name; /* "dumb-increment-protocol" */
i.pwsi = &client_wsi;
if (lws_cmdline_option(argc, argv, "--h2")) struct lws_context_creation_info info;
i.alpn = "h2"; struct lws_client_connect_info i;
struct lws_context* context;
const char* p;
int n = 0, logs = LLL_USER | LLL_ERR | LLL_WARN | LLL_NOTICE
/* for LLL_ verbosity above NOTICE to be built into lws, lws
* must have been configured with -DCMAKE_BUILD_TYPE=DEBUG
* instead of =RELEASE */
/* | LLL_INFO */ /* | LLL_PARSER */ /* | LLL_HEADER */
/* | LLL_EXT */ /* | LLL_CLIENT */ /* | LLL_LATENCY */
/* | LLL_DEBUG */;
lws_client_connect_via_info(&i); signal(SIGINT, sigint_handler);
if ((p = lws_cmdline_option(argc, argv, "-d"))) logs = atoi(p);
while (n >= 0 && client_wsi && !interrupted) lws_set_log_level(logs, NULL);
n = lws_service(context, 0); lwsl_user("LWS minimal ws client rx [-d <logs>] [--h2]\n");
lws_context_destroy(context); memset(&info, 0, sizeof info); /* otherwise uninitialized garbage */
info.port = CONTEXT_PORT_NO_LISTEN; /* we do not run any server */
info.protocols = protocols;
info.timeout_secs = 10;
lwsl_user("Completed %s\n", receivedCount > 10 ? "OK" : "Failed"); /*
* since we know this lws context is only ever going to be used with
* one client wsis / fds / sockets at a time, let lws know it doesn't
* have to use the default allocations for fd tables up to ulimit -n.
* It will just allocate for 1 internal and 1 (+ 1 http2 nwsi) that we
* will use.
*/
info.fd_limit_per_thread = 1 + 1 + 1;
t1.join(); context = lws_create_context(&info);
if (!context)
{
lwsl_err("lws init failed\n");
return 1;
}
return receivedCount > 10; memset(&i, 0, sizeof i); /* otherwise uninitialized garbage */
i.context = context;
i.port = 8008;
i.address = "127.0.0.1";
i.path = "/";
i.host = i.address;
i.origin = i.address;
i.protocol = protocols[0].name; /* "dumb-increment-protocol" */
i.pwsi = &client_wsi;
if (lws_cmdline_option(argc, argv, "--h2")) i.alpn = "h2";
lws_client_connect_via_info(&i);
while (n >= 0 && client_wsi && !interrupted)
n = lws_service(context, 0);
lws_context_destroy(context);
lwsl_user("Completed %s\n", receivedCount > 10 ? "OK" : "Failed");
t1.join();
return receivedCount > 10;
} }