project builds / gross hack to disable compression code path / ws connect -x works but test fails

.github/workflows/unittest_uwp.yml

@@ -10,10 +10,12 @@ jobs:
     steps:
     - uses: actions/checkout@v1
     - uses: seanmiddleditch/gha-setup-vsdevenv@master
+    - run: |
+        vcpkg install zlib:x64-uwp
     - run: |
         mkdir build
         cd build
-        cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0" -DCMAKE_CXX_COMPILER=cl.exe -DUSE_TEST=1 -DUSE_ZLIB=0 ..
+        cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0" -DCMAKE_CXX_COMPILER=cl.exe -DUSE_TEST=1 ..
     - run: cmake --build build
 
 #

.github/workflows/unittest_windows.yml

@@ -10,11 +10,10 @@ jobs:
     steps:
     - uses: actions/checkout@v1
     - uses: seanmiddleditch/gha-setup-vsdevenv@master
+    - run: |
+        vcpkg install zlib:x64-windows
     - run: |
         mkdir build
         cd build
-        cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_WS=1 -DUSE_TEST=1 -DUSE_ZLIB=0 ..
+        cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_WS=1 -DUSE_TEST=1 ..
     - run: cmake --build build
-
-#- run: ../build/test/ixwebsocket_unittest.exe
-# working-directory: test

CMakeLists.txt

@@ -30,15 +30,12 @@ set( IXWEBSOCKET_SOURCES
     ixwebsocket/IXConnectionState.cpp
     ixwebsocket/IXDNSLookup.cpp
     ixwebsocket/IXExponentialBackoff.cpp
-    ixwebsocket/IXGetFreePort.cpp
     ixwebsocket/IXHttp.cpp
     ixwebsocket/IXHttpClient.cpp
     ixwebsocket/IXHttpServer.cpp
     ixwebsocket/IXNetSystem.cpp
     ixwebsocket/IXSelectInterrupt.cpp
     ixwebsocket/IXSelectInterruptFactory.cpp
-    ixwebsocket/IXSelectInterruptPipe.cpp
-    ixwebsocket/IXSetThreadName.cpp
     ixwebsocket/IXSocket.cpp
     ixwebsocket/IXSocketConnect.cpp
     ixwebsocket/IXSocketFactory.cpp
@@ -54,7 +51,6 @@ set( IXWEBSOCKET_SOURCES
     ixwebsocket/IXWebSocketPerMessageDeflate.cpp
     ixwebsocket/IXWebSocketPerMessageDeflateCodec.cpp
     ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp
-    ixwebsocket/IXWebSocketProxyServer.cpp
     ixwebsocket/IXWebSocketServer.cpp
     ixwebsocket/IXWebSocketTransport.cpp
 )
@@ -62,11 +58,9 @@ set( IXWEBSOCKET_SOURCES
 set( IXWEBSOCKET_HEADERS
     ixwebsocket/IXBench.h
     ixwebsocket/IXCancellationRequest.h
-    ixwebsocket/IXConnectionInfo.h
     ixwebsocket/IXConnectionState.h
     ixwebsocket/IXDNSLookup.h
     ixwebsocket/IXExponentialBackoff.h
-    ixwebsocket/IXGetFreePort.h
     ixwebsocket/IXHttp.h
     ixwebsocket/IXHttpClient.h
     ixwebsocket/IXHttpServer.h
@@ -74,7 +68,6 @@ set( IXWEBSOCKET_HEADERS
     ixwebsocket/IXProgressCallback.h
     ixwebsocket/IXSelectInterrupt.h
     ixwebsocket/IXSelectInterruptFactory.h
-    ixwebsocket/IXSelectInterruptPipe.h
     ixwebsocket/IXSetThreadName.h
     ixwebsocket/IXSocket.h
     ixwebsocket/IXSocketConnect.h
@@ -99,13 +92,29 @@ set( IXWEBSOCKET_HEADERS
     ixwebsocket/IXWebSocketPerMessageDeflate.h
     ixwebsocket/IXWebSocketPerMessageDeflateCodec.h
     ixwebsocket/IXWebSocketPerMessageDeflateOptions.h
-    ixwebsocket/IXWebSocketProxyServer.h
     ixwebsocket/IXWebSocketSendInfo.h
     ixwebsocket/IXWebSocketServer.h
     ixwebsocket/IXWebSocketTransport.h
     ixwebsocket/IXWebSocketVersion.h
 )
 
+if (UNIX)
+    # Linux, Mac, iOS, Android
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSelectInterruptPipe.cpp )
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSelectInterruptPipe.h )
+endif()
+
+# Platform specific code
+if (APPLE)
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/apple/IXSetThreadName_apple.cpp)
+elseif (WIN32)
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/windows/IXSetThreadName_windows.cpp)
+elseif (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/freebsd/IXSetThreadName_freebsd.cpp)
+else()
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/linux/IXSetThreadName_linux.cpp)
+endif()
+
 option(USE_TLS "Enable TLS support" FALSE)
 
 if (USE_TLS)
@@ -190,16 +199,10 @@ if (USE_TLS)
   endif()
 endif()
 
-option(USE_ZLIB "Enable zlib support" TRUE)
-
-if (USE_ZLIB)
-  # Use ZLIB_ROOT CMake variable if you need to use your own zlib
-  find_package(ZLIB REQUIRED)
-  include_directories(${ZLIB_INCLUDE_DIRS})
-  target_link_libraries(ixwebsocket ${ZLIB_LIBRARIES})
-
-  target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_ZLIB)
-endif()
+# Use ZLIB_ROOT CMake variable if you need to use your own zlib
+find_package(ZLIB REQUIRED)
+include_directories(${ZLIB_INCLUDE_DIRS})
+target_link_libraries(ixwebsocket ${ZLIB_LIBRARIES})
 
 if (WIN32)
   target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)

docker/Dockerfile.ubuntu_groovy

@@ -1,23 +0,0 @@
-# Build time
-FROM ubuntu:groovy as build
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update
-
-RUN apt-get -y install g++ libssl-dev libz-dev make python ninja-build
-RUN apt-get -y install cmake
-RUN apt-get -y install gdb
-
-COPY . /opt
-WORKDIR /opt
-
-#
-# To use the container interactively for debugging/building
-# 1. Build with
-#    CMD ["ls"]
-# 2. Run with
-#    docker run --entrypoint sh -it docker-game-eng-dev.addsrv.com/ws:9.10.6 
-#
-
-RUN ["make", "test"]
-# CMD ["ls"]

docs/CHANGELOG.md

@@ -1,135 +1,6 @@
 # Changelog
-
 All changes to this project will be documented in this file.
 
-## [10.2.5] - 2020-08-15
-
-(ws) merge all ws_*.cpp files into a single one to speedup compilation
-
-## [10.2.4] - 2020-08-15
-
-(socket server) in the loop accepting connections, call select without a timeout on unix to avoid busy looping, and only wake up when a new connection happens
-
-## [10.2.3] - 2020-08-15
-
-(socket server) instead of busy looping with a sleep, only wake up the GC thread when a new thread will have to be joined, (we know that thanks to the ConnectionState OnSetTerminated callback
-
-## [10.2.2] - 2020-08-15
-
-(socket server) add a callback to the ConnectionState to be invoked when the connection is terminated. This will be used by the SocketServer in the future to know on time that the associated connection thread can be terminated.
-
-## [10.2.1] - 2020-08-15
-
-(socket server) do not create a select interrupt object everytime when polling for notifications while waiting for new connections, instead use a persistent one which is a member variable
-
-## [10.2.0] - 2020-08-14
-
-(ixwebsocket client) handle HTTP redirects
-
-## [10.2.0] - 2020-08-13
-
-(ws) upgrade to latest version of nlohmann json (3.9.1 from 3.2.0)
-
-## [10.1.9] - 2020-08-13
-
-(websocket proxy server) add ability to map different hosts to different websocket servers, using a json config file
-
-## [10.1.8] - 2020-08-12
-
-(ws) on macOS, with OpenSSL or MbedTLS, use /etc/ssl/cert.pem as the system certs
-
-## [10.1.7] - 2020-08-11
-
-(ws) -q option imply info log level, not warning log level
-
-## [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
-
-(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).
-
-## [10.1.4] - 2020-08-02
-
-(ws) Add a new ws sub-command, echo_client. This command sends a message to an echo server, and send back to a server whatever message it does receive. When connecting to a local ws echo_server, on my MacBook Pro 2015 I can send/receive around 30,000 messages per second. (cf #235)
-
-## [10.1.3] - 2020-08-02
-
-(ws) ws echo_server. Add a -q option to only enable warning and error log levels. This is useful for bench-marking so that we do not print a lot of things on the console. (cf #235)
-
-## [10.1.2] - 2020-07-31
-
-(build) make using zlib optional, with the caveat that some http and websocket features are not available when zlib is absent
-
-## [10.1.1] - 2020-07-29
-
-(websocket client) onProgressCallback not called for short messages on a websocket (fix #233)
-
-## [10.1.0] - 2020-07-29
-
-(websocket client) heartbeat is not sent at the requested frequency (fix #232)
-
-## [10.0.3] - 2020-07-28
-
-compiler warning fixes
-
-## [10.0.2] - 2020-07-28
-
-(ixcobra) CobraConnection: unsubscribe from all subscriptions when disconnecting
-
-## [10.0.1] - 2020-07-27
-
-(socket utility) move ix::getFreePort to ixwebsocket library
-
-## [10.0.0] - 2020-07-25
-
-(ixwebsocket server) change legacy api with 2 nested callbacks, so that the first api takes a weak_ptr<WebSocket> as its first argument
-
-## [9.10.7] - 2020-07-25
-
-(ixwebsocket) add WebSocketProxyServer, from ws. Still need to make the interface better.
-
-## [9.10.6] - 2020-07-24
-
-(ws) port broadcast_server sub-command to the new server API
-
-## [9.10.5] - 2020-07-24
-
-(unittest) port most unittests to the new server API
-
-## [9.10.3] - 2020-07-24
-
-(ws) port ws transfer to the new server API
-
-## [9.10.2] - 2020-07-24
-
-(websocket client) reset WebSocketTransport onClose callback in the WebSocket destructor
-
-## [9.10.1] - 2020-07-24
-
-(websocket server) reset client websocket callback when the connection is closed
-
-## [9.10.0] - 2020-07-23
-
-(websocket server) add a new simpler API to handle client connections / that API does not trigger a memory leak while the previous one did
-
-## [9.9.3] - 2020-07-17
-
-(build) merge platform specific files which were used to have different implementations for setting a thread name into a single file, to make it easier to include every source files and build the ixwebsocket library (fix #226)
-
-## [9.9.2] - 2020-07-10
-
-(socket server) bump default max connection count from 32 to 128
-
-## [9.9.1] - 2020-07-10
-
-(snake) implement super simple stream sql expression support in snake server
-
-## [9.9.0] - 2020-07-08
-
-(socket+websocket+http+redis+snake servers) expose the remote ip and remote port when a new connection is made
-
 ## [9.8.6] - 2020-07-06
 
 (cmake) change the way zlib and openssl are searched

docs/build.md

@@ -17,7 +17,6 @@ There is a unittest which can be executed by typing `make test`.
 
 Options for building:
 
-* `-DUSE_ZLIB=1` will enable zlib support, required for http client + server + websocket per message deflate extension
 * `-DUSE_TLS=1` will enable TLS support
 * `-DUSE_OPEN_SSL=1` will use [openssl](https://www.openssl.org/) for the TLS support (default on Linux and Windows)
 * `-DUSE_MBED_TLS=1` will use [mbedlts](https://tls.mbed.org/) for the TLS support

docs/performance.md

@@ -1,37 +0,0 @@
-
-## WebSocket Client performance
-
-We will run a client and a server on the same machine, connecting to localhost. This bench is run on a MacBook Pro from 2015. We can receive over 200,000 (small) messages per second, another way to put it is that it takes 5 micro-second to receive and process one message. This is an indication about the minimal latency to receive messages.
-
-### Receiving messages
-
-By using the push_server ws sub-command, the server will send the same message in a loop to any connected client.
-
-```
-ws push_server -q --send_msg 'yo'
-```
-
-By using the echo_client ws sub-command, with the -m (mute or no_send), we will display statistics on how many messages we can receive per second.
-
-```
-$ ws echo_client -m ws://localhost:8008
-[2020-08-02 12:31:17.284] [info] ws_echo_client: connected
-[2020-08-02 12:31:17.284] [info] Uri: /
-[2020-08-02 12:31:17.284] [info] Headers:
-[2020-08-02 12:31:17.284] [info] Connection: Upgrade
-[2020-08-02 12:31:17.284] [info] Sec-WebSocket-Accept: byy/pMK2d0PtRwExaaiOnXJTQHo=
-[2020-08-02 12:31:17.284] [info] Server: ixwebsocket/10.1.4 macos ssl/SecureTransport zlib 1.2.11
-[2020-08-02 12:31:17.284] [info] Upgrade: websocket
-[2020-08-02 12:31:17.663] [info] messages received: 0 per second 2595307 total
-[2020-08-02 12:31:18.668] [info] messages received: 79679 per second 2674986 total
-[2020-08-02 12:31:19.668] [info] messages received: 207438 per second 2882424 total
-[2020-08-02 12:31:20.673] [info] messages received: 209207 per second 3091631 total
-[2020-08-02 12:31:21.676] [info] messages received: 216056 per second 3307687 total
-[2020-08-02 12:31:22.680] [info] messages received: 214927 per second 3522614 total
-[2020-08-02 12:31:23.684] [info] messages received: 216960 per second 3739574 total
-[2020-08-02 12:31:24.688] [info] messages received: 215232 per second 3954806 total
-[2020-08-02 12:31:25.691] [info] messages received: 212300 per second 4167106 total
-[2020-08-02 12:31:26.694] [info] messages received: 212501 per second 4379607 total
-[2020-08-02 12:31:27.699] [info] messages received: 212330 per second 4591937 total
-[2020-08-02 12:31:28.702] [info] messages received: 216511 per second 4808448 total
-```

docs/usage.md

@@ -67,28 +67,9 @@ webSocket.stop()
 
 ### Sending messages
 
-`WebSocketSendInfo result = websocket.send("foo")` will send a message.
+`websocket.send("foo")` will send a message.
 
-If the connection was closed, sending will fail, and the success field of the result object  will be set to false. There could also be a compression error in which case the compressError field will be set to true. The payloadSize field and wireSize fields will tell you respectively how much bytes the message weight, and how many bytes were sent on the wire (potentially compressed + counting the message header (a few bytes).
-
-There is an optional progress callback that can be passed in as the second argument. If a message is large it will be fragmented into chunks which will be sent independantly. Everytime the we can write a fragment into the OS network cache, the callback will be invoked. If a user wants to cancel a slow send, false should be returned from within the callback.
-
-Here is an example code snippet copied from the ws send sub-command. Each fragment weights 32K, so the total integer is the wireSize divided by 32K. As an example if you are sending 32M of data, uncompressed, total will be 1000. current will be set to 0 for the first fragment, then 1, 2 etc...
-
-```
-auto result =
-    _webSocket.sendBinary(serializedMsg, [this, throttle](int current, int total) -> bool {
-        spdlog::info("ws_send: Step {} out of {}", current + 1, total);
-
-        if (throttle)
-        {
-            std::chrono::duration<double, std::milli> duration(10);
-            std::this_thread::sleep_for(duration);
-        }
-
-        return _connected;
-    });
-```
+If the connection was closed and sending failed, the return value will be set to false.
 
 ### ReadyState
 
@@ -265,10 +246,6 @@ uint32_t m = webSocket.getMaxWaitBetweenReconnectionRetries();
 
 ## WebSocket server API
 
-### Legacy api
-
-This api was actually changed to take a weak_ptr<WebSocket> as the first argument to setOnConnectionCallback ; previously it would take a shared_ptr<WebSocket> which was creating cycles and then memory leaks problems.
-
 ```cpp
 #include <ixwebsocket/IXWebSocketServer.h>
 
@@ -279,50 +256,39 @@ This api was actually changed to take a weak_ptr<WebSocket> as the first argumen
 ix::WebSocketServer server(port);
 
 server.setOnConnectionCallback(
-    [&server](std::weak_ptr<WebSocket> webSocket,
-              std::shared_ptr<ConnectionState> connectionState,
-              std::unique_ptr<ConnectionInfo> connectionInfo)
+    [&server](std::shared_ptr<WebSocket> webSocket,
+              std::shared_ptr<ConnectionState> connectionState)
     {
-        std::cout << "Remote ip: " << connectionInfo->remoteIp << std::endl;
-
-        auto ws = webSocket.lock();
-        if (ws)
-        {
-            ws->setOnMessageCallback(
-                [webSocket, connectionState, &server](const ix::WebSocketMessagePtr msg)
+        webSocket->setOnMessageCallback(
+            [webSocket, connectionState, &server](const ix::WebSocketMessagePtr msg)
+            {
+                if (msg->type == ix::WebSocketMessageType::Open)
                 {
-                    if (msg->type == ix::WebSocketMessageType::Open)
+                    std::cerr << "New connection" << std::endl;
+
+                    // A connection state object is available, and has a default id
+                    // You can subclass ConnectionState and pass an alternate factory
+                    // to override it. It is useful if you want to store custom
+                    // attributes per connection (authenticated bool flag, attributes, etc...)
+                    std::cerr << "id: " << connectionState->getId() << std::endl;
+
+                    // The uri the client did connect to.
+                    std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
+
+                    std::cerr << "Headers:" << std::endl;
+                    for (auto it : msg->openInfo.headers)
                     {
-                        std::cout << "New connection" << std::endl;
-
-                        // A connection state object is available, and has a default id
-                        // You can subclass ConnectionState and pass an alternate factory
-                        // to override it. It is useful if you want to store custom
-                        // attributes per connection (authenticated bool flag, attributes, etc...)
-                        std::cout << "id: " << connectionState->getId() << std::endl;
-
-                        // The uri the client did connect to.
-                        std::cout << "Uri: " << msg->openInfo.uri << std::endl;
-
-                        std::cout << "Headers:" << std::endl;
-                        for (auto it : msg->openInfo.headers)
-                        {
-                            std::cout << it.first << ": " << it.second << std::endl;
-                        }
-                    }
-                    else if (msg->type == ix::WebSocketMessageType::Message)
-                    {
-                        // For an echo server, we just send back to the client whatever was received by the server
-                        // All connected clients are available in an std::set. See the broadcast cpp example.
-                        // Second parameter tells whether we are sending the message in binary or text mode.
-                        // Here we send it in the same mode as it was received.
-                        auto ws = webSocket.lock();
-                        if (ws)
-                        {
-                            ws->send(msg->str, msg->binary);
-                        }
+                        std::cerr << it.first << ": " << it.second << std::endl;
                     }
                 }
+                else if (msg->type == ix::WebSocketMessageType::Message)
+                {
+                    // For an echo server, we just send back to the client whatever was received by the server
+                    // All connected clients are available in an std::set. See the broadcast cpp example.
+                    // Second parameter tells whether we are sending the message in binary or text mode.
+                    // Here we send it in the same mode as it was received.
+                    webSocket->send(msg->str, msg->binary);
+                }
             }
         );
     }
@@ -343,74 +309,6 @@ server.wait();
 
 ```
 
-### New api
-
-The new API does not require to use 2 nested callbacks, which is a bit annoying. The real fix is that there was a memory leak due to a shared_ptr cycle, due to passing down a shared_ptr<WebSocket> down to the callbacks.
-
-The webSocket reference is guaranteed to be always valid ; by design the callback will never be invoked with a null webSocket object.
-
-```cpp
-#include <ixwebsocket/IXWebSocketServer.h>
-
-...
-
-// Run a server on localhost at a given port.
-// Bound host name, max connections and listen backlog can also be passed in as parameters.
-ix::WebSocketServer server(port);
-
-server.setOnClientMessageCallback(std::shared_ptr<ConnectionState> connectionState,
-                                  ConnectionInfo& connectionInfo,
-                                  WebSocket& webSocket,
-                                  const WebSocketMessagePtr& msg)
-{
-    // The ConnectionInfo object contains information about the connection,
-    // at this point only the client ip address and the port.
-    std::cout << "Remote ip: " << connectionInfo.remoteIp << std::endl;
-
-    if (msg->type == ix::WebSocketMessageType::Open)
-    {
-        std::cout << "New connection" << std::endl;
-
-        // A connection state object is available, and has a default id
-        // You can subclass ConnectionState and pass an alternate factory
-        // to override it. It is useful if you want to store custom
-        // attributes per connection (authenticated bool flag, attributes, etc...)
-        std::cout << "id: " << connectionState->getId() << std::endl;
-
-        // The uri the client did connect to.
-        std::cout << "Uri: " << msg->openInfo.uri << std::endl;
-
-        std::cout << "Headers:" << std::endl;
-        for (auto it : msg->openInfo.headers)
-        {
-            std::cout << it.first << ": " << it.second << std::endl;
-        }
-    }
-    else if (msg->type == ix::WebSocketMessageType::Message)
-    {
-        // For an echo server, we just send back to the client whatever was received by the server
-        // All connected clients are available in an std::set. See the broadcast cpp example.
-        // Second parameter tells whether we are sending the message in binary or text mode.
-        // Here we send it in the same mode as it was received.
-        webSocket.send(msg->str, msg->binary);
-    }
-);
-
-auto res = server.listen();
-if (!res.first)
-{
-    // Error handling
-    return 1;
-}
-
-// Run the server in the background. Server can be stoped by calling server.stop()
-server.start();
-
-// Block until server.stop() is called.
-server.wait();
-
-```
-
 ## HTTP client API
 
 ```cpp
@@ -519,14 +417,11 @@ If you want to handle how requests are processed, implement the setOnConnectionC
 ```cpp
 setOnConnectionCallback(
     [this](HttpRequestPtr request,
-           std::shared_ptr<ConnectionState> /*connectionState*/,
-           std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr
+           std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr
     {
         // Build a string for the response
         std::stringstream ss;
-        ss << connectionInfo->remoteIp
-           << " "
-           << request->method
+        ss << request->method
            << " "
            << request->uri;
 

docs/ws.md

@@ -204,24 +204,6 @@ Listening on 127.0.0.1:8008
 
 If you connect to ws://127.0.0.1:8008, the proxy will connect to ws://127.0.0.1:9000 and pass all traffic to this server.
 
-You can also use a more complex setup if you want to redirect to different websocket servers based on the hostname your client is trying to connect to. If you have multiple CNAME aliases that point to the same server.
-
-A JSON config file is used to express that mapping ; here connecting to echo.jeanserge.com will proxy the client to ws://localhost:8008 on the local machine (which actually runs ws echo_server), while connecting to bavarde.jeanserge.com will proxy the client to ws://localhost:5678 where a cobra python server is running. As a side note you will need a wildcard SSL certificate if you want to have SSL enabled on that machine.
-
-```json
-{
-        "remote_urls": {
-                "echo.jeanserge.com": "ws://localhost:8008",
-                "bavarde.jeanserge.com": "ws://localhost:5678"
-        }
-}
-```
-The --config_path option is required to instruct ws proxy_server to read that file.
-
-```
-ws proxy_server --config_path proxyConfig.json --port 8765
-```
-
 ## File transfer
 
 ```

ixcobra/ixcobra/IXCobraConnection.cpp

@@ -111,12 +111,6 @@ namespace ix
 
     void CobraConnection::disconnect()
     {
-        auto subscriptionIds = getSubscriptionsIds();
-        for (auto&& subscriptionId : subscriptionIds)
-        {
-            unsubscribe(subscriptionId);
-        }
-
         _authenticated = false;
         _webSocket->stop();
     }
@@ -620,18 +614,6 @@ namespace ix
         _webSocket->send(pdu.toStyledString());
     }
 
-    std::vector<std::string> CobraConnection::getSubscriptionsIds()
-    {
-        std::vector<std::string> subscriptionIds;
-        std::lock_guard<std::mutex> lock(_cbsMutex);
-
-        for (auto&& it : _cbs)
-        {
-            subscriptionIds.push_back(it.first);
-        }
-        return subscriptionIds;
-    }
-
     //
     // Enqueue strategy drops old messages when we are at full capacity
     //

ixcobra/ixcobra/IXCobraConnection.h

@@ -163,9 +163,6 @@ namespace ix
         /// Tells whether the internal queue is empty or not
         bool isQueueEmpty();
 
-        /// Retrieve all subscriptions ids
-        std::vector<std::string> getSubscriptionsIds();
-
         ///
         /// Member variables
         ///

ixredis/ixredis/IXRedisServer.cpp

@@ -45,11 +45,8 @@ namespace ix
     }
 
     void RedisServer::handleConnection(std::unique_ptr<Socket> socket,
-                                       std::shared_ptr<ConnectionState> connectionState,
-                                       std::unique_ptr<ConnectionInfo> connectionInfo)
+                                       std::shared_ptr<ConnectionState> connectionState)
     {
-        logInfo("New connection from remote ip " + connectionInfo->remoteIp);
-
         _connectedClientsCount++;
 
         while (!_stopHandlingConnections)

ixredis/ixredis/IXRedisServer.h

@@ -44,8 +44,7 @@ namespace ix
 
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo) final;
+                                      std::shared_ptr<ConnectionState> connectionState) final;
         virtual size_t getConnectedClientsCount() final;
 
         bool startsWith(const std::string& str, const std::string& start);

ixsnake/CMakeLists.txt

@@ -7,14 +7,12 @@ set (IXSNAKE_SOURCES
     ixsnake/IXSnakeServer.cpp
     ixsnake/IXSnakeProtocol.cpp
     ixsnake/IXAppConfig.cpp
-    ixsnake/IXStreamSql.cpp
 )
 
 set (IXSNAKE_HEADERS
     ixsnake/IXSnakeServer.h
     ixsnake/IXSnakeProtocol.h
     ixsnake/IXAppConfig.h
-    ixsnake/IXStreamSql.h
 )
 
 add_library(ixsnake STATIC

ixsnake/ixsnake/IXAppConfig.cpp

@@ -26,12 +26,6 @@ namespace snake
         }
 
         auto roles = appConfig.apps[appkey]["roles"];
-        if (roles.count(role) == 0)
-        {
-            std::cerr << "Missing role " << role << std::endl;
-            return std::string();
-        }
-
         auto channel = roles[role]["secret"];
         return channel;
     }

ixsnake/ixsnake/IXAppConfig.h

@@ -33,9 +33,6 @@ namespace snake
         // Misc
         bool verbose;
         bool disablePong;
-
-        // If non empty, every published message gets republished to a given channel
-        std::string republishChannel;
     };
 
     bool isAppKeyValid(const AppConfig& appConfig, std::string appkey);

ixsnake/ixsnake/IXSnakeConnectionState.h

@@ -7,21 +7,15 @@
 #pragma once
 
 #include <ixredis/IXRedisClient.h>
-#include <thread>
+#include <future>
 #include <ixwebsocket/IXConnectionState.h>
 #include <string>
-#include "IXStreamSql.h"
 
 namespace snake
 {
     class SnakeConnectionState : public ix::ConnectionState
     {
     public:
-        virtual ~SnakeConnectionState()
-        {
-            stopSubScriptionThread();
-        }
-
         std::string getNonce()
         {
             return _nonce;
@@ -36,7 +30,6 @@ namespace snake
         {
             return _appkey;
         }
-
         void setAppkey(const std::string& appkey)
         {
             _appkey = appkey;
@@ -46,7 +39,6 @@ namespace snake
         {
             return _role;
         }
-
         void setRole(const std::string& role)
         {
             _role = role;
@@ -57,24 +49,7 @@ namespace snake
             return _redisClient;
         }
 
-        void stopSubScriptionThread()
-        {
-            if (subscriptionThread.joinable())
-            {
-                subscriptionRedisClient.stop();
-                subscriptionThread.join();
-            }
-        }
-
-        // We could make those accessible through methods
-        std::thread subscriptionThread;
-        std::string appChannel;
-        std::string subscriptionId;
-        uint64_t id;
-        std::unique_ptr<StreamSql> streamSql;
-        ix::RedisClient subscriptionRedisClient;
-        ix::RedisClient::OnRedisSubscribeResponseCallback onRedisSubscribeResponseCallback;
-        ix::RedisClient::OnRedisSubscribeCallback onRedisSubscribeCallback;
+        std::future<void> fut;
 
     private:
         std::string _nonce;

ixsnake/ixsnake/IXSnakeProtocol.cpp

@@ -18,22 +18,21 @@
 namespace snake
 {
     void handleError(const std::string& action,
-                     ix::WebSocket& ws,
-                     uint64_t pduId,
+                     std::shared_ptr<ix::WebSocket> ws,
+                     nlohmann::json pdu,
                      const std::string& errMsg)
     {
         std::string actionError(action);
         actionError += "/error";
 
         nlohmann::json response = {
-            {"action", actionError}, {"id", pduId}, {"body", {{"reason", errMsg}}}};
-        ws.sendText(response.dump());
+            {"action", actionError}, {"id", pdu.value("id", 1)}, {"body", {{"reason", errMsg}}}};
+        ws->sendText(response.dump());
     }
 
     void handleHandshake(std::shared_ptr<SnakeConnectionState> state,
-                         ix::WebSocket& ws,
-                         const nlohmann::json& pdu,
-                         uint64_t pduId)
+                         std::shared_ptr<ix::WebSocket> ws,
+                         const nlohmann::json& pdu)
     {
         std::string role = pdu["body"]["data"]["role"];
 
@@ -42,7 +41,7 @@ namespace snake
 
         nlohmann::json response = {
             {"action", "auth/handshake/ok"},
-            {"id", pduId},
+            {"id", pdu.value("id", 1)},
             {"body",
              {
                  {"data", {{"nonce", state->getNonce()}, {"connection_id", state->getId()}}},
@@ -50,14 +49,13 @@ namespace snake
 
         auto serializedResponse = response.dump();
 
-        ws.sendText(serializedResponse);
+        ws->sendText(serializedResponse);
     }
 
     void handleAuth(std::shared_ptr<SnakeConnectionState> state,
-                    ix::WebSocket& ws,
+                    std::shared_ptr<ix::WebSocket> ws,
                     const AppConfig& appConfig,
-                    const nlohmann::json& pdu,
-                    uint64_t pduId)
+                    const nlohmann::json& pdu)
     {
         auto secret = getRoleSecret(appConfig, state->appkey(), state->role());
 
@@ -65,9 +63,9 @@ namespace snake
         {
             nlohmann::json response = {
                 {"action", "auth/authenticate/error"},
-                {"id", pduId},
+                {"id", pdu.value("id", 1)},
                 {"body", {{"error", "authentication_failed"}, {"reason", "invalid secret"}}}};
-            ws.sendText(response.dump());
+            ws->sendText(response.dump());
             return;
         }
 
@@ -81,21 +79,19 @@ namespace snake
                 {"action", "auth/authenticate/error"},
                 {"id", pdu.value("id", 1)},
                 {"body", {{"error", "authentication_failed"}, {"reason", "invalid hash"}}}};
-            ws.sendText(response.dump());
+            ws->sendText(response.dump());
             return;
         }
 
         nlohmann::json response = {
             {"action", "auth/authenticate/ok"}, {"id", pdu.value("id", 1)}, {"body", {}}};
 
-        ws.sendText(response.dump());
+        ws->sendText(response.dump());
     }
 
     void handlePublish(std::shared_ptr<SnakeConnectionState> state,
-                       ix::WebSocket& ws,
-                       const AppConfig& appConfig,
-                       const nlohmann::json& pdu,
-                       uint64_t pduId)
+                       std::shared_ptr<ix::WebSocket> ws,
+                       const nlohmann::json& pdu)
     {
         std::vector<std::string> channels;
 
@@ -115,16 +111,10 @@ namespace snake
         {
             std::stringstream ss;
             ss << "Missing channels or channel field in publish data";
-            handleError("rtm/publish", ws, pduId, ss.str());
+            handleError("rtm/publish", ws, pdu, ss.str());
             return;
         }
 
-        // add an extra channel if the config has one specified
-        if (!appConfig.republishChannel.empty())
-        {
-            channels.push_back(appConfig.republishChannel);
-        }
-
         for (auto&& channel : channels)
         {
             std::stringstream ss;
@@ -135,7 +125,7 @@ namespace snake
             {
                 std::stringstream ss;
                 ss << "Cannot publish to redis host " << errMsg;
-                handleError("rtm/publish", ws, pduId, ss.str());
+                handleError("rtm/publish", ws, pdu, ss.str());
                 return;
             }
         }
@@ -143,27 +133,26 @@ namespace snake
         nlohmann::json response = {
             {"action", "rtm/publish/ok"}, {"id", pdu.value("id", 1)}, {"body", {}}};
 
-        ws.sendText(response.dump());
+        ws->sendText(response.dump());
     }
 
     //
     // FIXME: this is not cancellable. We should be able to cancel the redis subscription
     //
-    void handleSubscribe(std::shared_ptr<SnakeConnectionState> state,
-                         ix::WebSocket& ws,
-                         const AppConfig& appConfig,
-                         const nlohmann::json& pdu,
-                         uint64_t pduId)
+    void handleRedisSubscription(std::shared_ptr<SnakeConnectionState> state,
+                                 std::shared_ptr<ix::WebSocket> ws,
+                                 const AppConfig& appConfig,
+                                 const nlohmann::json& pdu)
     {
         std::string channel = pdu["body"]["channel"];
-        state->subscriptionId = channel;
+        std::string subscriptionId = channel;
 
         std::stringstream ss;
         ss << state->appkey() << "::" << channel;
 
-        state->appChannel = ss.str();
+        std::string appChannel(ss.str());
 
-        ix::RedisClient& redisClient = state->subscriptionRedisClient;
+        ix::RedisClient redisClient;
         int port = appConfig.redisPort;
 
         auto urls = appConfig.redisHosts;
@@ -174,7 +163,7 @@ namespace snake
         {
             std::stringstream ss;
             ss << "Cannot connect to redis host " << hostname << ":" << port;
-            handleError("rtm/subscribe", ws, pduId, ss.str());
+            handleError("rtm/subscribe", ws, pdu, ss.str());
             return;
         }
 
@@ -186,90 +175,80 @@ namespace snake
             {
                 std::stringstream ss;
                 ss << "Cannot authenticated to redis";
-                handleError("rtm/subscribe", ws, pduId, ss.str());
+                handleError("rtm/subscribe", ws, pdu, ss.str());
                 return;
             }
         }
 
-        std::string filterStr;
-        if (pdu["body"].find("filter") != pdu["body"].end())
-        {
-            std::string filterStr = pdu["body"]["filter"];
-        }
-        state->streamSql = std::make_unique<StreamSql>(filterStr);
-        state->id = 0;
-        state->onRedisSubscribeCallback = [&ws, state](const std::string& messageStr) {
+        int id = 0;
+        auto callback = [ws, &id, &subscriptionId](const std::string& messageStr) {
             auto msg = nlohmann::json::parse(messageStr);
 
             msg = msg["body"]["message"];
 
-            if (state->streamSql->valid() && !state->streamSql->match(msg))
-            {
-                return;
-            }
-
             nlohmann::json response = {
                 {"action", "rtm/subscription/data"},
-                {"id", state->id++},
+                {"id", id++},
                 {"body",
-                 {{"subscription_id", state->subscriptionId}, {"position", "0-0"}, {"messages", {msg}}}}};
+                 {{"subscription_id", subscriptionId}, {"position", "0-0"}, {"messages", {msg}}}}};
 
-            ws.sendText(response.dump());
+            ws->sendText(response.dump());
         };
 
-        state->onRedisSubscribeResponseCallback = [&ws, state, pduId](const std::string& redisResponse) {
+        auto responseCallback = [ws, pdu, &subscriptionId](const std::string& redisResponse) {
             std::stringstream ss;
             ss << "Redis Response: " << redisResponse << "...";
             ix::CoreLogger::log(ss.str().c_str());
 
             // Success
             nlohmann::json response = {{"action", "rtm/subscribe/ok"},
-                                       {"id", pduId},
-                                       {"body", {{"subscription_id", state->subscriptionId}}}};
-            ws.sendText(response.dump());
+                                       {"id", pdu.value("id", 1)},
+                                       {"body", {{"subscription_id", subscriptionId}}}};
+            ws->sendText(response.dump());
         };
 
         {
             std::stringstream ss;
-            ss << "Subscribing to " << state->appChannel << "...";
+            ss << "Subscribing to " << appChannel << "...";
             ix::CoreLogger::log(ss.str().c_str());
         }
 
-        auto subscription = [&redisClient, state, &ws, pduId]
+        if (!redisClient.subscribe(appChannel, responseCallback, callback))
         {
-            if (!redisClient.subscribe(state->appChannel, 
-                                       state->onRedisSubscribeResponseCallback,
-                                       state->onRedisSubscribeCallback))
-            {
-                std::stringstream ss;
-                ss << "Error subscribing to channel " << state->appChannel;
-                handleError("rtm/subscribe", ws, pduId, ss.str());
-                return;
-            }
-        };
+            std::stringstream ss;
+            ss << "Error subscribing to channel " << appChannel;
+            handleError("rtm/subscribe", ws, pdu, ss.str());
+            return;
+        }
+    }
 
-        state->subscriptionThread = std::thread(subscription);
+    void handleSubscribe(std::shared_ptr<SnakeConnectionState> state,
+                         std::shared_ptr<ix::WebSocket> ws,
+                         const AppConfig& appConfig,
+                         const nlohmann::json& pdu)
+    {
+        state->fut =
+            std::async(std::launch::async, handleRedisSubscription, state, ws, appConfig, pdu);
     }
 
     void handleUnSubscribe(std::shared_ptr<SnakeConnectionState> state,
-                           ix::WebSocket& ws,
-                           const nlohmann::json& pdu,
-                           uint64_t pduId)
+                           std::shared_ptr<ix::WebSocket> ws,
+                           const nlohmann::json& pdu)
     {
         // extract subscription_id
         auto body = pdu["body"];
         auto subscriptionId = body["subscription_id"];
 
-        state->stopSubScriptionThread();
+        state->redisClient().stop();
 
         nlohmann::json response = {{"action", "rtm/unsubscribe/ok"},
-                                   {"id", pduId},
+                                   {"id", pdu.value("id", 1)},
                                    {"body", {{"subscription_id", subscriptionId}}}};
-        ws.sendText(response.dump());
+        ws->sendText(response.dump());
     }
 
     void processCobraMessage(std::shared_ptr<SnakeConnectionState> state,
-                             ix::WebSocket& ws,
+                             std::shared_ptr<ix::WebSocket> ws,
                              const AppConfig& appConfig,
                              const std::string& str)
     {
@@ -284,32 +263,31 @@ namespace snake
             ss << "malformed json pdu: " << e.what() << " -> " << str << "";
 
             nlohmann::json response = {{"body", {{"error", "invalid_json"}, {"reason", ss.str()}}}};
-            ws.sendText(response.dump());
+            ws->sendText(response.dump());
             return;
         }
 
         auto action = pdu["action"];
-        uint64_t pduId = pdu.value("id", 1);
 
         if (action == "auth/handshake")
         {
-            handleHandshake(state, ws, pdu, pduId);
+            handleHandshake(state, ws, pdu);
         }
         else if (action == "auth/authenticate")
         {
-            handleAuth(state, ws, appConfig, pdu, pduId);
+            handleAuth(state, ws, appConfig, pdu);
         }
         else if (action == "rtm/publish")
         {
-            handlePublish(state, ws, appConfig, pdu, pduId);
+            handlePublish(state, ws, pdu);
         }
         else if (action == "rtm/subscribe")
         {
-            handleSubscribe(state, ws, appConfig, pdu, pduId);
+            handleSubscribe(state, ws, appConfig, pdu);
         }
         else if (action == "rtm/unsubscribe")
         {
-            handleUnSubscribe(state, ws, pdu, pduId);
+            handleUnSubscribe(state, ws, pdu);
         }
         else
         {

ixsnake/ixsnake/IXSnakeProtocol.h

@@ -20,7 +20,7 @@ namespace snake
     struct AppConfig;
 
     void processCobraMessage(std::shared_ptr<SnakeConnectionState> state,
-                             ix::WebSocket& ws,
+                             std::shared_ptr<ix::WebSocket> ws,
                              const AppConfig& appConfig,
                              const std::string& str);
 } // namespace snake

ixsnake/ixsnake/IXSnakeServer.cpp

@@ -59,68 +59,65 @@ namespace snake
         };
         _server.setConnectionStateFactory(factory);
 
-        _server.setOnClientMessageCallback(
-            [this](std::shared_ptr<ix::ConnectionState> connectionState,
-                   ix::ConnectionInfo& connectionInfo,
-                   ix::WebSocket& webSocket,
-                   const ix::WebSocketMessagePtr& msg) {
+        _server.setOnConnectionCallback(
+            [this](std::shared_ptr<ix::WebSocket> webSocket,
+                   std::shared_ptr<ix::ConnectionState> connectionState) {
                 auto state = std::dynamic_pointer_cast<SnakeConnectionState>(connectionState);
-                auto remoteIp = connectionInfo.remoteIp;
-            
-                std::stringstream ss;
-                ss << "[" << state->getId() << "] ";
 
-                ix::LogLevel logLevel = ix::LogLevel::Debug;
-                if (msg->type == ix::WebSocketMessageType::Open)
-                {
-                    ss << "New connection" << std::endl;
-                    ss << "remote ip: " << remoteIp << std::endl;
-                    ss << "id: " << state->getId() << std::endl;
-                    ss << "Uri: " << msg->openInfo.uri << std::endl;
-                    ss << "Headers:" << std::endl;
-                    for (auto it : msg->openInfo.headers)
-                    {
-                        ss << it.first << ": " << it.second << std::endl;
-                    }
+                webSocket->setOnMessageCallback(
+                    [this, webSocket, state](const ix::WebSocketMessagePtr& msg) {
+                        std::stringstream ss;
+                        ix::LogLevel logLevel = ix::LogLevel::Debug;
+                        if (msg->type == ix::WebSocketMessageType::Open)
+                        {
+                            ss << "New connection" << std::endl;
+                            ss << "id: " << state->getId() << std::endl;
+                            ss << "Uri: " << msg->openInfo.uri << std::endl;
+                            ss << "Headers:" << std::endl;
+                            for (auto it : msg->openInfo.headers)
+                            {
+                                ss << it.first << ": " << it.second << std::endl;
+                            }
 
-                    std::string appkey = parseAppKey(msg->openInfo.uri);
-                    state->setAppkey(appkey);
+                            std::string appkey = parseAppKey(msg->openInfo.uri);
+                            state->setAppkey(appkey);
 
-                    // Connect to redis first
-                    if (!state->redisClient().connect(_appConfig.redisHosts[0],
-                                                      _appConfig.redisPort))
-                    {
-                        ss << "Cannot connect to redis host" << std::endl;
-                        logLevel = ix::LogLevel::Error;
-                    }
-                }
-                else if (msg->type == ix::WebSocketMessageType::Close)
-                {
-                    ss << "Closed connection"
-                       << " code " << msg->closeInfo.code << " reason "
-                       << msg->closeInfo.reason << std::endl;
-                }
-                else if (msg->type == ix::WebSocketMessageType::Error)
-                {
-                    std::stringstream ss;
-                    ss << "Connection error: " << msg->errorInfo.reason << std::endl;
-                    ss << "#retries: " << msg->errorInfo.retries << std::endl;
-                    ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
-                    ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
-                    logLevel = ix::LogLevel::Error;
-                }
-                else if (msg->type == ix::WebSocketMessageType::Fragment)
-                {
-                    ss << "Received message fragment" << std::endl;
-                }
-                else if (msg->type == ix::WebSocketMessageType::Message)
-                {
-                    ss << "Received " << msg->wireSize << " bytes" << " " << msg->str << std::endl;
-                    processCobraMessage(state, webSocket, _appConfig, msg->str);
-                }
+                            // Connect to redis first
+                            if (!state->redisClient().connect(_appConfig.redisHosts[0],
+                                                              _appConfig.redisPort))
+                            {
+                                ss << "Cannot connect to redis host" << std::endl;
+                                logLevel = ix::LogLevel::Error;
+                            }
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Close)
+                        {
+                            ss << "Closed connection"
+                               << " code " << msg->closeInfo.code << " reason "
+                               << msg->closeInfo.reason << std::endl;
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Error)
+                        {
+                            std::stringstream ss;
+                            ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                            ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                            ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                            ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                            logLevel = ix::LogLevel::Error;
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Fragment)
+                        {
+                            ss << "Received message fragment" << std::endl;
+                        }
+                        else if (msg->type == ix::WebSocketMessageType::Message)
+                        {
+                            ss << "Received " << msg->wireSize << " bytes" << std::endl;
+                            processCobraMessage(state, webSocket, _appConfig, msg->str);
+                        }
 
-                ix::CoreLogger::log(ss.str().c_str(), logLevel);
-        });
+                        ix::CoreLogger::log(ss.str().c_str(), logLevel);
+                    });
+            });
 
         auto res = _server.listen();
         if (!res.first)

ixsnake/ixsnake/IXStreamSql.cpp

@@ -1,63 +0,0 @@
-/*
- *  IXStreamSql.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- *
- *  Super simple hacked up version of a stream sql expression,
- *  that only supports non nested field evaluation
- */
-
-#include "IXStreamSql.h"
-#include <sstream>
-#include <iostream>
-
-namespace snake
-{
-    StreamSql::StreamSql(const std::string& sqlFilter)
-        : _valid(false)
-    {
-        std::string token;
-        std::stringstream tokenStream(sqlFilter);
-        std::vector<std::string> tokens;
-
-        // Split by ' '
-        while (std::getline(tokenStream, token, ' '))
-        {
-            tokens.push_back(token);
-        }
-
-        _valid = tokens.size() == 8;
-        if (!_valid) return;
-
-        _field = tokens[5];
-        _operator = tokens[6];
-        _value = tokens[7];
-
-        // remove single quotes
-        _value = _value.substr(1, _value.size() - 2);
-
-        if (_operator == "LIKE")
-        {
-            _value = _value.substr(1, _value.size() - 2);
-        }
-    }
-
-    bool StreamSql::valid() const
-    {
-        return _valid;
-    }
-
-    bool StreamSql::match(const nlohmann::json& msg)
-    {
-        if (!_valid) return false;
-
-        if (msg.find(_field) == msg.end())
-        {
-            return false;
-        }
-
-        std::string value = msg[_field];
-        return value == _value;
-    }
-
-} // namespace snake

ixsnake/ixsnake/IXStreamSql.h

@@ -1,29 +0,0 @@
-/*
- *  IXStreamSql.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include <string>
-#include "nlohmann/json.hpp"
-
-namespace snake
-{
-    class StreamSql
-    {
-    public:
-        StreamSql(const std::string& sqlFilter = std::string());
-        ~StreamSql() = default;
-
-        bool match(const nlohmann::json& msg);
-        bool valid() const;
-
-    private:
-        std::string _field;
-        std::string _operator;
-        std::string _value;
-        bool _valid;
-    };
-}

ixwebsocket/IXBench.h

@@ -3,7 +3,6 @@
  *  Author: Benjamin Sergeant
  *  Copyright (c) 2017-2020 Machine Zone, Inc. All rights reserved.
  */
-#pragma once
 
 #include <chrono>
 #include <stdint.h>

ixwebsocket/IXConnectionInfo.h

@@ -1,25 +0,0 @@
-/*
- *  IXConnectionInfo.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include <string>
-
-namespace ix
-{
-    struct ConnectionInfo
-    {
-        std::string remoteIp;
-        int remotePort;
-
-        ConnectionInfo(const std::string& r = std::string(), int p = 0)
-            : remoteIp(r)
-            , remotePort(p)
-        {
-            ;
-        }
-    };
-} // namespace ix

ixwebsocket/IXConnectionState.cpp

@@ -31,11 +31,6 @@ namespace ix
         return std::make_shared<ConnectionState>();
     }
 
-    void ConnectionState::setOnSetTerminatedCallback(const OnSetTerminatedCallback& callback)
-    {
-        _onSetTerminatedCallback = callback;
-    }
-
     bool ConnectionState::isTerminated() const
     {
         return _terminated;
@@ -44,10 +39,5 @@ namespace ix
     void ConnectionState::setTerminated()
     {
         _terminated = true;
-
-        if (_onSetTerminatedCallback)
-        {
-            _onSetTerminatedCallback();
-        }
     }
 } // namespace ix

ixwebsocket/IXConnectionState.h

@@ -7,15 +7,12 @@
 #pragma once
 
 #include <atomic>
-#include <functional>
 #include <memory>
 #include <stdint.h>
 #include <string>
 
 namespace ix
 {
-    using OnSetTerminatedCallback = std::function<void()>;
-
     class ConnectionState
     {
     public:
@@ -30,16 +27,10 @@ namespace ix
 
         static std::shared_ptr<ConnectionState> createConnectionState();
 
-    private:
-        void setOnSetTerminatedCallback(const OnSetTerminatedCallback& callback);
-
     protected:
         std::atomic<bool> _terminated;
         std::string _id;
-        OnSetTerminatedCallback _onSetTerminatedCallback;
 
         static std::atomic<uint64_t> _globalId;
-
-        friend class SocketServer;
     };
 } // namespace ix

ixwebsocket/IXHttpClient.cpp

@@ -16,10 +16,7 @@
 #include <random>
 #include <sstream>
 #include <vector>
-
-#ifdef IXWEBSOCKET_USE_ZLIB
 #include <zlib.h>
-#endif
 
 namespace ix
 {
@@ -177,13 +174,11 @@ namespace ix
         ss << verb << " " << path << " HTTP/1.1\r\n";
         ss << "Host: " << host << "\r\n";
 
-#ifdef IXWEBSOCKET_USE_ZLIB
         if (args->compress)
         {
             ss << "Accept-Encoding: gzip"
                << "\r\n";
         }
-#endif
 
         // Append extra headers
         for (auto&& it : args->extraHeaders)
@@ -500,7 +495,6 @@ namespace ix
 
         downloadSize = payload.size();
 
-#ifdef IXWEBSOCKET_USE_ZLIB
         // If the content was compressed with gzip, decode it
         if (headers["Content-Encoding"] == "gzip")
         {
@@ -519,7 +513,6 @@ namespace ix
             }
             payload = decompressedPayload;
         }
-#endif
 
         return std::make_shared<HttpResponse>(code,
                                               description,
@@ -679,7 +672,6 @@ namespace ix
         return ss.str();
     }
 
-#ifdef IXWEBSOCKET_USE_ZLIB
     bool HttpClient::gzipInflate(const std::string& in, std::string& out)
     {
         z_stream inflateState;
@@ -724,7 +716,6 @@ namespace ix
         inflateEnd(&inflateState);
         return true;
     }
-#endif
 
     void HttpClient::log(const std::string& msg, HttpRequestArgsPtr args)
     {

ixwebsocket/IXHttpClient.h

@@ -90,9 +90,7 @@ namespace ix
     private:
         void log(const std::string& msg, HttpRequestArgsPtr args);
 
-#ifdef IXWEBSOCKET_USE_ZLIB
         bool gzipInflate(const std::string& in, std::string& out);
-#endif
 
         // Async API background thread runner
         void run();
@@ -105,9 +103,9 @@ namespace ix
         std::thread _thread;
 
         std::unique_ptr<Socket> _socket;
-        std::recursive_mutex _mutex; // to protect accessing the _socket (only one socket per
-                                     // client) the mutex needs to be recursive as this function
-                                     // might be called recursively to follow HTTP redirections
+        std::recursive_mutex _mutex; // to protect accessing the _socket (only one socket per client)
+                                     // the mutex needs to be recursive as this function might
+                                     // be called recursively to follow HTTP redirections
 
         SocketTLSOptions _tlsOptions;
 

ixwebsocket/IXHttpServer.cpp

@@ -9,14 +9,11 @@
 #include "IXNetSystem.h"
 #include "IXSocketConnect.h"
 #include "IXUserAgent.h"
-#include <cstring>
 #include <fstream>
 #include <sstream>
 #include <vector>
-
-#ifdef IXWEBSOCKET_USE_ZLIB
 #include <zlib.h>
-#endif
+#include <cstring>
 
 namespace
 {
@@ -44,7 +41,6 @@ namespace
         return std::make_pair(res.first, std::string(vec.begin(), vec.end()));
     }
 
-#ifdef IXWEBSOCKET_USE_ZLIB
     std::string gzipCompress(const std::string& str)
     {
         z_stream zs; // z_stream is zlib's control structure
@@ -54,11 +50,8 @@ namespace
         const int windowBits = 15;
         const int GZIP_ENCODING = 16;
 
-        deflateInit2(&zs,
-                     Z_DEFAULT_COMPRESSION,
-                     Z_DEFLATED,
-                     windowBits | GZIP_ENCODING,
-                     8,
+        deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                     windowBits | GZIP_ENCODING, 8,
                      Z_DEFAULT_STRATEGY);
 
         zs.next_in = (Bytef*) str.data();
@@ -76,18 +69,18 @@ namespace
 
             ret = deflate(&zs, Z_FINISH);
 
-            if (outstring.size() < zs.total_out)
+            if(outstring.size() < zs.total_out)
             {
                 // append the block to the output string
-                outstring.append(outbuffer, zs.total_out - outstring.size());
+                outstring.append(outbuffer,
+                                 zs.total_out - outstring.size());
             }
-        } while (ret == Z_OK);
+        } while(ret == Z_OK);
 
         deflateEnd(&zs);
 
         return outstring;
     }
-#endif
 } // namespace
 
 namespace ix
@@ -120,8 +113,7 @@ namespace ix
     }
 
     void HttpServer::handleConnection(std::unique_ptr<Socket> socket,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo)
+                                      std::shared_ptr<ConnectionState> connectionState)
     {
         _connectedClientsCount++;
 
@@ -130,8 +122,7 @@ namespace ix
 
         if (std::get<0>(ret))
         {
-            auto response =
-                _onConnectionCallback(std::get<2>(ret), connectionState, std::move(connectionInfo));
+            auto response = _onConnectionCallback(std::get<2>(ret), connectionState);
             if (!Http::sendResponse(response, socket))
             {
                 logError("Cannot send response");
@@ -151,8 +142,7 @@ namespace ix
     {
         setOnConnectionCallback(
             [this](HttpRequestPtr request,
-                   std::shared_ptr<ConnectionState> /*connectionState*/,
-                   std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
+                   std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr {
                 std::string uri(request->uri);
                 if (uri.empty() || uri == "/")
                 {
@@ -173,19 +163,16 @@ namespace ix
 
                 std::string content = res.second;
 
-#ifdef IXWEBSOCKET_USE_ZLIB
                 std::string acceptEncoding = request->headers["Accept-encoding"];
                 if (acceptEncoding == "*" || acceptEncoding.find("gzip") != std::string::npos)
                 {
                     content = gzipCompress(content);
                     headers["Content-Encoding"] = "gzip";
                 }
-#endif
 
                 // Log request
                 std::stringstream ss;
-                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
-                   << request->method << " " << request->headers["User-Agent"] << " "
+                ss << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri << " " << content.size();
                 logInfo(ss.str());
 
@@ -209,16 +196,15 @@ namespace ix
         // See https://developer.mozilla.org/en-US/docs/Web/HTTP/Redirections
         //
         setOnConnectionCallback(
-            [this, redirectUrl](HttpRequestPtr request,
-                                std::shared_ptr<ConnectionState> /*connectionState*/,
-                                std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
+            [this,
+             redirectUrl](HttpRequestPtr request,
+                          std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr {
                 WebSocketHttpHeaders headers;
                 headers["Server"] = userAgent();
 
                 // Log request
                 std::stringstream ss;
-                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
-                   << request->method << " " << request->headers["User-Agent"] << " "
+                ss << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri;
                 logInfo(ss.str());
 

ixwebsocket/IXHttpServer.h

@@ -23,9 +23,7 @@ namespace ix
     {
     public:
         using OnConnectionCallback =
-            std::function<HttpResponsePtr(HttpRequestPtr,
-                                          std::shared_ptr<ConnectionState>,
-                                          std::unique_ptr<ConnectionInfo> connectionInfo)>;
+            std::function<HttpResponsePtr(HttpRequestPtr, std::shared_ptr<ConnectionState>)>;
 
         HttpServer(int port = SocketServer::kDefaultPort,
                    const std::string& host = SocketServer::kDefaultHost,
@@ -46,8 +44,7 @@ namespace ix
 
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo) final;
+                                      std::shared_ptr<ConnectionState> connectionState) final;
         virtual size_t getConnectedClientsCount() final;
 
         void setDefaultConnectionCallback();

ixwebsocket/IXSelectInterrupt.cpp

@@ -8,9 +8,6 @@
 
 namespace ix
 {
-    const uint64_t SelectInterrupt::kSendRequest = 1;
-    const uint64_t SelectInterrupt::kCloseRequest = 2;
-
     SelectInterrupt::SelectInterrupt()
     {
         ;

ixwebsocket/IXSelectInterrupt.h

@@ -6,7 +6,6 @@
 
 #pragma once
 
-#include <memory>
 #include <stdint.h>
 #include <string>
 
@@ -24,11 +23,5 @@ namespace ix
         virtual bool clear();
         virtual uint64_t read();
         virtual int getFd() const;
-
-        // Used as special codes for pipe communication
-        static const uint64_t kSendRequest;
-        static const uint64_t kCloseRequest;
     };
-
-    using SelectInterruptPtr = std::unique_ptr<SelectInterrupt>;
 } // namespace ix

ixwebsocket/IXSelectInterruptPipe.cpp

@@ -5,10 +5,8 @@
  */
 
 //
-// On UNIX we use pipes to wake up select. There is no way to do that
-// on Windows so this file is compiled out on Windows.
+// On macOS we use UNIX pipes to wake up select.
 //
-#ifndef _WIN32
 
 #include "IXSelectInterruptPipe.h"
 
@@ -146,5 +144,3 @@ namespace ix
         return _fildes[kPipeReadIndex];
     }
 } // namespace ix
-
-#endif // !_WIN32

ixwebsocket/IXSetThreadName.cpp

@@ -1,81 +0,0 @@
-/*
- *  IXSetThreadName.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 2020 Machine Zone, Inc. All rights reserved.
- */
-#include "IXSetThreadName.h"
-
-// unix systems
-#if defined(__APPLE__) || defined(__linux__) || defined(BSD)
-#include <pthread.h>
-#endif
-
-// freebsd needs this header as well
-#if defined(BSD)
-#include <pthread_np.h>
-#endif
-
-// Windows
-#ifdef _WIN32
-#include <Windows.h>
-#endif
-
-namespace ix
-{
-#ifdef _WIN32
-    const DWORD MS_VC_EXCEPTION = 0x406D1388;
-
-#pragma pack(push, 8)
-    typedef struct tagTHREADNAME_INFO
-    {
-        DWORD dwType;     // Must be 0x1000.
-        LPCSTR szName;    // Pointer to name (in user addr space).
-        DWORD dwThreadID; // Thread ID (-1=caller thread).
-        DWORD dwFlags;    // Reserved for future use, must be zero.
-    } THREADNAME_INFO;
-#pragma pack(pop)
-
-    void SetThreadName(DWORD dwThreadID, const char* threadName)
-    {
-        THREADNAME_INFO info;
-        info.dwType = 0x1000;
-        info.szName = threadName;
-        info.dwThreadID = dwThreadID;
-        info.dwFlags = 0;
-
-        __try
-        {
-            RaiseException(
-                MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*) &info);
-        }
-        __except (EXCEPTION_EXECUTE_HANDLER)
-        {
-        }
-    }
-#endif
-
-    void setThreadName(const std::string& name)
-    {
-#if defined(__APPLE__)
-        //
-        // Apple reserves 16 bytes for its thread names
-        // Notice that the Apple version of pthread_setname_np
-        // does not take a pthread_t argument
-        //
-        pthread_setname_np(name.substr(0, 63).c_str());
-#elif defined(__linux__)
-        //
-        // Linux only reserves 16 bytes for its thread names
-        // See prctl and PR_SET_NAME property in
-        // http://man7.org/linux/man-pages/man2/prctl.2.html
-        //
-        pthread_setname_np(pthread_self(), name.substr(0, 15).c_str());
-#elif defined(_WIN32)
-        SetThreadName(-1, name.c_str());
-#elif defined(BSD)
-        pthread_set_name_np(pthread_self(), name.substr(0, 15).c_str());
-#else
-        // ... assert here ?
-#endif
-    }
-} // namespace ix

ixwebsocket/IXSocket.cpp

@@ -27,6 +27,8 @@ namespace ix
 {
     const int Socket::kDefaultPollNoTimeout = -1; // No poll timeout by default
     const int Socket::kDefaultPollTimeout = kDefaultPollNoTimeout;
+    const uint64_t Socket::kSendRequest = 1;
+    const uint64_t Socket::kCloseRequest = 2;
     constexpr size_t Socket::kChunkSize;
 
     Socket::Socket(int fd)
@@ -94,11 +96,11 @@ namespace ix
         {
             uint64_t value = selectInterrupt->read();
 
-            if (value == SelectInterrupt::kSendRequest)
+            if (value == kSendRequest)
             {
                 pollResult = PollResultType::SendRequest;
             }
-            else if (value == SelectInterrupt::kCloseRequest)
+            else if (value == kCloseRequest)
             {
                 pollResult = PollResultType::CloseRequest;
             }

ixwebsocket/IXSocket.h

@@ -34,10 +34,12 @@ typedef SSIZE_T ssize_t;
 
 #include "IXCancellationRequest.h"
 #include "IXProgressCallback.h"
-#include "IXSelectInterrupt.h"
 
 namespace ix
 {
+    class SelectInterrupt;
+    using SelectInterruptPtr = std::unique_ptr<SelectInterrupt>;
+
     enum class PollResultType
     {
         ReadyForRead = 0,
@@ -94,6 +96,11 @@ namespace ix
                                    int sockfd,
                                    const SelectInterruptPtr& selectInterrupt);
 
+
+        // Used as special codes for pipe communication
+        static const uint64_t kSendRequest;
+        static const uint64_t kCloseRequest;
+
     protected:
         std::atomic<int> _sockfd;
         std::mutex _socketMutex;

ixwebsocket/IXSocketServer.cpp

@@ -8,7 +8,6 @@
 
 #include "IXNetSystem.h"
 #include "IXSelectInterrupt.h"
-#include "IXSelectInterruptFactory.h"
 #include "IXSetThreadName.h"
 #include "IXSocket.h"
 #include "IXSocketConnect.h"
@@ -23,7 +22,7 @@ namespace ix
     const int SocketServer::kDefaultPort(8080);
     const std::string SocketServer::kDefaultHost("127.0.0.1");
     const int SocketServer::kDefaultTcpBacklog(5);
-    const size_t SocketServer::kDefaultMaxConnections(128);
+    const size_t SocketServer::kDefaultMaxConnections(32);
     const int SocketServer::kDefaultAddressFamily(AF_INET);
 
     SocketServer::SocketServer(
@@ -37,7 +36,6 @@ namespace ix
         , _stop(false)
         , _stopGc(false)
         , _connectionStateFactory(&ConnectionState::createConnectionState)
-        , _acceptSelectInterrupt(createSelectInterrupt())
     {
     }
 
@@ -60,16 +58,6 @@ namespace ix
 
     std::pair<bool, std::string> SocketServer::listen()
     {
-        std::string acceptSelectInterruptInitErrorMsg;
-        if (!_acceptSelectInterrupt->init(acceptSelectInterruptInitErrorMsg))
-        {
-            std::stringstream ss;
-            ss << "SocketServer::listen() error in SelectInterrupt::init: "
-               << acceptSelectInterruptInitErrorMsg;
-
-            return std::make_pair(false, ss.str());
-        }
-
         if (_addressFamily != AF_INET && _addressFamily != AF_INET6)
         {
             std::string errMsg("SocketServer::listen() AF_INET and AF_INET6 are currently "
@@ -205,12 +193,6 @@ namespace ix
         if (_thread.joinable())
         {
             _stop = true;
-            // Wake up select
-            if (!_acceptSelectInterrupt->notify(SelectInterrupt::kCloseRequest))
-            {
-                logError("SocketServer::stop: Cannot wake up from select");
-            }
-
             _thread.join();
             _stop = false;
         }
@@ -219,7 +201,6 @@ namespace ix
         if (_gcThread.joinable())
         {
             _stopGc = true;
-            _conditionVariableGC.notify_one();
             _gcThread.join();
             _stopGc = false;
         }
@@ -268,22 +249,18 @@ namespace ix
         // Set the socket to non blocking mode, so that accept calls are not blocking
         SocketConnect::configure(_serverFd);
 
-        setThreadName("SocketServer::accept");
+        setThreadName("SocketServer::listen");
 
         for (;;)
         {
             if (_stop) return;
 
             // Use poll to check whether a new connection is in progress
-            int timeoutMs = -1;
-#ifdef _WIN32
-            // select cannot be interrupted on Windows so we need to pass a small timeout
-            timeoutMs = 10;
-#endif
-
+            int timeoutMs = 10;
             bool readyToRead = true;
+            auto selectInterrupt = std::make_unique<SelectInterrupt>();
             PollResultType pollResult =
-                Socket::poll(readyToRead, timeoutMs, _serverFd, _acceptSelectInterrupt);
+                Socket::poll(readyToRead, timeoutMs, _serverFd, selectInterrupt);
 
             if (pollResult == PollResultType::Error)
             {
@@ -299,7 +276,6 @@ namespace ix
             }
 
             // Accept a connection.
-            // FIXME: Is this working for ipv6 ?
             struct sockaddr_in client; // client address information
             int clientFd;              // socket connected to client
             socklen_t addressLen = sizeof(client);
@@ -331,52 +307,11 @@ namespace ix
                 continue;
             }
 
-            // Retrieve connection info, the ip address of the remote peer/client)
-            std::unique_ptr<ConnectionInfo> connectionInfo;
-
-            if (_addressFamily == AF_INET)
-            {
-                char remoteIp[INET_ADDRSTRLEN];
-                if (inet_ntop(AF_INET, &client.sin_addr, remoteIp, INET_ADDRSTRLEN) == nullptr)
-                {
-                    int err = Socket::getErrno();
-                    std::stringstream ss;
-                    ss << "SocketServer::run() error calling inet_ntop (ipv4): " << err << ", "
-                       << strerror(err);
-                    logError(ss.str());
-
-                    Socket::closeSocket(clientFd);
-
-                    continue;
-                }
-
-                connectionInfo = std::make_unique<ConnectionInfo>(remoteIp, client.sin_port);
-            }
-            else // AF_INET6
-            {
-                char remoteIp[INET6_ADDRSTRLEN];
-                if (inet_ntop(AF_INET6, &client.sin_addr, remoteIp, INET6_ADDRSTRLEN) == nullptr)
-                {
-                    int err = Socket::getErrno();
-                    std::stringstream ss;
-                    ss << "SocketServer::run() error calling inet_ntop (ipv6): " << err << ", "
-                       << strerror(err);
-                    logError(ss.str());
-
-                    Socket::closeSocket(clientFd);
-
-                    continue;
-                }
-
-                connectionInfo = std::make_unique<ConnectionInfo>(remoteIp, client.sin_port);
-            }
-
             std::shared_ptr<ConnectionState> connectionState;
             if (_connectionStateFactory)
             {
                 connectionState = _connectionStateFactory();
             }
-            connectionState->setOnSetTerminatedCallback([this] { onSetTerminatedCallback(); });
 
             if (_stop) return;
 
@@ -404,13 +339,10 @@ namespace ix
 
             // Launch the handleConnection work asynchronously in its own thread.
             std::lock_guard<std::mutex> lock(_connectionsThreadsMutex);
-            _connectionsThreads.push_back(
-                std::make_pair(connectionState,
-                               std::thread(&SocketServer::handleConnection,
-                                           this,
-                                           std::move(socket),
-                                           connectionState,
-                                           std::move(connectionInfo))));
+            _connectionsThreads.push_back(std::make_pair(
+                connectionState,
+                std::thread(
+                    &SocketServer::handleConnection, this, std::move(socket), connectionState)));
         }
     }
 
@@ -436,14 +368,8 @@ namespace ix
                 break;
             }
 
-            // Unless we are stopping the server, wait for a connection
-            // to be terminated to run the threads GC, instead of busy waiting
-            // with a sleep
-            if (!_stopGc)
-            {
-                std::unique_lock<std::mutex> lock(_conditionVariableMutexGC);
-                _conditionVariableGC.wait(lock);
-            }
+            // Sleep a little bit then keep cleaning up
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
         }
     }
 
@@ -451,11 +377,4 @@ namespace ix
     {
         _socketTLSOptions = socketTLSOptions;
     }
-
-    void SocketServer::onSetTerminatedCallback()
-    {
-        // a connection got terminated, we can run the connection thread GC,
-        // so wake up the thread responsible for that
-        _conditionVariableGC.notify_one();
-    }
 } // namespace ix

ixwebsocket/IXSocketServer.h

@@ -6,9 +6,7 @@
 
 #pragma once
 
-#include "IXConnectionInfo.h"
 #include "IXConnectionState.h"
-#include "IXSelectInterrupt.h"
 #include "IXSocketTLSOptions.h"
 #include <atomic>
 #include <condition_variable>
@@ -85,7 +83,6 @@ namespace ix
         // background thread to wait for incoming connections
         std::thread _thread;
         void run();
-        void onSetTerminatedCallback();
 
         // background thread to cleanup (join) terminated threads
         std::atomic<bool> _stopGc;
@@ -105,8 +102,7 @@ namespace ix
         ConnectionStateFactory _connectionStateFactory;
 
         virtual void handleConnection(std::unique_ptr<Socket>,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo) = 0;
+                                      std::shared_ptr<ConnectionState> connectionState) = 0;
         virtual size_t getConnectedClientsCount() = 0;
 
         // Returns true if all connection threads are joined
@@ -114,13 +110,5 @@ namespace ix
         size_t getConnectionsThreadsCount();
 
         SocketTLSOptions _socketTLSOptions;
-
-        // to wake up from select
-        SelectInterruptPtr _acceptSelectInterrupt;
-
-        // used by the gc thread, to know that a thread needs to be garbage collected
-        // as a connection
-        std::condition_variable _conditionVariableGC;
-        std::mutex _conditionVariableMutexGC;
     };
 } // namespace ix

ixwebsocket/IXUrlParser.cpp

@@ -32,8 +32,8 @@
 #include "IXUrlParser.h"
 
 #include <algorithm>
-#include <cstdlib>
 #include <cstring>
+#include <cstdlib>
 
 namespace
 {

ixwebsocket/IXUserAgent.cpp

@@ -8,9 +8,7 @@
 
 #include "IXWebSocketVersion.h"
 #include <sstream>
-#ifdef IXWEBSOCKET_USE_ZLIB
 #include <zlib.h>
-#endif
 
 // Platform name
 #if defined(_WIN32)
@@ -79,10 +77,8 @@ namespace ix
         ss << " nossl";
 #endif
 
-#ifdef IXWEBSOCKET_USE_ZLIB
         // Zlib version
         ss << " zlib " << ZLIB_VERSION;
-#endif
 
         return ss.str();
     }

ixwebsocket/IXWebSocket.cpp

@@ -46,7 +46,6 @@ namespace ix
     WebSocket::~WebSocket()
     {
         stop();
-        _ws.setOnCloseCallback(nullptr);
     }
 
     void WebSocket::setUrl(const std::string& url)
@@ -405,11 +404,6 @@ namespace ix
         _onMessageCallback = callback;
     }
 
-    bool WebSocket::isOnMessageCallbackRegistered() const
-    {
-        return _onMessageCallback != nullptr;
-    }
-
     void WebSocket::setTrafficTrackerCallback(const OnTrafficTrackerCallback& callback)
     {
         _onTrafficTrackerCallback = callback;
@@ -435,6 +429,16 @@ namespace ix
         return (binary) ? sendBinary(data, onProgressCallback) : sendText(data, onProgressCallback);
     }
 
+    WebSocketSendInfo WebSocket::sendBinary(const std::vector<uint8_t>& data,
+                                            const OnProgressCallback& onProgressCallback)
+    {
+        if (!isConnected()) return WebSocketSendInfo(false);
+        std::lock_guard<std::mutex> lock(_writeMutex);
+        auto webSocketSendInfo = _ws.sendBinary(data, onProgressCallback);
+        WebSocket::invokeTrafficTrackerCallback(webSocketSendInfo.wireSize, false);
+        return webSocketSendInfo;
+    }
+
     WebSocketSendInfo WebSocket::sendBinary(const std::string& text,
                                             const OnProgressCallback& onProgressCallback)
     {

ixwebsocket/IXWebSocket.h

@@ -74,8 +74,11 @@ namespace ix
         WebSocketSendInfo send(const std::string& data,
                                bool binary = false,
                                const OnProgressCallback& onProgressCallback = nullptr);
+
         WebSocketSendInfo sendBinary(const std::string& text,
                                      const OnProgressCallback& onProgressCallback = nullptr);
+        WebSocketSendInfo sendBinary(const std::vector<uint8_t>& data,
+                                     const OnProgressCallback& onProgressCallback = nullptr);
         WebSocketSendInfo sendText(const std::string& text,
                                    const OnProgressCallback& onProgressCallback = nullptr);
         WebSocketSendInfo ping(const std::string& text);
@@ -84,7 +87,6 @@ namespace ix
                    const std::string& reason = WebSocketCloseConstants::kNormalClosureMessage);
 
         void setOnMessageCallback(const OnMessageCallback& callback);
-        bool isOnMessageCallbackRegistered() const;
         static void setTrafficTrackerCallback(const OnTrafficTrackerCallback& callback);
         static void resetTrafficTrackerCallback();
 

ixwebsocket/IXWebSocketHandshake.cpp

@@ -170,11 +170,20 @@ namespace ix
         {
             std::stringstream ss;
             ss << "Expecting HTTP/1.1, got " << httpVersion << ". "
-               << "Rejecting connection to " << url << ", status: " << status
+               << "Rejecting connection to " << host << ":" << port << ", status: " << status
                << ", HTTP Status line: " << line;
             return WebSocketInitResult(false, status, ss.str());
         }
 
+        // We want an 101 HTTP status
+        if (status != 101)
+        {
+            std::stringstream ss;
+            ss << "Expecting status 101 (Switching Protocol), got " << status
+               << " status connecting to " << host << ":" << port << ", HTTP Status line: " << line;
+            return WebSocketInitResult(false, status, ss.str());
+        }
+
         auto result = parseHttpHeaders(_socket, isCancellationRequested);
         auto headersValid = result.first;
         auto headers = result.second;
@@ -184,17 +193,6 @@ namespace ix
             return WebSocketInitResult(false, status, "Error parsing HTTP headers");
         }
 
-        // We want an 101 HTTP status for websocket, otherwise it could be
-        // a redirection (like 301)
-        if (status != 101)
-        {
-            std::stringstream ss;
-            ss << "Expecting status 101 (Switching Protocol), got " << status
-               << " status connecting to " << url << ", HTTP Status line: " << line;
-
-            return WebSocketInitResult(false, status, ss.str(), headers, path);
-        }
-
         // Check the presence of the connection field
         if (headers.find("connection") == headers.end())
         {

ixwebsocket/IXWebSocketPerMessageDeflateCodec.cpp

@@ -28,26 +28,21 @@ namespace ix
     WebSocketPerMessageDeflateCompressor::WebSocketPerMessageDeflateCompressor()
         : _compressBufferSize(kBufferSize)
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         memset(&_deflateState, 0, sizeof(_deflateState));
 
         _deflateState.zalloc = Z_NULL;
         _deflateState.zfree = Z_NULL;
         _deflateState.opaque = Z_NULL;
-#endif
     }
 
     WebSocketPerMessageDeflateCompressor::~WebSocketPerMessageDeflateCompressor()
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         deflateEnd(&_deflateState);
-#endif
     }
 
     bool WebSocketPerMessageDeflateCompressor::init(uint8_t deflateBits,
                                                     bool clientNoContextTakeOver)
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         int ret = deflateInit2(&_deflateState,
                                Z_DEFAULT_COMPRESSION,
                                Z_DEFLATED,
@@ -62,9 +57,6 @@ namespace ix
         _flush = (clientNoContextTakeOver) ? Z_FULL_FLUSH : Z_SYNC_FLUSH;
 
         return true;
-#else
-        return false;
-#endif
     }
 
     template<typename T>
@@ -83,28 +75,23 @@ namespace ix
         return compressData(in, out);
     }
 
-    bool WebSocketPerMessageDeflateCompressor::compress(const std::string& in,
-                                                        std::vector<uint8_t>& out)
+    bool WebSocketPerMessageDeflateCompressor::compress(const std::string& in, std::vector<uint8_t>& out)
     {
         return compressData(in, out);
     }
 
-    bool WebSocketPerMessageDeflateCompressor::compress(const std::vector<uint8_t>& in,
-                                                        std::string& out)
+    bool WebSocketPerMessageDeflateCompressor::compress(const std::vector<uint8_t>& in, std::string& out)
     {
         return compressData(in, out);
     }
 
-    bool WebSocketPerMessageDeflateCompressor::compress(const std::vector<uint8_t>& in,
-                                                        std::vector<uint8_t>& out)
+    bool WebSocketPerMessageDeflateCompressor::compress(const std::vector<uint8_t>& in, std::vector<uint8_t>& out)
     {
         return compressData(in, out);
     }
 
-    template<typename T, typename S>
-    bool WebSocketPerMessageDeflateCompressor::compressData(const T& in, S& out)
+    template<typename T, typename S> bool WebSocketPerMessageDeflateCompressor::compressData(const T& in, S& out)
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         //
         // 7.2.1.  Compression
         //
@@ -161,9 +148,6 @@ namespace ix
         }
 
         return true;
-#else
-        return false;
-#endif
     }
 
     //
@@ -172,7 +156,6 @@ namespace ix
     WebSocketPerMessageDeflateDecompressor::WebSocketPerMessageDeflateDecompressor()
         : _compressBufferSize(kBufferSize)
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         memset(&_inflateState, 0, sizeof(_inflateState));
 
         _inflateState.zalloc = Z_NULL;
@@ -180,20 +163,16 @@ namespace ix
         _inflateState.opaque = Z_NULL;
         _inflateState.avail_in = 0;
         _inflateState.next_in = Z_NULL;
-#endif
     }
 
     WebSocketPerMessageDeflateDecompressor::~WebSocketPerMessageDeflateDecompressor()
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         inflateEnd(&_inflateState);
-#endif
     }
 
     bool WebSocketPerMessageDeflateDecompressor::init(uint8_t inflateBits,
                                                       bool clientNoContextTakeOver)
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         int ret = inflateInit2(&_inflateState, -1 * inflateBits);
 
         if (ret != Z_OK) return false;
@@ -203,14 +182,10 @@ namespace ix
         _flush = (clientNoContextTakeOver) ? Z_FULL_FLUSH : Z_SYNC_FLUSH;
 
         return true;
-#else
-        return false;
-#endif
     }
 
     bool WebSocketPerMessageDeflateDecompressor::decompress(const std::string& in, std::string& out)
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         //
         // 7.2.2.  Decompression
         //
@@ -247,8 +222,5 @@ namespace ix
         } while (_inflateState.avail_out == 0);
 
         return true;
-#else
-        return false;
-#endif
     }
 } // namespace ix

ixwebsocket/IXWebSocketPerMessageDeflateCodec.h

@@ -6,9 +6,7 @@
 
 #pragma once
 
-#ifdef IXWEBSOCKET_USE_ZLIB
 #include "zlib.h"
-#endif
 #include <memory>
 #include <string>
 #include <vector>
@@ -28,18 +26,13 @@ namespace ix
         bool compress(const std::vector<uint8_t>& in, std::vector<uint8_t>& out);
 
     private:
-        template<typename T, typename S>
-        bool compressData(const T& in, S& out);
-        template<typename T>
-        bool endsWithEmptyUnCompressedBlock(const T& value);
+        template<typename T, typename S> bool compressData(const T& in, S& out);
+        template<typename T> bool endsWithEmptyUnCompressedBlock(const T& value);
 
         int _flush;
         size_t _compressBufferSize;
         std::unique_ptr<unsigned char[]> _compressBuffer;
-
-#ifdef IXWEBSOCKET_USE_ZLIB
         z_stream _deflateState;
-#endif
     };
 
     class WebSocketPerMessageDeflateDecompressor
@@ -55,10 +48,7 @@ namespace ix
         int _flush;
         size_t _compressBufferSize;
         std::unique_ptr<unsigned char[]> _compressBuffer;
-
-#ifdef IXWEBSOCKET_USE_ZLIB
         z_stream _inflateState;
-#endif
     };
 
 } // namespace ix

ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp

@@ -61,7 +61,6 @@ namespace ix
         _clientMaxWindowBits = kDefaultClientMaxWindowBits;
         _serverMaxWindowBits = kDefaultServerMaxWindowBits;
 
-#ifdef IXWEBSOCKET_USE_ZLIB
         // Split by ;
         std::string token;
         std::stringstream tokenStream(extension);
@@ -113,7 +112,6 @@ namespace ix
                 sanitizeClientMaxWindowBits();
             }
         }
-#endif
     }
 
     void WebSocketPerMessageDeflateOptions::sanitizeClientMaxWindowBits()
@@ -128,7 +126,6 @@ namespace ix
 
     std::string WebSocketPerMessageDeflateOptions::generateHeader()
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         std::stringstream ss;
         ss << "Sec-WebSocket-Extensions: permessage-deflate";
 
@@ -141,18 +138,11 @@ namespace ix
         ss << "\r\n";
 
         return ss.str();
-#else
-        return std::string();
-#endif
     }
 
     bool WebSocketPerMessageDeflateOptions::enabled() const
     {
-#ifdef IXWEBSOCKET_USE_ZLIB
         return _enabled;
-#else
-        return false;
-#endif
     }
 
     bool WebSocketPerMessageDeflateOptions::getClientNoContextTakeover() const

ixwebsocket/IXWebSocketProxyServer.cpp

@@ -1,138 +0,0 @@
-/*
- *  IXWebSocketProxyServer.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
- */
-
-#include "IXWebSocketProxyServer.h"
-
-#include "IXWebSocketServer.h"
-#include <sstream>
-
-namespace ix
-{
-    class ProxyConnectionState : public ix::ConnectionState
-    {
-    public:
-        ProxyConnectionState()
-            : _connected(false)
-        {
-        }
-
-        ix::WebSocket& webSocket()
-        {
-            return _serverWebSocket;
-        }
-
-        bool isConnected()
-        {
-            return _connected;
-        }
-
-        void setConnected()
-        {
-            _connected = true;
-        }
-
-    private:
-        ix::WebSocket _serverWebSocket;
-        bool _connected;
-    };
-
-    int websocket_proxy_server_main(int port,
-                                    const std::string& hostname,
-                                    const ix::SocketTLSOptions& tlsOptions,
-                                    const std::string& remoteUrl,
-                                    const RemoteUrlsMapping& remoteUrlsMapping,
-                                    bool /*verbose*/)
-    {
-        ix::WebSocketServer server(port, hostname);
-        server.setTLSOptions(tlsOptions);
-
-        auto factory = []() -> std::shared_ptr<ix::ConnectionState> {
-            return std::make_shared<ProxyConnectionState>();
-        };
-        server.setConnectionStateFactory(factory);
-
-        server.setOnConnectionCallback(
-            [remoteUrl, remoteUrlsMapping](std::weak_ptr<ix::WebSocket> webSocket,
-                                           std::shared_ptr<ConnectionState> connectionState,
-                                           std::unique_ptr<ConnectionInfo> connectionInfo) {
-                auto state = std::dynamic_pointer_cast<ProxyConnectionState>(connectionState);
-                auto remoteIp = connectionInfo->remoteIp;
-
-                // Server connection
-                state->webSocket().setOnMessageCallback(
-                    [webSocket, state, remoteIp](const WebSocketMessagePtr& msg) {
-                        if (msg->type == ix::WebSocketMessageType::Close)
-                        {
-                            state->setTerminated();
-                        }
-                        else if (msg->type == ix::WebSocketMessageType::Message)
-                        {
-                            auto ws = webSocket.lock();
-                            if (ws)
-                            {
-                                ws->send(msg->str, msg->binary);
-                            }
-                        }
-                    });
-
-                // Client connection
-                auto ws = webSocket.lock();
-                if (ws)
-                {
-                    ws->setOnMessageCallback([state, remoteUrl, remoteUrlsMapping](
-                                                 const WebSocketMessagePtr& msg) {
-                        if (msg->type == ix::WebSocketMessageType::Open)
-                        {
-                            // Connect to the 'real' server
-                            std::string url(remoteUrl);
-
-                            // maybe we want a different url based on the mapping
-                            std::string host = msg->openInfo.headers["Host"];
-                            auto it = remoteUrlsMapping.find(host);
-                            if (it != remoteUrlsMapping.end())
-                            {
-                                url = it->second;
-                            }
-
-                            // append the uri to form the full url
-                            // (say ws://localhost:1234/foo/?bar=baz)
-                            url += msg->openInfo.uri;
-
-                            state->webSocket().setUrl(url);
-                            state->webSocket().disableAutomaticReconnection();
-                            state->webSocket().start();
-
-                            // we should sleep here for a bit until we've established the
-                            // connection with the remote server
-                            while (state->webSocket().getReadyState() != ReadyState::Open)
-                            {
-                                std::this_thread::sleep_for(std::chrono::milliseconds(10));
-                            }
-                        }
-                        else if (msg->type == ix::WebSocketMessageType::Close)
-                        {
-                            state->webSocket().close(msg->closeInfo.code, msg->closeInfo.reason);
-                        }
-                        else if (msg->type == ix::WebSocketMessageType::Message)
-                        {
-                            state->webSocket().send(msg->str, msg->binary);
-                        }
-                    });
-                }
-            });
-
-        auto res = server.listen();
-        if (!res.first)
-        {
-            return 1;
-        }
-
-        server.start();
-        server.wait();
-
-        return 0;
-    }
-} // namespace ix

ixwebsocket/IXWebSocketProxyServer.h

@@ -1,24 +0,0 @@
-/*
- *  IXWebSocketProxyServer.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2019-2020 Machine Zone, Inc. All rights reserved.
- */
-#pragma once
-
-#include "IXSocketTLSOptions.h"
-#include <cstdint>
-#include <map>
-#include <stddef.h>
-#include <string>
-
-namespace ix
-{
-    using RemoteUrlsMapping = std::map<std::string, std::string>;
-
-    int websocket_proxy_server_main(int port,
-                                    const std::string& hostname,
-                                    const ix::SocketTLSOptions& tlsOptions,
-                                    const std::string& remoteUrl,
-                                    const RemoteUrlsMapping& remoteUrlsMapping,
-                                    bool verbose);
-} // namespace ix

ixwebsocket/IXWebSocketServer.cpp

@@ -71,47 +71,13 @@ namespace ix
         _onConnectionCallback = callback;
     }
 
-    void WebSocketServer::setOnClientMessageCallback(const OnClientMessageCallback& callback)
-    {
-        _onClientMessageCallback = callback;
-    }
-
     void WebSocketServer::handleConnection(std::unique_ptr<Socket> socket,
-                                           std::shared_ptr<ConnectionState> connectionState,
-                                           std::unique_ptr<ConnectionInfo> connectionInfo)
+                                           std::shared_ptr<ConnectionState> connectionState)
     {
         setThreadName("WebSocketServer::" + connectionState->getId());
 
         auto webSocket = std::make_shared<WebSocket>();
-        if (_onConnectionCallback)
-        {
-            _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)
-        {
-            webSocket->setOnMessageCallback(
-                [this, &ws = *webSocket.get(), connectionState, &ci = *connectionInfo.get()](
-                    const WebSocketMessagePtr& msg) {
-                    _onClientMessageCallback(connectionState, ci, ws, msg);
-                });
-        }
-        else
-        {
-            logError(
-                "WebSocketServer Application developer error: No server callback is registerered.");
-            logError("Missing call to setOnConnectionCallback or setOnClientMessageCallback.");
-            connectionState->setTerminated();
-            return;
-        }
+        _onConnectionCallback(webSocket, connectionState);
 
         webSocket->disableAutomaticReconnection();
 
@@ -145,8 +111,6 @@ namespace ix
             logError(ss.str());
         }
 
-        webSocket->setOnMessageCallback(nullptr);
-
         // Remove this client from our client set
         {
             std::lock_guard<std::mutex> lock(_clientsMutex);

ixwebsocket/IXWebSocketServer.h

@@ -23,14 +23,7 @@ namespace ix
     {
     public:
         using OnConnectionCallback =
-            std::function<void(std::weak_ptr<WebSocket>,
-                               std::shared_ptr<ConnectionState>,
-                               std::unique_ptr<ConnectionInfo> connectionInfo)>;
-
-        using OnClientMessageCallback = std::function<void(std::shared_ptr<ConnectionState>,
-                                                           ConnectionInfo&,
-                                                           WebSocket&,
-                                                           const WebSocketMessagePtr&)>;
+            std::function<void(std::shared_ptr<WebSocket>, std::shared_ptr<ConnectionState>)>;
 
         WebSocketServer(int port = SocketServer::kDefaultPort,
                         const std::string& host = SocketServer::kDefaultHost,
@@ -46,7 +39,6 @@ namespace ix
         void disablePerMessageDeflate();
 
         void setOnConnectionCallback(const OnConnectionCallback& callback);
-        void setOnClientMessageCallback(const OnClientMessageCallback& callback);
 
         // Get all the connected clients
         std::set<std::shared_ptr<WebSocket>> getClients();
@@ -60,7 +52,6 @@ namespace ix
         bool _enablePerMessageDeflate;
 
         OnConnectionCallback _onConnectionCallback;
-        OnClientMessageCallback _onClientMessageCallback;
 
         std::mutex _clientsMutex;
         std::set<std::shared_ptr<WebSocket>> _clients;
@@ -69,8 +60,7 @@ namespace ix
 
         // Methods
         virtual void handleConnection(std::unique_ptr<Socket> socket,
-                                      std::shared_ptr<ConnectionState> connectionState,
-                                      std::unique_ptr<ConnectionInfo> connectionInfo);
+                                      std::shared_ptr<ConnectionState> connectionState) final;
         virtual size_t getConnectedClientsCount() final;
     };
 } // namespace ix

ixwebsocket/IXWebSocketTransport.cpp

@@ -65,6 +65,7 @@ namespace ix
         , _receivedMessageCompressed(false)
         , _readyState(ReadyState::CLOSED)
         , _closeCode(WebSocketCloseConstants::kInternalErrorCode)
+        , _closeReason(WebSocketCloseConstants::kInternalErrorMessage)
         , _closeWireSize(0)
         , _closeRemote(false)
         , _enablePerMessageDeflate(false)
@@ -76,7 +77,6 @@ namespace ix
         , _pingCount(0)
         , _lastSendPingTimePoint(std::chrono::steady_clock::now())
     {
-        setCloseReason(WebSocketCloseConstants::kInternalErrorMessage);
         _readbuf.resize(kChunkSize);
     }
 
@@ -107,62 +107,36 @@ namespace ix
 
         std::string protocol, host, path, query;
         int port;
-        std::string remoteUrl(url);
 
-        WebSocketInitResult result;
-        const int maxRedirections = 10;
-
-        for (int i = 0; i < maxRedirections; ++i)
+        if (!UrlParser::parse(url, protocol, host, path, query, port))
         {
-            if (!UrlParser::parse(remoteUrl, protocol, host, path, query, port))
-            {
-                std::stringstream ss;
-                ss << "Could not parse url: '" << url << "'";
-                return WebSocketInitResult(false, 0, ss.str());
-            }
-
-            std::string errorMsg;
-            bool tls = protocol == "wss";
-            _socket = createSocket(tls, -1, errorMsg, _socketTLSOptions);
-            _perMessageDeflate = std::make_unique<WebSocketPerMessageDeflate>();
-
-            if (!_socket)
-            {
-                return WebSocketInitResult(false, 0, errorMsg);
-            }
-
-            WebSocketHandshake webSocketHandshake(_requestInitCancellation,
-                                                  _socket,
-                                                  _perMessageDeflate,
-                                                  _perMessageDeflateOptions,
-                                                  _enablePerMessageDeflate);
-
-            result = webSocketHandshake.clientHandshake(
-                remoteUrl, headers, host, path, port, timeoutSecs);
-
-            if (result.http_status >= 300 && result.http_status < 400)
-            {
-                auto it = result.headers.find("Location");
-                if (it == result.headers.end())
-                {
-                    std::stringstream ss;
-                    ss << "Missing Location Header for HTTP Redirect response. "
-                       << "Rejecting connection to " << url << ", status: " << result.http_status;
-                    result.errorStr = ss.str();
-                    break;
-                }
-
-                remoteUrl = it->second;
-                continue;
-            }
-
-            if (result.success)
-            {
-                setReadyState(ReadyState::OPEN);
-            }
-            return result;
+            std::stringstream ss;
+            ss << "Could not parse url: '" << url << "'";
+            return WebSocketInitResult(false, 0, ss.str());
         }
 
+        std::string errorMsg;
+        bool tls = protocol == "wss";
+        _socket = createSocket(tls, -1, errorMsg, _socketTLSOptions);
+        _perMessageDeflate = std::make_unique<WebSocketPerMessageDeflate>();
+
+        if (!_socket)
+        {
+            return WebSocketInitResult(false, 0, errorMsg);
+        }
+
+        WebSocketHandshake webSocketHandshake(_requestInitCancellation,
+                                              _socket,
+                                              _perMessageDeflate,
+                                              _perMessageDeflateOptions,
+                                              _enablePerMessageDeflate);
+
+        auto result =
+            webSocketHandshake.clientHandshake(url, headers, host, path, port, timeoutSecs);
+        if (result.success)
+        {
+            setReadyState(ReadyState::OPEN);
+        }
         return result;
     }
 
@@ -205,12 +179,10 @@ namespace ix
 
         if (readyState == ReadyState::CLOSED)
         {
-            if (_onCloseCallback)
-            {
-                _onCloseCallback(_closeCode, getCloseReason(), _closeWireSize, _closeRemote);
-            }
-            setCloseReason(WebSocketCloseConstants::kInternalErrorMessage);
+            std::lock_guard<std::mutex> lock(_closeDataMutex);
+            _onCloseCallback(_closeCode, _closeReason, _closeWireSize, _closeRemote);
             _closeCode = WebSocketCloseConstants::kInternalErrorCode;
+            _closeReason = WebSocketCloseConstants::kInternalErrorMessage;
             _closeWireSize = 0;
             _closeRemote = false;
         }
@@ -289,10 +261,9 @@ namespace ix
         {
             // compute lasting delay to wait for next ping / timeout, if at least one set
             auto now = std::chrono::steady_clock::now();
-            int timeSinceLastPingMs = (int) std::chrono::duration_cast<std::chrono::milliseconds>(
+            lastingTimeoutDelayInMs = (int) std::chrono::duration_cast<std::chrono::milliseconds>(
                                           now - _lastSendPingTimePoint)
                                           .count();
-            lastingTimeoutDelayInMs = (1000 * _pingIntervalSecs) - timeSinceLastPingMs;
         }
 
 #ifdef _WIN32
@@ -659,7 +630,7 @@ namespace ix
                     // send back the CLOSE frame
                     sendCloseFrame(code, reason);
 
-                    wakeUpFromPoll(SelectInterrupt::kCloseRequest);
+                    wakeUpFromPoll(Socket::kCloseRequest);
 
                     bool remote = true;
                     closeSocketAndSwitchToClosedState(code, reason, _rxbuf.size(), remote);
@@ -668,7 +639,11 @@ namespace ix
                 {
                     // we got the CLOSE frame answer from our close, so we can close the connection
                     // if the code/reason are the same
-                    bool identicalReason = _closeCode == code && getCloseReason() == reason;
+                    bool identicalReason;
+                    {
+                        std::lock_guard<std::mutex> lock(_closeDataMutex);
+                        identicalReason = _closeCode == code && _closeReason == reason;
+                    }
 
                     if (identicalReason)
                     {
@@ -776,11 +751,28 @@ namespace ix
         return static_cast<unsigned>(seconds);
     }
 
-    template<class T>
     WebSocketSendInfo WebSocketTransport::sendData(wsheader_type::opcode_type type,
-                                                   const T& message,
-                                                   bool compress,
-                                                   const OnProgressCallback& onProgressCallback)
+                               const std::string& message,
+                               bool compress,
+                               const OnProgressCallback& onProgressCallback)
+    {
+        return sendRawData(type, message, compress, onProgressCallback);
+    }
+
+    WebSocketSendInfo WebSocketTransport::sendData(wsheader_type::opcode_type type,
+                               const std::vector<uint8_t>& message,
+                               bool compress,
+                               const OnProgressCallback& onProgressCallback)
+    {
+        return sendRawData(type, message, compress, onProgressCallback);
+    }
+
+
+    template<class T>
+    WebSocketSendInfo WebSocketTransport::sendRawData(wsheader_type::opcode_type type,
+                                                      const T& message,
+                                                      bool compress,
+                                                      const OnProgressCallback& onProgressCallback)
     {
         if (_readyState != ReadyState::OPEN && _readyState != ReadyState::CLOSING)
         {
@@ -791,12 +783,14 @@ namespace ix
         size_t wireSize = message.size();
         bool compressionError = false;
 
-        auto message_begin = message.cbegin();
-        auto message_end = message.cend();
+        auto message_begin = message.begin();
+        auto message_end = message.end();
 
+#if 0
         if (compress)
         {
-            if (!_perMessageDeflate->compress(message, _compressedMessage))
+            T compressedMessage;
+            if (!_perMessageDeflate->compress(message, compressedMessage))
             {
                 bool success = false;
                 compressionError = true;
@@ -805,11 +799,12 @@ namespace ix
                 return WebSocketSendInfo(success, compressionError, payloadSize, wireSize);
             }
             compressionError = false;
-            wireSize = _compressedMessage.size();
+            wireSize = compressedMessage.size();
 
-            message_begin = _compressedMessage.cbegin();
-            message_end = _compressedMessage.cend();
+            message_begin = compressedMessage.begin();
+            message_end = compressedMessage.end();
         }
+#endif
 
         {
             std::lock_guard<std::mutex> lock(_txbufMutex);
@@ -822,11 +817,6 @@ namespace ix
         if (wireSize < kChunkSize)
         {
             success = sendFragment(type, true, message_begin, message_end, compress);
-
-            if (onProgressCallback)
-            {
-                onProgressCallback(0, 1);
-            }
         }
         else
         {
@@ -840,8 +830,8 @@ namespace ix
             //
             auto steps = wireSize / kChunkSize;
 
-            std::string::const_iterator begin = message_begin;
-            std::string::const_iterator end = message_end;
+            auto begin = message_begin;
+            auto end = message_end;
 
             for (uint64_t i = 0; i < steps; ++i)
             {
@@ -879,7 +869,7 @@ namespace ix
         // Request to flush the send buffer on the background thread if it isn't empty
         if (!isSendBufferEmpty())
         {
-            wakeUpFromPoll(SelectInterrupt::kSendRequest);
+            wakeUpFromPoll(Socket::kSendRequest);
 
             // FIXME: we should have a timeout when sending large messages: see #131
             if (_blockingSend && !flushSendBuffer())
@@ -994,6 +984,14 @@ namespace ix
         return info;
     }
 
+    WebSocketSendInfo WebSocketTransport::sendBinary(const std::vector<uint8_t>& message,
+                                                     const OnProgressCallback& onProgressCallback)
+
+    {
+        return sendData(
+            wsheader_type::BINARY_FRAME, message, _enablePerMessageDeflate, onProgressCallback);
+    }
+
     WebSocketSendInfo WebSocketTransport::sendBinary(const std::string& message,
                                                      const OnProgressCallback& onProgressCallback)
 
@@ -1111,10 +1109,13 @@ namespace ix
     {
         closeSocket();
 
-        setCloseReason(reason);
-        _closeCode = code;
-        _closeWireSize = closeWireSize;
-        _closeRemote = remote;
+        {
+            std::lock_guard<std::mutex> lock(_closeDataMutex);
+            _closeCode = code;
+            _closeReason = reason;
+            _closeWireSize = closeWireSize;
+            _closeRemote = remote;
+        }
 
         setReadyState(ReadyState::CLOSED);
         _requestInitCancellation = false;
@@ -1134,11 +1135,13 @@ namespace ix
             closeWireSize = reason.size();
         }
 
-        setCloseReason(reason);
-        _closeCode = code;
-        _closeWireSize = closeWireSize;
-        _closeRemote = remote;
-
+        {
+            std::lock_guard<std::mutex> lock(_closeDataMutex);
+            _closeCode = code;
+            _closeReason = reason;
+            _closeWireSize = closeWireSize;
+            _closeRemote = remote;
+        }
         {
             std::lock_guard<std::mutex> lock(_closingTimePointMutex);
             _closingTimePoint = std::chrono::steady_clock::now();
@@ -1148,7 +1151,7 @@ namespace ix
         sendCloseFrame(code, reason);
 
         // wake up the poll, but do not close yet
-        wakeUpFromPoll(SelectInterrupt::kSendRequest);
+        wakeUpFromPoll(Socket::kSendRequest);
     }
 
     size_t WebSocketTransport::bufferedAmount() const
@@ -1183,15 +1186,4 @@ namespace ix
         return true;
     }
 
-    void WebSocketTransport::setCloseReason(const std::string& reason)
-    {
-        std::lock_guard<std::mutex> lock(_closeReasonMutex);
-        _closeReason = reason;
-    }
-
-    const std::string& WebSocketTransport::getCloseReason() const
-    {
-        std::lock_guard<std::mutex> lock(_closeReasonMutex);
-        return _closeReason;
-    }
 } // namespace ix

ixwebsocket/IXWebSocketTransport.h

@@ -86,6 +86,9 @@ namespace ix
         WebSocketInitResult connectToSocket(std::unique_ptr<Socket> socket, int timeoutSecs);
 
         PollResult poll();
+
+        WebSocketSendInfo sendBinary(const std::vector<uint8_t>& message,
+                                     const OnProgressCallback& onProgressCallback);
         WebSocketSendInfo sendBinary(const std::string& message,
                                      const OnProgressCallback& onProgressCallback);
         WebSocketSendInfo sendText(const std::string& message,
@@ -178,11 +181,11 @@ namespace ix
         std::atomic<ReadyState> _readyState;
 
         OnCloseCallback _onCloseCallback;
+        uint16_t _closeCode;
         std::string _closeReason;
-        mutable std::mutex _closeReasonMutex;
-        std::atomic<uint16_t> _closeCode;
-        std::atomic<size_t> _closeWireSize;
-        std::atomic<bool> _closeRemote;
+        size_t _closeWireSize;
+        bool _closeRemote;
+        mutable std::mutex _closeDataMutex;
 
         // Data used for Per Message Deflate compression (with zlib)
         WebSocketPerMessageDeflatePtr _perMessageDeflate;
@@ -190,7 +193,7 @@ namespace ix
         std::atomic<bool> _enablePerMessageDeflate;
 
         std::string _decompressedMessage;
-        std::string _compressedMessage;
+        std::vector<uint8_t> _compressedMessage;
 
         // Used to control TLS connection behavior
         SocketTLSOptions _socketTLSOptions;
@@ -239,15 +242,28 @@ namespace ix
         bool sendOnSocket();
         bool receiveFromSocket();
 
-        template<class T>
         WebSocketSendInfo sendData(wsheader_type::opcode_type type,
-                                   const T& message,
+                                   const std::string& message,
                                    bool compress,
                                    const OnProgressCallback& onProgressCallback = nullptr);
 
+        WebSocketSendInfo sendData(wsheader_type::opcode_type type,
+                                   const std::vector<uint8_t>& message,
+                                   bool compress,
+                                   const OnProgressCallback& onProgressCallback = nullptr);
+
+        template<class T>
+        WebSocketSendInfo sendRawData(wsheader_type::opcode_type type,
+                                      const T& message,
+                                      bool compress,
+                                      const OnProgressCallback& onProgressCallback = nullptr);
+
         template<class Iterator>
-        bool sendFragment(
-            wsheader_type::opcode_type type, bool fin, Iterator begin, Iterator end, bool compress);
+        bool sendFragment(wsheader_type::opcode_type type,
+                          bool fin,
+                          Iterator begin,
+                          Iterator end,
+                          bool compress);
 
         void emitMessage(MessageKind messageKind,
                          const std::string& message,
@@ -267,8 +283,5 @@ namespace ix
         void unmaskReceiveBuffer(const wsheader_type& ws);
 
         std::string getMergedChunks() const;
-
-        void setCloseReason(const std::string& reason);
-        const std::string& getCloseReason() const;
     };
 } // namespace ix

ixwebsocket/IXWebSocketVersion.h

@@ -6,4 +6,4 @@
 
 #pragma once
 
-#define IX_WEBSOCKET_VERSION "10.2.5"
+#define IX_WEBSOCKET_VERSION "9.8.6"

ixwebsocket/apple/IXSetThreadName_apple.cpp

@@ -0,0 +1,20 @@
+/*
+ *  IXSetThreadName_apple.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+#include "../IXSetThreadName.h"
+#include <pthread.h>
+
+namespace ix
+{
+    void setThreadName(const std::string& name)
+    {
+        //
+        // Apple reserves 16 bytes for its thread names
+        // Notice that the Apple version of pthread_setname_np
+        // does not take a pthread_t argument
+        //
+        pthread_setname_np(name.substr(0, 63).c_str());
+    }
+} // namespace ix

ixwebsocket/freebsd/IXSetThreadName_freebsd.cpp

@@ -0,0 +1,16 @@
+/*
+ *  IXSetThreadName_freebsd.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+#include "../IXSetThreadName.h"
+#include <pthread.h>
+#include <pthread_np.h>
+
+namespace ix
+{
+    void setThreadName(const std::string& name)
+    {
+        pthread_set_name_np(pthread_self(), name.substr(0, 15).c_str());
+    }
+} // namespace ix

ixwebsocket/linux/IXSetThreadName_linux.cpp

@@ -0,0 +1,20 @@
+/*
+ *  IXSetThreadName_linux.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+#include "../IXSetThreadName.h"
+#include <pthread.h>
+
+namespace ix
+{
+    void setThreadName(const std::string& name)
+    {
+        //
+        // Linux only reserves 16 bytes for its thread names
+        // See prctl and PR_SET_NAME property in
+        // http://man7.org/linux/man-pages/man2/prctl.2.html
+        //
+        pthread_setname_np(pthread_self(), name.substr(0, 15).c_str());
+    }
+} // namespace ix

ixwebsocket/windows/IXSetThreadName_windows.cpp

@@ -0,0 +1,46 @@
+/*
+ *  IXSetThreadName_windows.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+#include "../IXSetThreadName.h"
+
+#include <Windows.h>
+
+namespace ix
+{
+    const DWORD MS_VC_EXCEPTION = 0x406D1388;
+
+#pragma pack(push, 8)
+    typedef struct tagTHREADNAME_INFO
+    {
+        DWORD dwType;     // Must be 0x1000.
+        LPCSTR szName;    // Pointer to name (in user addr space).
+        DWORD dwThreadID; // Thread ID (-1=caller thread).
+        DWORD dwFlags;    // Reserved for future use, must be zero.
+    } THREADNAME_INFO;
+#pragma pack(pop)
+
+    void SetThreadName(DWORD dwThreadID, const char* threadName)
+    {
+        THREADNAME_INFO info;
+        info.dwType = 0x1000;
+        info.szName = threadName;
+        info.dwThreadID = dwThreadID;
+        info.dwFlags = 0;
+
+        __try
+        {
+            RaiseException(
+                MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*) &info);
+        }
+        __except (EXCEPTION_EXECUTE_HANDLER)
+        {
+        }
+    }
+
+    void setThreadName(const std::string& name)
+    {
+        SetThreadName(-1, name.c_str());
+    }
+} // namespace ix

makefile

@@ -34,13 +34,10 @@ ws:
 	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. && ninja install)
 
 ws_install:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. -DUSE_TEST=0 && ninja install)
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. && make -j 4 install)
 
-ws_install_release:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. -DUSE_TEST=0 && ninja install)
-
-ws_openssl_install:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_OPEN_SSL=1 .. ; ninja install)
+ws_openssl:
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_OPEN_SSL=1 .. ; make -j 4)
 
 ws_mbedtls:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; make -j 4)
@@ -48,9 +45,6 @@ ws_mbedtls:
 ws_no_ssl:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_WS=1 .. ; make -j 4)
 
-ws_no_python:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 .. ; ninja install)
-
 uninstall:
 	xargs rm -fv < build/install_manifest.txt
 
@@ -110,10 +104,8 @@ test_server:
 # env TEST=Websocket_server make test
 # env TEST=Websocket_chat make test
 # env TEST=heartbeat make test
-build_test:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. ; ninja install)
-
-test: build_test
+test:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; ninja install)
 	(cd test ; python2.7 run.py -r)
 
 test_make:
@@ -180,7 +172,7 @@ autobahn_report:
 	cp -rvf ~/sandbox/reports/clients/* ../bsergean.github.io/IXWebSocket/autobahn/
 
 httpd:
-	clang++ --std=c++14 --stdlib=libc++ -o ixhttpd httpd.cpp \
+	clang++ --std=c++14 --stdlib=libc++ httpd.cpp \
 		ixwebsocket/IXSelectInterruptFactory.cpp \
 		ixwebsocket/IXCancellationRequest.cpp \
 		ixwebsocket/IXSocketTLSOptions.cpp \
@@ -199,11 +191,11 @@ httpd:
 		ixwebsocket/IXConnectionState.cpp \
 		ixwebsocket/IXUrlParser.cpp \
 		ixwebsocket/IXSelectInterrupt.cpp \
-		ixwebsocket/IXSetThreadName.cpp \
+		ixwebsocket/apple/IXSetThreadName_apple.cpp \
 		-lz
 
 httpd_linux:
-	g++ --std=c++14 -o ixhttpd httpd.cpp -Iixwebsocket \
+	g++ --std=c++11 -o ixhttpd httpd.cpp -Iixwebsocket \
 		ixwebsocket/IXSelectInterruptFactory.cpp \
 		ixwebsocket/IXCancellationRequest.cpp \
 		ixwebsocket/IXSocketTLSOptions.cpp \
@@ -222,7 +214,7 @@ httpd_linux:
 		ixwebsocket/IXConnectionState.cpp \
 		ixwebsocket/IXUrlParser.cpp \
 		ixwebsocket/IXSelectInterrupt.cpp \
-		ixwebsocket/IXSetThreadName.cpp \
+		ixwebsocket/linux/IXSetThreadName_linux.cpp \
 		-lz -lpthread
 	cp -f ixhttpd /usr/local/bin
 
@@ -244,12 +236,9 @@ install_cmake_for_linux:
 doc:
 	mkdocs gh-deploy
 
-change: format
+change:
 	vim ixwebsocket/IXWebSocketVersion.h docs/CHANGELOG.md
 
-commit:
-	git commit -am "`sh tools/extract_latest_change.sh`"
-
 .PHONY: test
 .PHONY: build
 .PHONY: ws

test/CMakeLists.txt

@@ -37,11 +37,11 @@ set (SOURCES
 
   test_runner.cpp
   IXTest.cpp
+  IXGetFreePort.cpp
   ../third_party/msgpack11/msgpack11.cpp
 
   IXSocketTest.cpp
   IXSocketConnectTest.cpp
-  # IXWebSocketLeakTest.cpp # commented until we have a fix for #224
   IXWebSocketServerTest.cpp
   IXWebSocketTestConnectionDisconnection.cpp
   IXUrlParserTest.cpp
@@ -55,8 +55,6 @@ set (SOURCES
   IXSentryClientTest.cpp
   IXWebSocketChatTest.cpp
   IXWebSocketBroadcastTest.cpp
-  IXWebSocketPerMessageDeflateCompressorTest.cpp
-  IXStreamSqlTest.cpp
 )
 
 # Some unittest don't work on windows yet

test/IXCobraMetricsPublisherTest.cpp

@@ -108,7 +108,7 @@ namespace
             }
             else if (event->type == ix::CobraEventType::UnSubscribed)
             {
-                TLogger() << "Subscriber: unsubscribed from channel " << event->subscriptionId;
+                TLogger() << "Subscriber: ununexpected from channel " << event->subscriptionId;
                 if (event->subscriptionId != channel)
                 {
                     TLogger() << "Subscriber: unexpected channel " << event->subscriptionId;

test/IXCobraToSentryBotTest.cpp

@@ -12,8 +12,8 @@
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <ixcrypto/IXUuid.h>
-#include <ixredis/IXRedisServer.h>
 #include <ixsentry/IXSentryClient.h>
+#include <ixredis/IXRedisServer.h>
 #include <ixsnake/IXSnakeServer.h>
 #include <ixwebsocket/IXHttpServer.h>
 #include <ixwebsocket/IXUserAgent.h>
@@ -95,15 +95,13 @@ TEST_CASE("Cobra_to_sentry_bot", "[cobra_bots]")
 
         sentryServer.setOnConnectionCallback(
             [](HttpRequestPtr request,
-               std::shared_ptr<ConnectionState> /*connectionState*/,
-               std::unique_ptr<ConnectionInfo> connectionInfo) -> HttpResponsePtr {
+               std::shared_ptr<ConnectionState> /*connectionState*/) -> HttpResponsePtr {
                 WebSocketHttpHeaders headers;
                 headers["Server"] = userAgent();
 
                 // Log request
                 std::stringstream ss;
-                ss << connectionInfo->remoteIp << ":" << connectionInfo->remotePort << " "
-                   << request->method << " " << request->headers["User-Agent"] << " "
+                ss << request->method << " " << request->headers["User-Agent"] << " "
                    << request->uri;
 
                 if (request->method == "POST")

test/IXCobraToStatsdBotTest.cpp

@@ -12,8 +12,8 @@
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <ixcrypto/IXUuid.h>
-#include <ixredis/IXRedisServer.h>
 #include <ixsentry/IXSentryClient.h>
+#include <ixredis/IXRedisServer.h>
 #include <ixsnake/IXSnakeServer.h>
 #include <ixwebsocket/IXHttpServer.h>
 #include <ixwebsocket/IXUserAgent.h>

test/IXCobraToStdoutBotTest.cpp

@@ -12,8 +12,8 @@
 #include <ixcobra/IXCobraConnection.h>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <ixcrypto/IXUuid.h>
-#include <ixredis/IXRedisServer.h>
 #include <ixsentry/IXSentryClient.h>
+#include <ixredis/IXRedisServer.h>
 #include <ixsnake/IXSnakeServer.h>
 #include <ixwebsocket/IXHttpServer.h>
 #include <ixwebsocket/IXUserAgent.h>
@@ -92,9 +92,6 @@ TEST_CASE("Cobra_to_stdout_bot", "[cobra_bots]")
         cobraBotConfig.enableHeartbeat = false;
         bool quiet = false;
 
-        cobraBotConfig.filter =
-            std::string("select * from `") + channel + "` where id = 'sms_metric_A_id'";
-
         // We could try to capture the output ... not sure how.
         bool fluentd = true;
 

test/IXHttpServerTest.cpp

@@ -4,9 +4,9 @@
  *  Copyright (c) 2019 Machine Zone. All rights reserved.
  */
 
+#include "IXGetFreePort.h"
 #include "catch.hpp"
 #include <iostream>
-#include <ixwebsocket/IXGetFreePort.h>
 #include <ixwebsocket/IXHttpClient.h>
 #include <ixwebsocket/IXHttpServer.h>
 
@@ -67,8 +67,7 @@ TEST_CASE("http server", "[httpd]")
 
 TEST_CASE("http server redirection", "[httpd_redirect]")
 {
-    SECTION(
-        "Connect to a local HTTP server, with redirection enabled, but we do not follow redirects")
+    SECTION("Connect to a local HTTP server, with redirection enabled, but we do not follow redirects")
     {
         int port = getFreePort();
         ix::HttpServer server(port, "127.0.0.1");

test/IXStreamSqlTest.cpp

@@ -1,42 +0,0 @@
-/*
- *  IXStreamSqlTest.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone. All rights reserved.
- */
-
-#include "IXTest.h"
-#include "catch.hpp"
-#include <iostream>
-#include <ixsnake/IXStreamSql.h>
-#include <string.h>
-
-using namespace ix;
-
-namespace ix
-{
-    TEST_CASE("stream_sql", "[streamsql]")
-    {
-        SECTION("expression A")
-        {
-            snake::StreamSql streamSql(
-                "select * from subscriber_republished_v1_neo where session LIKE '%123456%'");
-
-            nlohmann::json msg = {{"session", "123456"}, {"id", "foo_id"}, {"timestamp", 12}};
-
-            CHECK(streamSql.match(msg));
-        }
-
-        SECTION("expression A")
-        {
-            snake::StreamSql streamSql("select * from `subscriber_republished_v1_neo` where "
-                                       "session = '30091320ed8d4e50b758f8409b83bed7'");
-
-            nlohmann::json msg = {{"session", "30091320ed8d4e50b758f8409b83bed7"},
-                                  {"id", "foo_id"},
-                                  {"timestamp", 12}};
-
-            CHECK(streamSql.match(msg));
-        }
-    }
-
-} // namespace ix

test/IXTest.cpp

@@ -84,38 +84,36 @@ namespace ix
 
     bool startWebSocketEchoServer(ix::WebSocketServer& server)
     {
-        server.setOnClientMessageCallback(
-            [&server](std::shared_ptr<ConnectionState> /*connectionState*/,
-                      ConnectionInfo& connectionInfo,
-                      WebSocket& webSocket,
-                      const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
-                if (msg->type == ix::WebSocketMessageType::Open)
-                {
-                    TLogger() << "New connection";
-                    TLogger() << "Remote ip: " << remoteIp;
-                    TLogger() << "Uri: " << msg->openInfo.uri;
-                    TLogger() << "Headers:";
-                    for (auto it : msg->openInfo.headers)
+        server.setOnConnectionCallback([&server](std::shared_ptr<ix::WebSocket> webSocket,
+                                                 std::shared_ptr<ConnectionState> connectionState) {
+            webSocket->setOnMessageCallback(
+                [webSocket, connectionState, &server](const ix::WebSocketMessagePtr& msg) {
+                    if (msg->type == ix::WebSocketMessageType::Open)
                     {
-                        TLogger() << it.first << ": " << it.second;
-                    }
-                }
-                else if (msg->type == ix::WebSocketMessageType::Close)
-                {
-                    TLogger() << "Closed connection";
-                }
-                else if (msg->type == ix::WebSocketMessageType::Message)
-                {
-                    for (auto&& client : server.getClients())
-                    {
-                        if (client.get() != &webSocket)
+                        TLogger() << "New connection";
+                        TLogger() << "Uri: " << msg->openInfo.uri;
+                        TLogger() << "Headers:";
+                        for (auto it : msg->openInfo.headers)
                         {
-                            client->send(msg->str, msg->binary);
+                            TLogger() << it.first << ": " << it.second;
                         }
                     }
-                }
-            });
+                    else if (msg->type == ix::WebSocketMessageType::Close)
+                    {
+                        TLogger() << "Closed connection";
+                    }
+                    else if (msg->type == ix::WebSocketMessageType::Message)
+                    {
+                        for (auto&& client : server.getClients())
+                        {
+                            if (client != webSocket)
+                            {
+                                client->send(msg->str, msg->binary);
+                            }
+                        }
+                    }
+                });
+        });
 
         auto res = server.listen();
         if (!res.first)

test/IXTest.h

@@ -6,9 +6,9 @@
 
 #pragma once
 
+#include "IXGetFreePort.h"
 #include <iostream>
 #include <ixsnake/IXAppConfig.h>
-#include <ixwebsocket/IXGetFreePort.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocketServer.h>
 #include <mutex>

test/IXWebSocketBroadcastTest.cpp

@@ -189,19 +189,15 @@ namespace
         bool preferTLS = true;
         server.setTLSOptions(makeServerTLSOptions(preferTLS));
 
-        server.setOnClientMessageCallback(
-            [&server, &connectionId](std::shared_ptr<ConnectionState> connectionState,
-                                     ConnectionInfo& connectionInfo,
-                                     WebSocket& webSocket,
-                                     const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
-
-
+        server.setOnConnectionCallback([&server, &connectionId](
+                                           std::shared_ptr<ix::WebSocket> webSocket,
+                                           std::shared_ptr<ConnectionState> connectionState) {
+            webSocket->setOnMessageCallback([webSocket, connectionState, &connectionId, &server](
+                                                const ix::WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     TLogger() << "New connection";
                     connectionState->computeId();
-                    TLogger() << "remote ip: " << remoteIp;
                     TLogger() << "id: " << connectionState->getId();
                     TLogger() << "Uri: " << msg->openInfo.uri;
                     TLogger() << "Headers:";
@@ -220,13 +216,14 @@ namespace
                 {
                     for (auto&& client : server.getClients())
                     {
-                        if (client.get() != &webSocket)
+                        if (client != webSocket)
                         {
                             client->send(msg->str, msg->binary);
                         }
                     }
                 }
             });
+        });
 
         auto res = server.listen();
         if (!res.first)

test/IXWebSocketChatTest.cpp

@@ -100,6 +100,7 @@ namespace
         }
 
         _webSocket.setUrl(url);
+        _webSocket.disablePerMessageDeflate();
 
         std::stringstream ss;
         log(std::string("Connecting to url: ") + url);
@@ -188,44 +189,44 @@ namespace
 
     void WebSocketChat::sendMessage(const std::string& text)
     {
-        _webSocket.sendBinary(encodeMessage(text));
+        auto msg = encodeMessage(text);
+        std::vector<uint8_t> data(text.begin(), text.end());
+        _webSocket.sendBinary(data);
     }
 
     bool startServer(ix::WebSocketServer& server)
     {
-        server.setOnClientMessageCallback(
-            [&server](std::shared_ptr<ConnectionState> connectionState,
-                      ConnectionInfo& connectionInfo,
-                      WebSocket& webSocket,
-                      const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
-                if (msg->type == ix::WebSocketMessageType::Open)
-                {
-                    TLogger() << "New connection";
-                    TLogger() << "remote ip: " << remoteIp;
-                    TLogger() << "id: " << connectionState->getId();
-                    TLogger() << "Uri: " << msg->openInfo.uri;
-                    TLogger() << "Headers:";
-                    for (auto it : msg->openInfo.headers)
+        server.setOnConnectionCallback([&server](std::shared_ptr<ix::WebSocket> webSocket,
+                                                 std::shared_ptr<ConnectionState> connectionState) {
+            webSocket->setOnMessageCallback(
+                [webSocket, connectionState, &server](const ix::WebSocketMessagePtr& msg) {
+                    if (msg->type == ix::WebSocketMessageType::Open)
                     {
-                        TLogger() << it.first << ": " << it.second;
-                    }
-                }
-                else if (msg->type == ix::WebSocketMessageType::Close)
-                {
-                    log("Closed connection");
-                }
-                else if (msg->type == ix::WebSocketMessageType::Message)
-                {
-                    for (auto&& client : server.getClients())
-                    {
-                        if (client.get() != &webSocket)
+                        TLogger() << "New connection";
+                        TLogger() << "id: " << connectionState->getId();
+                        TLogger() << "Uri: " << msg->openInfo.uri;
+                        TLogger() << "Headers:";
+                        for (auto it : msg->openInfo.headers)
                         {
-                            client->sendBinary(msg->str);
+                            TLogger() << it.first << ": " << it.second;
                         }
                     }
-                }
-            });
+                    else if (msg->type == ix::WebSocketMessageType::Close)
+                    {
+                        log("Closed connection");
+                    }
+                    else if (msg->type == ix::WebSocketMessageType::Message)
+                    {
+                        for (auto&& client : server.getClients())
+                        {
+                            if (client != webSocket)
+                            {
+                                client->sendBinary(msg->str);
+                            }
+                        }
+                    }
+                });
+        });
 
         auto res = server.listen();
         if (!res.first)

test/IXWebSocketCloseTest.cpp

@@ -168,38 +168,41 @@ namespace
                      std::mutex& mutexWrite)
     {
         // A dev/null server
-        server.setOnClientMessageCallback(
+        server.setOnConnectionCallback(
             [&receivedCloseCode, &receivedCloseReason, &receivedCloseRemote, &mutexWrite](
-                std::shared_ptr<ConnectionState> connectionState,
-                ConnectionInfo& connectionInfo,
-                WebSocket& /*webSocket*/,
-                const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
-                if (msg->type == ix::WebSocketMessageType::Open)
-                {
-                    TLogger() << "New server connection";
-                    TLogger() << "remote ip: " << remoteIp;
-                    TLogger() << "id: " << connectionState->getId();
-                    TLogger() << "Uri: " << msg->openInfo.uri;
-                    TLogger() << "Headers:";
-                    for (auto it : msg->openInfo.headers)
+                std::shared_ptr<ix::WebSocket> webSocket,
+                std::shared_ptr<ConnectionState> connectionState) {
+                webSocket->setOnMessageCallback([webSocket,
+                                                 connectionState,
+                                                 &receivedCloseCode,
+                                                 &receivedCloseReason,
+                                                 &receivedCloseRemote,
+                                                 &mutexWrite](const ix::WebSocketMessagePtr& msg) {
+                    if (msg->type == ix::WebSocketMessageType::Open)
                     {
-                        TLogger() << it.first << ": " << it.second;
+                        TLogger() << "New server connection";
+                        TLogger() << "id: " << connectionState->getId();
+                        TLogger() << "Uri: " << msg->openInfo.uri;
+                        TLogger() << "Headers:";
+                        for (auto it : msg->openInfo.headers)
+                        {
+                            TLogger() << it.first << ": " << it.second;
+                        }
                     }
-                }
-                else if (msg->type == ix::WebSocketMessageType::Close)
-                {
-                    std::stringstream ss;
-                    ss << "Server closed connection(" << msg->closeInfo.code << ","
-                       << msg->closeInfo.reason << ")";
-                    log(ss.str());
+                    else if (msg->type == ix::WebSocketMessageType::Close)
+                    {
+                        std::stringstream ss;
+                        ss << "Server closed connection(" << msg->closeInfo.code << ","
+                           << msg->closeInfo.reason << ")";
+                        log(ss.str());
 
-                    std::lock_guard<std::mutex> lck(mutexWrite);
+                        std::lock_guard<std::mutex> lck(mutexWrite);
 
-                    receivedCloseCode = msg->closeInfo.code;
-                    receivedCloseReason = std::string(msg->closeInfo.reason);
-                    receivedCloseRemote = msg->closeInfo.remote;
-                }
+                        receivedCloseCode = msg->closeInfo.code;
+                        receivedCloseReason = std::string(msg->closeInfo.reason);
+                        receivedCloseRemote = msg->closeInfo.remote;
+                    }
+                });
             });
 
         auto res = server.listen();

test/IXWebSocketLeakTest.cpp

@@ -1,183 +0,0 @@
-/*
- *  IXWebSocketServer.cpp
- *  Author: Benjamin Sergeant, @marcelkauf
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#include "IXTest.h"
-#include "catch.hpp"
-#include <ixwebsocket/IXWebSocket.h>
-#include <ixwebsocket/IXWebSocketServer.h>
-#include <memory>
-#include <sstream>
-
-using namespace ix;
-
-namespace
-{
-    class WebSocketClient
-    {
-    public:
-        WebSocketClient(int port);
-        void start();
-        void stop();
-        bool isReady() const;
-        bool hasConnectionError() const;
-
-    private:
-        ix::WebSocket _webSocket;
-        int _port;
-        std::atomic<bool> _connectionError;
-    };
-
-    WebSocketClient::WebSocketClient(int port)
-        : _port(port)
-        , _connectionError(false)
-    {
-    }
-
-    bool WebSocketClient::hasConnectionError() const
-    {
-        return _connectionError;
-    }
-
-    bool WebSocketClient::isReady() const
-    {
-        return _webSocket.getReadyState() == ix::ReadyState::Open;
-    }
-
-    void WebSocketClient::stop()
-    {
-        _webSocket.stop();
-    }
-
-    void WebSocketClient::start()
-    {
-        std::string url;
-        {
-            std::stringstream ss;
-            ss << "ws://localhost:" << _port << "/";
-
-            url = ss.str();
-        }
-
-        _webSocket.setUrl(url);
-        _webSocket.disableAutomaticReconnection();
-
-        std::stringstream ss;
-        log(std::string("Connecting to url: ") + url);
-
-        _webSocket.setOnMessageCallback([this](const ix::WebSocketMessagePtr& msg) {
-            std::stringstream ss;
-            if (msg->type == ix::WebSocketMessageType::Open)
-            {
-                log("client connected");
-            }
-            else if (msg->type == ix::WebSocketMessageType::Close)
-            {
-                log("client disconnected");
-            }
-            else if (msg->type == ix::WebSocketMessageType::Error)
-            {
-                _connectionError = true;
-                log("error");
-            }
-            else if (msg->type == ix::WebSocketMessageType::Pong)
-            {
-                log("pong");
-            }
-            else if (msg->type == ix::WebSocketMessageType::Ping)
-            {
-                log("ping");
-            }
-            else if (msg->type == ix::WebSocketMessageType::Message)
-            {
-                log("message");
-            }
-            else
-            {
-                log("invalid type");
-            }
-        });
-
-        _webSocket.start();
-    }
-} // namespace
-
-TEST_CASE("Websocket leak test")
-{
-    SECTION("Websocket destructor is called when closing the connection.")
-    {
-        // stores the server websocket in order to check the use_count
-        std::shared_ptr<WebSocket> webSocketPtr;
-
-        {
-            int port = getFreePort();
-            WebSocketServer server(port);
-
-            server.setOnConnectionCallback(
-                [&webSocketPtr](std::shared_ptr<ix::WebSocket> webSocket,
-                                std::shared_ptr<ConnectionState> connectionState,
-                                std::unique_ptr<ConnectionInfo> connectionInfo) {
-                    // original ptr in WebSocketServer::handleConnection and the callback argument
-                    REQUIRE(webSocket.use_count() == 2);
-                    webSocket->setOnMessageCallback([&webSocketPtr, webSocket, connectionState](
-                                                        const ix::WebSocketMessagePtr& msg) {
-                        if (msg->type == ix::WebSocketMessageType::Open)
-                        {
-                            log(std::string("New connection id: ") + connectionState->getId());
-                            // original ptr in WebSocketServer::handleConnection, captured ptr of
-                            // this callback, and ptr in WebSocketServer::_clients
-                            REQUIRE(webSocket.use_count() == 3);
-                            webSocketPtr = std::shared_ptr<WebSocket>(webSocket);
-                            REQUIRE(webSocket.use_count() == 4);
-                        }
-                        else if (msg->type == ix::WebSocketMessageType::Close)
-                        {
-                            log(std::string("Client closed connection id: ") +
-                                connectionState->getId());
-                        }
-                        else
-                        {
-                            log(std::string(msg->str));
-                        }
-                    });
-                    // original ptr in WebSocketServer::handleConnection, argument of this callback,
-                    // and captured ptr in websocket callback
-                    REQUIRE(webSocket.use_count() == 3);
-                });
-
-            server.listen();
-            server.start();
-
-            WebSocketClient webSocketClient(port);
-            webSocketClient.start();
-
-            while (true)
-            {
-                REQUIRE(!webSocketClient.hasConnectionError());
-                if (webSocketClient.isReady()) break;
-                ix::msleep(10);
-            }
-
-            REQUIRE(server.getClients().size() == 1);
-            // same value as in Open-handler above
-            REQUIRE(webSocketPtr.use_count() == 4);
-
-            ix::msleep(500);
-            webSocketClient.stop();
-            ix::msleep(500);
-            REQUIRE(server.getClients().size() == 0);
-
-            // websocket should only be referenced by webSocketPtr but is still used by the
-            // websocket callback
-            REQUIRE(webSocketPtr.use_count() == 1);
-            webSocketPtr->setOnMessageCallback(nullptr);
-            // websocket should only be referenced by webSocketPtr
-            REQUIRE(webSocketPtr.use_count() == 1);
-            server.stop();
-        }
-        // websocket should only be referenced by webSocketPtr
-        REQUIRE(webSocketPtr.use_count() == 1);
-    }
-}

test/IXWebSocketPerMessageDeflateCompressorTest.cpp

@@ -1,76 +0,0 @@
-/*
- *  IXWebSocketPerMessageDeflateCodecTest.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone. All rights reserved.
- *
- *  make build_test && build/test/ixwebsocket_unittest per-message-deflate-codec
- */
-
-#include "IXTest.h"
-#include "catch.hpp"
-#include <iostream>
-#include <ixwebsocket/IXWebSocketPerMessageDeflateCodec.h>
-#include <string.h>
-
-using namespace ix;
-
-namespace ix
-{
-    std::string compressAndDecompress(const std::string& a)
-    {
-        std::string b, c;
-
-        WebSocketPerMessageDeflateCompressor compressor;
-        compressor.init(11, true);
-        compressor.compress(a, b);
-
-        WebSocketPerMessageDeflateDecompressor decompressor;
-        decompressor.init(11, true);
-        decompressor.decompress(b, c);
-
-        return c;
-    }
-
-    std::string compressAndDecompressVector(const std::string& a)
-    {
-        std::string b, c;
-
-        std::vector<uint8_t> vec(a.begin(), a.end());
-
-        WebSocketPerMessageDeflateCompressor compressor;
-        compressor.init(11, true);
-        compressor.compress(vec, b);
-
-        WebSocketPerMessageDeflateDecompressor decompressor;
-        decompressor.init(11, true);
-        decompressor.decompress(b, c);
-
-        return c;
-    }
-
-    TEST_CASE("per-message-deflate-codec", "[zlib]")
-    {
-        SECTION("string api")
-        {
-            REQUIRE(compressAndDecompress("") == "");
-            REQUIRE(compressAndDecompress("foo") == "foo");
-            REQUIRE(compressAndDecompress("bar") == "bar");
-            REQUIRE(compressAndDecompress("asdcaseqw`21897dehqwed") == "asdcaseqw`21897dehqwed");
-            REQUIRE(compressAndDecompress("/usr/local/include/ixwebsocket/IXSocketAppleSSL.h") ==
-                    "/usr/local/include/ixwebsocket/IXSocketAppleSSL.h");
-        }
-
-        SECTION("vector api")
-        {
-            REQUIRE(compressAndDecompressVector("") == "");
-            REQUIRE(compressAndDecompressVector("foo") == "foo");
-            REQUIRE(compressAndDecompressVector("bar") == "bar");
-            REQUIRE(compressAndDecompressVector("asdcaseqw`21897dehqwed") ==
-                    "asdcaseqw`21897dehqwed");
-            REQUIRE(
-                compressAndDecompressVector("/usr/local/include/ixwebsocket/IXSocketAppleSSL.h") ==
-                "/usr/local/include/ixwebsocket/IXSocketAppleSSL.h");
-        }
-    }
-
-} // namespace ix

test/IXWebSocketServerTest.cpp

@@ -33,19 +33,15 @@ namespace ix
         };
         server.setConnectionStateFactory(factory);
 
-        server.setOnClientMessageCallback(
-            [&server, &connectionId](std::shared_ptr<ConnectionState> connectionState,
-                                     ConnectionInfo& connectionInfo,
-                                     WebSocket& webSocket,
-                                     const ix::WebSocketMessagePtr& msg) {
-                auto remoteIp = connectionInfo.remoteIp;
-
-
+        server.setOnConnectionCallback([&server, &connectionId](
+                                           std::shared_ptr<ix::WebSocket> webSocket,
+                                           std::shared_ptr<ConnectionState> connectionState) {
+            webSocket->setOnMessageCallback([webSocket, connectionState, &connectionId, &server](
+                                                const ix::WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     TLogger() << "New connection";
                     connectionState->computeId();
-                    TLogger() << "remote ip: " << remoteIp;
                     TLogger() << "id: " << connectionState->getId();
                     TLogger() << "Uri: " << msg->openInfo.uri;
                     TLogger() << "Headers:";
@@ -64,13 +60,14 @@ namespace ix
                 {
                     for (auto&& client : server.getClients())
                     {
-                        if (client.get() != &webSocket)
+                        if (client != webSocket)
                         {
                             client->send(msg->str, msg->binary);
                         }
                     }
                 }
             });
+        });
 
         auto res = server.listen();
         if (!res.first)

test/IXWebSocketSubProtocolTest.cpp

@@ -16,40 +16,39 @@ using namespace ix;
 
 bool startServer(ix::WebSocketServer& server, std::string& subProtocols)
 {
-    server.setOnClientMessageCallback(
-        [&server, &subProtocols](std::shared_ptr<ConnectionState> connectionState,
-                                 ConnectionInfo& connectionInfo,
-                                 WebSocket& webSocket,
-                                 const ix::WebSocketMessagePtr& msg) {
-            auto remoteIp = connectionInfo.remoteIp;
-            if (msg->type == ix::WebSocketMessageType::Open)
-            {
-                TLogger() << "New connection";
-                TLogger() << "remote ip: " << remoteIp;
-                TLogger() << "id: " << connectionState->getId();
-                TLogger() << "Uri: " << msg->openInfo.uri;
-                TLogger() << "Headers:";
-                for (auto it : msg->openInfo.headers)
+    server.setOnConnectionCallback(
+        [&server, &subProtocols](std::shared_ptr<ix::WebSocket> webSocket,
+                                 std::shared_ptr<ConnectionState> connectionState) {
+            webSocket->setOnMessageCallback([webSocket, connectionState, &server, &subProtocols](
+                                                const ix::WebSocketMessagePtr& msg) {
+                if (msg->type == ix::WebSocketMessageType::Open)
                 {
-                    TLogger() << it.first << ": " << it.second;
-                }
-
-                subProtocols = msg->openInfo.headers["Sec-WebSocket-Protocol"];
-            }
-            else if (msg->type == ix::WebSocketMessageType::Close)
-            {
-                log("Closed connection");
-            }
-            else if (msg->type == ix::WebSocketMessageType::Message)
-            {
-                for (auto&& client : server.getClients())
-                {
-                    if (client.get() != &webSocket)
+                    TLogger() << "New connection";
+                    TLogger() << "id: " << connectionState->getId();
+                    TLogger() << "Uri: " << msg->openInfo.uri;
+                    TLogger() << "Headers:";
+                    for (auto it : msg->openInfo.headers)
                     {
-                        client->sendBinary(msg->str);
+                        TLogger() << it.first << ": " << it.second;
+                    }
+
+                    subProtocols = msg->openInfo.headers["Sec-WebSocket-Protocol"];
+                }
+                else if (msg->type == ix::WebSocketMessageType::Close)
+                {
+                    log("Closed connection");
+                }
+                else if (msg->type == ix::WebSocketMessageType::Message)
+                {
+                    for (auto&& client : server.getClients())
+                    {
+                        if (client != webSocket)
+                        {
+                            client->sendBinary(msg->str);
+                        }
                     }
                 }
-            }
+            });
         });
 
     auto res = server.listen();

test/compatibility/cpp/libwebsockets/devnull_client.cpp

@@ -1,171 +0,0 @@
-/*
- * lws-minimal-ws-client
- *
- * Written in 2010-2019 by Andy Green <andy@warmcat.com>
- *
- * This file is made available under the Creative Commons CC0 1.0
- * Universal Public Domain Dedication.
- *
- * This demonstrates the a minimal ws client using lws.
- *
- * Original programs connects to https://libwebsockets.org/ and makes a
- * wss connection to the dumb-increment protocol there.  While
- * connected, it prints the numbers it is being sent by
- * dumb-increment protocol.
- *
- * This is modified to make a test client which counts how much messages
- * per second can be received.
- *
- * libwebsockets$ make && ./a.out
- * g++ --std=c++14 -I/usr/local/opt/openssl/include devnull_client.cpp -lwebsockets
- * messages received: 0 per second 0 total
- * [2020/08/02 19:22:21:4774] U: LWS minimal ws client rx [-d <logs>] [--h2]
- * [2020/08/02 19:22:21:4814] U: callback_dumb_increment: established
- * messages received: 0 per second 0 total
- * messages received: 180015 per second 180015 total
- * messages received: 172866 per second 352881 total
- * messages received: 176177 per second 529058 total
- * messages received: 174191 per second 703249 total
- * messages received: 193397 per second 896646 total
- * messages received: 196385 per second 1093031 total
- * messages received: 194593 per second 1287624 total
- * messages received: 189484 per second 1477108 total
- * messages received: 200825 per second 1677933 total
- * messages received: 183542 per second 1861475 total
- * ^C[2020/08/02 19:22:33:4450] U: Completed OK
- *
- */
-
-#include <atomic>
-#include <iostream>
-#include <libwebsockets.h>
-#include <signal.h>
-#include <string.h>
-#include <thread>
-
-static int interrupted;
-static struct lws* client_wsi;
-
-std::atomic<uint64_t> receivedCount(0);
-
-static int callback_dumb_increment(
-    struct lws* wsi, enum lws_callback_reasons reason, void* user, void* in, size_t len)
-{
-    switch (reason)
-    {
-        /* because we are protocols[0] ... */
-        case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
-            lwsl_err("CLIENT_CONNECTION_ERROR: %s\n", in ? (char*) in : "(null)");
-            client_wsi = NULL;
-            break;
-
-        case LWS_CALLBACK_CLIENT_ESTABLISHED: lwsl_user("%s: established\n", __func__); break;
-
-        case LWS_CALLBACK_CLIENT_RECEIVE: receivedCount++; break;
-
-        case LWS_CALLBACK_CLIENT_CLOSED: client_wsi = NULL; break;
-
-        default: break;
-    }
-
-    return lws_callback_http_dummy(wsi, reason, user, in, len);
-}
-
-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)
-        {
-            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 */
-    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;
-}

test/compatibility/csharp/.gitignore

@@ -1,2 +0,0 @@
-bin
-obj

test/compatibility/csharp/Main.cs

@@ -1,99 +0,0 @@
-//
-// Main.cs
-// Author: Benjamin Sergeant
-// Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
-//
-// In a different terminal, start a push server:
-// $ ws push_server -q
-//
-// $ dotnet run
-// messages received per second: 145157
-// messages received per second: 141405
-// messages received per second: 152202
-// messages received per second: 157149
-// messages received per second: 157673
-// messages received per second: 153594
-// messages received per second: 157830
-// messages received per second: 158422
-//
-
-using System;
-using System.Net.WebSockets;
-using System.Threading;
-using System.Threading.Tasks;
-
-public class DevNullClientCli
-{
-    private static int receivedMessage = 0;
-
-    public static async Task<byte[]> ReceiveAsync(ClientWebSocket ws, CancellationToken token)
-    {
-        int bufferSize = 8192; // 8K
-        var buffer = new byte[bufferSize];
-        var offset = 0;
-        var free = buffer.Length;
-
-        while (true)
-        {
-            var result = await ws.ReceiveAsync(new ArraySegment<byte>(buffer, offset, free), token).ConfigureAwait(false);
-
-            offset += result.Count;
-            free -= result.Count;
-            if (result.EndOfMessage) break;
-
-            if (free == 0)
-            {
-                // No free space
-                // Resize the outgoing buffer
-                var newSize = buffer.Length + bufferSize;
-
-                var newBuffer = new byte[newSize];
-                Array.Copy(buffer, 0, newBuffer, 0, offset);
-                buffer = newBuffer;
-                free = buffer.Length - offset;
-            }
-        }
-
-        return buffer;
-    }
-
-    private static void OnTimedEvent(object source, EventArgs e)
-    {
-        Console.WriteLine($"messages received per second: {receivedMessage}");
-        receivedMessage = 0;
-    }
-
-    public static async Task ReceiveMessagesAsync(string url)
-    {
-        var ws = new ClientWebSocket();
-
-        System.Uri uri = new System.Uri(url);
-        var cancellationToken = CancellationToken.None;
-
-        try 
-        {
-            await ws.ConnectAsync(uri, cancellationToken).ConfigureAwait(false);
-            while (true)
-            {
-                var data = await DevNullClientCli.ReceiveAsync(ws, cancellationToken);
-                receivedMessage += 1;
-            }
-        }
-        catch (System.Net.WebSockets.WebSocketException e)
-        {
-            Console.WriteLine($"WebSocket error: {e}");
-            return;
-        }
-    }
-
-    public static async Task Main()
-    {
-        var timer = new System.Timers.Timer(1000);
-        timer.Elapsed += OnTimedEvent;
-        timer.Enabled = true;
-        timer.Start();
-
-        var url = "ws://localhost:8008";
-        await ReceiveMessagesAsync(url);
-    }
-}

test/compatibility/csharp/devnull_client.csproj

@@ -1,6 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
-  </PropertyGroup>
-</Project>

test/compatibility/node/devnull_client.js

@@ -1,42 +0,0 @@
-//
-// With ws@7.3.1
-// and 
-// node --version
-// v13.11.0
-//
-// In a different terminal, start a push server:
-// $ ws push_server -q
-//
-// $ node devnull_client.js
-// messages received per second: 16643
-// messages received per second: 28065
-// messages received per second: 28432
-// messages received per second: 22207
-// messages received per second: 28805
-// messages received per second: 28694
-// messages received per second: 28180
-// messages received per second: 28601
-// messages received per second: 28698
-// messages received per second: 28931
-// messages received per second: 27975
-//
-const WebSocket = require('ws');
-
-const ws = new WebSocket('ws://localhost:8008');
-
-ws.on('open', function open() {
-  ws.send('hello from node');
-});
-
-var receivedMessages = 0;
-
-setInterval(function timeout() {
-  console.log(`messages received per second: ${receivedMessages}`)
-  receivedMessages = 0;
-}, 1000);
-
-ws.on('message', function incoming(data) {
-  receivedMessages += 1;
-});
-
-

test/compatibility/python/websockets/devnull_client.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-
-# websocket send client
-
-import argparse
-import asyncio
-import websockets
-
-try:
-    import uvloop
-    uvloop.install()
-except ImportError:
-    print('uvloop not available')
-    pass
-
-msgCount = 0
-
-async def timer():
-    global msgCount
-
-    while True:
-        print(f'Received messages: {msgCount}')
-        msgCount = 0
-
-        await asyncio.sleep(1)
-
-
-async def client(url):
-    global msgCount
-
-    asyncio.ensure_future(timer())
-
-    async with websockets.connect(url) as ws:
-        async for message in ws:
-            msgCount += 1
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='websocket proxy.')
-    parser.add_argument('--url', help='Remote websocket url',
-                        default='wss://echo.websocket.org')
-    args = parser.parse_args()
-
-    asyncio.get_event_loop().run_until_complete(client(args.url))

test/compatibility/python/websockets/echo_server.py

@@ -10,7 +10,7 @@ import websockets
 async def echo(websocket, path):
     while True:
         msg = await websocket.recv()
-        # print(f'Received {len(msg)} bytes')
+        print(f'Received {len(msg)} bytes')
         await websocket.send(msg)
 
 host = os.getenv('BIND_HOST', 'localhost')

test/test_runner.cpp

@@ -10,18 +10,10 @@
 #include <ixwebsocket/IXNetSystem.h>
 #include <spdlog/spdlog.h>
 
-#ifndef _WIN32
-#include <signal.h>
-#endif
-
 int main(int argc, char* argv[])
 {
     ix::initNetSystem();
 
-#ifndef _WIN32
-    signal(SIGPIPE, SIG_IGN);
-#endif
-
     ix::CoreLogger::LogFunc logFunc = [](const char* msg, ix::LogLevel level) {
         switch (level)
         {
@@ -57,7 +49,6 @@ int main(int argc, char* argv[])
         }
     };
     ix::CoreLogger::setLogFunction(logFunc);
-    spdlog::set_level(spdlog::level::debug);
 
     int result = Catch::Session().run(argc, argv);
 

third_party/cpp-linenoise/linenoise.hpp

@@ -122,8 +122,6 @@
 
 #pragma once
 
-#include <string>
-
 namespace linenoise 
 {
     bool Readline(const char *prompt, std::string& line);

tools/extract_latest_change.sh

@@ -1,3 +0,0 @@
-#!/bin/sh
-
-grep -A 3 '^##' docs/CHANGELOG.md | head -n 3 | tail -n 1

ws/CMakeLists.txt

@@ -20,6 +20,7 @@ option(USE_TLS "Add TLS support" ON)
 
 include_directories(ws .)
 include_directories(ws ..)
+include_directories(ws ../third_party)
 include_directories(ws ../third_party/spdlog/include)
 include_directories(ws ../third_party/cpp-linenoise)
 
@@ -46,6 +47,28 @@ add_executable(ws
   ../third_party/msgpack11/msgpack11.cpp
   ../third_party/cpp-linenoise/linenoise.cpp
   ${JSONCPP_SOURCES}
+
+  ws_http_client.cpp
+  ws_ping_pong.cpp
+  ws_broadcast_server.cpp
+  ws_echo_server.cpp
+  ws_chat.cpp
+  ws_connect.cpp
+  ws_transfer.cpp
+  ws_send.cpp
+  ws_receive.cpp
+  ws_redis_cli.cpp
+  ws_redis_publish.cpp
+  ws_redis_subscribe.cpp
+  ws_redis_server.cpp
+  ws_snake.cpp
+  ws_cobra_metrics_publish.cpp
+  ws_cobra_publish.cpp
+  ws_httpd.cpp
+  ws_autobahn.cpp
+  ws_proxy_server.cpp
+  ws_sentry_minidump_upload.cpp
+  ws_dns_lookup.cpp
   ws.cpp)
 
 # library with the most dependencies come first

ws/proxyConfig.json

@@ -1,6 +0,0 @@
-{
-	"remote_urls": {
-		"echo.localhost:8008": "ws://localhost:8009",
-		"cobra.localhost:8008": "ws://localhost:5678"
-	}
-}

ws/test_ws.sh

@@ -14,7 +14,6 @@ function cleanup_and_exit {
 }
 
 WITH_TLS=${WITH_TLS:-0}
-BLOCKS=${BLOCKS:-20000}
 
 rm -rf /tmp/ws_test
 mkdir -p /tmp/ws_test
@@ -58,7 +57,7 @@ ws receive "${protocol}127.0.0.1:8090" ${delay} --pidfile /tmp/ws_test/pidfile.r
 
 mkdir -p /tmp/ws_test/send
 cd /tmp/ws_test/send
-dd if=/dev/urandom of=/tmp/ws_test/send/20M_file count=$BLOCKS bs=1024
+dd if=/dev/urandom of=/tmp/ws_test/send/20M_file count=20000 bs=1024
 
 # Start the sender job
 ws send ${client_tls} --pidfile /tmp/ws_test/pidfile.send "${protocol}127.0.0.1:8090" /tmp/ws_test/send/20M_file

ws/test_ws_proxy.sh

@@ -1,39 +0,0 @@
-#!/bin/sh
-
-# This test requires cobra to be available
-which cobra > /dev/null || {
-    echo cobra is not installed on this machine.
-    exit 0
-}
-
-# Handle Ctrl-C by killing all sub-processing AND exiting
-trap cleanup INT
-
-function cleanup {
-    exit_code=${1:-1}
-    echo "Killing all servers (ws and cobra)"
-    echo
-    kill `cat /tmp/pidfile.proxy`  &>/dev/null
-    kill `cat /tmp/pidfile.echo_server`  &>/dev/null
-    kill `cat /tmp/pidfile.cobra`  &>/dev/null
-    kill `cat /tmp/pidfile.connect.echo`  &>/dev/null
-    kill `cat /tmp/pidfile.connect.cobra`  &>/dev/null
-    exit ${exit_code}
-}
-
-ws proxy_server --pidfile /tmp/pidfile.proxy --config_path proxyConfig.json &
-ws echo_server --pidfile /tmp/pidfile.echo_server --port 8009 &
-cobra -v run --pidfile /tmp/pidfile.cobra --port 5678 &
-
-# Wait for the servers to be up
-sleep 1
-
-# unbuffer comes with expect (written in tcl)
-echo 'hello' | unbuffer ws connect --pidfile /tmp/pidfile.connect.echo ws://echo.localhost:8008 &
-
-echo 'hello' | unbuffer ws connect --pidfile /tmp/pidfile.connect.cobra ws://cobra.localhost:8008 &
-
-# Wait
-sleep 2
-
-cleanup

ws/ws.h

@@ -0,0 +1,133 @@
+/*
+ *  ws.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+#pragma once
+
+#include <ixcobra/IXCobraConfig.h>
+#include <ixwebsocket/IXSocketTLSOptions.h>
+#include <string>
+
+namespace ix
+{
+    int ws_http_client_main(const std::string& url,
+                            const std::string& headers,
+                            const std::string& data,
+                            bool headersOnly,
+                            int connectTimeout,
+                            int transferTimeout,
+                            bool followRedirects,
+                            int maxRedirects,
+                            bool verbose,
+                            bool save,
+                            const std::string& output,
+                            bool compress,
+                            const ix::SocketTLSOptions& tlsOptions);
+
+    int ws_ping_pong_main(const std::string& url, const ix::SocketTLSOptions& tlsOptions);
+
+    int ws_echo_server_main(int port,
+                            bool greetings,
+                            const std::string& hostname,
+                            const ix::SocketTLSOptions& tlsOptions,
+                            bool ipv6,
+                            bool disablePerMessageDeflate,
+                            bool disablePong);
+
+    int ws_broadcast_server_main(int port,
+                                 const std::string& hostname,
+                                 const ix::SocketTLSOptions& tlsOptions);
+    int ws_transfer_main(int port,
+                         const std::string& hostname,
+                         const ix::SocketTLSOptions& tlsOptions);
+
+    int ws_chat_main(const std::string& url, const std::string& user);
+
+    int ws_connect_main(const std::string& url,
+                        const std::string& headers,
+                        bool disableAutomaticReconnection,
+                        bool disablePerMessageDeflate,
+                        bool binaryMode,
+                        uint32_t maxWaitBetweenReconnectionRetries,
+                        const ix::SocketTLSOptions& tlsOptions,
+                        const std::string& subprotocol,
+                        int pingIntervalSecs);
+
+    int ws_receive_main(const std::string& url,
+                        bool enablePerMessageDeflate,
+                        int delayMs,
+                        const ix::SocketTLSOptions& tlsOptions);
+
+    int ws_send_main(const std::string& url,
+                     const std::string& path,
+                     bool disablePerMessageDeflate,
+                     const ix::SocketTLSOptions& tlsOptions);
+
+    int ws_redis_cli_main(const std::string& hostname,
+                          int port,
+                          const std::string& password);
+
+    int ws_redis_publish_main(const std::string& hostname,
+                              int port,
+                              const std::string& password,
+                              const std::string& channel,
+                              const std::string& message,
+                              int count);
+
+    int ws_redis_subscribe_main(const std::string& hostname,
+                                int port,
+                                const std::string& password,
+                                const std::string& channel,
+                                bool verbose);
+
+    int ws_cobra_publish_main(const ix::CobraConfig& appkey,
+                              const std::string& channel,
+                              const std::string& path);
+
+    int ws_cobra_metrics_publish_main(const ix::CobraConfig& config,
+                                      const std::string& channel,
+                                      const std::string& path,
+                                      bool stress);
+
+    int ws_cobra_metrics_to_redis(const ix::CobraConfig& config,
+                                  const std::string& channel,
+                                  const std::string& filter,
+                                  const std::string& position,
+                                  const std::string& host,
+                                  int port);
+
+    int ws_snake_main(int port,
+                      const std::string& hostname,
+                      const std::string& redisHosts,
+                      int redisPort,
+                      const std::string& redisPassword,
+                      bool verbose,
+                      const std::string& appsConfigPath,
+                      const ix::SocketTLSOptions& tlsOptions,
+                      bool disablePong);
+
+    int ws_httpd_main(int port,
+                      const std::string& hostname,
+                      bool redirect,
+                      const std::string& redirectUrl,
+                      const ix::SocketTLSOptions& tlsOptions);
+
+    int ws_autobahn_main(const std::string& url, bool quiet);
+
+    int ws_redis_server_main(int port, const std::string& hostname);
+
+    int ws_proxy_server_main(int port,
+                             const std::string& hostname,
+                             const ix::SocketTLSOptions& tlsOptions,
+                             const std::string& remoteHost,
+                             bool verbose);
+
+    int ws_sentry_minidump_upload(const std::string& metadataPath,
+                                  const std::string& minidump,
+                                  const std::string& project,
+                                  const std::string& key,
+                                  bool verbose);
+
+    int ws_dns_lookup(const std::string& hostname);
+} // namespace ix

ws/ws_autobahn.cpp

@@ -0,0 +1,298 @@
+/*
+ *  ws_autobahn.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+//
+// 1. First you need to generate a config file in a config folder,
+//    which can use a white list of test to execute (with globbing),
+//    or a black list of tests to ignore
+//
+// config/fuzzingserver.json
+// {
+//     "url": "ws://127.0.0.1:9001",
+//     "outdir": "./reports/clients",
+//     "cases": ["2.*"],
+//     "exclude-cases": [
+//     ],
+//     "exclude-agent-cases": {}
+// }
+//
+//
+// 2 Run the test server (using docker)
+// docker run -it --rm -v "${PWD}/config:/config" -v "${PWD}/reports:/reports" -p 9001:9001 --name
+// fuzzingserver crossbario/autobahn-testsuite
+//
+// 3. Run this command
+//    ws autobahn -q --url ws://localhost:9001
+//
+// 4. A HTML report will be generated, you can inspect it to see if you are compliant or not
+//
+
+#include <atomic>
+#include <condition_variable>
+#include <ixwebsocket/IXSocket.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <mutex>
+#include <spdlog/spdlog.h>
+#include <sstream>
+
+
+namespace
+{
+    std::string truncate(const std::string& str, size_t n)
+    {
+        if (str.size() < n)
+        {
+            return str;
+        }
+        else
+        {
+            return str.substr(0, n) + "...";
+        }
+    }
+} // namespace
+
+namespace ix
+{
+    class AutobahnTestCase
+    {
+    public:
+        AutobahnTestCase(const std::string& _url, bool quiet);
+        void run();
+
+    private:
+        void log(const std::string& msg);
+
+        std::string _url;
+        ix::WebSocket _webSocket;
+
+        bool _quiet;
+
+        std::mutex _mutex;
+        std::condition_variable _condition;
+    };
+
+    AutobahnTestCase::AutobahnTestCase(const std::string& url, bool quiet)
+        : _url(url)
+        , _quiet(quiet)
+    {
+        _webSocket.disableAutomaticReconnection();
+
+        // FIXME: this should be on by default
+        ix::WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(
+            true, false, false, 15, 15);
+        _webSocket.setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
+    }
+
+    void AutobahnTestCase::log(const std::string& msg)
+    {
+        if (!_quiet)
+        {
+            spdlog::info(msg);
+        }
+    }
+
+    void AutobahnTestCase::run()
+    {
+        _webSocket.setUrl(_url);
+
+        std::stringstream ss;
+        log(std::string("Connecting to url: ") + _url);
+
+        _webSocket.setOnMessageCallback([this](const ix::WebSocketMessagePtr& msg) {
+            std::stringstream ss;
+            if (msg->type == ix::WebSocketMessageType::Open)
+            {
+                log("autobahn: connected");
+                ss << "Uri: " << msg->openInfo.uri << std::endl;
+                ss << "Handshake Headers:" << std::endl;
+                for (auto it : msg->openInfo.headers)
+                {
+                    ss << it.first << ": " << it.second << std::endl;
+                }
+            }
+            else if (msg->type == ix::WebSocketMessageType::Close)
+            {
+                ss << "autobahn: connection closed:";
+                ss << " code " << msg->closeInfo.code;
+                ss << " reason " << msg->closeInfo.reason << std::endl;
+
+                _condition.notify_one();
+            }
+            else if (msg->type == ix::WebSocketMessageType::Message)
+            {
+                ss << "Received " << msg->wireSize << " bytes" << std::endl;
+
+                ss << "autobahn: received message: " << truncate(msg->str, 40) << std::endl;
+
+                _webSocket.send(msg->str, msg->binary);
+            }
+            else if (msg->type == ix::WebSocketMessageType::Error)
+            {
+                ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+
+                // And error can happen, in which case the test-case is marked done
+                _condition.notify_one();
+            }
+            else if (msg->type == ix::WebSocketMessageType::Fragment)
+            {
+                ss << "Received message fragment" << std::endl;
+            }
+            else if (msg->type == ix::WebSocketMessageType::Ping)
+            {
+                ss << "Received ping" << std::endl;
+            }
+            else if (msg->type == ix::WebSocketMessageType::Pong)
+            {
+                ss << "Received pong" << std::endl;
+            }
+            else
+            {
+                ss << "Invalid ix::WebSocketMessageType" << std::endl;
+            }
+
+            log(ss.str());
+        });
+
+        _webSocket.start();
+
+        log("Waiting for test completion ...");
+        std::unique_lock<std::mutex> lock(_mutex);
+        _condition.wait(lock);
+
+        _webSocket.stop();
+    }
+
+    bool generateReport(const std::string& url)
+    {
+        ix::WebSocket webSocket;
+        std::string reportUrl(url);
+        reportUrl += "/updateReports?agent=ixwebsocket";
+        webSocket.setUrl(reportUrl);
+        webSocket.disableAutomaticReconnection();
+
+        std::atomic<bool> success(true);
+        std::condition_variable condition;
+
+        webSocket.setOnMessageCallback([&condition, &success](const ix::WebSocketMessagePtr& msg) {
+            if (msg->type == ix::WebSocketMessageType::Close)
+            {
+                spdlog::info("Report generated");
+                condition.notify_one();
+            }
+            else if (msg->type == ix::WebSocketMessageType::Error)
+            {
+                std::stringstream ss;
+                ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                spdlog::info(ss.str());
+
+                success = false;
+            }
+        });
+
+        webSocket.start();
+        std::mutex mutex;
+        std::unique_lock<std::mutex> lock(mutex);
+        condition.wait(lock);
+        webSocket.stop();
+
+        if (!success)
+        {
+            spdlog::error("Cannot generate report at url {}", reportUrl);
+        }
+
+        return success;
+    }
+
+    int getTestCaseCount(const std::string& url)
+    {
+        ix::WebSocket webSocket;
+        std::string caseCountUrl(url);
+        caseCountUrl += "/getCaseCount";
+        webSocket.setUrl(caseCountUrl);
+        webSocket.disableAutomaticReconnection();
+
+        int count = -1;
+        std::condition_variable condition;
+
+        webSocket.setOnMessageCallback([&condition, &count](const ix::WebSocketMessagePtr& msg) {
+            if (msg->type == ix::WebSocketMessageType::Close)
+            {
+                condition.notify_one();
+            }
+            else if (msg->type == ix::WebSocketMessageType::Error)
+            {
+                std::stringstream ss;
+                ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                spdlog::info(ss.str());
+
+                condition.notify_one();
+            }
+            else if (msg->type == ix::WebSocketMessageType::Message)
+            {
+                // response is a string
+                std::stringstream ss;
+                ss << msg->str;
+                ss >> count;
+            }
+        });
+
+        webSocket.start();
+        std::mutex mutex;
+        std::unique_lock<std::mutex> lock(mutex);
+        condition.wait(lock);
+        webSocket.stop();
+
+        if (count == -1)
+        {
+            spdlog::error("Cannot retrieve test case count at url {}", caseCountUrl);
+        }
+
+        return count;
+    }
+
+    //
+    // make && bench ws autobahn --url ws://localhost:9001
+    //
+    int ws_autobahn_main(const std::string& url, bool quiet)
+    {
+        int testCasesCount = getTestCaseCount(url);
+        spdlog::info("Test cases count: {}", testCasesCount);
+
+        if (testCasesCount == -1)
+        {
+            spdlog::error("Cannot retrieve test case count at url {}", url);
+            return 1;
+        }
+
+        testCasesCount++;
+
+        for (int i = 1; i < testCasesCount; ++i)
+        {
+            spdlog::info("Execute test case {}", i);
+
+            int caseNumber = i;
+
+            std::stringstream ss;
+            ss << url << "/runCase?case=" << caseNumber << "&agent=ixwebsocket";
+
+            std::string url(ss.str());
+
+            AutobahnTestCase testCase(url, quiet);
+            testCase.run();
+        }
+
+        return generateReport(url) ? 0 : 1;
+    }
+} // namespace ix

ws/ws_broadcast_server.cpp

@@ -0,0 +1,96 @@
+/*
+ *  ws_broadcast_server.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <ixwebsocket/IXWebSocketServer.h>
+#include <spdlog/spdlog.h>
+#include <sstream>
+
+
+namespace ix
+{
+    int ws_broadcast_server_main(int port,
+                                 const std::string& hostname,
+                                 const ix::SocketTLSOptions& tlsOptions)
+    {
+        spdlog::info("Listening on {}:{}", hostname, port);
+
+        ix::WebSocketServer server(port, hostname);
+        server.setTLSOptions(tlsOptions);
+
+        server.setOnConnectionCallback([&server](std::shared_ptr<WebSocket> webSocket,
+                                                 std::shared_ptr<ConnectionState> connectionState) {
+            webSocket->setOnMessageCallback([webSocket, connectionState, &server](
+                                                const WebSocketMessagePtr& msg) {
+                if (msg->type == ix::WebSocketMessageType::Open)
+                {
+                    spdlog::info("New connection");
+                    spdlog::info("id: {}", connectionState->getId());
+                    spdlog::info("Uri: {}", msg->openInfo.uri);
+                    spdlog::info("Headers:");
+                    for (auto it : msg->openInfo.headers)
+                    {
+                        spdlog::info("{}: {}", it.first, it.second);
+                    }
+                }
+                else if (msg->type == ix::WebSocketMessageType::Close)
+                {
+                    spdlog::info("Closed connection: code {} reason {}",
+                                 msg->closeInfo.code,
+                                 msg->closeInfo.reason);
+                }
+                else if (msg->type == ix::WebSocketMessageType::Error)
+                {
+                    std::stringstream ss;
+                    ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                    ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                    ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                    ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                    spdlog::info(ss.str());
+                }
+                else if (msg->type == ix::WebSocketMessageType::Fragment)
+                {
+                    spdlog::info("Received message fragment");
+                }
+                else if (msg->type == ix::WebSocketMessageType::Message)
+                {
+                    spdlog::info("Received {} bytes", msg->wireSize);
+
+                    for (auto&& client : server.getClients())
+                    {
+                        if (client != webSocket)
+                        {
+                            client->send(msg->str, msg->binary, [](int current, int total) -> bool {
+                                spdlog::info("Step {} out of {}", current, total);
+                                return true;
+                            });
+
+                            do
+                            {
+                                size_t bufferedAmount = client->bufferedAmount();
+                                spdlog::info("{} bytes left to be sent", bufferedAmount);
+
+                                std::chrono::duration<double, std::milli> duration(500);
+                                std::this_thread::sleep_for(duration);
+                            } while (client->bufferedAmount() != 0);
+                        }
+                    }
+                }
+            });
+        });
+
+        auto res = server.listen();
+        if (!res.first)
+        {
+            spdlog::info(res.second);
+            return 1;
+        }
+
+        server.start();
+        server.wait();
+
+        return 0;
+    }
+} // namespace ix

ws/ws_chat.cpp

@@ -0,0 +1,191 @@
+/*
+ *  ws_chat.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2017-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+//
+// Simple chat program that talks to a broadcast server
+// Broadcast server can be ran with `ws broadcast_server`
+//
+
+#include "nlohmann/json.hpp"
+#include <iostream>
+#include <ixwebsocket/IXSocket.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <queue>
+#include <spdlog/spdlog.h>
+#include <sstream>
+
+// for convenience
+using json = nlohmann::json;
+
+namespace ix
+{
+    class WebSocketChat
+    {
+    public:
+        WebSocketChat(const std::string& url, const std::string& user);
+
+        void subscribe(const std::string& channel);
+        void start();
+        void stop();
+        bool isReady() const;
+
+        void sendMessage(const std::string& text);
+        size_t getReceivedMessagesCount() const;
+
+        std::string encodeMessage(const std::string& text);
+        std::pair<std::string, std::string> decodeMessage(const std::string& str);
+
+    private:
+        std::string _url;
+        std::string _user;
+        ix::WebSocket _webSocket;
+        std::queue<std::string> _receivedQueue;
+
+        void log(const std::string& msg);
+    };
+
+    WebSocketChat::WebSocketChat(const std::string& url, const std::string& user)
+        : _url(url)
+        , _user(user)
+    {
+        ;
+    }
+
+    void WebSocketChat::log(const std::string& msg)
+    {
+        spdlog::info(msg);
+    }
+
+    size_t WebSocketChat::getReceivedMessagesCount() const
+    {
+        return _receivedQueue.size();
+    }
+
+    bool WebSocketChat::isReady() const
+    {
+        return _webSocket.getReadyState() == ix::ReadyState::Open;
+    }
+
+    void WebSocketChat::stop()
+    {
+        _webSocket.stop();
+    }
+
+    void WebSocketChat::start()
+    {
+        _webSocket.setUrl(_url);
+
+        std::stringstream ss;
+        log(std::string("Connecting to url: ") + _url);
+
+        _webSocket.setOnMessageCallback([this](const WebSocketMessagePtr& msg) {
+            std::stringstream ss;
+            if (msg->type == ix::WebSocketMessageType::Open)
+            {
+                log("ws chat: connected");
+                spdlog::info("Uri: {}", msg->openInfo.uri);
+                spdlog::info("Headers:");
+                for (auto it : msg->openInfo.headers)
+                {
+                    spdlog::info("{}: {}", it.first, it.second);
+                }
+
+                spdlog::info("ws chat: user {} connected !", _user);
+                log(ss.str());
+            }
+            else if (msg->type == ix::WebSocketMessageType::Close)
+            {
+                ss << "ws chat user disconnected: " << _user;
+                ss << " code " << msg->closeInfo.code;
+                ss << " reason " << msg->closeInfo.reason << std::endl;
+                log(ss.str());
+            }
+            else if (msg->type == ix::WebSocketMessageType::Message)
+            {
+                auto result = decodeMessage(msg->str);
+
+                // Our "chat" / "broacast" node.js server does not send us
+                // the messages we send, so we don't have to filter it out.
+
+                // store text
+                _receivedQueue.push(result.second);
+
+                ss << std::endl
+                   << result.first << "(" << msg->wireSize << " bytes)"
+                   << " > " << result.second << std::endl
+                   << _user << " > ";
+                log(ss.str());
+            }
+            else if (msg->type == ix::WebSocketMessageType::Error)
+            {
+                ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                log(ss.str());
+            }
+            else
+            {
+                ss << "Invalid ix::WebSocketMessageType";
+                log(ss.str());
+            }
+        });
+
+        _webSocket.start();
+    }
+
+    std::pair<std::string, std::string> WebSocketChat::decodeMessage(const std::string& str)
+    {
+        auto j = json::parse(str);
+
+        std::string msg_user = j["user"];
+        std::string msg_text = j["text"];
+
+        return std::pair<std::string, std::string>(msg_user, msg_text);
+    }
+
+    std::string WebSocketChat::encodeMessage(const std::string& text)
+    {
+        json j;
+        j["user"] = _user;
+        j["text"] = text;
+
+        std::string output = j.dump();
+        return output;
+    }
+
+    void WebSocketChat::sendMessage(const std::string& text)
+    {
+        _webSocket.sendText(encodeMessage(text));
+    }
+
+    int ws_chat_main(const std::string& url, const std::string& user)
+    {
+        spdlog::info("Type Ctrl-D to exit prompt...");
+        WebSocketChat webSocketChat(url, user);
+        webSocketChat.start();
+
+        while (true)
+        {
+            // Read line
+            std::string line;
+            std::cout << user << " > " << std::flush;
+            std::getline(std::cin, line);
+
+            if (!std::cin)
+            {
+                break;
+            }
+
+            webSocketChat.sendMessage(line);
+        }
+
+        spdlog::info("");
+        webSocketChat.stop();
+
+        return 0;
+    }
+} // namespace ix

ws/ws_cobra_metrics_publish.cpp

@@ -0,0 +1,78 @@
+/*
+ *  ws_cobra_metrics_publish.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <atomic>
+#include <chrono>
+#include <fstream>
+#include <ixcobra/IXCobraMetricsPublisher.h>
+#include <jsoncpp/json/json.h>
+#include <spdlog/spdlog.h>
+#include <sstream>
+#include <thread>
+
+namespace ix
+{
+    int ws_cobra_metrics_publish_main(const ix::CobraConfig& config,
+                                      const std::string& channel,
+                                      const std::string& path,
+                                      bool stress)
+    {
+        std::atomic<int> sentMessages(0);
+        std::atomic<int> ackedMessages(0);
+        CobraConnection::setPublishTrackerCallback(
+            [&sentMessages, &ackedMessages](bool sent, bool acked) {
+                if (sent) sentMessages++;
+                if (acked) ackedMessages++;
+            });
+
+        CobraMetricsPublisher cobraMetricsPublisher;
+        cobraMetricsPublisher.enable(true);
+        cobraMetricsPublisher.configure(config, channel);
+
+        while (!cobraMetricsPublisher.isAuthenticated())
+            ;
+
+        std::ifstream f(path);
+        std::string str((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+
+        Json::Value data;
+        Json::Reader reader;
+        if (!reader.parse(str, data)) return 1;
+
+        if (!stress)
+        {
+            auto msgId = cobraMetricsPublisher.push(channel, data);
+            spdlog::info("Sent message: {}", msgId);
+        }
+        else
+        {
+            // Stress mode to try to trigger server and client bugs
+            while (true)
+            {
+                for (int i = 0; i < 1000; ++i)
+                {
+                    cobraMetricsPublisher.push(channel, data);
+                }
+
+                cobraMetricsPublisher.suspend();
+                cobraMetricsPublisher.resume();
+
+                // FIXME: investigate why without this check we trigger a lock
+                while (!cobraMetricsPublisher.isAuthenticated())
+                    ;
+            }
+        }
+
+        // Wait a bit for the message to get a chance to be sent
+        // there isn't any ack on publish right now so it's the best we can do
+        // FIXME: this comment is a lie now
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+        spdlog::info("Sent messages: {} Acked messages {}", sentMessages, ackedMessages);
+
+        return 0;
+    }
+} // namespace ix

ws/ws_cobra_publish.cpp

@@ -0,0 +1,107 @@
+/*
+ *  ws_cobra_publish.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <atomic>
+#include <chrono>
+#include <fstream>
+#include <ixcobra/IXCobraMetricsPublisher.h>
+#include <jsoncpp/json/json.h>
+#include <mutex>
+#include <spdlog/spdlog.h>
+#include <sstream>
+#include <thread>
+
+namespace ix
+{
+    int ws_cobra_publish_main(const ix::CobraConfig& config,
+                              const std::string& channel,
+                              const std::string& path)
+    {
+        std::ifstream f(path);
+        std::string str((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
+
+        Json::Value data;
+        Json::Reader reader;
+        if (!reader.parse(str, data))
+        {
+            spdlog::info("Input file is not a JSON file");
+            return 1;
+        }
+
+        ix::CobraConnection conn;
+        conn.configure(config);
+
+        // Display incoming messages
+        std::atomic<bool> authenticated(false);
+        std::atomic<bool> messageAcked(false);
+
+        conn.setEventCallback(
+            [&conn, &channel, &data, &authenticated, &messageAcked](const CobraEventPtr& event) {
+                if (event->type == ix::CobraEventType::Open)
+                {
+                    spdlog::info("Publisher connected");
+
+                    for (auto&& it : event->headers)
+                    {
+                        spdlog::info("{}: {}", it.first, it.second);
+                    }
+                }
+                else if (event->type == ix::CobraEventType::Closed)
+                {
+                    spdlog::info("Subscriber closed: {}", event->errMsg);
+                }
+                else if (event->type == ix::CobraEventType::Authenticated)
+                {
+                    spdlog::info("Publisher authenticated");
+                    authenticated = true;
+
+                    Json::Value channels;
+                    channels[0] = channel;
+                    auto msgId = conn.publish(channels, data);
+
+                    spdlog::info("Published msg {}", msgId);
+                }
+                else if (event->type == ix::CobraEventType::Subscribed)
+                {
+                    spdlog::info("Publisher: subscribed to channel {}", event->subscriptionId);
+                }
+                else if (event->type == ix::CobraEventType::UnSubscribed)
+                {
+                    spdlog::info("Publisher: unsubscribed from channel {}", event->subscriptionId);
+                }
+                else if (event->type == ix::CobraEventType::Error)
+                {
+                    spdlog::error("Publisher: error {}", event->errMsg);
+                }
+                else if (event->type == ix::CobraEventType::Published)
+                {
+                    spdlog::info("Published message id {} acked", event->msgId);
+                    messageAcked = true;
+                }
+                else if (event->type == ix::CobraEventType::Pong)
+                {
+                    spdlog::info("Received websocket pong");
+                }
+                else if (event->type == ix::CobraEventType::HandshakeError)
+                {
+                    spdlog::error("Subscriber: Handshake error: {}", event->errMsg);
+                }
+                else if (event->type == ix::CobraEventType::AuthenticationError)
+                {
+                    spdlog::error("Subscriber: Authentication error: {}", event->errMsg);
+                }
+            });
+
+        conn.connect();
+
+        while (!authenticated)
+            ;
+        while (!messageAcked)
+            ;
+
+        return 0;
+    }
+} // namespace ix

ws/ws_connect.cpp

@@ -0,0 +1,289 @@
+/*
+ *  ws_connect.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXBench.h"
+#include "linenoise.hpp"
+#include <ixwebsocket/IXSocket.h>
+#include <ixwebsocket/IXSocketTLSOptions.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <spdlog/spdlog.h>
+#include <sstream>
+#include <iostream>
+
+
+namespace ix
+{
+    class WebSocketConnect
+    {
+    public:
+        WebSocketConnect(const std::string& _url,
+                         const std::string& headers,
+                         bool disableAutomaticReconnection,
+                         bool disablePerMessageDeflate,
+                         bool binaryMode,
+                         uint32_t maxWaitBetweenReconnectionRetries,
+                         const ix::SocketTLSOptions& tlsOptions,
+                         const std::string& subprotocol,
+                         int pingIntervalSecs);
+
+        void subscribe(const std::string& channel);
+        void start();
+        void stop();
+
+        int getSentBytes()
+        {
+            return _sentBytes;
+        }
+        int getReceivedBytes()
+        {
+            return _receivedBytes;
+        }
+
+        void sendMessage(const std::string& text);
+
+    private:
+        std::string _url;
+        WebSocketHttpHeaders _headers;
+        ix::WebSocket _webSocket;
+        bool _disablePerMessageDeflate;
+        bool _binaryMode;
+        std::atomic<int> _receivedBytes;
+        std::atomic<int> _sentBytes;
+
+        void log(const std::string& msg);
+        WebSocketHttpHeaders parseHeaders(const std::string& data);
+    };
+
+    WebSocketConnect::WebSocketConnect(const std::string& url,
+                                       const std::string& headers,
+                                       bool disableAutomaticReconnection,
+                                       bool disablePerMessageDeflate,
+                                       bool binaryMode,
+                                       uint32_t maxWaitBetweenReconnectionRetries,
+                                       const ix::SocketTLSOptions& tlsOptions,
+                                       const std::string& subprotocol,
+                                       int pingIntervalSecs)
+        : _url(url)
+        , _disablePerMessageDeflate(disablePerMessageDeflate)
+        , _binaryMode(binaryMode)
+        , _receivedBytes(0)
+        , _sentBytes(0)
+    {
+        if (disableAutomaticReconnection)
+        {
+            _webSocket.disableAutomaticReconnection();
+        }
+        _webSocket.setMaxWaitBetweenReconnectionRetries(maxWaitBetweenReconnectionRetries);
+        _webSocket.setTLSOptions(tlsOptions);
+        _webSocket.setPingInterval(pingIntervalSecs);
+
+        _headers = parseHeaders(headers);
+
+        if (!subprotocol.empty())
+        {
+            _webSocket.addSubProtocol(subprotocol);
+        }
+
+        WebSocket::setTrafficTrackerCallback([this](int size, bool incoming) {
+            if (incoming)
+            {
+                _receivedBytes += size;
+            }
+            else
+            {
+                _sentBytes += size;
+            }
+        });
+    }
+
+    void WebSocketConnect::log(const std::string& msg)
+    {
+        std::cout << msg << std::endl;
+    }
+
+    WebSocketHttpHeaders WebSocketConnect::parseHeaders(const std::string& data)
+    {
+        WebSocketHttpHeaders headers;
+
+        // Split by \n
+        std::string token;
+        std::stringstream tokenStream(data);
+
+        while (std::getline(tokenStream, token))
+        {
+            std::size_t pos = token.rfind(':');
+
+            // Bail out if last '.' is found
+            if (pos == std::string::npos) continue;
+
+            auto key = token.substr(0, pos);
+            auto val = token.substr(pos + 1);
+
+            spdlog::info("{}: {}", key, val);
+            headers[key] = val;
+        }
+
+        return headers;
+    }
+
+    void WebSocketConnect::stop()
+    {
+        {
+            Bench bench("ws_connect: stop connection");
+            _webSocket.stop();
+        }
+    }
+
+    void WebSocketConnect::start()
+    {
+        _webSocket.setUrl(_url);
+        _webSocket.setExtraHeaders(_headers);
+
+        if (_disablePerMessageDeflate)
+        {
+            _webSocket.disablePerMessageDeflate();
+        }
+        else
+        {
+            ix::WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(
+                true, false, false, 15, 15);
+            _webSocket.setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
+        }
+
+        std::stringstream ss;
+        log(std::string("Connecting to url: ") + _url);
+
+        _webSocket.setOnMessageCallback([this](const ix::WebSocketMessagePtr& msg) {
+            std::stringstream ss;
+            if (msg->type == ix::WebSocketMessageType::Open)
+            {
+                log("ws_connect: connected");
+                spdlog::info("Uri: {}", msg->openInfo.uri);
+                spdlog::info("Headers:");
+                for (auto it : msg->openInfo.headers)
+                {
+                    spdlog::info("{}: {}", it.first, it.second);
+                }
+            }
+            else if (msg->type == ix::WebSocketMessageType::Close)
+            {
+                ss << "ws_connect: connection closed:";
+                ss << " code " << msg->closeInfo.code;
+                ss << " reason " << msg->closeInfo.reason << std::endl;
+                log(ss.str());
+            }
+            else if (msg->type == ix::WebSocketMessageType::Message)
+            {
+                spdlog::info("Received {} bytes", msg->wireSize);
+
+                ss << "ws_connect: received message: " << msg->str;
+                log(ss.str());
+            }
+            else if (msg->type == ix::WebSocketMessageType::Error)
+            {
+                ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                log(ss.str());
+            }
+            else if (msg->type == ix::WebSocketMessageType::Fragment)
+            {
+                spdlog::info("Received message fragment");
+            }
+            else if (msg->type == ix::WebSocketMessageType::Ping)
+            {
+                spdlog::info("Received ping");
+            }
+            else if (msg->type == ix::WebSocketMessageType::Pong)
+            {
+                spdlog::info("Received pong");
+            }
+            else
+            {
+                ss << "Invalid ix::WebSocketMessageType";
+                log(ss.str());
+            }
+        });
+
+        _webSocket.start();
+    }
+
+    void WebSocketConnect::sendMessage(const std::string& text)
+    {
+        if (_binaryMode)
+        {
+            std::vector<uint8_t> data(text.begin(), text.end());
+            _webSocket.sendBinary(data);
+        }
+        else
+        {
+            _webSocket.sendText(text);
+        }
+    }
+
+    int ws_connect_main(const std::string& url,
+                        const std::string& headers,
+                        bool disableAutomaticReconnection,
+                        bool disablePerMessageDeflate,
+                        bool binaryMode,
+                        uint32_t maxWaitBetweenReconnectionRetries,
+                        const ix::SocketTLSOptions& tlsOptions,
+                        const std::string& subprotocol,
+                        int pingIntervalSecs)
+    {
+        std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
+        WebSocketConnect webSocketChat(url,
+                                       headers,
+                                       disableAutomaticReconnection,
+                                       disablePerMessageDeflate,
+                                       binaryMode,
+                                       maxWaitBetweenReconnectionRetries,
+                                       tlsOptions,
+                                       subprotocol,
+                                       pingIntervalSecs);
+        webSocketChat.start();
+
+        while (true)
+        {
+            // Read line
+            std::string line;
+            auto quit = linenoise::Readline("> ", line);
+
+            if (quit)
+            {
+                break;
+            }
+
+            if (line == "/stop")
+            {
+                spdlog::info("Stopping connection...");
+                webSocketChat.stop();
+                continue;
+            }
+
+            if (line == "/start")
+            {
+                spdlog::info("Starting connection...");
+                webSocketChat.start();
+                continue;
+            }
+
+            webSocketChat.sendMessage(line);
+
+            // Add text to history
+            linenoise::AddHistory(line.c_str());
+        }
+
+        spdlog::info("");
+        webSocketChat.stop();
+
+        spdlog::info("Received {} bytes", webSocketChat.getReceivedBytes());
+        spdlog::info("Sent {} bytes", webSocketChat.getSentBytes());
+
+        return 0;
+    }
+} // namespace ix

ws/ws_dns_lookup.cpp

@@ -0,0 +1,34 @@
+/*
+ *  ws_dns_lookup.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <atomic>
+#include <ixwebsocket/IXDNSLookup.h>
+#include <ixwebsocket/IXNetSystem.h>
+#include <spdlog/spdlog.h>
+#include <sstream>
+
+
+namespace ix
+{
+    int ws_dns_lookup(const std::string& hostname)
+    {
+        auto dnsLookup = std::make_shared<DNSLookup>(hostname, 80);
+
+        std::string errMsg;
+        struct addrinfo* res;
+
+        res = dnsLookup->resolve(errMsg, [] { return false; });
+
+        auto addr = res->ai_addr;
+
+        char str[INET_ADDRSTRLEN];
+        inet_ntop(AF_INET, &addr, str, INET_ADDRSTRLEN);
+
+        spdlog::info("host: {} ip: {}", hostname, str);
+
+        return 0;
+    }
+} // namespace ix