quit checkConnection after sleeping if requested to stop (iterate on #151)

* Doc update for Conan

* Migration notice

.gitignore

@@ -1,3 +1,7 @@
 build
 *.pyc
 venv
+ixsnake/ixsnake/.certs/
+site/
+ws/.certs/
+ws/.srl

CMakeLists.txt

@@ -113,22 +113,24 @@ else()
     list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSelectInterruptEventFd.h)
 endif()
 
-if (WIN32)
-  set(USE_MBED_TLS TRUE)
-endif()
+option(USE_TLS "Enable TLS support" FALSE)
 
 if (USE_TLS)
+    if (WIN32)
+        option(USE_MBED_TLS "Use Mbed TLS" ON)
+    else()
+        option(USE_MBED_TLS "Use Mbed TLS" OFF)
+    endif()
+    option(USE_OPEN_SSL "Use OpenSSL" OFF)
+    
     if (USE_MBED_TLS)
         list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketMbedTLS.h)
         list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketMbedTLS.cpp)
     elseif (APPLE AND NOT USE_OPEN_SSL)
         list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketAppleSSL.h)
         list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketAppleSSL.cpp)
-    elseif (WIN32)
-        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketSChannel.h)
-        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketSChannel.cpp)
     else()
-        set(USE_OPEN_SSL TRUE)
+        set(USE_OPEN_SSL ON)
         list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketOpenSSL.h)
         list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketOpenSSL.cpp)
     endif()
@@ -145,19 +147,15 @@ if (USE_TLS)
         target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_MBED_TLS)
     elseif (USE_OPEN_SSL)
         target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_OPEN_SSL)
-    elseif (APPLE)
-    elseif (WIN32)
-    else()
-        target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_OPEN_SSL)
     endif()
 endif()
 
-if (APPLE AND USE_TLS AND NOT USE_MBED_TLS)
+if (APPLE AND USE_TLS AND NOT USE_MBED_TLS AND NOT USE_OPEN_SSL)
   target_link_libraries(ixwebsocket "-framework foundation" "-framework security")
 endif()
 
 if (WIN32)
-  target_link_libraries(ixwebsocket wsock32 ws2_32)
+  target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 endif()
 
@@ -174,7 +172,9 @@ if (USE_TLS AND USE_OPEN_SSL)
     set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} /usr/local/opt/openssl/include)
   endif()
 
-  find_package(OpenSSL REQUIRED)
+  if(NOT OPENSSL_FOUND)
+    find_package(OpenSSL REQUIRED)
+  endif()
   add_definitions(${OPENSSL_DEFINITIONS})
   message(STATUS "OpenSSL: " ${OPENSSL_VERSION})
   include_directories(${OPENSSL_INCLUDE_DIR})
@@ -207,7 +207,7 @@ else()
 endif()
 
 set( IXWEBSOCKET_INCLUDE_DIRS
-    .
+    ${CMAKE_CURRENT_SOURCE_DIR}
 )
 
 if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")

Dockerfile

@@ -1,35 +0,0 @@
-FROM alpine:edge as build
-
-RUN apk add --no-cache gcc g++ musl-dev linux-headers cmake openssl-dev 
-RUN apk add --no-cache make
-RUN apk add --no-cache zlib-dev
-
-RUN addgroup -S app && adduser -S -G app app 
-RUN chown -R app:app /opt
-RUN chown -R app:app /usr/local
-
-# There is a bug in CMake where we cannot build from the root top folder
-# So we build from /opt
-COPY --chown=app:app . /opt
-WORKDIR /opt
-
-USER app
-RUN [ "make", "ws_install" ]
-
-FROM alpine:edge as runtime
-
-RUN apk add --no-cache libstdc++
-RUN apk add --no-cache strace
-
-RUN addgroup -S app && adduser -S -G app app 
-COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
-RUN chmod +x /usr/local/bin/ws
-RUN ldd /usr/local/bin/ws
-
-# Now run in usermode
-USER app
-WORKDIR /home/app
-
-ENTRYPOINT ["ws"]
-EXPOSE 8008
-CMD ["--help"]

Dockerfile

@@ -0,0 +1 @@
+docker/Dockerfile.centos

README.md

@@ -38,4 +38,10 @@ Interested? Go read the [docs](https://machinezone.github.io/IXWebSocket/)! If t
 
 IXWebSocket is actively being developed, check out the [changelog](https://machinezone.github.io/IXWebSocket/CHANGELOG/) to know what's cooking. If you are looking for a real time messaging service (the chat-like 'server' your websocket code will talk to) with many features such as history, backed by Redis, look at [cobra](https://github.com/machinezone/cobra).
 
-IXWebSocket client code is autobahn compliant beginning with the 6.0.0 version. See the current [test results](https://bsergean.github.io/IXWebSocket/autobahn/index.html). Some tests are still failing in the server code.
+IXWebSocket client code is autobahn compliant beginning with the 6.0.0 version. See the current [test results](https://bsergean.github.io/autobahn/reports/clients/index.html). Some tests are still failing in the server code.
+
+## Users
+
+If your company or project is using this library, feel free to open an issue or PR to amend this list.
+
+- [Machine Zone](https://www.mz.com)

docker/Dockerfile.alpine

@@ -1,4 +1,4 @@
-FROM alpine as build
+FROM alpine:3.11 as build
 
 RUN apk add --no-cache gcc g++ musl-dev linux-headers cmake openssl-dev 
 RUN apk add --no-cache make
@@ -15,20 +15,25 @@ WORKDIR /opt
 
 USER app
 RUN [ "make", "ws_install" ]
+RUN [ "rm", "-rf", "build" ]
 
-FROM alpine as runtime
+FROM alpine:3.11 as runtime
 
 RUN apk add --no-cache libstdc++
+RUN apk add --no-cache strace
+RUN apk add --no-cache gdb
 
 RUN addgroup -S app && adduser -S -G app app 
 COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
 RUN chmod +x /usr/local/bin/ws
 RUN ldd /usr/local/bin/ws
 
+# Copy source code for gcc
+COPY --chown=app:app --from=build /opt /opt
+
 # Now run in usermode
 USER app
 WORKDIR /home/app
 
 ENTRYPOINT ["ws"]
 EXPOSE 8008
-CMD ["--help"]

docker/Dockerfile.centos

@@ -0,0 +1,35 @@
+FROM centos:8 as build
+
+RUN yum install -y gcc-c++ make cmake zlib-devel openssl-devel redhat-rpm-config 
+
+RUN groupadd app && useradd -g app app
+RUN chown -R app:app /opt
+RUN chown -R app:app /usr/local
+
+# There is a bug in CMake where we cannot build from the root top folder
+# So we build from /opt
+COPY --chown=app:app . /opt
+WORKDIR /opt
+
+USER app
+RUN [ "make", "ws_install" ]
+RUN [ "rm", "-rf", "build" ]
+
+FROM centos:8 as runtime
+
+RUN yum install -y gdb strace
+
+RUN groupadd app && useradd -g app app
+COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
+RUN chmod +x /usr/local/bin/ws
+RUN ldd /usr/local/bin/ws
+
+# Copy source code for gcc
+COPY --chown=app:app --from=build /opt /opt
+
+# Now run in usermode
+USER app
+WORKDIR /home/app
+
+ENTRYPOINT ["ws"]
+EXPOSE 8008

docs/CHANGELOG.md

@@ -1,5 +1,112 @@
 # Changelog
-All notable changes to this project will be documented in this file.
+All changes to this project will be documented in this file.
+
+## [8.0.0] - 2020-01-26
+
+(SocketServer) add ability to bind on an ipv6 address
+
+## [7.9.6] - 2020-01-22
+
+(ws) add a dnslookup sub-command, to get the ip address of a remote host
+
+## [7.9.5] - 2020-01-14
+
+(windows) fix #144, get rid of stubbed/un-implemented windows schannel ssl backend
+
+## [7.9.4] - 2020-01-12
+
+(openssl + mbedssl) fix #140, can send large files with ws send over ssl / still broken with apple ssl
+
+## [7.9.3] - 2020-01-10
+
+(apple ssl) model write method after the OpenSSL one for consistency
+
+## [7.9.2] - 2020-01-06
+
+(apple ssl) unify read and write ssl utility code
+
+## [7.9.1] - 2020-01-06
+
+(websocket client) better error propagation when errors are detected while sending data
+(ws send) detect failures to send big files, terminate in those cases and report error
+
+## [7.9.0] - 2020-01-04
+
+(ws send) add option (-x) to disable per message deflate compression
+
+## [7.8.9] - 2020-01-04
+
+(ws send + receive) handle all message types (ping + pong + fragment) / investigate #140
+
+## [7.8.8] - 2019-12-28
+
+(mbedtls) fix related to private key file parsing and initialization
+
+## [7.8.6] - 2019-12-28
+
+(ws cobra to sentry/statsd) fix for handling null events properly for empty queues + use queue to send data to statsd
+
+## [7.8.5] - 2019-12-28
+
+(ws cobra to sentry) handle null events for empty queues
+
+## [7.8.4] - 2019-12-27
+
+(ws cobra to sentry) game is picked in a fair manner, so that all games get the same share of sent events
+
+## [7.8.3] - 2019-12-27
+
+(ws cobra to sentry) refactor queue related code into a class
+
+## [7.8.2] - 2019-12-25
+
+(ws cobra to sentry) bound the queue size used to hold up cobra messages before they are sent to sentry. Default queue size is a 100 messages. Without such limit the program runs out of memory when a subscriber receive a lot of messages that cannot make it to sentry
+
+## [7.8.1] - 2019-12-25
+
+(ws client) use correct compilation defines so that spdlog is not used as a header only library (reduce binary size and increase compilation speed)
+
+## [7.8.0] - 2019-12-24
+
+(ws client) all commands use spdlog instead of std::cerr or std::cout for logging
+
+## [7.6.5] - 2019-12-24
+
+(cobra client) send a websocket ping every 30s to keep the connection opened
+
+## [7.6.4] - 2019-12-22
+
+(client) error handling, quote url in error case when failing to parse one
+(ws) ws_cobra_publish: register callbacks before connecting
+(doc) mention mbedtls in supported ssl server backend
+
+## [7.6.3] - 2019-12-20
+
+(tls) add a simple description of the TLS configuration routine for debugging
+
+## [7.6.2] - 2019-12-20
+
+(mbedtls) correct support for using own certificate and private key
+
+## [7.6.1] - 2019-12-20
+
+(ws commands) in websocket proxy, disable automatic reconnections + in Dockerfile, use alpine 3.11
+
+## [7.6.0] - 2019-12-19
+
+(cobra) Add TLS options to all cobra commands and classes. Add example to the doc.
+
+## [7.5.8] - 2019-12-18
+
+(cobra-to-sentry) capture application version from device field
+
+## [7.5.7] - 2019-12-18
+
+(tls) Experimental TLS server support with mbedtls (windows) + process cert tlsoption (client + server)
+
+## [7.5.6] - 2019-12-18
+
+(tls servers) Make it clear that apple ssl and mbedtls backends do not support SSL in server mode
 
 ## [7.5.5] - 2019-12-17
 

docs/build.md

@@ -33,11 +33,16 @@ vcpkg install ixwebsocket
 
 ### Conan
 
-Support for building with conan was contributed by Olivia Zoe (thanks!). The package name to reference is `IXWebSocket/5.0.0@LunarWatcher/stable`, and a list of the uploaded versions is available on [Bintray](https://bintray.com/oliviazoe0/conan-packages/IXWebSocket%3ALunarWatcher). The package is in the process to be published to the official conan package repo, but in the meantime, it can be accessed by adding a new remote
+[ ![Download](https://api.bintray.com/packages/conan/conan-center/ixwebsocket%3A_/images/download.svg) ](https://bintray.com/conan/conan-center/ixwebsocket%3A_/_latestVersion)
 
-```
-conan remote add remote_name_here https://api.bintray.com/conan/oliviazoe0/conan-packages
-```
+Conan is currently supported through a recipe in [Conan Center](https://github.com/conan-io/conan-center-index/tree/master/recipes/ixwebsocket) ([Bintray entry](https://bintray.com/conan/conan-center/ixwebsocket%3A_)).
+
+Package reference 
+
+* Conan 1.21.0 and up: `ixwebsocket/7.9.2`
+* Earlier versions: `ixwebsocket/7.9.2@_/_`
+
+Note that the version listed here might not be the latest one. See Bintray or the recipe itself for the latest version. If you're migrating from the previous, custom Bintray remote, note that the package reference _has_ to be lower-case.  
 
 ### Docker
 

docs/ws.md

@@ -243,6 +243,127 @@ Options:
   --transfer-timeout INT      Transfer timeout
 ```
 
-## Cobra Client
+## Cobra client and server
 
-[cobra](https://github.com/machinezone/cobra) is a real time messenging server. ws has a sub-command to interact with cobra.
+[cobra](https://github.com/machinezone/cobra) is a real time messenging server. ws has several sub-command to interact with cobra. There is also a minimal cobra compatible server named snake available.
+
+Below are examples on running a snake server and clients with TLS enabled (the server only works with the OpenSSL and the Mbed TLS backend for now).
+
+First, generate certificates.
+
+```
+$ cd /path/to/IXWebSocket
+$ cd ixsnake/ixsnake
+$ bash ../../ws/generate_certs.sh
+Generating RSA private key, 2048 bit long modulus
+.....+++
+.................+++
+e is 65537 (0x10001)
+generated ./.certs/trusted-ca-key.pem
+generated ./.certs/trusted-ca-crt.pem
+Generating RSA private key, 2048 bit long modulus
+..+++
+.......................................+++
+e is 65537 (0x10001)
+generated ./.certs/trusted-server-key.pem
+Signature ok
+subject=/O=machinezone/O=IXWebSocket/CN=trusted-server
+Getting CA Private Key
+generated ./.certs/trusted-server-crt.pem
+Generating RSA private key, 2048 bit long modulus
+...................................+++
+..................................................+++
+e is 65537 (0x10001)
+generated ./.certs/trusted-client-key.pem
+Signature ok
+subject=/O=machinezone/O=IXWebSocket/CN=trusted-client
+Getting CA Private Key
+generated ./.certs/trusted-client-crt.pem
+Generating RSA private key, 2048 bit long modulus
+..............+++
+.......................................+++
+e is 65537 (0x10001)
+generated ./.certs/untrusted-ca-key.pem
+generated ./.certs/untrusted-ca-crt.pem
+Generating RSA private key, 2048 bit long modulus
+..........+++
+................................................+++
+e is 65537 (0x10001)
+generated ./.certs/untrusted-client-key.pem
+Signature ok
+subject=/O=machinezone/O=IXWebSocket/CN=untrusted-client
+Getting CA Private Key
+generated ./.certs/untrusted-client-crt.pem
+Generating RSA private key, 2048 bit long modulus
+.....................................................................................+++
+...........+++
+e is 65537 (0x10001)
+generated ./.certs/selfsigned-client-key.pem
+Signature ok
+subject=/O=machinezone/O=IXWebSocket/CN=selfsigned-client
+Getting Private key
+generated ./.certs/selfsigned-client-crt.pem
+```
+
+Now run the snake server.
+
+```
+$ export certs=.certs
+$ ws snake --tls --port 8765 --cert-file ${certs}/trusted-server-crt.pem --key-file ${certs}/trusted-server-key.pem --ca-file ${certs}/trusted-ca-crt.pem
+{
+  "apps": {
+    "FC2F10139A2BAc53BB72D9db967b024f": {
+      "roles": {
+        "_sub": {
+          "secret": "66B1dA3ED5fA074EB5AE84Dd8CE3b5ba"
+        },
+        "_pub": {
+          "secret": "1c04DB8fFe76A4EeFE3E318C72d771db"
+        }
+      }
+    }
+  }
+}
+
+redis host: 127.0.0.1
+redis password:
+redis port: 6379
+```
+
+As a new connection comes in, such output should be printed
+
+```
+[2019-12-19 20:27:19.724] [info] New connection
+id: 0
+Uri: /v2?appkey=_health
+Headers:
+Connection: Upgrade
+Host: 127.0.0.1:8765
+Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15; client_max_window_bits=15
+Sec-WebSocket-Key: d747B0fE61Db73f7Eh47c0==
+Sec-WebSocket-Protocol: json
+Sec-WebSocket-Version: 13
+Upgrade: websocket
+User-Agent: ixwebsocket/7.5.8 macos ssl/OpenSSL OpenSSL 1.0.2q  20 Nov 2018 zlib 1.2.11
+```
+
+To connect and publish a message, do:
+
+```
+$ export certs=.certs
+$ cd /path/to/ws/folder
+$ ls cobraMetricsSample.json
+cobraMetricsSample.json
+$ ws cobra_publish --endpoint wss://127.0.0.1:8765 --appkey FC2F10139A2BAc53BB72D9db967b024f --rolename _pub --rolesecret 1c04DB8fFe76A4EeFE3E318C72d771db --channel foo --cert-file ${certs}/trusted-client-crt.pem --key-file ${certs}/trusted-client-key.pem --ca-file ${certs}/trusted-ca-crt.pem cobraMetricsSample.json
+[2019-12-19 20:46:42.656] [info] Publisher connected
+[2019-12-19 20:46:42.657] [info] Connection: Upgrade
+[2019-12-19 20:46:42.657] [info] Sec-WebSocket-Accept: rs99IFThoBrhSg+k8G4ixH9yaq4=
+[2019-12-19 20:46:42.657] [info] Sec-WebSocket-Extensions: permessage-deflate; server_max_window_bits=15; client_max_window_bits=15
+[2019-12-19 20:46:42.657] [info] Server: ixwebsocket/7.5.8 macos ssl/OpenSSL OpenSSL 1.0.2q  20 Nov 2018 zlib 1.2.11
+[2019-12-19 20:46:42.657] [info] Upgrade: websocket
+[2019-12-19 20:46:42.658] [info] Publisher authenticated
+[2019-12-19 20:46:42.658] [info] Published msg 3
+[2019-12-19 20:46:42.659] [info] Published message id 3 acked
+```
+
+To use OpenSSL on macOS, compile with `make ws_openssl`. First you will have to install OpenSSL libraries, which can be done with Homebrew. Use `make ws_mbedtls` accordingly to use MbedTLS.

ixcobra/ixcobra/IXCobraConnection.cpp

@@ -7,6 +7,7 @@
 #include "IXCobraConnection.h"
 #include <ixcrypto/IXHMac.h>
 #include <ixwebsocket/IXWebSocket.h>
+#include <ixwebsocket/IXSocketTLSOptions.h>
 
 #include <algorithm>
 #include <stdexcept>
@@ -23,6 +24,7 @@ namespace ix
     PublishTrackerCallback CobraConnection::_publishTrackerCallback = nullptr;
     constexpr size_t CobraConnection::kQueueMaxSize;
     constexpr CobraConnection::MsgId CobraConnection::kInvalidMsgId;
+    constexpr int CobraConnection::kPingIntervalSecs;
 
     CobraConnection::CobraConnection() :
         _webSocket(new WebSocket()),
@@ -227,6 +229,10 @@ namespace ix
                     ss << "HTTP Status: "      << msg->errorInfo.http_status << std::endl;
                     invokeErrorCallback(ss.str(), std::string());
                 }
+                else if (msg->type == ix::WebSocketMessageType::Pong)
+                {
+                    invokeEventCallback(ix::CobraConnection_EventType_Pong);
+                }
         });
     }
 
@@ -244,7 +250,8 @@ namespace ix
                                     const std::string& endpoint,
                                     const std::string& rolename,
                                     const std::string& rolesecret,
-                                    const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions)
+                                    const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions,
+                                    const SocketTLSOptions& socketTLSOptions)
     {
         _roleName = rolename;
         _roleSecret = rolesecret;
@@ -257,6 +264,8 @@ namespace ix
         std::string url = ss.str();
         _webSocket->setUrl(url);
         _webSocket->setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
+        _webSocket->setTLSOptions(socketTLSOptions);
+        _webSocket->setPingInterval(kPingIntervalSecs);
     }
 
     //

ixcobra/ixcobra/IXCobraConnection.h

@@ -20,6 +20,7 @@
 namespace ix
 {
     class WebSocket;
+    struct SocketTLSOptions;
 
     enum CobraConnectionEventType
     {
@@ -29,7 +30,8 @@ namespace ix
         CobraConnection_EventType_Closed = 3,
         CobraConnection_EventType_Subscribed = 4,
         CobraConnection_EventType_UnSubscribed = 5,
-        CobraConnection_EventType_Published = 6
+        CobraConnection_EventType_Published = 6,
+        CobraConnection_EventType_Pong = 7
     };
 
     enum CobraConnectionPublishMode
@@ -62,7 +64,8 @@ namespace ix
                        const std::string& endpoint,
                        const std::string& rolename,
                        const std::string& rolesecret,
-                       const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions);
+                       const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions,
+                       const SocketTLSOptions& socketTLSOptions);
 
         /// Set the traffic tracker callback
         static void setTrafficTrackerCallback(const TrafficTrackerCallback& callback);
@@ -213,6 +216,9 @@ namespace ix
 
         // Each pdu sent should have an incremental unique id
         std::atomic<uint64_t> _id;
+
+        // Frequency at which we send a websocket ping to the backing cobra connection
+        static constexpr int kPingIntervalSecs = 30;
     };
 
 } // namespace ix

ixcobra/ixcobra/IXCobraMetricsPublisher.cpp

@@ -5,6 +5,7 @@
  */
 
 #include "IXCobraMetricsPublisher.h"
+#include <ixwebsocket/IXSocketTLSOptions.h>
 
 #include <algorithm>
 #include <stdexcept>
@@ -31,14 +32,15 @@ namespace ix
                                           const std::string& channel,
                                           const std::string& rolename,
                                           const std::string& rolesecret,
-                                          bool enablePerMessageDeflate)
+                                          bool enablePerMessageDeflate,
+                                          const SocketTLSOptions& socketTLSOptions)
     {
         // Configure the satori connection and start its publish background thread
         _cobra_metrics_theaded_publisher.start();
 
         _cobra_metrics_theaded_publisher.configure(appkey, endpoint, channel,
                                                    rolename, rolesecret,
-                                                   enablePerMessageDeflate);
+                                                   enablePerMessageDeflate, socketTLSOptions);
     }
 
     Json::Value& CobraMetricsPublisher::getGenericAttributes()

ixcobra/ixcobra/IXCobraMetricsPublisher.h

@@ -15,6 +15,8 @@
 
 namespace ix
 {
+    struct SocketTLSOptions;
+
     class CobraMetricsPublisher
     {
     public:
@@ -43,7 +45,8 @@ namespace ix
                        const std::string& channel,
                        const std::string& rolename,
                        const std::string& rolesecret,
-                       bool enablePerMessageDeflate);
+                       bool enablePerMessageDeflate,
+                       const SocketTLSOptions& socketTLSOptions);
 
         /// Setter for the list of blacklisted metrics ids.
         /// That list is sorted internally for fast lookups

ixcobra/ixcobra/IXCobraMetricsThreadedPublisher.cpp

@@ -6,6 +6,7 @@
 
 #include "IXCobraMetricsThreadedPublisher.h"
 #include <ixwebsocket/IXSetThreadName.h>
+#include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixcore/utils/IXCoreLogger.h>
 
 #include <algorithm>
@@ -64,6 +65,10 @@ namespace ix
                 {
                     ss << "Published message " << msgId << " acked";
                 }
+                else if (eventType == ix::CobraConnection_EventType_Pong)
+                {
+                    ss << "Received websocket pong";
+                }
 
                 ix::IXCoreLogger::Log(ss.str().c_str());
         });
@@ -92,14 +97,17 @@ namespace ix
                                                   const std::string& channel,
                                                   const std::string& rolename,
                                                   const std::string& rolesecret,
-                                                  bool enablePerMessageDeflate)
+                                                  bool enablePerMessageDeflate,
+                                                  const SocketTLSOptions& socketTLSOptions)
     {
         _channel = channel;
 
+        ix::IXCoreLogger::Log(socketTLSOptions.getDescription().c_str());
+
         ix::WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(enablePerMessageDeflate);
         _cobra_connection.configure(appkey, endpoint,
                                     rolename, rolesecret,
-                                    webSocketPerMessageDeflateOptions);
+                                    webSocketPerMessageDeflateOptions, socketTLSOptions);
     }
 
     void CobraMetricsThreadedPublisher::pushMessage(MessageKind messageKind)

ixcobra/ixcobra/IXCobraMetricsThreadedPublisher.h

@@ -18,6 +18,8 @@
 
 namespace ix
 {
+    struct SocketTLSOptions;
+
     class CobraMetricsThreadedPublisher
     {
     public:
@@ -30,7 +32,8 @@ namespace ix
                        const std::string& channel,
                        const std::string& rolename,
                        const std::string& rolesecret,
-                       bool enablePerMessageDeflate);
+                       bool enablePerMessageDeflate,
+                       const SocketTLSOptions& socketTLSOptions);
 
         /// Start the worker thread, used for background publishing
         void start();

ixsentry/ixsentry/IXSentryClient.cpp

@@ -182,7 +182,6 @@ namespace ix
 
         Json::Value extra;
         extra["cobra_event"] = msg;
-        extra["cobra_event"] = msg;
 
         // Builtin tags
         Json::Value gameTag;
@@ -200,6 +199,11 @@ namespace ix
         environmentTag.append(msg["device"]["environment"]);
         tags.append(environmentTag);
 
+        Json::Value clientVersionTag;
+        clientVersionTag.append("client_version");
+        clientVersionTag.append(msg["device"]["app_version"]);
+        tags.append(clientVersionTag);
+
         payload["tags"] = tags;
 
         return _jsonWriter.write(payload);

ixsnake/ixsnake/IXAppConfig.h

@@ -9,6 +9,7 @@
 #include <nlohmann/json.hpp>
 #include <string>
 #include <vector>
+#include <ixwebsocket/IXSocketTLSOptions.h>
 
 namespace snake
 {
@@ -26,6 +27,9 @@ namespace snake
         // AppKeys
         nlohmann::json apps;
 
+        // TLS options
+        ix::SocketTLSOptions socketTLSOptions;
+
         // Misc
         bool verbose;
     };

ixsnake/ixsnake/IXRedisServer.cpp

@@ -17,8 +17,8 @@
 
 namespace ix
 {
-    RedisServer::RedisServer(int port, const std::string& host, int backlog, size_t maxConnections)
-        : SocketServer(port, host, backlog, maxConnections)
+    RedisServer::RedisServer(int port, const std::string& host, int backlog, size_t maxConnections, int addressFamily)
+        : SocketServer(port, host, backlog, maxConnections, addressFamily)
         , _connectedClientsCount(0)
         , _stopHandlingConnections(false)
     {

ixsnake/ixsnake/IXRedisServer.h

@@ -25,7 +25,8 @@ namespace ix
         RedisServer(int port = SocketServer::kDefaultPort,
                     const std::string& host = SocketServer::kDefaultHost,
                     int backlog = SocketServer::kDefaultTcpBacklog,
-                    size_t maxConnections = SocketServer::kDefaultMaxConnections);
+                    size_t maxConnections = SocketServer::kDefaultMaxConnections,
+                    int addressFamily = SocketServer::kDefaultAddressFamily);
         virtual ~RedisServer();
         virtual void stop() final;
 

ixsnake/ixsnake/IXSnakeServer.cpp

@@ -20,7 +20,7 @@ namespace snake
         : _appConfig(appConfig)
         , _server(appConfig.port, appConfig.hostname)
     {
-        ;
+        _server.setTLSOptions(appConfig.socketTLSOptions);
     }
 
     //

ixwebsocket/IXHttpServer.cpp

@@ -10,7 +10,6 @@
 #include "IXSocketConnect.h"
 #include "IXUserAgent.h"
 #include <fstream>
-#include <iostream>
 #include <sstream>
 #include <vector>
 
@@ -43,8 +42,8 @@ namespace
 
 namespace ix
 {
-    HttpServer::HttpServer(int port, const std::string& host, int backlog, size_t maxConnections)
-        : SocketServer(port, host, backlog, maxConnections)
+    HttpServer::HttpServer(int port, const std::string& host, int backlog, size_t maxConnections, int addressFamily)
+        : SocketServer(port, host, backlog, maxConnections, addressFamily)
         , _connectedClientsCount(0)
     {
         setDefaultConnectionCallback();

ixwebsocket/IXHttpServer.h

@@ -28,7 +28,8 @@ namespace ix
         HttpServer(int port = SocketServer::kDefaultPort,
                    const std::string& host = SocketServer::kDefaultHost,
                    int backlog = SocketServer::kDefaultTcpBacklog,
-                   size_t maxConnections = SocketServer::kDefaultMaxConnections);
+                   size_t maxConnections = SocketServer::kDefaultMaxConnections,
+                   int addressFamily = SocketServer::kDefaultAddressFamily);
         virtual ~HttpServer();
         virtual void stop() final;
 

ixwebsocket/IXSelectInterruptFactory.cpp

@@ -7,9 +7,9 @@
 #include "IXSelectInterruptFactory.h"
 
 #if defined(__linux__) || defined(__APPLE__)
-#include <ixwebsocket/IXSelectInterruptPipe.h>
+#include "IXSelectInterruptPipe.h"
 #else
-#include <ixwebsocket/IXSelectInterrupt.h>
+#include "IXSelectInterrupt.h"
 #endif
 
 namespace ix

ixwebsocket/IXSocket.cpp

@@ -54,14 +54,17 @@ namespace ix
         // to ::poll does fix that.
         //
         // However poll isn't as portable as select and has bugs on Windows, so we
-        // should write a shim to fallback to select on those platforms. See
+        // have a shim to fallback to select on those platforms. See
         // https://github.com/mpv-player/mpv/pull/5203/files for such a select wrapper.
         //
         nfds_t nfds = 1;
         struct pollfd fds[2];
+        memset(fds, 0, sizeof(fds));
 
         fds[0].fd = sockfd;
         fds[0].events = (readyToRead) ? POLLIN : POLLOUT;
+
+        // this is ignored by poll, but our select based poll wrapper on Windows needs it
         fds[0].events |= POLLERR;
 
         // File descriptor used to interrupt select when needed
@@ -132,6 +135,11 @@ namespace ix
             }
 #endif
         }
+        else if (sockfd != -1 && (fds[0].revents & POLLERR || fds[0].revents & POLLHUP ||
+                                  fds[0].revents & POLLNVAL))
+        {
+            pollResult = PollResultType::Error;
+        }
 
         return pollResult;
     }

ixwebsocket/IXSocket.h

@@ -73,7 +73,7 @@ namespace ix
         virtual void close();
 
         virtual ssize_t send(char* buffer, size_t length);
-        virtual ssize_t send(const std::string& buffer);
+        ssize_t send(const std::string& buffer);
         virtual ssize_t recv(void* buffer, size_t length);
 
         // Blocking and cancellable versions, working with socket that can be set

ixwebsocket/IXSocketAppleSSL.cpp

@@ -24,9 +24,47 @@
 
 #include <Security/SecureTransport.h>
 
-namespace
+namespace ix
 {
-    OSStatus read_from_socket(SSLConnectionRef connection, void* data, size_t* len)
+    SocketAppleSSL::SocketAppleSSL(const SocketTLSOptions& tlsOptions, int fd)
+        : Socket(fd)
+        , _sslContext(nullptr)
+        , _tlsOptions(tlsOptions)
+    {
+        ;
+    }
+
+    SocketAppleSSL::~SocketAppleSSL()
+    {
+        SocketAppleSSL::close();
+    }
+
+    std::string SocketAppleSSL::getSSLErrorDescription(OSStatus status)
+    {
+        std::string errMsg("Unknown SSL error.");
+
+        CFErrorRef error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainOSStatus, status, NULL);
+        if (error)
+        {
+            CFStringRef message = CFErrorCopyDescription(error);
+            if (message)
+            {
+                char localBuffer[128];
+                Boolean success;
+                success = CFStringGetCString(message, localBuffer, 128, kCFStringEncodingUTF8);
+                if (success)
+                {
+                    errMsg = localBuffer;
+                }
+                CFRelease(message);
+            }
+            CFRelease(error);
+        }
+
+        return errMsg;
+    }
+
+    OSStatus SocketAppleSSL::readFromSocket(SSLConnectionRef connection, void* data, size_t* len)
     {
         int fd = (int) (long) connection;
         if (fd < 0) return errSSLInternal;
@@ -42,11 +80,15 @@ namespace
         {
             *len = (size_t) status;
             if (requested_sz > *len)
+            {
                 return errSSLWouldBlock;
+            }
             else
+            {
                 return noErr;
+            }
         }
-        else if (0 == status)
+        else if (status == 0)
         {
             *len = 0;
             return errSSLClosedGraceful;
@@ -58,7 +100,8 @@ namespace
             {
                 case ENOENT: return errSSLClosedGraceful;
 
-                case EAGAIN: return errSSLWouldBlock;
+                case EAGAIN: return errSSLWouldBlock; // EWOULDBLOCK is a define for EAGAIN on osx
+                case EINPROGRESS: return errSSLWouldBlock;
 
                 case ECONNRESET: return errSSLClosedAbort;
 
@@ -67,7 +110,9 @@ namespace
         }
     }
 
-    OSStatus write_to_socket(SSLConnectionRef connection, const void* data, size_t* len)
+    OSStatus SocketAppleSSL::writeToSocket(SSLConnectionRef connection,
+                                           const void* data,
+                                           size_t* len)
     {
         int fd = (int) (long) connection;
         if (fd < 0) return errSSLInternal;
@@ -82,11 +127,15 @@ namespace
         {
             *len = (size_t) status;
             if (to_write_sz > *len)
+            {
                 return errSSLWouldBlock;
+            }
             else
+            {
                 return noErr;
+            }
         }
-        else if (0 == status)
+        else if (status == 0)
         {
             *len = 0;
             return errSSLClosedGraceful;
@@ -94,58 +143,25 @@ namespace
         else
         {
             *len = 0;
-            if (EAGAIN == errno)
+            switch (errno)
             {
-                return errSSLWouldBlock;
-            }
-            else
-            {
-                return errSecIO;
+                case ENOENT: return errSSLClosedGraceful;
+
+                case EAGAIN: return errSSLWouldBlock; // EWOULDBLOCK is a define for EAGAIN on osx
+                case EINPROGRESS: return errSSLWouldBlock;
+
+                case ECONNRESET: return errSSLClosedAbort;
+
+                default: return errSecIO;
             }
         }
     }
 
-    std::string getSSLErrorDescription(OSStatus status)
+
+    bool SocketAppleSSL::accept(std::string& errMsg)
     {
-        std::string errMsg("Unknown SSL error.");
-
-        CFErrorRef error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainOSStatus, status, NULL);
-        if (error)
-        {
-            CFStringRef message = CFErrorCopyDescription(error);
-            if (message)
-            {
-                char localBuffer[128];
-                Boolean success;
-                success =
-                    CFStringGetCString(message, localBuffer, 128, kCFStringEncodingUTF8);
-                if (success)
-                {
-                    errMsg = localBuffer;
-                }
-                CFRelease(message);
-            }
-            CFRelease(error);
-        }
-
-        return errMsg;
-    }
-
-} // anonymous namespace
-
-namespace ix
-{
-    SocketAppleSSL::SocketAppleSSL(const SocketTLSOptions& tlsOptions, int fd)
-        : Socket(fd)
-        , _sslContext(nullptr)
-        , _tlsOptions(tlsOptions)
-    {
-        ;
-    }
-
-    SocketAppleSSL::~SocketAppleSSL()
-    {
-        SocketAppleSSL::close();
+        errMsg = "TLS not supported yet in server mode with apple ssl backend";
+        return false;
     }
 
     // No wait support
@@ -163,7 +179,8 @@ namespace ix
 
             _sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType);
 
-            SSLSetIOFuncs(_sslContext, read_from_socket, write_to_socket);
+            SSLSetIOFuncs(
+                _sslContext, SocketAppleSSL::readFromSocket, SocketAppleSSL::writeToSocket);
             SSLSetConnection(_sslContext, (SSLConnectionRef)(long) _sockfd);
             SSLSetProtocolVersionMin(_sslContext, kTLSProtocol12);
             SSLSetPeerDomainName(_sslContext, host.c_str(), host.size());
@@ -176,7 +193,7 @@ namespace ix
                 do
                 {
                     status = SSLHandshake(_sslContext);
-                } while (errSSLWouldBlock == status || errSSLServerAuthCompleted == status);
+                } while (status == errSSLWouldBlock || status == errSSLServerAuthCompleted);
 
                 if (status == errSSLServerAuthCompleted)
                 {
@@ -184,7 +201,7 @@ namespace ix
                     do
                     {
                         status = SSLHandshake(_sslContext);
-                    } while (errSSLWouldBlock == status || errSSLServerAuthCompleted == status);
+                    } while (status == errSSLWouldBlock || status == errSSLServerAuthCompleted);
                 }
             }
             else
@@ -192,11 +209,11 @@ namespace ix
                 do
                 {
                     status = SSLHandshake(_sslContext);
-                } while (errSSLWouldBlock == status || errSSLServerAuthCompleted == status);
+                } while (status == errSSLWouldBlock || status == errSSLServerAuthCompleted);
             }
         }
 
-        if (noErr != status)
+        if (status != noErr)
         {
             errMsg = getSSLErrorDescription(status);
             close();
@@ -221,32 +238,38 @@ namespace ix
 
     ssize_t SocketAppleSSL::send(char* buf, size_t nbyte)
     {
-        ssize_t ret = 0;
-        OSStatus status;
-        do
+        OSStatus status = errSSLWouldBlock;
+        while (status == errSSLWouldBlock)
         {
             size_t processed = 0;
             std::lock_guard<std::mutex> lock(_mutex);
             status = SSLWrite(_sslContext, buf, nbyte, &processed);
-            ret += processed;
-            buf += processed;
-            nbyte -= processed;
-        } while (nbyte > 0 && errSSLWouldBlock == status);
 
-        if (ret == 0 && errSSLClosedAbort != status) ret = -1;
-        return ret;
-    }
+            if (processed > 0) return (ssize_t) processed;
 
-    ssize_t SocketAppleSSL::send(const std::string& buffer)
-    {
-        return send((char*) &buffer[0], buffer.size());
+            // The connection was reset, inform the caller that this
+            // Socket should close
+            if (status == errSSLClosedGraceful || status == errSSLClosedNoNotify ||
+                status == errSSLClosedAbort)
+            {
+                errno = ECONNRESET;
+                return -1;
+            }
+
+            if (status == errSSLWouldBlock)
+            {
+                errno = EWOULDBLOCK;
+                return -1;
+            }
+        }
+        return -1;
     }
 
     // No wait support
     ssize_t SocketAppleSSL::recv(void* buf, size_t nbyte)
     {
         OSStatus status = errSSLWouldBlock;
-        while (errSSLWouldBlock == status)
+        while (status == errSSLWouldBlock)
         {
             size_t processed = 0;
             std::lock_guard<std::mutex> lock(_mutex);

ixwebsocket/IXSocketAppleSSL.h

@@ -21,6 +21,8 @@ namespace ix
         SocketAppleSSL(const SocketTLSOptions& tlsOptions, int fd = -1);
         ~SocketAppleSSL();
 
+        virtual bool accept(std::string& errMsg) final;
+
         virtual bool connect(const std::string& host,
                              int port,
                              std::string& errMsg,
@@ -28,10 +30,13 @@ namespace ix
         virtual void close() final;
 
         virtual ssize_t send(char* buffer, size_t length) final;
-        virtual ssize_t send(const std::string& buffer) final;
         virtual ssize_t recv(void* buffer, size_t length) final;
 
     private:
+        static std::string getSSLErrorDescription(OSStatus status);
+        static OSStatus writeToSocket(SSLConnectionRef connection, const void* data, size_t* len);
+        static OSStatus readFromSocket(SSLConnectionRef connection, void* data, size_t* len);
+
         SSLContextRef _sslContext;
         mutable std::mutex _mutex; // AppleSSL routines are not thread-safe
 

ixwebsocket/IXSocketFactory.cpp

@@ -9,18 +9,16 @@
 #ifdef IXWEBSOCKET_USE_TLS
 
 #ifdef IXWEBSOCKET_USE_MBED_TLS
-#include <ixwebsocket/IXSocketMbedTLS.h>
-#elif defined(_WIN32)
-#include <ixwebsocket/IXSocketSChannel.h>
+#include "IXSocketMbedTLS.h"
 #elif defined(IXWEBSOCKET_USE_OPEN_SSL)
-#include <ixwebsocket/IXSocketOpenSSL.h>
+#include "IXSocketOpenSSL.h"
 #elif __APPLE__
-#include <ixwebsocket/IXSocketAppleSSL.h>
+#include "IXSocketAppleSSL.h"
 #endif
 
 #else
 
-#include <ixwebsocket/IXSocket.h>
+#include "IXSocket.h"
 
 #endif
 
@@ -46,8 +44,6 @@ namespace ix
             socket = std::make_shared<SocketMbedTLS>(tlsOptions, fd);
 #elif defined(IXWEBSOCKET_USE_OPEN_SSL)
             socket = std::make_shared<SocketOpenSSL>(tlsOptions, fd);
-#elif defined(_WIN32)
-            socket = std::make_shared<SocketSChannel>(tlsOptions, fd);
 #elif defined(__APPLE__)
             socket = std::make_shared<SocketAppleSSL>(tlsOptions, fd);
 #endif

ixwebsocket/IXSocketMbedTLS.cpp

@@ -38,9 +38,11 @@ namespace ix
         mbedtls_ctr_drbg_init(&_ctr_drbg);
         mbedtls_entropy_init(&_entropy);
         mbedtls_x509_crt_init(&_cacert);
+        mbedtls_x509_crt_init(&_cert);
+        mbedtls_pk_init(&_pkey);
     }
 
-    bool SocketMbedTLS::init(const std::string& host, std::string& errMsg)
+    bool SocketMbedTLS::init(const std::string& host, bool isClient, std::string& errMsg)
     {
         initMBedTLS();
         std::lock_guard<std::mutex> lock(_mutex);
@@ -58,7 +60,7 @@ namespace ix
         }
 
         if (mbedtls_ssl_config_defaults(&_conf,
-                                        MBEDTLS_SSL_IS_CLIENT,
+                                        (isClient) ? MBEDTLS_SSL_IS_CLIENT : MBEDTLS_SSL_IS_SERVER,
                                         MBEDTLS_SSL_TRANSPORT_STREAM,
                                         MBEDTLS_SSL_PRESET_DEFAULT) != 0)
         {
@@ -68,13 +70,32 @@ namespace ix
 
         mbedtls_ssl_conf_rng(&_conf, mbedtls_ctr_drbg_random, &_ctr_drbg);
 
+        if (_tlsOptions.hasCertAndKey())
+        {
+            if (mbedtls_x509_crt_parse_file(&_cert, _tlsOptions.certFile.c_str()) < 0)
+            {
+                errMsg = "Cannot parse cert file '" + _tlsOptions.certFile + "'";
+                return false;
+            }
+            if (mbedtls_pk_parse_keyfile(&_pkey, _tlsOptions.keyFile.c_str(), "") < 0)
+            {
+                errMsg = "Cannot parse key file '" + _tlsOptions.keyFile + "'";
+                return false;
+            }
+            if (mbedtls_ssl_conf_own_cert(&_conf, &_cert, &_pkey) < 0)
+            {
+                errMsg = "Problem configuring cert '" + _tlsOptions.certFile + "'";
+                return false;
+            }
+        }
+
         if (_tlsOptions.isPeerVerifyDisabled())
         {
             mbedtls_ssl_conf_authmode(&_conf, MBEDTLS_SSL_VERIFY_NONE);
         }
         else
         {
-            mbedtls_ssl_conf_ca_chain(&_conf, &_cacert, NULL);
+            mbedtls_ssl_conf_authmode(&_conf, MBEDTLS_SSL_VERIFY_REQUIRED);
 
             // FIXME: should we call mbedtls_ssl_conf_verify ?
 
@@ -87,7 +108,8 @@ namespace ix
                 errMsg = "Cannot parse CA file '" + _tlsOptions.caFile + "'";
                 return false;
             }
-            mbedtls_ssl_conf_authmode(&_conf, MBEDTLS_SSL_VERIFY_REQUIRED);
+
+            mbedtls_ssl_conf_ca_chain(&_conf, &_cacert, NULL);
         }
 
         if (mbedtls_ssl_setup(&_ssl, &_conf) != 0)
@@ -96,7 +118,7 @@ namespace ix
             return false;
         }
 
-        if (mbedtls_ssl_set_hostname(&_ssl, host.c_str()) != 0)
+        if (!host.empty() && mbedtls_ssl_set_hostname(&_ssl, host.c_str()) != 0)
         {
             errMsg = "SNI setup failed";
             return false;
@@ -105,6 +127,50 @@ namespace ix
         return true;
     }
 
+    bool SocketMbedTLS::accept(std::string& errMsg)
+    {
+        bool isClient = false;
+        bool initialized = init(std::string(), isClient, errMsg);
+        if (!initialized)
+        {
+            close();
+            return false;
+        }
+
+        mbedtls_ssl_set_bio(&_ssl, &_sockfd, mbedtls_net_send, mbedtls_net_recv, NULL);
+
+        int res;
+        do
+        {
+            std::lock_guard<std::mutex> lock(_mutex);
+            res = mbedtls_ssl_handshake(&_ssl);
+        } while (res == MBEDTLS_ERR_SSL_WANT_READ || res == MBEDTLS_ERR_SSL_WANT_WRITE);
+
+        if (res != 0)
+        {
+            char buf[256];
+            mbedtls_strerror(res, buf, sizeof(buf));
+
+            errMsg = "error in handshake : ";
+            errMsg += buf;
+
+            if (res == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED)
+            {
+                char verifyBuf[512];
+                uint32_t flags = mbedtls_ssl_get_verify_result(&_ssl);
+
+                mbedtls_x509_crt_verify_info(verifyBuf, sizeof(verifyBuf), "  ! ", flags);
+                errMsg += " : ";
+                errMsg += verifyBuf;
+            }
+
+            close();
+            return false;
+        }
+
+        return true;
+    }
+
     bool SocketMbedTLS::connect(const std::string& host,
                                 int port,
                                 std::string& errMsg,
@@ -116,7 +182,8 @@ namespace ix
             if (_sockfd == -1) return false;
         }
 
-        bool initialized = init(host, errMsg);
+        bool isClient = true;
+        bool initialized = init(host, isClient, errMsg);
         if (!initialized)
         {
             close();
@@ -156,41 +223,30 @@ namespace ix
         mbedtls_ctr_drbg_free(&_ctr_drbg);
         mbedtls_entropy_free(&_entropy);
         mbedtls_x509_crt_free(&_cacert);
+        mbedtls_x509_crt_free(&_cert);
 
         Socket::close();
     }
 
     ssize_t SocketMbedTLS::send(char* buf, size_t nbyte)
     {
-        ssize_t sent = 0;
+        std::lock_guard<std::mutex> lock(_mutex);
 
-        while (nbyte > 0)
+        ssize_t res = mbedtls_ssl_write(&_ssl, (unsigned char*) buf, nbyte);
+
+        if (res > 0)
         {
-            std::lock_guard<std::mutex> lock(_mutex);
-
-            ssize_t res = mbedtls_ssl_write(&_ssl, (unsigned char*) buf, nbyte);
-
-            if (res > 0)
-            {
-                nbyte -= res;
-                sent += res;
-            }
-            else if (res == MBEDTLS_ERR_SSL_WANT_READ || res == MBEDTLS_ERR_SSL_WANT_WRITE)
-            {
-                errno = EWOULDBLOCK;
-                return -1;
-            }
-            else
-            {
-                return -1;
-            }
+            return res;
+        }
+        else if (res == MBEDTLS_ERR_SSL_WANT_READ || res == MBEDTLS_ERR_SSL_WANT_WRITE)
+        {
+            errno = EWOULDBLOCK;
+            return -1;
+        }
+        else
+        {
+            return -1;
         }
-        return sent;
-    }
-
-    ssize_t SocketMbedTLS::send(const std::string& buffer)
-    {
-        return send((char*) &buffer[0], buffer.size());
     }
 
     ssize_t SocketMbedTLS::recv(void* buf, size_t nbyte)

ixwebsocket/IXSocketMbedTLS.h

@@ -26,6 +26,8 @@ namespace ix
         SocketMbedTLS(const SocketTLSOptions& tlsOptions, int fd = -1);
         ~SocketMbedTLS();
 
+        virtual bool accept(std::string& errMsg) final;
+
         virtual bool connect(const std::string& host,
                              int port,
                              std::string& errMsg,
@@ -33,7 +35,6 @@ namespace ix
         virtual void close() final;
 
         virtual ssize_t send(char* buffer, size_t length) final;
-        virtual ssize_t send(const std::string& buffer) final;
         virtual ssize_t recv(void* buffer, size_t length) final;
 
     private:
@@ -42,11 +43,13 @@ namespace ix
         mbedtls_entropy_context _entropy;
         mbedtls_ctr_drbg_context _ctr_drbg;
         mbedtls_x509_crt _cacert;
+        mbedtls_x509_crt _cert;
+        mbedtls_pk_context _pkey;
 
         std::mutex _mutex;
         SocketTLSOptions _tlsOptions;
 
-        bool init(const std::string& host, std::string& errMsg);
+        bool init(const std::string& host, bool isClient, std::string& errMsg);
         void initMBedTLS();
     };
 

ixwebsocket/IXSocketOpenSSL.cpp

@@ -11,8 +11,14 @@
 #include "IXSocketConnect.h"
 #include <cassert>
 #include <errno.h>
+#ifdef _WIN32
+#include <Shlwapi.h>
+#else
 #include <fnmatch.h>
+#endif
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
 #include <openssl/x509v3.h>
+#endif
 #define socketerrno errno
 
 namespace ix
@@ -136,7 +142,11 @@ namespace ix
      */
     bool SocketOpenSSL::checkHost(const std::string& host, const char* pattern)
     {
+#ifdef _WIN32
+        return PathMatchSpecA(host.c_str(), pattern);
+#else
         return fnmatch(pattern, host.c_str(), 0) != FNM_NOMATCH;
+#endif
     }
 
     bool SocketOpenSSL::openSSLCheckServerCert(SSL* ssl,
@@ -593,42 +603,30 @@ namespace ix
 
     ssize_t SocketOpenSSL::send(char* buf, size_t nbyte)
     {
-        ssize_t sent = 0;
+        std::lock_guard<std::mutex> lock(_mutex);
 
-        while (nbyte > 0)
+        if (_ssl_connection == nullptr || _ssl_context == nullptr)
         {
-            std::lock_guard<std::mutex> lock(_mutex);
-
-            if (_ssl_connection == nullptr || _ssl_context == nullptr)
-            {
-                return 0;
-            }
-
-            ERR_clear_error();
-            ssize_t write_result = SSL_write(_ssl_connection, buf + sent, (int) nbyte);
-            int reason = SSL_get_error(_ssl_connection, (int) write_result);
-
-            if (reason == SSL_ERROR_NONE)
-            {
-                nbyte -= write_result;
-                sent += write_result;
-            }
-            else if (reason == SSL_ERROR_WANT_READ || reason == SSL_ERROR_WANT_WRITE)
-            {
-                errno = EWOULDBLOCK;
-                return -1;
-            }
-            else
-            {
-                return -1;
-            }
+            return 0;
         }
-        return sent;
-    }
 
-    ssize_t SocketOpenSSL::send(const std::string& buffer)
-    {
-        return send((char*) &buffer[0], buffer.size());
+        ERR_clear_error();
+        ssize_t write_result = SSL_write(_ssl_connection, buf, (int) nbyte);
+        int reason = SSL_get_error(_ssl_connection, (int) write_result);
+
+        if (reason == SSL_ERROR_NONE)
+        {
+            return write_result;
+        }
+        else if (reason == SSL_ERROR_WANT_READ || reason == SSL_ERROR_WANT_WRITE)
+        {
+            errno = EWOULDBLOCK;
+            return -1;
+        }
+        else
+        {
+            return -1;
+        }
     }
 
     ssize_t SocketOpenSSL::recv(void* buf, size_t nbyte)

ixwebsocket/IXSocketOpenSSL.h

@@ -33,7 +33,6 @@ namespace ix
         virtual void close() final;
 
         virtual ssize_t send(char* buffer, size_t length) final;
-        virtual ssize_t send(const std::string& buffer) final;
         virtual ssize_t recv(void* buffer, size_t length) final;
 
     private:

ixwebsocket/IXSocketSChannel.cpp

@@ -1,103 +0,0 @@
-/*
- *  IXSocketSChannel.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
- *
- *  See https://docs.microsoft.com/en-us/windows/desktop/WinSock/using-secure-socket-extensions
- *
- *  https://github.com/pauldotknopf/WindowsSDK7-Samples/blob/master/netds/winsock/securesocket/stcpclient/tcpclient.c
- *
- *  This is the right example to look at:
- *  https://www.codeproject.com/Articles/1000189/A-Working-TCP-Client-and-Server-With-SSL
- *
- *  Similar code is available from this git repo
- *  https://github.com/david-maw/StreamSSL
- */
-#include "IXSocketSChannel.h"
-
-#ifdef _WIN32
-#include <WS2tcpip.h>
-#include <WinSock2.h>
-#include <basetsd.h>
-#include <io.h>
-#include <schannel.h>
-#include <ws2def.h>
-
-#define WIN32_LEAN_AND_MEAN
-
-#ifndef UNICODE
-#define UNICODE
-#endif
-
-#include <mstcpip.h>
-#include <ntdsapi.h>
-#include <rpc.h>
-#include <stdio.h>
-#include <tchar.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-
-#include <windows.h>
-
-#define RECV_DATA_BUF_SIZE 256
-
-// Link with ws2_32.lib
-#pragma comment(lib, "Ws2_32.lib")
-
-// link with fwpuclnt.lib for Winsock secure socket extensions
-#pragma comment(lib, "fwpuclnt.lib")
-
-// link with ntdsapi.lib for DsMakeSpn function
-#pragma comment(lib, "ntdsapi.lib")
-
-// The following function assumes that Winsock
-// has already been initialized
-
-
-#else
-#error("This file should only be built on Windows")
-#endif
-
-namespace ix
-{
-    SocketSChannel::SocketSChannel()
-    {
-        ;
-    }
-
-    SocketSChannel::~SocketSChannel()
-    {
-    }
-
-    bool SocketSChannel::connect(const std::string& host, int port, std::string& errMsg)
-    {
-        return Socket::connect(host, port, errMsg, nullptr);
-    }
-
-
-    void SocketSChannel::secureSocket()
-    {
-        // there will be a lot to do here ...
-    }
-
-    void SocketSChannel::close()
-    {
-        Socket::close();
-    }
-
-    ssize_t SocketSChannel::send(char* buf, size_t nbyte)
-    {
-        return Socket::send(buf, nbyte);
-    }
-
-    ssize_t SocketSChannel::send(const std::string& buffer)
-    {
-        return Socket::send(buffer);
-    }
-
-    ssize_t SocketSChannel::recv(void* buf, size_t nbyte)
-    {
-        return Socket::recv(buf, nbyte);
-    }
-
-} // namespace ix

ixwebsocket/IXSocketSChannel.h

@@ -1,32 +0,0 @@
-/*
- *  IXSocketSChannel.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include "IXSocket.h"
-
-namespace ix
-{
-    class SocketSChannel final : public Socket
-    {
-    public:
-        SocketSChannel();
-        ~SocketSChannel();
-
-        virtual bool connect(const std::string& host, int port, std::string& errMsg) final;
-        virtual void close() final;
-
-        // The important override
-        virtual void secureSocket() final;
-
-        virtual ssize_t send(char* buffer, size_t length) final;
-        virtual ssize_t send(const std::string& buffer) final;
-        virtual ssize_t recv(void* buffer, size_t length) final;
-
-    private:
-    };
-
-} // namespace ix

ixwebsocket/IXSocketServer.cpp

@@ -11,8 +11,8 @@
 #include "IXSocketConnect.h"
 #include "IXSocketFactory.h"
 #include <assert.h>
-#include <iostream>
 #include <sstream>
+#include <stdio.h>
 #include <string.h>
 
 namespace ix
@@ -21,15 +21,18 @@ namespace ix
     const std::string SocketServer::kDefaultHost("127.0.0.1");
     const int SocketServer::kDefaultTcpBacklog(5);
     const size_t SocketServer::kDefaultMaxConnections(32);
+    const int SocketServer::kDefaultAddressFamily(AF_INET);
 
     SocketServer::SocketServer(int port,
                                const std::string& host,
                                int backlog,
-                               size_t maxConnections)
+                               size_t maxConnections,
+                               int addressFamily)
         : _port(port)
         , _host(host)
         , _backlog(backlog)
         , _maxConnections(maxConnections)
+        , _addressFamily(addressFamily)
         , _serverFd(-1)
         , _stop(false)
         , _stopGc(false)
@@ -45,21 +48,26 @@ namespace ix
     void SocketServer::logError(const std::string& str)
     {
         std::lock_guard<std::mutex> lock(_logMutex);
-        std::cerr << str << std::endl;
+        fprintf(stderr, "%s\n", str.c_str());
     }
 
     void SocketServer::logInfo(const std::string& str)
     {
         std::lock_guard<std::mutex> lock(_logMutex);
-        std::cout << str << std::endl;
+        fprintf(stdout, "%s\n", str.c_str());
     }
 
     std::pair<bool, std::string> SocketServer::listen()
     {
-        struct sockaddr_in server; // server address information
+        if (_addressFamily != AF_INET && _addressFamily != AF_INET6)
+        {
+            std::string errMsg("SocketServer::listen() AF_INET and AF_INET6 are currently "
+                               "the only supported address families");
+            return std::make_pair(false, errMsg);
+        }
 
         // Get a socket for accepting connections.
-        if ((_serverFd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+        if ((_serverFd = socket(_addressFamily, SOCK_STREAM, 0)) < 0)
         {
             std::stringstream ss;
             ss << "SocketServer::listen() error creating socket): " << strerror(Socket::getErrno());
@@ -79,27 +87,59 @@ namespace ix
             return std::make_pair(false, ss.str());
         }
 
-        // Bind the socket to the server address.
-        server.sin_family = AF_INET;
-        server.sin_port = htons(_port);
-
-        // Using INADDR_ANY trigger a pop-up box as binding to any address is detected
-        // by the osx firewall. We need to codesign the binary with a self-signed cert
-        // to allow that, but this is a bit of a pain. (this is what node or python would do).
-        //
-        // Using INADDR_LOOPBACK also does not work ... while it should.
-        // We default to 127.0.0.1 (localhost)
-        //
-        server.sin_addr.s_addr = inet_addr(_host.c_str());
-
-        if (bind(_serverFd, (struct sockaddr*) &server, sizeof(server)) < 0)
+        if (_addressFamily == AF_INET)
         {
-            std::stringstream ss;
-            ss << "SocketServer::listen() error calling bind "
-               << "at address " << _host << ":" << _port << " : " << strerror(Socket::getErrno());
+            struct sockaddr_in server;
+            server.sin_family = _addressFamily;
+            server.sin_port = htons(_port);
 
-            Socket::closeSocket(_serverFd);
-            return std::make_pair(false, ss.str());
+            if (inet_pton(_addressFamily, _host.c_str(), &server.sin_addr.s_addr) <= 0)
+            {
+                std::stringstream ss;
+                ss << "SocketServer::listen() error calling inet_pton "
+                   << "at address " << _host << ":" << _port << " : " << strerror(Socket::getErrno());
+
+                Socket::closeSocket(_serverFd);
+                return std::make_pair(false, ss.str());
+            }
+
+            // Bind the socket to the server address.
+            if (bind(_serverFd, (struct sockaddr*) &server, sizeof(server)) < 0)
+            {
+                std::stringstream ss;
+                ss << "SocketServer::listen() error calling bind "
+                   << "at address " << _host << ":" << _port << " : " << strerror(Socket::getErrno());
+
+                Socket::closeSocket(_serverFd);
+                return std::make_pair(false, ss.str());
+            }
+        }
+        else // AF_INET6
+        {
+            struct sockaddr_in6 server;
+            server.sin6_family = _addressFamily;
+            server.sin6_port = htons(_port);
+
+            if (inet_pton(_addressFamily, _host.c_str(), &server.sin6_addr) <= 0)
+            {
+                std::stringstream ss;
+                ss << "SocketServer::listen() error calling inet_pton "
+                   << "at address " << _host << ":" << _port << " : " << strerror(Socket::getErrno());
+
+                Socket::closeSocket(_serverFd);
+                return std::make_pair(false, ss.str());
+            }
+
+            // Bind the socket to the server address.
+            if (bind(_serverFd, (struct sockaddr*) &server, sizeof(server)) < 0)
+            {
+                std::stringstream ss;
+                ss << "SocketServer::listen() error calling bind "
+                   << "at address " << _host << ":" << _port << " : " << strerror(Socket::getErrno());
+
+                Socket::closeSocket(_serverFd);
+                return std::make_pair(false, ss.str());
+            }
         }
 
         //

ixwebsocket/IXSocketServer.h

@@ -36,7 +36,8 @@ namespace ix
         SocketServer(int port = SocketServer::kDefaultPort,
                      const std::string& host = SocketServer::kDefaultHost,
                      int backlog = SocketServer::kDefaultTcpBacklog,
-                     size_t maxConnections = SocketServer::kDefaultMaxConnections);
+                     size_t maxConnections = SocketServer::kDefaultMaxConnections,
+                     int addressFamily = SocketServer::kDefaultAddressFamily);
         virtual ~SocketServer();
         virtual void stop();
 
@@ -49,6 +50,7 @@ namespace ix
         const static std::string kDefaultHost;
         const static int kDefaultTcpBacklog;
         const static size_t kDefaultMaxConnections;
+        const static int kDefaultAddressFamily;
 
         void start();
         std::pair<bool, std::string> listen();
@@ -69,6 +71,7 @@ namespace ix
         std::string _host;
         int _backlog;
         size_t _maxConnections;
+        int _addressFamily;
 
         // socket for accepting connections
         int _serverFd;

ixwebsocket/IXSocketTLSOptions.cpp

@@ -8,6 +8,7 @@
 
 #include <assert.h>
 #include <fstream>
+#include <sstream>
 
 namespace ix
 {
@@ -71,4 +72,16 @@ namespace ix
     {
         return _errMsg;
     }
+
+    std::string SocketTLSOptions::getDescription() const
+    {
+        std::stringstream ss;
+        ss << "TLS Options:" << std::endl;
+        ss << "  certFile = " << certFile << std::endl;
+        ss << "  keyFile  = " << keyFile << std::endl;
+        ss << "  caFile   = " << caFile << std::endl;
+        ss << "  ciphers  = " << ciphers << std::endl;
+        ss << "  ciphers  = " << ciphers << std::endl;
+        return ss.str();
+    }
 } // namespace ix

ixwebsocket/IXSocketTLSOptions.h

@@ -43,6 +43,8 @@ namespace ix
 
         const std::string& getErrorMsg() const;
 
+        std::string getDescription() const;
+
     private:
         mutable std::string _errMsg;
         mutable bool _validated = false;

ixwebsocket/IXWebSocket.cpp

@@ -169,6 +169,7 @@ namespace ix
             // wait until working thread will exit
             // it will exit after close operation is finished
             _stop = true;
+            _sleepCondition.notify_one();
             _thread.join();
             _stop = false;
         }
@@ -282,8 +283,13 @@ namespace ix
             // Only sleep if we are retrying
             if (duration.count() > 0)
             {
-                // to do: make sleeping conditional
-                std::this_thread::sleep_for(duration);
+                std::unique_lock<std::mutex> lock(_sleepMutex);
+                _sleepCondition.wait_for(lock, duration);
+            }
+
+            if (_stop)
+            {
+                break;
             }
 
             // Try to connect synchronously

ixwebsocket/IXWebSocket.h

@@ -22,6 +22,7 @@
 #include <mutex>
 #include <string>
 #include <thread>
+#include <condition_variable>
 
 namespace ix
 {
@@ -140,6 +141,10 @@ namespace ix
         static const uint32_t kDefaultMaxWaitBetweenReconnectionRetries;
         uint32_t _maxWaitBetweenReconnectionRetries;
 
+        // Make the sleeping in the automatic reconnection cancellable
+        std::mutex _sleepMutex;
+        std::condition_variable _sleepCondition;
+
         std::atomic<int> _handshakeTimeoutSecs;
         static const int kDefaultHandShakeTimeoutSecs;
 

ixwebsocket/IXWebSocketServer.cpp

@@ -23,8 +23,9 @@ namespace ix
                                      const std::string& host,
                                      int backlog,
                                      size_t maxConnections,
-                                     int handshakeTimeoutSecs)
-        : SocketServer(port, host, backlog, maxConnections)
+                                     int handshakeTimeoutSecs,
+                                     int addressFamily)
+        : SocketServer(port, host, backlog, maxConnections, addressFamily)
         , _handshakeTimeoutSecs(handshakeTimeoutSecs)
         , _enablePong(kDefaultEnablePong)
     {
@@ -106,7 +107,6 @@ namespace ix
             }
         }
 
-        logInfo("WebSocketServer::handleConnection() done");
         connectionState->setTerminated();
     }
 

ixwebsocket/IXWebSocketServer.h

@@ -29,7 +29,8 @@ namespace ix
                         const std::string& host = SocketServer::kDefaultHost,
                         int backlog = SocketServer::kDefaultTcpBacklog,
                         size_t maxConnections = SocketServer::kDefaultMaxConnections,
-                        int handshakeTimeoutSecs = WebSocketServer::kDefaultHandShakeTimeoutSecs);
+                        int handshakeTimeoutSecs = WebSocketServer::kDefaultHandShakeTimeoutSecs,
+                        int addressFamily = SocketServer::kDefaultAddressFamily);
         virtual ~WebSocketServer();
         virtual void stop() final;
 
@@ -41,6 +42,8 @@ namespace ix
         // Get all the connected clients
         std::set<std::shared_ptr<WebSocket>> getClients();
 
+        const static int kDefaultHandShakeTimeoutSecs;
+
     private:
         // Member variables
         int _handshakeTimeoutSecs;
@@ -51,7 +54,6 @@ namespace ix
         std::mutex _clientsMutex;
         std::set<std::shared_ptr<WebSocket>> _clients;
 
-        const static int kDefaultHandShakeTimeoutSecs;
         const static bool kDefaultEnablePong;
 
         // Methods

ixwebsocket/IXWebSocketTransport.cpp

@@ -144,7 +144,9 @@ namespace ix
 
         if (!UrlParser::parse(url, protocol, host, path, query, port))
         {
-            return WebSocketInitResult(false, 0, std::string("Could not parse URL ") + url);
+            std::stringstream ss;
+            ss << "Could not parse url: '" << url << "'";
+            return WebSocketInitResult(false, 0, ss.str());
         }
 
         std::string errorMsg;
@@ -348,28 +350,9 @@ namespace ix
         }
         else if (pollResult == PollResultType::ReadyForRead)
         {
-            while (true)
+            if (!receiveFromSocket())
             {
-                ssize_t ret = _socket->recv((char*) &_readbuf[0], _readbuf.size());
-
-                if (ret < 0 && Socket::isWaitNeeded())
-                {
-                    break;
-                }
-                else if (ret <= 0)
-                {
-                    // if there are received data pending to be processed, then delay the abnormal
-                    // closure to after dispatch (other close code/reason could be read from the
-                    // buffer)
-
-                    closeSocket();
-
-                    return PollResult::AbnormalClose;
-                }
-                else
-                {
-                    _rxbuf.insert(_rxbuf.end(), _readbuf.begin(), _readbuf.begin() + ret);
-                }
+                return PollResult::AbnormalClose;
             }
         }
         else if (pollResult == PollResultType::Error)
@@ -737,7 +720,7 @@ namespace ix
 
         // if an abnormal closure was raised in poll, and nothing else triggered a CLOSED state in
         // the received and processed data then close the connection
-        if (pollResult == PollResult::AbnormalClose)
+        if (pollResult != PollResult::Succeeded)
         {
             _rxbuf.clear();
 
@@ -863,10 +846,12 @@ namespace ix
             _txbuf.reserve(wireSize);
         }
 
+        bool success = true;
+
         // Common case for most message. No fragmentation required.
         if (wireSize < kChunkSize)
         {
-            sendFragment(type, true, message_begin, message_end, compress);
+            success = sendFragment(type, true, message_begin, message_end, compress);
         }
         else
         {
@@ -902,7 +887,10 @@ namespace ix
                 }
 
                 // Send message
-                sendFragment(opcodeType, fin, begin, end, compress);
+                if (!sendFragment(opcodeType, fin, begin, end, compress))
+                {
+                    return WebSocketSendInfo(false);
+                }
 
                 if (onProgressCallback && !onProgressCallback((int) i, (int) steps))
                 {
@@ -913,8 +901,6 @@ namespace ix
             }
         }
 
-        bool success = true;
-
         // Request to flush the send buffer on the background thread if it isn't empty
         if (!isSendBufferEmpty())
         {
@@ -930,7 +916,7 @@ namespace ix
         return WebSocketSendInfo(success, compressionError, payloadSize, wireSize);
     }
 
-    void WebSocketTransport::sendFragment(wsheader_type::opcode_type type,
+    bool WebSocketTransport::sendFragment(wsheader_type::opcode_type type,
                                           bool fin,
                                           std::string::const_iterator message_begin,
                                           std::string::const_iterator message_end,
@@ -1015,7 +1001,7 @@ namespace ix
         appendToSendBuffer(header, message_begin, message_end, message_size, masking_key);
 
         // Now actually send this data
-        sendOnSocket();
+        return sendOnSocket();
     }
 
     WebSocketSendInfo WebSocketTransport::sendPing(const std::string& message)
@@ -1048,19 +1034,17 @@ namespace ix
             wsheader_type::TEXT_FRAME, message, _enablePerMessageDeflate, onProgressCallback);
     }
 
-    ssize_t WebSocketTransport::send()
-    {
-        std::lock_guard<std::mutex> lock(_socketMutex);
-        return _socket->send((char*) &_txbuf[0], _txbuf.size());
-    }
-
-    void WebSocketTransport::sendOnSocket()
+    bool WebSocketTransport::sendOnSocket()
     {
         std::lock_guard<std::mutex> lock(_txbufMutex);
 
         while (_txbuf.size())
         {
-            ssize_t ret = send();
+            ssize_t ret = 0;
+            {
+                std::lock_guard<std::mutex> lock(_socketMutex);
+                ret = _socket->send((char*) &_txbuf[0], _txbuf.size());
+            }
 
             if (ret < 0 && Socket::isWaitNeeded())
             {
@@ -1070,13 +1054,43 @@ namespace ix
             {
                 closeSocket();
                 setReadyState(ReadyState::CLOSED);
-                break;
+                return false;
             }
             else
             {
                 _txbuf.erase(_txbuf.begin(), _txbuf.begin() + ret);
             }
         }
+
+        return true;
+    }
+
+    bool WebSocketTransport::receiveFromSocket()
+    {
+        while (true)
+        {
+            ssize_t ret = _socket->recv((char*) &_readbuf[0], _readbuf.size());
+
+            if (ret < 0 && Socket::isWaitNeeded())
+            {
+                break;
+            }
+            else if (ret <= 0)
+            {
+                // if there are received data pending to be processed, then delay the abnormal
+                // closure to after dispatch (other close code/reason could be read from the
+                // buffer)
+
+                closeSocket();
+                return false;
+            }
+            else
+            {
+                _rxbuf.insert(_rxbuf.end(), _readbuf.begin(), _readbuf.begin() + ret);
+            }
+        }
+
+        return true;
     }
 
     void WebSocketTransport::sendCloseFrame(uint16_t code, const std::string& reason)
@@ -1181,7 +1195,10 @@ namespace ix
             }
             else if (result == PollResultType::ReadyForWrite)
             {
-                sendOnSocket();
+                if (!sendOnSocket())
+                {
+                    return false;
+                }
             }
         }
 

ixwebsocket/IXWebSocketTransport.h

@@ -99,7 +99,6 @@ namespace ix
                    bool remote = false);
 
         void closeSocket();
-        ssize_t send();
 
         ReadyState getReadyState() const;
         void setReadyState(ReadyState readyState);
@@ -244,13 +243,15 @@ namespace ix
                                                bool remote);
 
         bool flushSendBuffer();
-        void sendOnSocket();
+        bool sendOnSocket();
+        bool receiveFromSocket();
+
         WebSocketSendInfo sendData(wsheader_type::opcode_type type,
                                    const std::string& message,
                                    bool compress,
                                    const OnProgressCallback& onProgressCallback = nullptr);
 
-        void sendFragment(wsheader_type::opcode_type type,
+        bool sendFragment(wsheader_type::opcode_type type,
                           bool fin,
                           std::string::const_iterator begin,
                           std::string::const_iterator end,

ixwebsocket/IXWebSocketVersion.h

@@ -6,4 +6,4 @@
 
 #pragma once
 
-#define IX_WEBSOCKET_VERSION "7.5.5"
+#define IX_WEBSOCKET_VERSION "8.0.0"

test/CMakeLists.txt

@@ -23,6 +23,8 @@ include_directories(
   ../ws
 )
 
+add_definitions(-DSPDLOG_COMPILED_LIB=1)
+
 find_package(JsonCpp)
 if (NOT JSONCPP_FOUND)
   include_directories(../third_party/jsoncpp)
@@ -53,12 +55,12 @@ set (SOURCES
   IXDNSLookupTest.cpp
   IXWebSocketSubProtocolTest.cpp
   IXSentryClientTest.cpp
+  IXWebSocketChatTest.cpp
 )
 
 # Some unittest don't work on windows yet
 if (UNIX)
   list(APPEND SOURCES
-    IXWebSocketChatTest.cpp
     IXWebSocketCloseTest.cpp
   )
 endif()
@@ -98,4 +100,6 @@ target_link_libraries(ixwebsocket_unittest ixcrypto)
 target_link_libraries(ixwebsocket_unittest ixcore)
 target_link_libraries(ixwebsocket_unittest ixsentry)
 
+target_link_libraries(ixwebsocket_unittest spdlog)
+
 install(TARGETS ixwebsocket_unittest DESTINATION bin)

test/IXCobraChatTest.cpp

@@ -34,12 +34,10 @@ namespace
         });
     }
 
-    class SatoriChat
+    class CobraChat
     {
     public:
-        SatoriChat(const std::string& user,
-                   const std::string& session,
-                   const std::string& endpoint);
+        CobraChat(const std::string& user, const std::string& session, const std::string& endpoint);
 
         void subscribe(const std::string& channel);
         void start();
@@ -72,9 +70,9 @@ namespace
         std::mutex _logMutex;
     };
 
-    SatoriChat::SatoriChat(const std::string& user,
-                           const std::string& session,
-                           const std::string& endpoint)
+    CobraChat::CobraChat(const std::string& user,
+                         const std::string& session,
+                         const std::string& endpoint)
         : _user(user)
         , _session(session)
         , _endpoint(endpoint)
@@ -83,34 +81,34 @@ namespace
     {
     }
 
-    void SatoriChat::start()
+    void CobraChat::start()
     {
-        _thread = std::thread(&SatoriChat::run, this);
+        _thread = std::thread(&CobraChat::run, this);
     }
 
-    void SatoriChat::stop()
+    void CobraChat::stop()
     {
         _stop = true;
         _thread.join();
     }
 
-    bool SatoriChat::isReady() const
+    bool CobraChat::isReady() const
     {
         return _connectedAndSubscribed;
     }
 
-    size_t SatoriChat::getReceivedMessagesCount() const
+    size_t CobraChat::getReceivedMessagesCount() const
     {
         return _receivedQueue.size();
     }
 
-    bool SatoriChat::hasPendingMessages() const
+    bool CobraChat::hasPendingMessages() const
     {
         std::unique_lock<std::mutex> lock(_queue_mutex);
         return !_publish_queue.empty();
     }
 
-    Json::Value SatoriChat::popMessage()
+    Json::Value CobraChat::popMessage()
     {
         std::unique_lock<std::mutex> lock(_queue_mutex);
         auto msg = _publish_queue.front();
@@ -121,7 +119,7 @@ namespace
     //
     // Callback to handle received messages, that are printed on the console
     //
-    void SatoriChat::subscribe(const std::string& channel)
+    void CobraChat::subscribe(const std::string& channel)
     {
         std::string filter;
         _conn.subscribe(channel, filter, [this](const Json::Value& msg) {
@@ -151,7 +149,7 @@ namespace
         });
     }
 
-    void SatoriChat::sendMessage(const std::string& text)
+    void CobraChat::sendMessage(const std::string& text)
     {
         Json::Value msg;
         msg["user"] = _user;
@@ -166,16 +164,21 @@ namespace
     // Do satori communication on a background thread, where we can have
     // something like an event loop that publish, poll and receive data
     //
-    void SatoriChat::run()
+    void CobraChat::run()
     {
         // "chat" conf
         std::string appkey("FC2F10139A2BAc53BB72D9db967b024f");
         std::string channel = _session;
         std::string role = "_sub";
         std::string secret = "66B1dA3ED5fA074EB5AE84Dd8CE3b5ba";
+        SocketTLSOptions socketTLSOptions;
 
-        _conn.configure(
-            appkey, _endpoint, role, secret, ix::WebSocketPerMessageDeflateOptions(true));
+        _conn.configure(appkey,
+                        _endpoint,
+                        role,
+                        secret,
+                        ix::WebSocketPerMessageDeflateOptions(true),
+                        socketTLSOptions);
         _conn.connect();
 
         _conn.setEventCallback([this, channel](ix::CobraConnectionEventType eventType,
@@ -280,8 +283,8 @@ TEST_CASE("Cobra_chat", "[cobra_chat]")
         ss << "ws://localhost:" << port;
         std::string endpoint = ss.str();
 
-        SatoriChat chatA("jean", session, endpoint);
-        SatoriChat chatB("paul", session, endpoint);
+        CobraChat chatA("jean", session, endpoint);
+        CobraChat chatB("paul", session, endpoint);
 
         chatA.start();
         chatB.start();

test/IXCobraMetricsPublisherTest.cpp

@@ -62,11 +62,14 @@ namespace
         gMessageCount = 0;
 
         ix::CobraConnection conn;
+        SocketTLSOptions socketTLSOptions;
+
         conn.configure(APPKEY,
                        endpoint,
                        SUBSCRIBER_ROLE,
                        SUBSCRIBER_SECRET,
-                       ix::WebSocketPerMessageDeflateOptions(true));
+                       ix::WebSocketPerMessageDeflateOptions(true),
+                       socketTLSOptions);
         conn.connect();
 
         conn.setEventCallback([&conn](ix::CobraConnectionEventType eventType,
@@ -202,9 +205,15 @@ TEST_CASE("Cobra_Metrics_Publisher", "[cobra]")
 
     ix::CobraMetricsPublisher cobraMetricsPublisher;
 
+    SocketTLSOptions socketTLSOptions;
     bool perMessageDeflate = true;
-    cobraMetricsPublisher.configure(
-        APPKEY, endpoint, CHANNEL, PUBLISHER_ROLE, PUBLISHER_SECRET, perMessageDeflate);
+    cobraMetricsPublisher.configure(APPKEY,
+                                    endpoint,
+                                    CHANNEL,
+                                    PUBLISHER_ROLE,
+                                    PUBLISHER_SECRET,
+                                    perMessageDeflate,
+                                    socketTLSOptions);
     cobraMetricsPublisher.setSession(uuid4());
     cobraMetricsPublisher.enable(true); // disabled by default, needs to be enabled to be active
 

test/compatibility/C/uWebSockets/.github/workflows/cpp.yml

@@ -0,0 +1,26 @@
+name: C++ CI
+
+on: [push]
+
+jobs:
+  build_linux:
+
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Clone source
+      run: git clone --recursive https://github.com/uNetworking/uWebSockets.git
+    - name: Build source
+      run: make -C uWebSockets
+      
+      
+  build_osx:
+
+    runs-on: macos-latest
+    
+    steps:
+    - name: Clone source
+      run: git clone --recursive https://github.com/uNetworking/uWebSockets.git
+    - name: Build source
+      run: make -C uWebSockets
+      

test/compatibility/C/uWebSockets/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "uSockets"]
+	path = uSockets
+	url = https://github.com/uNetworking/uSockets.git

test/compatibility/C/uWebSockets/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

test/compatibility/C/uWebSockets/Makefile

@@ -0,0 +1,40 @@
+EXAMPLE_FILES := HelloWorld EchoServer BroadcastingEchoServer
+THREADED_EXAMPLE_FILES := HelloWorldThreaded EchoServerThreaded
+override CXXFLAGS += -lpthread -Wconversion -std=c++17 -Isrc -IuSockets/src
+override LDFLAGS += uSockets/*.o -lz
+
+# WITH_OPENSSL=1 enables OpenSSL 1.1+ support
+ifeq ($(WITH_OPENSSL),1)
+	# With problems on macOS, make sure to pass needed LDFLAGS required to find these
+	override LDFLAGS += -lssl -lcrypto
+else
+	# WITH_WOLFSSL=1 enables WolfSSL 4.2.0 support (mutually exclusive with OpenSSL)
+	ifeq ($(WITH_WOLFSSL),1)
+		override LDFLAGS += -L/usr/local/lib -lwolfssl
+	endif
+endif
+
+# WITH_LIBUV=1 builds with libuv as event-loop
+ifeq ($(WITH_LIBUV),1)
+	override LDFLAGS += -luv
+endif
+
+# WITH_ASAN builds with sanitizers
+ifeq ($(WITH_ASAN),1)
+	override CXXFLAGS += -fsanitize=address
+	override LDFLAGS += -lasan
+endif
+
+.PHONY: examples
+examples:
+	cd uSockets && make
+	$(foreach FILE,$(EXAMPLE_FILES),$(CXX) -flto -O3 $(CXXFLAGS) examples/$(FILE).cpp -o $(FILE) $(LDFLAGS);)
+	$(foreach FILE,$(THREADED_EXAMPLE_FILES),$(CXX) -pthread -flto -O3 $(CXXFLAGS) examples/$(FILE).cpp -o $(FILE) $(LDFLAGS);)
+
+all:
+	make examples
+	make -C fuzzing
+	make -C benchmarks
+clean:
+	rm -rf $(EXAMPLE_FILES) $(THREADED_EXAMPLE_FILES)
+	rm -rf fuzzing/*.o benchmarks/*.o

test/compatibility/C/uWebSockets/README.md

@@ -0,0 +1,65 @@
+<div align="center">
+<img src="misc/logo.svg" height="180" />
+
+*µWebSockets™ (it's "[micro](https://en.wikipedia.org/wiki/Micro-)") is simple, secure*<sup>[[1]](fuzzing)</sup> *& standards compliant*<sup>[[2]](https://unetworking.github.io/uWebSockets.js/report.pdf)</sup> *web I/O for the most demanding*<sup>[[3]](benchmarks)</sup> *of applications.*
+
+• [Read more](misc/READMORE.md) • [Read about uSockets](https://github.com/uNetworking/uSockets) • [See uWebSockets.js](https://github.com/uNetworking/uWebSockets.js)
+
+*© 2016-2019, >39,632,272 downloads*
+
+</div>
+
+#### Express yourself briefly.
+```c++
+uWS::SSLApp({
+
+    /* There are tons of SSL options */
+    .cert_file_name = "cert.pem",
+    .key_file_name = "key.pem"
+    
+}).get("/hello", [](auto *res, auto *req) {
+
+    /* You can efficiently stream huge files too */
+    res->writeHeader("Content-Type", "text/html; charset=utf-8")->end("Hello HTTP!");
+    
+}).ws<UserData>("/*", {
+
+    /* Just a few of the available handlers */
+    .open = [](auto *ws, auto *req) {
+        ws->subscribe("buzzword weekly");
+    },
+    .message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
+        ws->send(message, opCode);
+    }
+    
+}).listen(9001, [](auto *token) {
+
+    if (token) {
+        std::cout << "Listening on port " << 9001 << std::endl;
+    }
+    
+}).run();
+```
+Don't miss the [user manual](https://github.com/uNetworking/uWebSockets/blob/master/misc/READMORE.md#user-manual), the [C++ examples](https://github.com/uNetworking/uWebSockets/tree/master/examples) or the [JavaScript examples](https://github.com/uNetworking/uWebSockets.js/tree/master/examples). JavaScript examples are very applicable to C++ developers, so go through them as well.
+
+#### Pay what you want.
+A free & open source ([permissive](LICENSE)) project since 2016. Kindly sponsored by [BitMEX](https://bitmex.com), [Bitfinex](https://bitfinex.com) & [Coinbase](https://www.coinbase.com/) in 2018 and/or 2019. Individual donations are always accepted via [PayPal](https://paypal.me/uwebsockets).
+
+<div align="center"><img src="misc/2018.png"/></div>
+
+*Code is provided as-is, do not expect or demand **free** consulting services, personal tutoring, advice or debugging.*
+
+#### Deploy like a boss.
+Commercial support is available via a per-hourly consulting plan or as otherwise negotiated. If you're stuck, worried about design or just in need of help don't hesitate throwing [me, the author](https://github.com/alexhultman) a mail and we'll figure out what's best for both parties. I want your business to have a proper understanding of the problem before rushing in to one of the many pitfalls.
+
+#### Excel across the board.
+All that glitters is not gold. Especially so in a market driven by flashy logos, hype and pointless badges.
+
+Http | WebSockets
+--- | ---
+![](misc/bigshot_lineup.png) | ![](misc/websocket_lineup.png)
+
+#### Keep it legal.
+Intellectual property, all rights reserved.
+
+*You are forbidden to use logos, product names, texts, names or otherwise perceived brand identity, of copyright holder, in any way that might state or imply that the copyright holder endorses your distribution or in any way that might state or imply that you created the original software. Modified distributions must carry, from the original distribution, significantly different names and must not be confused with the original distribution.*

test/compatibility/C/uWebSockets/benchmarks/Makefile

@@ -0,0 +1,4 @@
+default:
+	clang -flto -O3 -DLIBUS_USE_OPENSSL -I../uSockets/src ../uSockets/src/*.c ../uSockets/src/eventing/*.c ../uSockets/src/crypto/*.c broadcast_test.c -o broadcast_test -lssl -lcrypto
+	clang -flto -O3 -DLIBUS_USE_OPENSSL -I../uSockets/src ../uSockets/src/*.c ../uSockets/src/eventing/*.c ../uSockets/src/crypto/*.c load_test.c -o load_test -lssl -lcrypto
+	clang -flto -O3 -DLIBUS_USE_OPENSSL -I../uSockets/src ../uSockets/src/*.c ../uSockets/src/eventing/*.c ../uSockets/src/crypto/*.c scale_test.c -o scale_test -lssl -lcrypto

test/compatibility/C/uWebSockets/benchmarks/README.md

@@ -0,0 +1,17 @@
+# Benchmark-driven development
+
+Just like testing code for correctness and stability, testing for performance is just as important if performance is a goal. You cannot really argue or reason about performance without having tests for it.
+
+* Do not trust anyone who claims performance of any kind unless they provide benchmarks. Do not listen to people who talk about performance without having actual scientific data to back their claims up.
+* Never accept absolute numbers without a direct comparison with an alternative solution. Many projects can give you a number, X, which can be "50 billion messages per second". How much is this? What kind of worth does this number have? Impossible to know without a comparison. Absolute numbers mean nothing, relative comparisons are what you should look for.
+* Make sure to benchmark the correct thing. This is an extremely common mistake, done by many of the most well-known developers out there. If you measure for CPU-time efficiency (which you do) then normalizing for spent CPU-time is the difference between a completely invalid, botched and bogus test and something that might be valid.
+
+Here are the current relative comparisons:
+
+Http | WebSockets
+--- | ---
+![](../misc/bigshot_lineup.png) | ![](../misc/websocket_lineup.png)
+
+Over the period of a few years I have never come across any web server which can score as high as µWebSockets do. This is not to say that µWebSockets is fastest, as "fastest" is a silly superlative nobody should *ever* use.
+
+Never trust anyone using superlatives to describe their work; they are more often wrong than right.

test/compatibility/C/uWebSockets/benchmarks/broadcast_test.c

@@ -0,0 +1,196 @@
+/* This benchmark establishes _connections_ number of WebSocket
+   clients, then iteratively performs the following:
+
+   1. Send one message for every client.
+   2. Wait for the quadratic (_connections_^2) amount of responses from the server.
+   3. Once received all expected bytes, repeat by going to step 1.
+
+   Every 4 seconds we print the current average "iterations per second".
+   */
+
+#include <libusockets.h>
+int SSL;
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+unsigned char web_socket_request[26] = {130, 128 | 20, 1, 2, 3, 4};
+
+char request[] = "GET / HTTP/1.1\r\n"
+                 "Upgrade: websocket\r\n"
+                 "Connection: Upgrade\r\n"
+                 "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n"
+                 "Host: server.example.com\r\n"
+                 "Sec-WebSocket-Version: 13\r\n\r\n";
+char *host;
+int port;
+int connections;
+
+int satisfied_sockets;
+int iterations;
+
+struct http_socket {
+    /* How far we have streamed our websocket request */
+    int offset;
+
+    /* How far we have streamed our upgrade request */
+    int upgrade_offset;
+
+    /* Are we upgraded? */
+    int is_upgraded;
+
+    /* Bytes received */
+    int bytes_received;
+};
+
+/* We track upgraded websockets */
+void **web_sockets;
+int num_web_sockets;
+
+/* We don't need any of these */
+void noop(struct us_loop_t *loop) {
+
+}
+
+void start_iteration() {
+    for (int i = 0; i < num_web_sockets; i++) {
+        struct us_socket_t *s = (struct us_socket_t *) web_sockets[i];
+        struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+        http_socket->offset = us_socket_write(SSL, s, (char *) web_socket_request, sizeof(web_socket_request), 0);
+    }
+}
+
+void next_connection(struct us_socket_t *s) {
+    /* Add this connection to our array */
+    web_sockets[num_web_sockets++] = s;
+
+    /* We could wait with this until properly upgraded */
+    if (--connections) {
+        us_socket_context_connect(SSL, us_socket_context(SSL, s), host, port, 0, sizeof(struct http_socket));
+    } else {
+        printf("Running benchmark now...\n");
+        start_iteration();
+
+        us_socket_timeout(SSL, s, LIBUS_TIMEOUT_GRANULARITY);
+    }
+}
+
+struct us_socket_t *on_http_socket_writable(struct us_socket_t *s) {
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+    /* Are we still not upgraded yet? */
+    if (http_socket->upgrade_offset < sizeof(request) - 1) {
+        http_socket->upgrade_offset += us_socket_write(SSL, s, request + http_socket->upgrade_offset, sizeof(request) - 1 - http_socket->upgrade_offset, 0);
+    } else {
+        /* Stream whatever is remaining of the request */
+        http_socket->offset += us_socket_write(SSL, s, (char *) web_socket_request + http_socket->offset, sizeof(web_socket_request) - http_socket->offset, 0);
+    }
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_close(struct us_socket_t *s) {
+
+    printf("Client was disconnected, exiting!\n");
+    exit(-1);
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_end(struct us_socket_t *s) {
+    return us_socket_close(SSL, s);
+}
+
+struct us_socket_t *on_http_socket_data(struct us_socket_t *s, char *data, int length) {
+    /* Get socket extension and the socket's context's extension */
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+    /* Are we already upgraded? */
+    if (http_socket->is_upgraded) {
+        http_socket->bytes_received += length;
+
+        if (http_socket->bytes_received == (sizeof(web_socket_request) - 4) * num_web_sockets) {
+            satisfied_sockets++;
+            http_socket->bytes_received = 0;
+
+            if (satisfied_sockets == num_web_sockets) {
+                iterations++;
+                satisfied_sockets = 0;
+
+                start_iteration();
+            }
+        }
+    } else {
+        /* We assume the server is not sending anything immediately following upgrade and that we get rnrn in one chunk */
+        if (length >= 4 && data[length - 1] == '\n' && data[length - 2] == '\r' && data[length - 3] == '\n' && data[length - 4] == '\r') {
+            http_socket->is_upgraded = 1;
+            next_connection(s);
+        }
+    }
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_open(struct us_socket_t *s, int is_client, char *ip, int ip_length) {
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+    /* Reset offsets */
+    http_socket->offset = 0;
+    http_socket->is_upgraded = 0;
+    http_socket->bytes_received = 0;
+
+    /* Send an upgrade request */
+    http_socket->upgrade_offset = us_socket_write(SSL, s, request, sizeof(request) - 1, 0);
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_timeout(struct us_socket_t *s) {
+    /* Print current statistics */
+    printf("Iterations/second (%d clients): %f\n", num_web_sockets, ((float)iterations) / LIBUS_TIMEOUT_GRANULARITY);
+
+    iterations = 0;
+    us_socket_timeout(SSL, s, LIBUS_TIMEOUT_GRANULARITY);
+
+    return s;
+}
+
+int main(int argc, char **argv) {
+
+    /* Parse host and port */
+    if (argc != 5) {
+        printf("Usage: connections host port ssl\n");
+        return 0;
+    }
+
+    port = atoi(argv[3]);
+    host = malloc(strlen(argv[2]) + 1);
+    memcpy(host, argv[2], strlen(argv[2]) + 1);
+    connections = atoi(argv[1]);
+    SSL = atoi(argv[4]);
+
+    /* Allocate room for every socket */
+    web_sockets = (void **) malloc(sizeof(void *) * connections);
+
+    /* Create the event loop */
+    struct us_loop_t *loop = us_create_loop(0, noop, noop, noop, 0);
+
+    /* Create a socket context for HTTP */
+    struct us_socket_context_options_t options = {};
+    struct us_socket_context_t *http_context = us_create_socket_context(SSL, loop, 0, options);
+
+    /* Set up event handlers */
+    us_socket_context_on_open(SSL, http_context, on_http_socket_open);
+    us_socket_context_on_data(SSL, http_context, on_http_socket_data);
+    us_socket_context_on_writable(SSL, http_context, on_http_socket_writable);
+    us_socket_context_on_close(SSL, http_context, on_http_socket_close);
+    us_socket_context_on_timeout(SSL, http_context, on_http_socket_timeout);
+    us_socket_context_on_end(SSL, http_context, on_http_socket_end);
+
+    /* Start making HTTP connections */
+    us_socket_context_connect(SSL, http_context, host, port, 0, sizeof(struct http_socket));
+
+    us_loop_run(loop);
+}

test/compatibility/C/uWebSockets/benchmarks/load_test.c

@@ -0,0 +1,161 @@
+/* This is a simple yet efficient WebSocket server benchmark much like WRK */
+
+#include <libusockets.h>
+int SSL;
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// request eller upgradeRequest samt webSocketFrame
+
+unsigned char web_socket_request[26] = {130, 128 | 20, 1, 2, 3, 4};
+
+char request[] = "GET / HTTP/1.1\r\n"
+                 "Upgrade: websocket\r\n"
+                 "Connection: Upgrade\r\n"
+                 "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n"
+                 "Host: server.example.com\r\n"
+                 "Sec-WebSocket-Version: 13\r\n\r\n";
+char *host;
+int port;
+int connections;
+
+int responses;
+
+struct http_socket {
+    /* How far we have streamed our websocket request */
+    int offset;
+
+    /* How far we have streamed our upgrade request */
+    int upgrade_offset;
+};
+
+/* We don't need any of these */
+void on_wakeup(struct us_loop_t *loop) {
+
+}
+
+void on_pre(struct us_loop_t *loop) {
+
+}
+
+/* This is not HTTP POST, it is merely an event emitted post loop iteration */
+void on_post(struct us_loop_t *loop) {
+
+}
+
+void next_connection(struct us_socket_t *s) {
+    /* We could wait with this until properly upgraded */
+    if (--connections) {
+        us_socket_context_connect(SSL, us_socket_context(SSL, s), host, port, 0, sizeof(struct http_socket));
+    } else {
+        printf("Running benchmark now...\n");
+
+        us_socket_timeout(SSL, s, LIBUS_TIMEOUT_GRANULARITY);
+    }
+}
+
+struct us_socket_t *on_http_socket_writable(struct us_socket_t *s) {
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+    /* Are we still not upgraded yet? */
+    if (http_socket->upgrade_offset < sizeof(request) - 1) {
+        http_socket->upgrade_offset += us_socket_write(SSL, s, request + http_socket->upgrade_offset, sizeof(request) - 1 - http_socket->upgrade_offset, 0);
+
+        /* Now we should be */
+        if (http_socket->upgrade_offset == sizeof(request) - 1) {
+            next_connection(s);
+        }
+    } else {
+        /* Stream whatever is remaining of the request */
+        http_socket->offset += us_socket_write(SSL, s, (char *) web_socket_request + http_socket->offset, sizeof(web_socket_request) - http_socket->offset, 0);
+    }
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_close(struct us_socket_t *s) {
+
+    printf("Closed!\n");
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_end(struct us_socket_t *s) {
+    return us_socket_close(SSL, s);
+}
+
+struct us_socket_t *on_http_socket_data(struct us_socket_t *s, char *data, int length) {
+    /* Get socket extension and the socket's context's extension */
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+    //struct http_context *http_context = (struct http_context *) us_socket_context_ext(SSL, us_socket_context(SSL, s));
+
+    /* We treat all data events as a response */
+    http_socket->offset = us_socket_write(SSL, s, (char *) web_socket_request, sizeof(web_socket_request), 0);
+
+    /* */
+    responses++;
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_open(struct us_socket_t *s, int is_client, char *ip, int ip_length) {
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+    /* Reset offsets */
+    http_socket->offset = 0;
+
+    /* Send an upgrade request */
+    http_socket->upgrade_offset = us_socket_write(SSL, s, request, sizeof(request) - 1, 0);
+    if (http_socket->upgrade_offset == sizeof(request) - 1) {
+        next_connection(s);
+    }
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_timeout(struct us_socket_t *s) {
+    /* Print current statistics */
+    printf("Msg/sec: %f\n", ((float)responses) / LIBUS_TIMEOUT_GRANULARITY);
+
+    responses = 0;
+    us_socket_timeout(SSL, s, LIBUS_TIMEOUT_GRANULARITY);
+
+    return s;
+}
+
+int main(int argc, char **argv) {
+
+    /* Parse host and port */
+    if (argc != 5) {
+        printf("Usage: connections host port ssl\n");
+        return 0;
+    }
+
+    port = atoi(argv[3]);
+    host = malloc(strlen(argv[2]) + 1);
+    memcpy(host, argv[2], strlen(argv[2]) + 1);
+    connections = atoi(argv[1]);
+    SSL = atoi(argv[4]);
+
+    /* Create the event loop */
+    struct us_loop_t *loop = us_create_loop(0, on_wakeup, on_pre, on_post, 0);
+
+    /* Create a socket context for HTTP */
+    struct us_socket_context_options_t options = {};
+    struct us_socket_context_t *http_context = us_create_socket_context(SSL, loop, 0, options);
+
+    /* Set up event handlers */
+    us_socket_context_on_open(SSL, http_context, on_http_socket_open);
+    us_socket_context_on_data(SSL, http_context, on_http_socket_data);
+    us_socket_context_on_writable(SSL, http_context, on_http_socket_writable);
+    us_socket_context_on_close(SSL, http_context, on_http_socket_close);
+    us_socket_context_on_timeout(SSL, http_context, on_http_socket_timeout);
+    us_socket_context_on_end(SSL, http_context, on_http_socket_end);
+
+    /* Start making HTTP connections */
+    us_socket_context_connect(SSL, http_context, host, port, 0, sizeof(struct http_socket));
+
+    us_loop_run(loop);
+}

test/compatibility/C/uWebSockets/benchmarks/scale_test.c

@@ -0,0 +1,185 @@
+/* This is a scalability test for testing million(s) of pinging connections */
+
+#include <libusockets.h>
+int SSL;
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+unsigned char web_socket_request[26] = {130, 128 | 20, 1, 2, 3, 4};
+
+char request[] = "GET / HTTP/1.1\r\n"
+                 "Upgrade: websocket\r\n"
+                 "Connection: Upgrade\r\n"
+                 "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n"
+                 "Host: server.example.com\r\n"
+                 "Sec-WebSocket-Version: 13\r\n\r\n";
+char *host;
+int port;
+int connections;
+
+/* Send ping every 16 seconds */
+int WEBSOCKET_PING_INTERVAL = 16;
+
+/* We only establish 20k connections per address */
+int CONNECTIONS_PER_ADDRESS = 20000;
+
+/* How many connections a time */
+int BATCH_CONNECT = 1;
+
+/* Currently open and alive connections */
+int opened_connections;
+/* Dead connections */
+int closed_connections;
+
+struct http_socket {
+    /* How far we have streamed our websocket request */
+    int offset;
+
+    /* How far we have streamed our upgrade request */
+    int upgrade_offset;
+};
+
+/* We don't need any of these */
+void on_wakeup(struct us_loop_t *loop) {
+
+}
+
+void on_pre(struct us_loop_t *loop) {
+
+}
+
+/* This is not HTTP POST, it is merely an event emitted post loop iteration */
+void on_post(struct us_loop_t *loop) {
+
+}
+
+void next_connection(struct us_socket_t *s) {
+    /* We could wait with this until properly upgraded */
+    if (--connections/* > BATCH_CONNECT*/) {
+        /* Swap address */
+        int address = opened_connections / CONNECTIONS_PER_ADDRESS + 1;
+        char buf[16];
+        sprintf(buf, "127.0.0.%d", address);
+
+        us_socket_context_connect(SSL, us_socket_context(SSL, s), buf, port, 0, sizeof(struct http_socket));
+    }
+}
+
+struct us_socket_t *on_http_socket_writable(struct us_socket_t *s) {
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+    /* Are we still not upgraded yet? */
+    if (http_socket->upgrade_offset < sizeof(request) - 1) {
+        http_socket->upgrade_offset += us_socket_write(SSL, s, request + http_socket->upgrade_offset, sizeof(request) - 1 - http_socket->upgrade_offset, 0);
+
+        /* Now we should be */
+        if (http_socket->upgrade_offset == sizeof(request) - 1) {
+            next_connection(s);
+
+            /* Make sure to send ping */
+            us_socket_timeout(SSL, s, WEBSOCKET_PING_INTERVAL);
+        }
+    } else {
+        /* Stream whatever is remaining of the request */
+        http_socket->offset += us_socket_write(SSL, s, (char *) web_socket_request + http_socket->offset, sizeof(web_socket_request) - http_socket->offset, 0);
+        if (http_socket->offset == sizeof(web_socket_request)) {
+            /* Reset timeout if we managed to */
+            us_socket_timeout(SSL, s, WEBSOCKET_PING_INTERVAL);
+        }
+    }
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_close(struct us_socket_t *s) {
+
+    closed_connections++;
+    if (closed_connections % 1000 == 0) {
+        printf("Alive: %d, dead: %d\n", opened_connections, closed_connections);
+    }
+
+    return s;
+}
+
+struct us_socket_t *on_http_socket_end(struct us_socket_t *s) {
+    return us_socket_close(SSL, s);
+}
+
+// should never get a response!
+struct us_socket_t *on_http_socket_data(struct us_socket_t *s, char *data, int length) {
+    return s;
+}
+
+struct us_socket_t *on_http_socket_open(struct us_socket_t *s, int is_client, char *ip, int ip_length) {
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+    /* Display number of opened connections */
+    opened_connections++;
+    if (opened_connections % 1000 == 0) {
+        printf("Alive: %d, dead: %d\n", opened_connections, closed_connections);
+    }
+
+    /* Send an upgrade request */
+    http_socket->upgrade_offset = us_socket_write(SSL, s, request, sizeof(request) - 1, 0);
+    if (http_socket->upgrade_offset == sizeof(request) - 1) {
+        next_connection(s);
+
+        /* Make sure to send ping */
+        us_socket_timeout(SSL, s, WEBSOCKET_PING_INTERVAL);
+    }
+
+    return s;
+}
+
+// here we should send a message as ping (part of the test)
+struct us_socket_t *on_http_socket_timeout(struct us_socket_t *s) {
+    struct http_socket *http_socket = (struct http_socket *) us_socket_ext(SSL, s);
+
+    /* Send ping here */
+    http_socket->offset = us_socket_write(SSL, s, (char *) web_socket_request, sizeof(web_socket_request), 0);
+    if (http_socket->offset == sizeof(web_socket_request)) {
+        /* Reset timeout if we managed to */
+        us_socket_timeout(SSL, s, WEBSOCKET_PING_INTERVAL);
+    }
+
+    return s;
+}
+
+int main(int argc, char **argv) {
+
+    /* Parse host and port */
+    if (argc != 5) {
+        printf("Usage: connections host port ssl\n");
+        return 0;
+    }
+
+    port = atoi(argv[3]);
+    host = malloc(strlen(argv[2]) + 1);
+    memcpy(host, argv[2], strlen(argv[2]) + 1);
+    connections = atoi(argv[1]);
+    SSL = atoi(argv[4]);
+
+    /* Create the event loop */
+    struct us_loop_t *loop = us_create_loop(0, on_wakeup, on_pre, on_post, 0);
+
+    /* Create a socket context for HTTP */
+    struct us_socket_context_options_t options = {};
+    struct us_socket_context_t *http_context = us_create_socket_context(SSL, loop, 0, options);
+
+    /* Set up event handlers */
+    us_socket_context_on_open(SSL, http_context, on_http_socket_open);
+    us_socket_context_on_data(SSL, http_context, on_http_socket_data);
+    us_socket_context_on_writable(SSL, http_context, on_http_socket_writable);
+    us_socket_context_on_close(SSL, http_context, on_http_socket_close);
+    us_socket_context_on_timeout(SSL, http_context, on_http_socket_timeout);
+    us_socket_context_on_end(SSL, http_context, on_http_socket_end);
+
+    /* Start making HTTP connections */
+    for (int i = 0; i < BATCH_CONNECT; i++) {
+        us_socket_context_connect(SSL, http_context, host, port, 0, sizeof(struct http_socket));
+    }
+
+    us_loop_run(loop);
+}

test/compatibility/C/uWebSockets/examples/BroadcastingEchoServer.cpp

@@ -0,0 +1,52 @@
+#include "App.h"
+
+struct us_listen_socket_t *listen_socket;
+
+int main() {
+    /* ws->getUserData returns one of these */
+    struct PerSocketData {
+
+    };
+
+    /* Very simple WebSocket broadcasting echo server */
+    uWS::App().ws<PerSocketData>("/*", {
+        /* Settings */
+        .compression = uWS::SHARED_COMPRESSOR,
+        .maxPayloadLength = 16 * 1024 * 1024,
+        .idleTimeout = 10,
+        .maxBackpressure = 1 * 1024 * 1204,
+        /* Handlers */
+        .open = [](auto *ws, auto *req) {
+            /* Let's make every connection subscribe to the "broadcast" topic */
+            ws->subscribe("broadcast");
+        },
+        .message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
+            /* Exit gracefully if we get a closedown message (ASAN debug) */
+            if (message == "closedown") {
+               /* Bye bye */
+               us_listen_socket_close(0, listen_socket);
+               ws->close();
+            }
+
+            /* Simply broadcast every single message we get */
+            ws->publish("broadcast", message, opCode);
+        },
+        .drain = [](auto *ws) {
+            /* Check getBufferedAmount here */
+        },
+        .ping = [](auto *ws) {
+
+        },
+        .pong = [](auto *ws) {
+
+        },
+        .close = [](auto *ws, int code, std::string_view message) {
+            /* We automatically unsubscribe from any topic here */
+        }
+    }).listen(9001, [](auto *token) {
+        listen_socket = token;
+        if (token) {
+            std::cout << "Listening on port " << 9001 << std::endl;
+        }
+    }).run();
+}

test/compatibility/C/uWebSockets/examples/EchoServer.cpp

@@ -0,0 +1,50 @@
+/* We simply call the root header file "App.h", giving you uWS::App and uWS::SSLApp */
+#include "App.h"
+
+/* This is a simple WebSocket echo server example.
+ * You may compile it with "WITH_OPENSSL=1 make" or with "make" */
+
+int main() {
+    /* ws->getUserData returns one of these */
+    struct PerSocketData {
+        /* Fill with user data */
+    };
+
+    /* Keep in mind that uWS::SSLApp({options}) is the same as uWS::App() when compiled without SSL support.
+     * You may swap to using uWS:App() if you don't need SSL */
+    uWS::SSLApp({
+        /* There are example certificates in uWebSockets.js repo */
+	    .key_file_name = "../misc/key.pem",
+	    .cert_file_name = "../misc/cert.pem",
+	    .passphrase = "1234"
+	}).ws<PerSocketData>("/*", {
+        /* Settings */
+        .compression = uWS::SHARED_COMPRESSOR,
+        .maxPayloadLength = 16 * 1024,
+        .idleTimeout = 10,
+        .maxBackpressure = 1 * 1024 * 1204,
+        /* Handlers */
+        .open = [](auto *ws, auto *req) {
+            /* Open event here, you may access ws->getUserData() which points to a PerSocketData struct */
+        },
+        .message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
+            ws->send(message, opCode);
+        },
+        .drain = [](auto *ws) {
+            /* Check ws->getBufferedAmount() here */
+        },
+        .ping = [](auto *ws) {
+            /* Not implemented yet */
+        },
+        .pong = [](auto *ws) {
+            /* Not implemented yet */
+        },
+        .close = [](auto *ws, int code, std::string_view message) {
+            /* You may access ws->getUserData() here */
+        }
+    }).listen(9001, [](auto *token) {
+        if (token) {
+            std::cout << "Listening on port " << 9001 << std::endl;
+        }
+    }).run();
+}

test/compatibility/C/uWebSockets/examples/EchoServerThreaded.cpp

@@ -0,0 +1,57 @@
+#include "App.h"
+#include <thread>
+#include <algorithm>
+
+int main() {
+    /* ws->getUserData returns one of these */
+    struct PerSocketData {
+
+    };
+
+    /* Simple echo websocket server, using multiple threads */
+    std::vector<std::thread *> threads(std::thread::hardware_concurrency());
+
+    std::transform(threads.begin(), threads.end(), threads.begin(), [](std::thread *t) {
+        return new std::thread([]() {
+
+            /* Very simple WebSocket echo server */
+            uWS::App().ws<PerSocketData>("/*", {
+                /* Settings */
+                .compression = uWS::SHARED_COMPRESSOR,
+                .maxPayloadLength = 16 * 1024,
+                .idleTimeout = 10,
+                .maxBackpressure = 1 * 1024 * 1204,
+                /* Handlers */
+                .open = [](auto *ws, auto *req) {
+
+                },
+                .message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
+                    ws->send(message, opCode);
+                },
+                .drain = [](auto *ws) {
+                    /* Check getBufferedAmount here */
+                },
+                .ping = [](auto *ws) {
+
+                },
+                .pong = [](auto *ws) {
+
+                },
+                .close = [](auto *ws, int code, std::string_view message) {
+
+                }
+            }).listen(9001, [](auto *token) {
+                if (token) {
+                    std::cout << "Thread " << std::this_thread::get_id() << " listening on port " << 9001 << std::endl;
+                } else {
+                    std::cout << "Thread " << std::this_thread::get_id() << " failed to listen on port 9001" << std::endl;
+                }
+            }).run();
+
+        });
+    });
+
+    std::for_each(threads.begin(), threads.end(), [](std::thread *t) {
+        t->join();
+    });
+}

test/compatibility/C/uWebSockets/examples/HelloWorld.cpp

@@ -0,0 +1,20 @@
+#include "App.h"
+
+/* Note that uWS::SSLApp({options}) is the same as uWS::App() when compiled without SSL support */
+
+int main() {
+	/* Overly simple hello world app */
+	uWS::SSLApp({
+	  .key_file_name = "../misc/key.pem",
+	  .cert_file_name = "../misc/cert.pem",
+	  .passphrase = "1234"
+	}).get("/*", [](auto *res, auto *req) {
+	    res->end("Hello world!");
+	}).listen(3000, [](auto *token) {
+	    if (token) {
+		std::cout << "Listening on port " << 3000 << std::endl;
+	    }
+	}).run();
+
+	std::cout << "Failed to listen on port 3000" << std::endl;
+}

test/compatibility/C/uWebSockets/examples/HelloWorldThreaded.cpp

@@ -0,0 +1,28 @@
+#include "App.h"
+#include <thread>
+#include <algorithm>
+
+int main() {
+    /* Overly simple hello world app, using multiple threads */
+    std::vector<std::thread *> threads(std::thread::hardware_concurrency());
+
+    std::transform(threads.begin(), threads.end(), threads.begin(), [](std::thread *t) {
+        return new std::thread([]() {
+
+            uWS::App().get("/*", [](auto *res, auto *req) {
+                res->end("Hello world!");
+            }).listen(3000, [](auto *token) {
+                if (token) {
+                    std::cout << "Thread " << std::this_thread::get_id() << " listening on port " << 3000 << std::endl;
+                } else {
+                    std::cout << "Thread " << std::this_thread::get_id() << " failed to listen on port 3000" << std::endl;
+                }
+            }).run();
+
+        });
+    });
+
+    std::for_each(threads.begin(), threads.end(), [](std::thread *t) {
+        t->join();
+    });
+}

test/compatibility/C/uWebSockets/examples/HttpServer.cpp

@@ -0,0 +1,90 @@
+/* This is a simple HTTP(S) web server much like Python's SimpleHTTPServer */
+
+#include <App.h>
+
+/* Helpers for this example */
+#include "helpers/AsyncFileReader.h"
+#include "helpers/AsyncFileStreamer.h"
+#include "helpers/Middleware.h"
+
+/* optparse */
+#define OPTPARSE_IMPLEMENTATION
+#include "helpers/optparse.h"
+
+int main(int argc, char **argv) {
+
+    int option;
+    struct optparse options;
+    optparse_init(&options, argv);
+
+    struct optparse_long longopts[] = {
+        {"port", 'p', OPTPARSE_REQUIRED},
+        {"help", 'h', OPTPARSE_NONE},
+        {"passphrase", 'a', OPTPARSE_REQUIRED},
+        {"key", 'k', OPTPARSE_REQUIRED},
+        {"cert", 'c', OPTPARSE_REQUIRED},
+        {"dh_params", 'd', OPTPARSE_REQUIRED},
+        {0}
+    };
+
+    int port = 3000;
+    struct us_socket_context_options_t ssl_options = {};
+
+    while ((option = optparse_long(&options, longopts, nullptr)) != -1) {
+        switch (option) {
+        case 'p':
+            port = atoi(options.optarg);
+            break;
+        case 'a':
+            ssl_options.passphrase = options.optarg;
+            break;
+        case 'c':
+            ssl_options.cert_file_name = options.optarg;
+            break;
+        case 'k':
+            ssl_options.key_file_name = options.optarg;
+            break;
+        case 'd':
+            ssl_options.dh_params_file_name = options.optarg;
+            break;
+        case 'h':
+        case '?':
+            fail:
+            std::cout << "Usage: " << argv[0] << " [--help] [--port <port>] [--key <ssl key>] [--cert <ssl cert>] [--passphrase <ssl key passphrase>] [--dh_params <ssl dh params file>] <public root>" << std::endl;
+            return 0;
+        }
+    }
+
+    char *root = optparse_arg(&options);
+    if (!root) {
+        goto fail;
+    }
+
+    AsyncFileStreamer asyncFileStreamer(root);
+
+    /* Either serve over HTTP or HTTPS */
+    struct us_socket_context_options_t empty_ssl_options = {};
+    if (memcmp(&ssl_options, &empty_ssl_options, sizeof(empty_ssl_options))) {
+        /* HTTPS */
+        uWS::SSLApp(ssl_options).get("/*", [&asyncFileStreamer](auto *res, auto *req) {
+            serveFile(res, req);
+            asyncFileStreamer.streamFile(res, req->getUrl());
+        }).listen(port, [port, root](auto *token) {
+            if (token) {
+                std::cout << "Serving " << root << " over HTTPS a " << port << std::endl;
+            }
+        }).run();
+    } else {
+        /* HTTP */
+        uWS::App().get("/*", [&asyncFileStreamer](auto *res, auto *req) {
+            serveFile(res, req);
+            asyncFileStreamer.streamFile(res, req->getUrl());
+        }).listen(port, [port, root](auto *token) {
+            if (token) {
+                std::cout << "Serving " << root << " over HTTP a " << port << std::endl;
+            }
+        }).run();
+    }
+
+    std::cout << "Failed to listen to port " << port << std::endl;
+}

test/compatibility/C/uWebSockets/examples/helpers/AsyncFileReader.h

@@ -0,0 +1,130 @@
+#include <map>
+#include <cstring>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <future>
+
+/* This is just a very simple and inefficient demo of async responses,
+ * please do roll your own variant or use a database or Node.js's async
+ * features instead of this really bad demo */
+struct AsyncFileReader {
+private:
+    /* The cache we have in memory for this file */
+    std::string cache;
+    int cacheOffset;
+    bool hasCache;
+
+    /* The pending async file read (yes we only support one pending read) */
+    std::function<void(std::string_view)> pendingReadCb;
+
+    int fileSize;
+    std::string fileName;
+    std::ifstream fin;
+    uWS::Loop *loop;
+
+public:
+    /* Construct a demo async. file reader for fileName */
+    AsyncFileReader(std::string fileName) : fileName(fileName) {
+        fin.open(fileName, std::ios::binary);
+
+        // get fileSize
+        fin.seekg(0, fin.end);
+        fileSize = fin.tellg();
+
+        //std::cout << "File size is: " << fileSize << std::endl;
+
+        // cache up 1 mb!
+        cache.resize(1024 * 1024);
+
+        //std::cout << "Caching 1 MB at offset = " << 0 << std::endl;
+        fin.seekg(0, fin.beg);
+        fin.read(cache.data(), cache.length());
+        cacheOffset = 0;
+        hasCache = true;
+
+        // get loop for thread
+
+        loop = uWS::Loop::get();
+    }
+
+    /* Returns any data already cached for this offset */
+    std::string_view peek(int offset) {
+        /* Did we hit the cache? */
+        if (hasCache && offset >= cacheOffset && ((offset - cacheOffset) < cache.length())) {
+            /* Cache hit */
+            //std::cout << "Cache hit!" << std::endl;
+
+            /*if (fileSize - offset < cache.length()) {
+                std::cout << "LESS THAN WHAT WE HAVE!" << std::endl;
+            }*/
+
+            int chunkSize = std::min<int>(fileSize - offset, cache.length() - offset + cacheOffset);
+
+            return std::string_view(cache.data() + offset - cacheOffset, chunkSize);
+        } else {
+            /* Cache miss */
+            //std::cout << "Cache miss!" << std::endl;
+            return std::string_view(nullptr, 0);
+        }
+    }
+
+    /* Asynchronously request more data at offset */
+    void request(int offset, std::function<void(std::string_view)> cb) {
+
+        // in this case, what do we do?
+        // we need to queue up this chunk request and callback!
+        // if queue is full, either block or close the connection via abort!
+        if (!hasCache) {
+            // already requesting a chunk!
+            std::cout << "ERROR: already requesting a chunk!" << std::endl;
+            return;
+        }
+
+        // disable cache
+        hasCache = false;
+
+        std::async(std::launch::async, [this, cb, offset]() {
+            //std::cout << "ASYNC Caching 1 MB at offset = " << offset << std::endl;
+
+
+
+            // den har stängts! öppna igen!
+            if (!fin.good()) {
+                fin.close();
+                //std::cout << "Reopening fin!" << std::endl;
+                fin.open(fileName, std::ios::binary);
+            }
+            fin.seekg(offset, fin.beg);
+            fin.read(cache.data(), cache.length());
+
+            cacheOffset = offset;
+
+            loop->defer([this, cb, offset]() {
+
+                int chunkSize = std::min<int>(cache.length(), fileSize - offset);
+
+                // båda dessa sker, wtf?
+                if (chunkSize == 0) {
+                    std::cout << "Zero size!?" << std::endl;
+                }
+
+                if (chunkSize != cache.length()) {
+                    std::cout << "LESS THAN A CACHE 1 MB!" << std::endl;
+                }
+
+                hasCache = true;
+                cb(std::string_view(cache.data(), chunkSize));
+            });
+        });
+    }
+
+    /* Abort any pending async. request */
+    void abort() {
+
+    }
+
+    int getFileSize() {
+        return fileSize;
+    }
+};

test/compatibility/C/uWebSockets/examples/helpers/AsyncFileStreamer.h

@@ -0,0 +1,84 @@
+#include <filesystem>
+
+struct AsyncFileStreamer {
+
+    std::map<std::string_view, AsyncFileReader *> asyncFileReaders;
+    std::string root;
+
+    AsyncFileStreamer(std::string root) : root(root) {
+        // for all files in this path, init the map of AsyncFileReaders
+        updateRootCache();
+    }
+
+    void updateRootCache() {
+        // todo: if the root folder changes, we want to reload the cache
+        for(auto &p : std::filesystem::recursive_directory_iterator(root)) {
+            std::string url = p.path().string().substr(root.length());
+            if (url == "/index.html") {
+                url = "/";
+            }
+
+            char *key = new char[url.length()];
+            memcpy(key, url.data(), url.length());
+            asyncFileReaders[std::string_view(key, url.length())] = new AsyncFileReader(p.path().string());
+        }
+    }
+
+    template <bool SSL>
+    void streamFile(uWS::HttpResponse<SSL> *res, std::string_view url) {
+        auto it = asyncFileReaders.find(url);
+        if (it == asyncFileReaders.end()) {
+            std::cout << "Did not find file: " << url << std::endl;
+        } else {
+            streamFile(res, it->second);
+        }
+    }
+
+    template <bool SSL>
+    static void streamFile(uWS::HttpResponse<SSL> *res, AsyncFileReader *asyncFileReader) {
+        /* Peek from cache */
+        std::string_view chunk = asyncFileReader->peek(res->getWriteOffset());
+        if (!chunk.length() || res->tryEnd(chunk, asyncFileReader->getFileSize()).first) {
+            /* Request new chunk */
+            // todo: we need to abort this callback if peer closed!
+            // this also means Loop::defer needs to support aborting (functions should embedd an atomic boolean abort or something)
+
+            // Loop::defer(f) -> integer
+            // Loop::abort(integer)
+
+            // hmm? no?
+
+            // us_socket_up_ref eftersom vi delar ägandeskapet
+
+            if (chunk.length() < asyncFileReader->getFileSize()) {
+                asyncFileReader->request(res->getWriteOffset(), [res, asyncFileReader](std::string_view chunk) {
+                    // check if we were closed in the mean time
+                    //if (us_socket_is_closed()) {
+                        // free it here
+                        //return;
+                    //}
+
+                    /* We were aborted for some reason */
+                    if (!chunk.length()) {
+                        // todo: make sure to check for is_closed internally after all callbacks!
+                        res->close();
+                    } else {
+                        AsyncFileStreamer::streamFile(res, asyncFileReader);
+                    }
+                });
+            }
+        } else {
+            /* We failed writing everything, so let's continue when we can */
+            res->onWritable([res, asyncFileReader](int offset) {
+
+                // här kan skiten avbrytas!
+
+                AsyncFileStreamer::streamFile(res, asyncFileReader);
+                // todo: I don't really know what this is supposed to mean?
+                return false;
+            })->onAborted([]() {
+                std::cout << "ABORTED!" << std::endl;
+            });
+        }
+    }
+};

test/compatibility/C/uWebSockets/examples/helpers/Middleware.h

@@ -0,0 +1,19 @@
+/* Middleware to fill out content-type */
+inline bool hasExt(std::string_view file, std::string_view ext) {
+    if (ext.size() > file.size()) {
+        return false;
+    }
+    return std::equal(ext.rbegin(), ext.rend(), file.rbegin());
+}
+
+/* This should be a filter / middleware like app.use(handler) */
+template <bool SSL>
+uWS::HttpResponse<SSL> *serveFile(uWS::HttpResponse<SSL> *res, uWS::HttpRequest *req) {
+    res->writeStatus(uWS::HTTP_200_OK);
+
+    if (hasExt(req->getUrl(), ".svg")) {
+        res->writeHeader("Content-Type", "image/svg+xml");
+    }
+
+    return res;
+}

test/compatibility/C/uWebSockets/examples/helpers/optparse.h

@@ -0,0 +1,407 @@
+/* Nicked from third-party https://github.com/skeeto/optparse 2018-09-24 */
+/* µWebSockets is not the origin of this software file */
+/* ------------------------------------------------------ */
+
+/* Optparse --- portable, reentrant, embeddable, getopt-like option parser
+ *
+ * This is free and unencumbered software released into the public domain.
+ *
+ * To get the implementation, define OPTPARSE_IMPLEMENTATION.
+ * Optionally define OPTPARSE_API to control the API's visibility
+ * and/or linkage (static, __attribute__, __declspec).
+ *
+ * The POSIX getopt() option parser has three fatal flaws. These flaws
+ * are solved by Optparse.
+ *
+ * 1) Parser state is stored entirely in global variables, some of
+ * which are static and inaccessible. This means only one thread can
+ * use getopt(). It also means it's not possible to recursively parse
+ * nested sub-arguments while in the middle of argument parsing.
+ * Optparse fixes this by storing all state on a local struct.
+ *
+ * 2) The POSIX standard provides no way to properly reset the parser.
+ * This means for portable code that getopt() is only good for one
+ * run, over one argv with one option string. It also means subcommand
+ * options cannot be processed with getopt(). Most implementations
+ * provide a method to reset the parser, but it's not portable.
+ * Optparse provides an optparse_arg() function for stepping over
+ * subcommands and continuing parsing of options with another option
+ * string. The Optparse struct itself can be passed around to
+ * subcommand handlers for additional subcommand option parsing. A
+ * full reset can be achieved by with an additional optparse_init().
+ *
+ * 3) Error messages are printed to stderr. This can be disabled with
+ * opterr, but the messages themselves are still inaccessible.
+ * Optparse solves this by writing an error message in its errmsg
+ * field. The downside to Optparse is that this error message will
+ * always be in English rather than the current locale.
+ *
+ * Optparse should be familiar with anyone accustomed to getopt(), and
+ * it could be a nearly drop-in replacement. The option string is the
+ * same and the fields have the same names as the getopt() global
+ * variables (optarg, optind, optopt).
+ *
+ * Optparse also supports GNU-style long options with optparse_long().
+ * The interface is slightly different and simpler than getopt_long().
+ *
+ * By default, argv is permuted as it is parsed, moving non-option
+ * arguments to the end. This can be disabled by setting the `permute`
+ * field to 0 after initialization.
+ */
+#ifndef OPTPARSE_H
+#define OPTPARSE_H
+
+#ifndef OPTPARSE_API
+#  define OPTPARSE_API
+#endif
+
+struct optparse {
+    char **argv;
+    int permute;
+    int optind;
+    int optopt;
+    char *optarg;
+    char errmsg[64];
+    int subopt;
+};
+
+enum optparse_argtype {
+    OPTPARSE_NONE,
+    OPTPARSE_REQUIRED,
+    OPTPARSE_OPTIONAL
+};
+
+struct optparse_long {
+    const char *longname;
+    int shortname;
+    enum optparse_argtype argtype;
+};
+
+/**
+ * Initializes the parser state.
+ */
+OPTPARSE_API
+void optparse_init(struct optparse *options, char **argv);
+
+/**
+ * Read the next option in the argv array.
+ * @param optstring a getopt()-formatted option string.
+ * @return the next option character, -1 for done, or '?' for error
+ *
+ * Just like getopt(), a character followed by no colons means no
+ * argument. One colon means the option has a required argument. Two
+ * colons means the option takes an optional argument.
+ */
+OPTPARSE_API
+int optparse(struct optparse *options, const char *optstring);
+
+/**
+ * Handles GNU-style long options in addition to getopt() options.
+ * This works a lot like GNU's getopt_long(). The last option in
+ * longopts must be all zeros, marking the end of the array. The
+ * longindex argument may be NULL.
+ */
+OPTPARSE_API
+int optparse_long(struct optparse *options,
+                  const struct optparse_long *longopts,
+                  int *longindex);
+
+/**
+ * Used for stepping over non-option arguments.
+ * @return the next non-option argument, or NULL for no more arguments
+ *
+ * Argument parsing can continue with optparse() after using this
+ * function. That would be used to parse the options for the
+ * subcommand returned by optparse_arg(). This function allows you to
+ * ignore the value of optind.
+ */
+OPTPARSE_API
+char *optparse_arg(struct optparse *options);
+
+/* Implementation */
+#ifdef OPTPARSE_IMPLEMENTATION
+
+#define OPTPARSE_MSG_INVALID "invalid option"
+#define OPTPARSE_MSG_MISSING "option requires an argument"
+#define OPTPARSE_MSG_TOOMANY "option takes no arguments"
+
+static int
+optparse_error(struct optparse *options, const char *msg, const char *data)
+{
+    unsigned p = 0;
+    const char *sep = " -- '";
+    while (*msg)
+        options->errmsg[p++] = *msg++;
+    while (*sep)
+        options->errmsg[p++] = *sep++;
+    while (p < sizeof(options->errmsg) - 2 && *data)
+        options->errmsg[p++] = *data++;
+    options->errmsg[p++] = '\'';
+    options->errmsg[p++] = '\0';
+    return '?';
+}
+
+OPTPARSE_API
+void
+optparse_init(struct optparse *options, char **argv)
+{
+    options->argv = argv;
+    options->permute = 1;
+    options->optind = 1;
+    options->subopt = 0;
+    options->optarg = 0;
+    options->errmsg[0] = '\0';
+}
+
+static int
+optparse_is_dashdash(const char *arg)
+{
+    return arg != 0 && arg[0] == '-' && arg[1] == '-' && arg[2] == '\0';
+}
+
+static int
+optparse_is_shortopt(const char *arg)
+{
+    return arg != 0 && arg[0] == '-' && arg[1] != '-' && arg[1] != '\0';
+}
+
+static int
+optparse_is_longopt(const char *arg)
+{
+    return arg != 0 && arg[0] == '-' && arg[1] == '-' && arg[2] != '\0';
+}
+
+static void
+optparse_permute(struct optparse *options, int index)
+{
+    char *nonoption = options->argv[index];
+    int i;
+    for (i = index; i < options->optind - 1; i++)
+        options->argv[i] = options->argv[i + 1];
+    options->argv[options->optind - 1] = nonoption;
+}
+
+static int
+optparse_argtype(const char *optstring, char c)
+{
+    int count = OPTPARSE_NONE;
+    if (c == ':')
+        return -1;
+    for (; *optstring && c != *optstring; optstring++);
+    if (!*optstring)
+        return -1;
+    if (optstring[1] == ':')
+        count += optstring[2] == ':' ? 2 : 1;
+    return count;
+}
+
+OPTPARSE_API
+int
+optparse(struct optparse *options, const char *optstring)
+{
+    int type;
+    char *next;
+    char *option = options->argv[options->optind];
+    options->errmsg[0] = '\0';
+    options->optopt = 0;
+    options->optarg = 0;
+    if (option == 0) {
+        return -1;
+    } else if (optparse_is_dashdash(option)) {
+        options->optind++; /* consume "--" */
+        return -1;
+    } else if (!optparse_is_shortopt(option)) {
+        if (options->permute) {
+            int index = options->optind++;
+            int r = optparse(options, optstring);
+            optparse_permute(options, index);
+            options->optind--;
+            return r;
+        } else {
+            return -1;
+        }
+    }
+    option += options->subopt + 1;
+    options->optopt = option[0];
+    type = optparse_argtype(optstring, option[0]);
+    next = options->argv[options->optind + 1];
+    switch (type) {
+    case -1: {
+        char str[2] = {0, 0};
+        str[0] = option[0];
+        options->optind++;
+        return optparse_error(options, OPTPARSE_MSG_INVALID, str);
+    }
+    case OPTPARSE_NONE:
+        if (option[1]) {
+            options->subopt++;
+        } else {
+            options->subopt = 0;
+            options->optind++;
+        }
+        return option[0];
+    case OPTPARSE_REQUIRED:
+        options->subopt = 0;
+        options->optind++;
+        if (option[1]) {
+            options->optarg = option + 1;
+        } else if (next != 0) {
+            options->optarg = next;
+            options->optind++;
+        } else {
+            char str[2] = {0, 0};
+            str[0] = option[0];
+            options->optarg = 0;
+            return optparse_error(options, OPTPARSE_MSG_MISSING, str);
+        }
+        return option[0];
+    case OPTPARSE_OPTIONAL:
+        options->subopt = 0;
+        options->optind++;
+        if (option[1])
+            options->optarg = option + 1;
+        else
+            options->optarg = 0;
+        return option[0];
+    }
+    return 0;
+}
+
+OPTPARSE_API
+char *
+optparse_arg(struct optparse *options)
+{
+    char *option = options->argv[options->optind];
+    options->subopt = 0;
+    if (option != 0)
+        options->optind++;
+    return option;
+}
+
+static int
+optparse_longopts_end(const struct optparse_long *longopts, int i)
+{
+    return !longopts[i].longname && !longopts[i].shortname;
+}
+
+static void
+optparse_from_long(const struct optparse_long *longopts, char *optstring)
+{
+    char *p = optstring;
+    int i;
+    for (i = 0; !optparse_longopts_end(longopts, i); i++) {
+        if (longopts[i].shortname) {
+            int a;
+            *p++ = longopts[i].shortname;
+            for (a = 0; a < (int)longopts[i].argtype; a++)
+                *p++ = ':';
+        }
+    }
+    *p = '\0';
+}
+
+/* Unlike strcmp(), handles options containing "=". */
+static int
+optparse_longopts_match(const char *longname, const char *option)
+{
+    const char *a = option, *n = longname;
+    if (longname == 0)
+        return 0;
+    for (; *a && *n && *a != '='; a++, n++)
+        if (*a != *n)
+            return 0;
+    return *n == '\0' && (*a == '\0' || *a == '=');
+}
+
+/* Return the part after "=", or NULL. */
+static char *
+optparse_longopts_arg(char *option)
+{
+    for (; *option && *option != '='; option++);
+    if (*option == '=')
+        return option + 1;
+    else
+        return 0;
+}
+
+static int
+optparse_long_fallback(struct optparse *options,
+                       const struct optparse_long *longopts,
+                       int *longindex)
+{
+    int result;
+    char optstring[96 * 3 + 1]; /* 96 ASCII printable characters */
+    optparse_from_long(longopts, optstring);
+    result = optparse(options, optstring);
+    if (longindex != 0) {
+        *longindex = -1;
+        if (result != -1) {
+            int i;
+            for (i = 0; !optparse_longopts_end(longopts, i); i++)
+                if (longopts[i].shortname == options->optopt)
+                    *longindex = i;
+        }
+    }
+    return result;
+}
+
+OPTPARSE_API
+int
+optparse_long(struct optparse *options,
+              const struct optparse_long *longopts,
+              int *longindex)
+{
+    int i;
+    char *option = options->argv[options->optind];
+    if (option == 0) {
+        return -1;
+    } else if (optparse_is_dashdash(option)) {
+        options->optind++; /* consume "--" */
+        return -1;
+    } else if (optparse_is_shortopt(option)) {
+        return optparse_long_fallback(options, longopts, longindex);
+    } else if (!optparse_is_longopt(option)) {
+        if (options->permute) {
+            int index = options->optind++;
+            int r = optparse_long(options, longopts, longindex);
+            optparse_permute(options, index);
+            options->optind--;
+            return r;
+        } else {
+            return -1;
+        }
+    }
+
+    /* Parse as long option. */
+    options->errmsg[0] = '\0';
+    options->optopt = 0;
+    options->optarg = 0;
+    option += 2; /* skip "--" */
+    options->optind++;
+    for (i = 0; !optparse_longopts_end(longopts, i); i++) {
+        const char *name = longopts[i].longname;
+        if (optparse_longopts_match(name, option)) {
+            char *arg;
+            if (longindex)
+                *longindex = i;
+            options->optopt = longopts[i].shortname;
+            arg = optparse_longopts_arg(option);
+            if (longopts[i].argtype == OPTPARSE_NONE && arg != 0) {
+                return optparse_error(options, OPTPARSE_MSG_TOOMANY, name);
+            } if (arg != 0) {
+                options->optarg = arg;
+            } else if (longopts[i].argtype == OPTPARSE_REQUIRED) {
+                options->optarg = options->argv[options->optind];
+                if (options->optarg == 0)
+                    return optparse_error(options, OPTPARSE_MSG_MISSING, name);
+                else
+                    options->optind++;
+            }
+            return options->optopt;
+        }
+    }
+    return optparse_error(options, OPTPARSE_MSG_INVALID, option);
+}
+
+#endif /* OPTPARSE_IMPLEMENTATION */
+#endif /* OPTPARSE_H */

test/compatibility/C/uWebSockets/fuzzing/Extensions.cpp

@@ -0,0 +1,39 @@
+/* This is a fuzz test of the websocket extensions parser */
+
+#define WIN32_EXPORT
+
+#include <cstdio>
+#include <string>
+
+/* We test the websocket extensions parser */
+#include "../src/WebSocketExtensions.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+
+    {
+        uWS::ExtensionsNegotiator<true> extensionsNegotiator(uWS::Options::PERMESSAGE_DEFLATE);
+        extensionsNegotiator.readOffer({(char *) data, size});
+
+        extensionsNegotiator.generateOffer();
+        extensionsNegotiator.getNegotiatedOptions();
+    }
+
+    {
+        uWS::ExtensionsNegotiator<true> extensionsNegotiator(uWS::Options::NO_OPTIONS);
+        extensionsNegotiator.readOffer({(char *) data, size});
+
+        extensionsNegotiator.generateOffer();
+        extensionsNegotiator.getNegotiatedOptions();
+    }
+
+    {
+        uWS::ExtensionsNegotiator<true> extensionsNegotiator(uWS::Options::CLIENT_NO_CONTEXT_TAKEOVER);
+        extensionsNegotiator.readOffer({(char *) data, size});
+
+        extensionsNegotiator.generateOffer();
+        extensionsNegotiator.getNegotiatedOptions();
+    }
+
+    return 0;
+}
+

test/compatibility/C/uWebSockets/fuzzing/Handshake.cpp

@@ -0,0 +1,20 @@
+/* This is a fuzz test of the websocket handshake generator */
+
+#define WIN32_EXPORT
+
+#include <cstdio>
+#include <string>
+
+/* We test the websocket handshake generator */
+#include "../src/WebSocketHandshake.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+
+    char output[28];
+    if (size >= 24) {
+        uWS::WebSocketHandshake::generate((char *) data, output);
+    }
+
+    return 0;
+}
+

test/compatibility/C/uWebSockets/fuzzing/Http.cpp

@@ -0,0 +1,124 @@
+/* This is a fuzz test of the http parser */
+
+#define WIN32_EXPORT
+
+#include "helpers.h"
+
+/* We test the websocket parser */
+#include "../src/HttpParser.h"
+
+/* And the router */
+#include "../src/HttpRouter.h"
+
+struct StaticData {
+
+    struct RouterData {
+
+    };
+
+    uWS::HttpRouter<RouterData> router;
+
+    StaticData() {
+
+        router.add({"get"}, "/:hello/:hi", [](auto *h) mutable {
+            auto [paramsTop, params] = h->getParameters();
+
+            /* Something is horribly wrong */
+            if (paramsTop != 1 || !params[0].length() || !params[1].length()) {
+                exit(-1);
+            }
+
+            /* This route did handle it */
+            return true;
+        });
+
+        router.add({"post"}, "/:hello/:hi/*", [](auto *h) mutable {
+            auto [paramsTop, params] = h->getParameters();
+
+            /* Something is horribly wrong */
+            if (paramsTop != 1 || !params[0].length() || !params[1].length()) {
+                exit(-1);
+            }
+
+            /* This route did handle it */
+            return true;
+        });
+
+        router.add({"get"}, "/*", [](auto *h) mutable {
+            auto [paramsTop, params] = h->getParameters();
+
+            /* Something is horribly wrong */
+            if (paramsTop != -1) {
+                exit(-1);
+            }
+
+            /* This route did not handle it */
+            return false;
+        });
+
+        router.add({"get"}, "/hi", [](auto *h) mutable {
+            auto [paramsTop, params] = h->getParameters();
+
+            /* Something is horribly wrong */
+            if (paramsTop != -1) {
+                exit(-1);
+            }
+
+            /* This route did handle it */
+            return true;
+        });
+    }
+} staticData;
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+    /* Create parser */
+    uWS::HttpParser httpParser;
+    /* User data */
+    void *user = (void *) 13;
+
+    /* Iterate the padded fuzz as chunks */
+    makeChunked(makePadded(data, size), size, [&httpParser, user](const uint8_t *data, size_t size) {
+        /* We need at least 1 byte post padding */
+        if (size) {
+            size--;
+        } else {
+            /* We might be given zero length chunks */
+            return;
+        }
+        
+        /* Parse it */
+        httpParser.consumePostPadded((char *) data, size, user, [](void *s, uWS::HttpRequest *httpRequest) -> void * {
+
+            readBytes(httpRequest->getHeader(httpRequest->getUrl()));
+            readBytes(httpRequest->getMethod());
+            readBytes(httpRequest->getQuery());
+
+            /* Route the method and URL in two passes */
+            staticData.router.getUserData() = {};
+            if (!staticData.router.route(httpRequest->getMethod(), httpRequest->getUrl())) {
+                /* It was not handled */
+                return nullptr;
+            }
+
+            for (auto p : *httpRequest) {
+
+            }
+
+            /* Return ok */
+            return s;
+
+        }, [](void *user, std::string_view data, bool fin) -> void * {
+
+            /* Return ok */
+            return user;
+
+        }, [](void *user) {
+
+            /* Return break */
+            return nullptr;
+        });
+    });
+
+    return 0;
+}
+

test/compatibility/C/uWebSockets/fuzzing/Makefile

@@ -0,0 +1,21 @@
+# You can select which sanitizer to use by setting this
+SANITIZER ?= address
+# These are set by OSS-Fuzz, we default to AddressSanitizer
+CXXFLAGS ?= -DLIBUS_NO_SSL -fsanitize=$(SANITIZER),fuzzer
+CFLAGS ?= -DLIBUS_NO_SSL
+OUT ?= .
+
+oss-fuzz:
+# "Unit tests"
+	$(CXX) $(CXXFLAGS) -std=c++17 -O3 WebSocket.cpp -o $(OUT)/WebSocket $(LIB_FUZZING_ENGINE)
+	$(CXX) $(CXXFLAGS) -std=c++17 -O3 Http.cpp -o $(OUT)/Http $(LIB_FUZZING_ENGINE)
+	$(CXX) $(CXXFLAGS) -std=c++17 -O3 PerMessageDeflate.cpp -o $(OUT)/PerMessageDeflate $(LIB_FUZZING_ENGINE) -lz
+# "Integration tests"
+	$(CC) $(CFLAGS) -DLIBUS_NO_SSL -c -O3 uSocketsMock.c
+	$(CXX) $(CXXFLAGS) -std=c++17 -O3 -DLIBUS_NO_SSL -I../src -I../uSockets/src MockedHelloWorld.cpp uSocketsMock.o -lz -o $(OUT)/MockedHelloWorld $(LIB_FUZZING_ENGINE)
+	$(CXX) $(CXXFLAGS) -std=c++17 -O3 -DLIBUS_NO_SSL -I../src -I../uSockets/src MockedEchoServer.cpp uSocketsMock.o -lz -o $(OUT)/MockedEchoServer $(LIB_FUZZING_ENGINE)
+
+broken:
+# Too small tests, failing coverage test
+	$(CXX) $(CXXFLAGS) -std=c++17 -O3 Extensions.cpp -o $(OUT)/Extensions $(LIB_FUZZING_ENGINE)
+	$(CXX) $(CXXFLAGS) -std=c++17 -O3 Handshake.cpp -o $(OUT)/Handshake $(LIB_FUZZING_ENGINE)

test/compatibility/C/uWebSockets/fuzzing/MockedEchoServer.cpp

@@ -0,0 +1,75 @@
+#include "App.h"
+
+#include "helpers.h"
+
+/* This function pushes data to the uSockets mock */
+extern "C" void us_loop_read_mocked_data(struct us_loop *loop, char *data, unsigned int size);
+
+uWS::TemplatedApp<false> *app;
+us_listen_socket_t *listenSocket;
+
+extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
+
+    /* ws->getUserData returns one of these */
+    struct PerSocketData {
+        int nothing;
+    };
+
+    /* Very simple WebSocket echo server */
+    app = new uWS::TemplatedApp<false>(uWS::App().ws<PerSocketData>("/*", {
+        /* Settings */
+        .compression = uWS::SHARED_COMPRESSOR,
+        /* We want this to be low so that we can hit it, yet bigger than 256 */
+        .maxPayloadLength = 300,
+        .idleTimeout = 10,
+        /* Handlers */
+        .open = [](auto *ws, auto *req) {
+            if (req->getHeader("close_me").length()) {
+                ws->close();
+            } else if (req->getHeader("end_me").length()) {
+                ws->end(1006);
+            }
+        },
+        .message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
+            if (message.length() > 300) {
+                /* Inform the sanitizer of the fault */
+                fprintf(stderr, "Too long message passed\n");
+                free((void *) -1);
+            }
+
+            if (message.length() && message[0] == 'C') {
+                ws->close();
+            } else if (message.length() && message[0] == 'E') {
+                ws->end(1006);
+            } else {
+                ws->send(message, opCode, true);
+            }
+        },
+        .drain = [](auto *ws) {
+            /* Check getBufferedAmount here */
+        },
+        .ping = [](auto *ws) {
+
+        },
+        .pong = [](auto *ws) {
+
+        },
+        .close = [](auto *ws, int code, std::string_view message) {
+
+        }
+    }).listen(9001, [](us_listen_socket_t *listenSocket) {
+        if (listenSocket) {
+            std::cout << "Listening on port " << 9001 << std::endl;
+            ::listenSocket = listenSocket;
+        }
+    }));
+
+    return 0;
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+
+    us_loop_read_mocked_data((struct us_loop *) uWS::Loop::get(), (char *) makePadded(data, size), size);
+
+    return 0;
+}

test/compatibility/C/uWebSockets/fuzzing/MockedHelloWorld.cpp

@@ -0,0 +1,47 @@
+#include "App.h"
+
+#include "helpers.h"
+
+/* This function pushes data to the uSockets mock */
+extern "C" void us_loop_read_mocked_data(struct us_loop *loop, char *data, unsigned int size);
+
+uWS::TemplatedApp<false> *app;
+us_listen_socket_t *listenSocket;
+
+extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
+
+    app = new uWS::TemplatedApp<false>(uWS::App().get("/*", [](auto *res, auto *req) {
+        if (req->getHeader("use_write").length()) {
+            res->writeStatus("200 OK")->writeHeader("write", "true")->write("Hello");
+            res->write(" world!");
+            res->end();
+        } else if (req->getQuery().length()) {
+            res->close();
+        } else {
+            res->end("Hello world!");
+        }
+    })/*.post("/*", [](auto *res, auto *req) {
+        res->onAborted([]() {
+
+        });
+        res->onData([res](std::string_view chunk, bool isEnd) {
+            if (isEnd) {
+                res->end(chunk);
+            }
+        });
+    })*/.listen(9001, [](us_listen_socket_t *listenSocket) {
+        if (listenSocket) {
+            std::cout << "Listening on port " << 9001 << std::endl;
+            ::listenSocket = listenSocket;
+        }
+    }));
+
+    return 0;
+}
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+
+    us_loop_read_mocked_data((struct us_loop *) uWS::Loop::get(), (char *) makePadded(data, size), size);
+
+    return 0;
+}

test/compatibility/C/uWebSockets/fuzzing/PerMessageDeflate.cpp

@@ -0,0 +1,38 @@
+/* This is a fuzz test of the permessage-deflate module */
+
+#define WIN32_EXPORT
+
+#include <cstdio>
+#include <string>
+
+/* We test the permessage deflate module */
+#include "../src/PerMessageDeflate.h"
+
+#include "helpers.h"
+
+struct StaticData {
+    uWS::ZlibContext zlibContext;
+
+    uWS::InflationStream inflationStream;
+    uWS::DeflationStream deflationStream;
+} staticData;
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+
+    /* Why is this padded? */
+    makeChunked(makePadded(data, size), size, [](const uint8_t *data, size_t size) {
+        std::string_view inflation = staticData.inflationStream.inflate(&staticData.zlibContext, std::string_view((char *) data, size), 256);
+        if (inflation.length() > 256) {
+            /* Cause ASAN to freak out */
+            delete (int *) (void *) 1;
+        }
+    });
+
+    makeChunked(makePadded(data, size), size, [](const uint8_t *data, size_t size) {
+        /* Always reset */
+        staticData.deflationStream.deflate(&staticData.zlibContext, std::string_view((char *) data, size), true);
+    });
+
+    return 0;
+}
+

test/compatibility/C/uWebSockets/fuzzing/README.md

@@ -0,0 +1,29 @@
+# Fuzz-testing of various parsers and mocked examples
+
+A secure web server must be capable of receiving mass amount of malicious input without misbehaving or performing illegal actions, such as stepping outside of a memory block or otherwise spilling the beans.
+
+### Continuous fuzzing under various sanitizers is done as part of the [Google OSS-Fuzz](https://github.com/google/oss-fuzz#oss-fuzz---continuous-fuzzing-for-open-source-software) project:
+* UndefinedBehaviorSanitizer
+* AddressSanitizer
+* MemorySanitizer
+
+### Currently the following parts are individually fuzzed:
+
+* WebSocket handshake generator
+* WebSocket message parser
+* WebSocket extensions parser & negotiator
+* WebSocket permessage-deflate compression/inflation helper
+* Http parser
+* Http method/url router
+
+### While entire (mocked) examples are fuzzed:
+
+* HelloWorld
+* EchoServer
+
+No defects or issues are left unfixed, covered up or otherwise neglected. In fact we **cannot** cover up security issues as OSS-Fuzz automatically and publicly reports security issues as they happen.
+
+Currently we are at ~80% total fuzz coverage and OSS-Fuzz is reporting **zero** issues whatsoever. The goal is to approach 90% total coverage.
+
+### Security awards
+Google have sent us thousands of USD for the integration with OSS-Fuzz - we continue working on bettering the testing with every new release.

test/compatibility/C/uWebSockets/fuzzing/WebSocket.cpp

@@ -0,0 +1,59 @@
+/* This is a fuzz test of the websocket parser */
+
+#define WIN32_EXPORT
+
+#include "helpers.h"
+
+/* We test the websocket parser */
+#include "../src/WebSocketProtocol.h"
+
+struct Impl {
+    static bool refusePayloadLength(uint64_t length, uWS::WebSocketState<true> *wState, void *s) {
+
+        /* We need a limit */
+        if (length > 16000) {
+            return true;
+        }
+
+        /* Return ok */
+        return false;
+    }
+
+    static bool setCompressed(uWS::WebSocketState<true> *wState, void *s) {
+        /* We support it */
+        return true;
+    }
+
+    static void forceClose(uWS::WebSocketState<true> *wState, void *s) {
+
+    }
+
+    static bool handleFragment(char *data, size_t length, unsigned int remainingBytes, int opCode, bool fin, uWS::WebSocketState<true> *webSocketState, void *s) {
+
+        if (opCode == uWS::TEXT) {
+            if (!uWS::protocol::isValidUtf8((unsigned char *)data, length)) {
+                /* Return break */
+                return true;
+            }
+        } else if (opCode == uWS::CLOSE) {
+            uWS::protocol::parseClosePayload((char *)data, length);
+        }
+
+        /* Return ok */
+        return false;
+    }
+};
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+
+    /* Create the parser state */
+    uWS::WebSocketState<true> state;
+
+    makeChunked(makePadded(data, size), size, [&state](const uint8_t *data, size_t size) {
+        /* Parse it */
+        uWS::WebSocketProtocol<true, Impl>::consume((char *) data, size, &state, nullptr);
+    });
+
+    return 0;
+}
+

test/compatibility/C/uWebSockets/fuzzing/helpers.h

@@ -0,0 +1,51 @@
+#ifndef HELPERS_H
+#define HELPERS_H
+
+/* Common helpers for fuzzing */
+
+#include <functional>
+#include <string_view>
+#include <cstring>
+
+/* We use this to pad the fuzz */
+static inline const uint8_t *makePadded(const uint8_t *data, size_t size) {
+    static int paddedLength = 512 * 1024;
+    static char *padded = new char[128 + paddedLength + 128];
+
+    /* Increase landing area if required */
+    if (paddedLength < size) {
+        delete [] padded;
+        paddedLength = size;
+        padded = new char [128 + paddedLength + 128];
+    }
+
+    memcpy(padded + 128, data, size);
+
+    return (uint8_t *) padded + 128;
+}
+
+/* Splits the fuzz data in one or many chunks */
+static inline void makeChunked(const uint8_t *data, size_t size, std::function<void(const uint8_t *data, size_t size)> cb) {
+    /* First byte determines chunk size; 0 is all that remains, 1-255 is small chunk */
+    for (int i = 0; i < size; ) {
+        unsigned int chunkSize = data[i++];
+        if (!chunkSize) {
+            chunkSize = size - i;
+        } else {
+            chunkSize = std::min<int>(chunkSize, size - i);
+        }
+
+        cb(data + i, chunkSize);
+        i += chunkSize;
+    }
+}
+
+/* Reads all bytes to trigger invalid reads */
+static inline void readBytes(std::string_view s) {
+    volatile int sum = 0;
+    for (int i = 0; i < s.size(); i++) {
+        sum += s[i];
+    }
+}
+
+#endif

test/compatibility/C/uWebSockets/fuzzing/uSocketsMock.c

@@ -0,0 +1,285 @@
+/* uSockets is entierly opaque so we can use the real header straight up */
+#include "../uSockets/src/libusockets.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdalign.h>
+#include <string.h>
+
+struct us_loop_t {
+
+    /* We only support one listen socket */
+    alignas(16) struct us_listen_socket_t *listen_socket;
+
+    /* The list of closed sockets */
+    struct us_socket_t *close_list;
+};
+
+struct us_loop_t *us_create_loop(void *hint, void (*wakeup_cb)(struct us_loop_t *loop), void (*pre_cb)(struct us_loop_t *loop), void (*post_cb)(struct us_loop_t *loop), unsigned int ext_size) {
+    struct us_loop_t *loop = (struct us_loop_t *) malloc(sizeof(struct us_loop_t) + ext_size);
+
+    loop->listen_socket = 0;
+    loop->close_list = 0;
+
+    return loop;
+}
+
+void us_loop_free(struct us_loop_t *loop) {
+    free(loop);
+}
+
+void *us_loop_ext(struct us_loop_t *loop) {
+    return loop + 1;
+}
+
+void us_loop_run(struct us_loop_t *loop) {
+
+}
+
+struct us_socket_context_t {
+    alignas(16) struct us_loop_t *loop;
+
+    struct us_socket_t *(*on_open)(struct us_socket_t *s, int is_client, char *ip, int ip_length);
+    struct us_socket_t *(*on_close)(struct us_socket_t *s);
+    struct us_socket_t *(*on_data)(struct us_socket_t *s, char *data, int length);
+    struct us_socket_t *(*on_writable)(struct us_socket_t *s);
+    struct us_socket_t *(*on_timeout)(struct us_socket_t *s);
+    struct us_socket_t *(*on_end)(struct us_socket_t *s);
+};
+
+struct us_socket_context_t *us_create_socket_context(int ssl, struct us_loop_t *loop, int ext_size, struct us_socket_context_options_t options) {
+    struct us_socket_context_t *socket_context = (struct us_socket_context_t *) malloc(sizeof(struct us_socket_context_t) + ext_size);
+
+    socket_context->loop = loop;
+
+    //printf("us_create_socket_context: %p\n", socket_context);
+
+    return socket_context;
+}
+
+void us_socket_context_free(int ssl, struct us_socket_context_t *context) {
+    //printf("us_socket_context_free: %p\n", context);
+    free(context);
+}
+
+void us_socket_context_on_open(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_open)(struct us_socket_t *s, int is_client, char *ip, int ip_length)) {
+    context->on_open = on_open;
+}
+
+void us_socket_context_on_close(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_close)(struct us_socket_t *s)) {
+    context->on_close = on_close;
+}
+
+void us_socket_context_on_data(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_data)(struct us_socket_t *s, char *data, int length)) {
+    context->on_data = on_data;
+}
+
+void us_socket_context_on_writable(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_writable)(struct us_socket_t *s)) {
+    context->on_writable = on_writable;
+}
+
+void us_socket_context_on_timeout(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_timeout)(struct us_socket_t *s)) {
+    context->on_timeout = on_timeout;
+}
+
+void us_socket_context_on_end(int ssl, struct us_socket_context_t *context, struct us_socket_t *(*on_end)(struct us_socket_t *s)) {
+    context->on_end = on_end;
+}
+
+void *us_socket_context_ext(int ssl, struct us_socket_context_t *context) {
+    return context + 1;
+}
+
+struct us_listen_socket_t {
+    int socket_ext_size;
+    struct us_socket_context_t *context;
+};
+
+struct us_listen_socket_t *us_socket_context_listen(int ssl, struct us_socket_context_t *context, const char *host, int port, int options, int socket_ext_size) {
+    struct us_listen_socket_t *listen_socket = (struct us_listen_socket_t *) malloc(sizeof(struct us_listen_socket_t));
+
+    listen_socket->socket_ext_size = socket_ext_size;
+    listen_socket->context = context;
+
+    context->loop->listen_socket = listen_socket;
+
+    return listen_socket;
+}
+
+void us_listen_socket_close(int ssl, struct us_listen_socket_t *ls) {
+    free(ls);
+}
+
+struct us_socket_t {
+    alignas(16) struct us_socket_context_t *context;
+
+    int closed;
+    int shutdown;
+    int wants_writable;
+
+    //struct us_socket_t *next;
+};
+
+struct us_socket_t *us_socket_context_connect(int ssl, struct us_socket_context_t *context, const char *host, int port, int options, int socket_ext_size) {
+    //printf("us_socket_context_connect\n");
+
+    return 0;
+}
+
+struct us_loop_t *us_socket_context_loop(int ssl, struct us_socket_context_t *context) {
+    return context->loop;
+}
+
+struct us_socket_t *us_socket_context_adopt_socket(int ssl, struct us_socket_context_t *context, struct us_socket_t *s, int ext_size) {
+    struct us_socket_t *new_s = (struct us_socket_t *) realloc(s, sizeof(struct us_socket_t) + ext_size);
+    new_s->context = context;
+
+    return new_s;
+}
+
+struct us_socket_context_t *us_create_child_socket_context(int ssl, struct us_socket_context_t *context, int context_ext_size) {
+    /* We simply create a new context in this mock */
+    struct us_socket_context_options_t options = {};
+    struct us_socket_context_t *child_context = us_create_socket_context(ssl, context->loop, context_ext_size, options);
+
+    return child_context;
+}
+
+int us_socket_write(int ssl, struct us_socket_t *s, const char *data, int length, int msg_more) {
+
+    if (!length) {
+        return 0;
+    }
+
+    /* Last byte determines if we send everything or not, to stress the buffering mechanism */
+    if (data[length - 1] % 2 == 0) {
+        /* Send only half, but first set our outgoing flag */
+        s->wants_writable = 1;
+        return length / 2;
+    }
+
+    /* Send everything */
+    return length;
+}
+
+void us_socket_timeout(int ssl, struct us_socket_t *s, unsigned int seconds) {
+
+}
+
+void *us_socket_ext(int ssl, struct us_socket_t *s) {
+    return s + 1;
+}
+
+struct us_socket_context_t *us_socket_context(int ssl, struct us_socket_t *s) {
+    return s->context;
+}
+
+void us_socket_flush(int ssl, struct us_socket_t *s) {
+
+}
+
+void us_socket_shutdown(int ssl, struct us_socket_t *s) {
+    s->shutdown = 1;
+}
+
+int us_socket_is_shut_down(int ssl, struct us_socket_t *s) {
+    return s->shutdown;
+}
+
+int us_socket_is_closed(int ssl, struct us_socket_t *s) {
+    return s->closed;
+}
+
+struct us_socket_t *us_socket_close(int ssl, struct us_socket_t *s) {
+
+    if (!us_socket_is_closed(0, s)) {
+        /* Emit close event */
+        s = s->context->on_close(s);
+    }
+
+    /* We are now closed */
+    s->closed = 1;
+
+    /* Add us to the close list */
+
+    return s;
+}
+
+void us_socket_remote_address(int ssl, struct us_socket_t *s, char *buf, int *length) {
+    printf("us_socket_remote_address\n");
+}
+
+/* We expose this function to let fuzz targets push data to uSockets */
+void us_loop_read_mocked_data(struct us_loop_t *loop, char *data, unsigned int size) {
+
+    /* We are unwound so let's free all closed polls here */
+
+
+    /* We have one listen socket */
+    int socket_ext_size = loop->listen_socket->socket_ext_size;
+
+    /* Create a socket with information from the listen socket */
+    struct us_socket_t *s = (struct us_socket_t *) malloc(sizeof(struct us_socket_t) + socket_ext_size);
+    s->context = loop->listen_socket->context;
+    s->closed = 0;
+    s->shutdown = 0;
+    s->wants_writable = 0;
+
+    /* Emit open event */
+    s = s->context->on_open(s, 0, 0, 0);
+    if (!us_socket_is_closed(0, s) && !us_socket_is_shut_down(0, s)) {
+
+        /* Trigger writable event if we want it */
+        if (s->wants_writable) {
+            s->wants_writable = 0;
+            s = s->context->on_writable(s);
+            /* Check if we closed inside of writable */
+            if (us_socket_is_closed(0, s) || us_socket_is_shut_down(0, s)) {
+                goto done;
+            }
+        }
+
+        /* Loop over the data, emitting it in chunks of 0-255 bytes */
+        for (int i = 0; i < size; ) {
+            unsigned char chunkLength = data[i++];
+            if (i + chunkLength > size) {
+                chunkLength = size - i;
+            }
+
+            /* Copy the data chunk to a properly padded buffer */
+            static char *paddedBuffer;
+            if (!paddedBuffer) {
+                paddedBuffer = malloc(128 + 255 + 128);
+                memset(paddedBuffer, 0, 128 + 255 + 128);
+            }
+            memcpy(paddedBuffer + 128, data + i, chunkLength);
+
+            /* Emit a bunch of data events here */
+            s = s->context->on_data(s, paddedBuffer + 128, chunkLength);
+            if (us_socket_is_closed(0, s) || us_socket_is_shut_down(0, s)) {
+                break;
+            }
+
+            /* Also trigger it here */
+            if (s->wants_writable) {
+                s->wants_writable = 0;
+                s = s->context->on_writable(s);
+                /* Check if we closed inside of writable */
+                if (us_socket_is_closed(0, s) || us_socket_is_shut_down(0, s)) {
+                    goto done;
+                }
+            }
+
+            i += chunkLength;
+        }
+    }
+
+done:
+    if (!us_socket_is_closed(0, s)) {
+        /* Emit close event */
+        s = s->context->on_close(s);
+    }
+
+    /* Free the socket */
+    free(s);
+}

test/compatibility/C/uWebSockets/misc/15.pro

@@ -0,0 +1,41 @@
+TEMPLATE = app
+CONFIG += console c++1z
+CONFIG -= app_bundle
+CONFIG -= qt
+
+SOURCES += \
+    main.cpp \
+    ../uSockets/src/eventing/epoll.c \
+    ../uSockets/src/context.c \
+    ../uSockets/src/socket.c \
+    ../uSockets/src/eventing/libuv.c \
+    ../uSockets/src/ssl.c \
+    ../uSockets/src/loop.c
+
+HEADERS += \
+    ../src/HttpRouter.h \
+    ../src/HttpParser.h \
+    ../src/libwshandshake.hpp \
+    ../src/WebSocketProtocol.h \
+    ../src/HttpContext.h \
+    ../src/HttpContextData.h \
+    ../src/HttpResponseData.h \
+    ../src/HttpResponse.h \
+    ../src/LoopData.h \
+    ../src/AsyncSocket.h \
+    ../src/AsyncSocketData.h \
+    ../src/Loop.h \
+    ../src/App.h \
+    ../src/Utilities.h \
+    ../src/WebSocket.h \
+    ../src/WebSocketData.h \
+    ../src/WebSocketContext.h \
+    ../src/WebSocketContextData.h \
+    ../src/WebSocketExtensions.h \
+    ../src/PerMessageDeflate.h \
+    ../src/TopicTree.h
+
+INCLUDEPATH += ../uSockets/src ../src
+QMAKE_CXXFLAGS += -Wno-unused-variable -Wno-unused-parameter -Wno-unused-but-set-parameter -fsanitize=address
+QMAKE_CFLAGS += -Wno-unused-parameter -Wno-unused-variable
+LIBS += -lasan -pthread -lssl -lcrypto -lz -lstdc++fs

test/compatibility/C/uWebSockets/misc/FAQ.md

@@ -0,0 +1,19 @@
+## Build systems
+Q:
+```
+Hi Alex,
+I've used your library and I like it, however, to integrate it in my process it needs to use cmake and conan. I have written those for my own project, would you like me to submit a pull request? 
+
+Regards,
+Ioannis
+```
+A:
+```
+Hi Ioannis,
+
+This is a very common request. I don't accept any specific build systems because I know from experience that doing so opens up hell. People simply cannot agree on which build system to use, or even how to use one particular build system.
+
+That's why I no longer accept any such PRs. I've had too many CMake PRs dragging in completely different directions to know this is the only solution.
+
+You'll have to clone the repo and create a new project in whatever build system you want to use.
+```

test/compatibility/C/uWebSockets/misc/READMORE.md

@@ -0,0 +1,205 @@
+# µWebSockets v0.17 user manual
+
+For a list of frequently asked questions you may filter the GitHub issue tracker by label FAQ. Please don't misuse the issue tracker as your personal Q&A.
+
+## Motivation and goals
+µWebSockets is a simple to use yet thoroughly optimized implementation of HTTP and WebSockets.
+It comes with built-in pub/sub support, HTTP routing, TLS 1.3, IPv6, permessage-deflate and is battle tested as one of the most popular implementations, reaching many end-users daily.
+Unlike other "pub/sub brokers", µWS does not assume or push any particular protocol but only operates over standard WebSockets.
+
+The implementation is header-only C++17, cross-platform and compiles down to a tiny binary of a handful kilobytes.
+It depends on µSockets, which is a standard C project for Linux, macOS & Windows.
+
+Performance wise you can expect to outperform, or equal, just about anything similar out there, that's the fundamental goal of the project.
+I can show certain cases where µWS with SSL significantly outperforms Golang servers running non-SSL. You get the SSL for free in a sense, well, in this particular case at least.
+
+Another goal of the project is minimalism, simplicity and elegance.
+Design wise it follows an ExpressJS-like interface where you attach callbacks to different URL routes.
+This way you can easily build complete REST/WebSocket services in a few lines of code.
+
+The project is async only and runs local to one thread. You scale it as individual threads much like Node.js scales as individual processes. That is, the implementation only sees a single thread and is not thread-safe. There are simple ways to do threading via async delegates though, if you really need to.
+
+## Compiling
+µWebSockets is 100% standard header-only C++17 - it compiles on any platform. However, it depends on µSockets in all cases, which is platform-specific C code that runs on Linux, Windows and macOS.
+
+There are a few compilation flags for µSockets (see its documentation), but common between µSockets and µWebSockets flags are as follows:
+
+* LIBUS_NO_SSL - disable OpenSSL dependency/functionality for uSockets and uWebSockets builds
+* UWS_NO_ZLIB - disable Zlib dependency/functionality for uWebSockets
+
+## Node.js
+V8 addon is developed over at https://github.com/uNetworking/uWebSockets.js.
+
+## User manual
+
+### uWS::App & uWS::SSLApp
+You begin your journey by constructing an "App". Either an SSL-app or a regular TCP-only App. The uWS::SSLApp constructor takes a struct holding SSL options such as cert and key. Interfaces for both apps are identical, so let's call them both "App" from now on.
+
+Apps follow the builder pattern, member functions return the App so that you can chain calls.
+
+### App.get, post, put, [...] and any routes
+You attach behavior to "URL routes". A lambda is paired with a "method" (Http method that is) and a pattern (the URL matching pattern).
+
+Methods are many, but most common are probably get & post. They all have the same signature, let's look at one example:
+
+```c++
+uWS::App().get("/hello", [](auto *res, auto *req) {
+    res->end("Hello World!");
+});
+```
+
+Important for all routes is that "req", the `uWS::HttpRequest *` dies with return. In other words, req is stack allocated so don't keep it in your pocket.
+
+res, the `uWS::HttpResponse<SSL> *` will be alive and accessible until either its .onAborted callback emits, or you've responded to the request via res.end or res.tryEnd.
+
+In other words, you either respond to the request immediately and return, or you attach lambdas to the res (which may hold captured data), and respond later on in some other async callback.
+
+Data that you capture in a res follows RAII and is move-only so you can properly move-in for instance std::string buffers that you may use to, for instance, buffer upp streaming POST data. It's pretty cool, check out mutable lambdas with move-only captures.
+
+The "any" route will match any method.
+
+#### Pattern matching
+Routes are matched in **order of specificity**, not by the order you register them:
+
+* Highest priority - static routes, think "/hello/this/is/static".
+* Middle priority - parameter routes, think "/candy/:kind", where value of :kind is retrieved by req.getParameter(0).
+* Lowest priority - wildcard routes, think "/hello/*".
+
+In other words, the more specific a route is, the earlier it will match. This allows you to define wildcard routes that match a wide range of URLs and then "carve" out more specific behavior from that.
+
+"Any" routes, those who match any HTTP method, will match with lower priority than routes which specify their specific HTTP method (such as GET) if and only if the two routes otherwise are equally specific.
+
+#### Streaming data
+You should never call res.end(huge buffer). res.end guarantees sending so backpressure will probably spike. Instead you should use res.tryEnd to stream huge data part by part. Use in combination with res.onWritable and res.onAborted callbacks.
+
+Tip: Check out the JavaScript project, it has many useful examples of async streaming of huge data.
+
+#### Corking
+It is very important to understand the corking mechanism, as that is responsible for efficiently formatting, packing and sending data. Without corking your app will still work reliably, but can perform very bad and use excessive networking. In some cases the performance can be dreadful without proper corking.
+
+That's why your sockets will be corked by default in most simple cases, including all of the examples provided. However there are cases where default corking cannot happen automatically.
+
+* Whenever your registered business logic (your callbacks) are called from the library, such as when receiving a message or when a socket opens, you'll be corked by default. Whatever you do with the socket inside of that callback will be efficient and properly corked.
+
+* If you have callbacks registered to some other library, say libhiredis, those callbacks will not be called with corked sockets (how could **we** know when to cork the socket if we don't control the third-party library!?).
+
+* Only one single socket can be corked at any point in time (isolated per thread, of course). It is efficient to cork-and-uncork.
+
+* Whenever your callback is a coroutine, such as the JavaScript async/await, automatic corking can only happen in the very first portion of the coroutine (consider await a separator which essentially cuts the coroutine into smaller segments). Only the first "segment" of the coroutine will be called from µWS, the following async segments will be called by the JavaScript runtime at a later point in time and will thus not be under our control with default corking enabled.
+
+* Corking is important even for calls which seem to be "atomic" and only send one chunk. res->end, res->tryEnd, res->writeStatus, res->writeHeader will most likely send multiple chunks of data and is very important to properly cork.
+
+You can make sure corking is enabled, even for cases where default corking would be enabled, by wrapping whatever sending function calls in a lambda like so:
+
+```c++
+res->cork([]() {
+    res->end("This Http response will be properly corked and efficient in all cases");
+});
+```
+
+The above res->end call will actually call three separate send functions; res->writeStatus, res->writeHeader and whatever it does itself. By wrapping the call in res->cork you make sure these three send functions are efficient and only result in one single send syscall and one single SSL block if using SSL.
+
+Keep this in mind, corking is by far the single most important performance trick to use. Even when streaming huge amounts of data it can be useful to cork. At least in the very tip of the response, as that holds the headers and status.
+
+### The App.ws route
+WebSocket "routes" are registered similarly, but not identically.
+
+Every websocket route has the same pattern and pattern matching as for Http, but instead of one single callback you have a whole set of them, here's an example:
+
+```c++
+uWS::App().ws<PerSocketData>("/*", {
+    /* Settings */
+    .compression = uWS::SHARED_COMPRESSOR,
+    .maxPayloadLength = 16 * 1024,
+    .idleTimeout = 10,
+    /* Handlers */
+    .open = [](auto *ws, auto *req) {
+        /* Here you can use req just like as for Http */
+    },
+    .message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
+        ws->send(message, opCode);
+    },
+    .drain = [](auto *ws) {
+        /* Check getBufferedAmount here */
+    },
+    .ping = [](auto *ws) {
+
+    },
+    .pong = [](auto *ws) {
+
+    },
+    .close = [](auto *ws, int code, std::string_view message) {
+
+    }
+});
+```
+
+WebSocket routes specify a user data type that should be used to keep per-websocket data. Many times people tend to attach user data
+which should belong to the websocket by putting the pointer and the user data in a std::map. That's wrong! Don't do that!
+
+#### Use the WebSocket.getUserData() feature
+You should use the provided user data feature to store and attach any per-socket user data. Going from user data to WebSocket is possible if you make your user data hold a pointer to WebSocket, and hook things up in the WebSocket open handler. Your user data memory is valid while your WebSocket is.
+
+If you want to create something more elaborate you could have the user data hold a pointer to some dynamically allocated memory block that keeps a boolean whether the WebSocket is still valid or not. Sky is the limit here, you should never need any std::map for this.
+
+#### WebSockets are valid from open to close
+All given WebSocket pointers are guaranteed to live from open event (where you got your WebSocket) until close event is called. So is the user data memory. One open event will always end in exactly one close event, they are 1-to-1 and will always be balanced no matter what. Use them to drive your RAII data types, they can be seen as constructor and destructor.
+
+Message events will never emit outside of open/close. Calling WebSocket.close or WebSocket.end will immediately call the close handler.
+
+#### Backpressure in websockets
+Similarly to for Http, methods such as ws.send(...) can cause backpressure. Make sure to check ws.getBufferedAmount() before sending, and check the return value of ws.send before sending any more data. WebSockets do not have .onWritable, but instead make use of the .drain handler of the websocket route handler.
+
+Inside of .drain event you should check ws.getBufferedAmount(), it might have drained, or even increased. Most likely drained but don't assume that it has, .drain event is only a hint that it has changed.
+
+#### Settings
+Compression (permessage-deflate) has three options, uWS::DISABLED, uWS::SHARED_COMPRESSOR and uWS::DEDICATED_COMPRESSOR. Disabled and shared options require no memory, while dedicated compressor requires somewhere close to 300kb per socket, a very significant cost.
+
+Compressing using shared means that every WebSocket message is an isolated compression stream, it does not have a sliding compression window, kept between multiple send calls.
+
+Shared compression is my personal favorite, since it doesn't change memory usage while still provide decent compression, especially for larger messages.
+
+* idleTimeout is roughly the amount of seconds that may pass between messages. Being idle for more than this, and the connection is severed. This means you should make your clients send small ping messages every now and then, to keep the connection alive. You can also make the server send ping messages but I would definitely put that labor on the client side.
+
+### Listening on a port
+Once you have defined your routes and their behavior, it is time to start listening for new connections. You do this by calling
+
+```c++
+App.listen(port, [](auto *listenSocket) {
+    /* listenSocket is either nullptr or us_listen_socket */
+})
+```
+
+Cancelling listenning is done with the uSockets function call `us_listen_socket_close`.
+
+### App.run and fallthrough
+When you are done and want to enter the event loop, you call, once and only once, App.run.
+This will block the calling thread until "fallthrough". The event loop will block until no more async work is scheduled, just like for Node.js.
+
+Many users ask how they should stop the event loop. That's not how it is done, you never stop it, you let it fall through. By closing all sockets, stopping the listen socket, removing any timers, etc, the loop will automatically cause App.run to return gracefully, with no memory leaks.
+
+Because the App itself is under RAII control, once the blocking .run call returns and the App goes out of scope, all memory will gracefully be deleted.
+
+### Putting it all toghether
+
+```c++
+int main() {
+    uWS::App().get("/*", [](auto *res, auto *req) {
+        res->end("Hello World!");
+    }).listen(9001, [](auto *listenSocket) {
+        if (listenSocket) {
+            std::cout << "Listening for connections..." << std::endl;
+        }
+    }).run();
+
+    std::cout << "Shoot! We failed to listen and the App fell through, exiting now!" << std::endl;
+}
+```
+
+### Scaling up
+
+One event-loop per thread, isolated and without shared data. That's the design here. Just like Node.js, but instead of per-process, it's per thread (well, obviously you can do it per-process also).
+
+If you want to, you can simply take the previous example, put it inside of a few `std::thread` and listen to separate ports, or share the same port (works on Linux). More features like these will probably come, such as master/slave set-ups but it really isn't that hard to understand the concept - keep things isolated and spawn multiple instances of whatever code you have.
+
+Recent Node.js versions may scale using multiple threads, via the new Worker threads support. Scaling using that feature is identical to scaling using multiple threads in C++.

test/compatibility/C/uWebSockets/misc/main.cpp

@@ -0,0 +1,119 @@
+#include "App.h"
+
+//#include "../examples/helpers/AsyncFileReader.h"
+//#include "../examples/helpers/AsyncFileStreamer.h"
+
+us_listen_socket *token;
+
+int main(int argc, char **argv) {
+
+    struct PerSocketData {
+        char pad[256];
+        int hello;
+    };
+
+    auto app = uWS::/*SSL*/App({
+        .key_file_name = "/home/alexhultman/key.pem",
+        .cert_file_name = "/home/alexhultman/cert.pem",
+        .passphrase = "1234"
+    }).any("/anything", [](auto *res, auto *req) {
+        std::cout << "Any route with method: " << req->getMethod() << std::endl;
+        res->end("Hello Any route!");
+    }).get("/exit", [](auto *res, auto *req) {
+
+        if (!token) {
+            res->end("Server already closed down!");
+            return;
+        }
+
+        res->end("Closing down server now");
+
+        /* Use this route to signal stop listening */
+        us_listen_socket_close(token);
+        token = nullptr;
+    }).ws<PerSocketData>("/*", {
+        /* Settings */
+        .compression = uWS::DEDICATED_COMPRESSOR,
+        .maxPayloadLength = 16 * 1024 * 1024,
+        .idleTimeout = 10,
+        /* Handlers */
+        .open = [](auto *ws, auto *req) {
+            std::cout << "WebSocket connected" << std::endl;
+            /* Access per socket data */
+            PerSocketData *perSocketData = (PerSocketData *) ws->getUserData();
+            perSocketData->hello = 13;
+        },
+        .message = [](auto *ws, std::string_view message, uWS::OpCode opCode) {
+            ws->send(message, opCode, true);
+            PerSocketData *perSocketData = (PerSocketData *) ws->getUserData();
+            std::cout << "OK per socket data: " << (perSocketData->hello == 13) << std::endl;
+        },
+        .drain = [](auto *ws) {
+            std::cout << "Drainage: " << ws->getBufferedAmount() << std::endl;
+        },
+        .ping = [](auto *ws) {
+            std::cout << "Ping" << std::endl;
+        },
+        .pong = [](auto *ws) {
+            std::cout << "Pong" << std::endl;
+        },
+        .close = [](auto *ws, int code, std::string_view message) {
+            std::cout << "WebSocket disconnected: " << code << "[" << message << "]" << std::endl;
+            /* Access per socket data */
+            PerSocketData *perSocketData = (PerSocketData *) ws->getUserData();
+            std::cout << "OK per socket data: " << (perSocketData->hello == 13) << std::endl;
+        }
+    }).listen(9001, [](auto *token) {
+        ::token = token;
+        if (token) {
+            std::cout << "Listening on port " << 3000 << std::endl;
+        }
+    }).run();
+
+
+    std::cout << "Everything fine, falling through" << std::endl;
+
+//    return 0;
+
+//    AsyncFileStreamer *asyncFileStreamer = new AsyncFileStreamer("/home/alexhultman/v0.15/public");
+
+//    uWS::/*SSL*/App(/*{
+//        .key_file_name = "/home/alexhultman/uWebSockets/misc/ssl/key.pem",
+//        .cert_file_name = "/home/alexhultman/uWebSockets/misc/ssl/cert.pem",
+//        .dh_params_file_name = "/home/alexhultman/dhparams.pem",
+//        .passphrase = "1234"
+//    }*/)/*.get("/*", [](auto *res, auto *req) {
+
+//        res->end("GET /WILDCARD");
+
+//    })*/.get("/:param1/:param2", [](auto *res, auto *req) {
+
+//        res->write("GET /:param1/:param2 = ");
+//        res->write(req->getParameter(0));
+//        res->write(" and ");
+//        res->end(req->getParameter(1));
+
+//    }).post("/hello", [asyncFileStreamer](auto *res, auto *req) {
+
+//        // depending on the file type we want to also add mime!
+//        //asyncFileStreamer->streamFile(res, req->getUrl());
+
+//        res->end("POST /hello");
+
+//    }).get("/hello", [](auto *res, auto *req) {
+
+//        res->end("GET /hello");
+
+//    }).unhandled([](auto *res, auto *req) {
+
+//        res->writeStatus("404 Not Found");
+//        res->writeHeader("Content-Type", "text/html; charset=utf-8");
+//        res->end("<h1>404 Not Found</h1><i>µWebSockets v0.15</i>");
+
+//    }).listen(3000, [](auto *token) {
+//        if (token) {
+//            std::cout << "Listening on port " << 3000 << std::endl;
+//        }
+//    }).run();
+
+}

test/compatibility/C/uWebSockets/misc/tests.cpp

@@ -0,0 +1,94 @@
+#include "HttpParser.h"
+
+#include <chrono>
+#include <iostream>
+
+// todo: random test of chunked http parsing of randomly generated requests
+void testHttpParser() {
+
+    char headers[] = "GET /hello.htm HTTP/1.1\r\n"
+            "User-Agent: Mozilla/4.0 (compatible; MSIE5.01; Windows NT)\r\n"
+            "Host: www.tutorialspoint.com\r\n"
+            "Accept-Language: en-us\r\n"
+            "Accept-Encoding: gzip, deflate\r\n"
+            "Connection: Keep-Alive\r\n"
+            "Content-length: 1048576\r\n\r\n";
+
+    const int requestLength = sizeof(headers) - 1 + 1048576;
+    char *request = (char *) malloc(requestLength + 32);
+    memset(request, 0, requestLength);
+    memcpy(request, headers, sizeof(headers) - 1);
+
+    char *data = (char *) malloc(requestLength * 10);
+    int length = requestLength * 10;
+
+    int maxChunkSize = 10000;
+    char *paddedBuffer = (char *) malloc(maxChunkSize + 32);
+
+    // dela upp dessa 10 i 5 segment
+    HttpParser httpParser;
+    int validRequests = 0, numDataEmits = 0, numChunks = 0;
+    size_t dataBytes = 0;
+
+    for (int i = 0; i < 10; i++) {
+        memcpy(data + requestLength * i, request, requestLength);
+    }
+
+    for (int j = 0; j < 1000; j++) {
+        for (int currentOffset = 0; currentOffset != length; ) {
+
+            int chunkSize = rand() % 10000;
+            if (currentOffset + chunkSize > length) {
+                chunkSize = length - currentOffset;
+            }
+
+            memcpy(paddedBuffer, data + currentOffset, chunkSize);
+
+            httpParser.consumePostPadded(paddedBuffer, chunkSize, nullptr, [&validRequests](void *user, HttpRequest *req) {
+                validRequests++;
+
+                if (req->getUrl() != "/hello.htm") {
+                    std::cout << "WRONG URL!" << std::endl;
+                    exit(-1);
+                }
+
+            }, [&dataBytes, &numDataEmits](void *, std::string_view data) {
+                numDataEmits++;
+                dataBytes += data.length();
+            }, [](void *) {
+
+                std::cout << "Error!" << std::endl;
+                return;
+            });
+
+            numChunks++;
+
+            currentOffset += chunkSize;
+        }
+    }
+
+    std::cout << "validRequests: " << validRequests << std::endl;
+    std::cout << "Data bytes: " << dataBytes << std::endl;
+    std::cout << "Data emits: " << numDataEmits << std::endl;
+    std::cout << "Chunks parsed: " << numChunks << std::endl;
+
+    validRequests = 0;
+
+    auto start = std::chrono::high_resolution_clock::now();
+    for (int i = 0; i < 10000000; i++) {
+        httpParser.consumePostPadded(request, requestLength, nullptr, [&validRequests](void *user, HttpRequest *req) {
+            validRequests++;
+        }, [](void *, std::string_view data) {
+
+        }, [](void *) {
+
+        });
+    }
+    auto stop = std::chrono::high_resolution_clock::now();
+
+    std::cout << "Parsed " << validRequests << " in " << std::chrono::duration_cast<std::chrono::milliseconds>(stop - start).count() << "ms" << std::endl;
+}
+
+int main() {
+	testHttpParser();
+}

test/compatibility/C/uWebSockets/src/App.h

@@ -0,0 +1,348 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_APP_H
+#define UWS_APP_H
+
+/* An app is a convenience wrapper of some of the most used fuctionalities and allows a
+ * builder-pattern kind of init. Apps operate on the implicit thread local Loop */
+
+#include "HttpContext.h"
+#include "HttpResponse.h"
+#include "WebSocketContext.h"
+#include "WebSocket.h"
+#include "WebSocketExtensions.h"
+#include "WebSocketHandshake.h"
+
+namespace uWS {
+
+/* Compress options (really more like PerMessageDeflateOptions) */
+enum CompressOptions {
+    /* Compression disabled */
+    DISABLED = 0,
+    /* We compress using a shared non-sliding window. No added memory usage, worse compression. */
+    SHARED_COMPRESSOR = 1,
+    /* We compress using a dedicated sliding window. Major memory usage added, better compression of similarly repeated messages. */
+    DEDICATED_COMPRESSOR = 2
+};
+
+template <bool SSL>
+struct TemplatedApp {
+private:
+    /* The app always owns at least one http context, but creates websocket contexts on demand */
+    HttpContext<SSL> *httpContext;
+    std::vector<WebSocketContext<SSL, true> *> webSocketContexts;
+
+public:
+
+    /* Attaches a "filter" function to track socket connections/disconnections */
+    void filter(fu2::unique_function<void(HttpResponse<SSL> *, int)> &&filterHandler) {
+        httpContext->filter(std::move(filterHandler));
+    }
+
+    /* Publishes a message to all websocket contexts */
+    void publish(std::string_view topic, std::string_view message, OpCode opCode, bool compress = false) {
+        for (auto *webSocketContext : webSocketContexts) {
+            webSocketContext->getExt()->publish(topic, message, opCode, compress);
+        }
+    }
+
+    ~TemplatedApp() {
+        /* Let's just put everything here */
+        if (httpContext) {
+            httpContext->free();
+
+            for (auto *webSocketContext : webSocketContexts) {
+                webSocketContext->free();
+            }
+        }
+    }
+
+    /* Disallow copying, only move */
+    TemplatedApp(const TemplatedApp &other) = delete;
+
+    TemplatedApp(TemplatedApp &&other) {
+        /* Move HttpContext */
+        httpContext = other.httpContext;
+        other.httpContext = nullptr;
+
+        /* Move webSocketContexts */
+        webSocketContexts = std::move(other.webSocketContexts);
+    }
+
+    TemplatedApp(us_socket_context_options_t options = {}) {
+        httpContext = uWS::HttpContext<SSL>::create(uWS::Loop::get(), options);
+    }
+
+    bool constructorFailed() {
+        return !httpContext;
+    }
+
+    struct WebSocketBehavior {
+        CompressOptions compression = DISABLED;
+        int maxPayloadLength = 16 * 1024;
+        int idleTimeout = 120;
+        int maxBackpressure = 1 * 1024 * 1204;
+        fu2::unique_function<void(uWS::WebSocket<SSL, true> *, HttpRequest *)> open = nullptr;
+        fu2::unique_function<void(uWS::WebSocket<SSL, true> *, std::string_view, uWS::OpCode)> message = nullptr;
+        fu2::unique_function<void(uWS::WebSocket<SSL, true> *)> drain = nullptr;
+        fu2::unique_function<void(uWS::WebSocket<SSL, true> *)> ping = nullptr;
+        fu2::unique_function<void(uWS::WebSocket<SSL, true> *)> pong = nullptr;
+        fu2::unique_function<void(uWS::WebSocket<SSL, true> *, int, std::string_view)> close = nullptr;
+    };
+
+    template <typename UserData>
+    TemplatedApp &&ws(std::string pattern, WebSocketBehavior &&behavior) {
+        /* Don't compile if alignment rules cannot be satisfied */
+        static_assert(alignof(UserData) <= LIBUS_EXT_ALIGNMENT,
+        "µWebSockets cannot satisfy UserData alignment requirements. You need to recompile µSockets with LIBUS_EXT_ALIGNMENT adjusted accordingly.");
+
+        /* Every route has its own websocket context with its own behavior and user data type */
+        auto *webSocketContext = WebSocketContext<SSL, true>::create(Loop::get(), (us_socket_context_t *) httpContext);
+
+        /* We need to clear this later on */
+        webSocketContexts.push_back(webSocketContext);
+
+        /* Quick fix to disable any compression if set */
+#ifdef UWS_NO_ZLIB
+        behavior.compression = uWS::DISABLED;
+#endif
+
+        /* If we are the first one to use compression, initialize it */
+        if (behavior.compression) {
+            LoopData *loopData = (LoopData *) us_loop_ext(us_socket_context_loop(SSL, webSocketContext->getSocketContext()));
+
+            /* Initialize loop's deflate inflate streams */
+            if (!loopData->zlibContext) {
+                loopData->zlibContext = new ZlibContext;
+                loopData->inflationStream = new InflationStream;
+                loopData->deflationStream = new DeflationStream;
+            }
+        }
+
+        /* Copy all handlers */
+        webSocketContext->getExt()->messageHandler = std::move(behavior.message);
+        webSocketContext->getExt()->drainHandler = std::move(behavior.drain);
+        webSocketContext->getExt()->closeHandler = std::move([closeHandler = std::move(behavior.close)](WebSocket<SSL, true> *ws, int code, std::string_view message) mutable {
+            closeHandler(ws, code, message);
+
+            /* Destruct user data after returning from close handler */
+            ((UserData *) ws->getUserData())->~UserData();
+        });
+
+        /* Copy settings */
+        webSocketContext->getExt()->maxPayloadLength = behavior.maxPayloadLength;
+        webSocketContext->getExt()->idleTimeout = behavior.idleTimeout;
+        webSocketContext->getExt()->maxBackpressure = behavior.maxBackpressure;
+
+        httpContext->onHttp("get", pattern, [webSocketContext, httpContext = this->httpContext, behavior = std::move(behavior)](auto *res, auto *req) mutable {
+
+            /* If we have this header set, it's a websocket */
+            std::string_view secWebSocketKey = req->getHeader("sec-websocket-key");
+            if (secWebSocketKey.length() == 24) {
+                /* Note: OpenSSL can be used here to speed this up somewhat */
+                char secWebSocketAccept[29] = {};
+                WebSocketHandshake::generate(secWebSocketKey.data(), secWebSocketAccept);
+
+                res->writeStatus("101 Switching Protocols")
+                    ->writeHeader("Upgrade", "websocket")
+                    ->writeHeader("Connection", "Upgrade")
+                    ->writeHeader("Sec-WebSocket-Accept", secWebSocketAccept);
+
+                /* Select first subprotocol if present */
+                std::string_view secWebSocketProtocol = req->getHeader("sec-websocket-protocol");
+                if (secWebSocketProtocol.length()) {
+                    res->writeHeader("Sec-WebSocket-Protocol", secWebSocketProtocol.substr(0, secWebSocketProtocol.find(',')));
+                }
+
+                /* Negotiate compression */
+                bool perMessageDeflate = false;
+                bool slidingDeflateWindow = false;
+                if (behavior.compression != DISABLED) {
+                    std::string_view extensions = req->getHeader("sec-websocket-extensions");
+                    if (extensions.length()) {
+                        /* We never support client context takeover (the client cannot compress with a sliding window). */
+                        int wantedOptions = PERMESSAGE_DEFLATE | CLIENT_NO_CONTEXT_TAKEOVER;
+
+                        /* Shared compressor is the default */
+                        if (behavior.compression == SHARED_COMPRESSOR) {
+                            /* Disable per-socket compressor */
+                            wantedOptions |= SERVER_NO_CONTEXT_TAKEOVER;
+                        }
+
+                        /* isServer = true */
+                        ExtensionsNegotiator<true> extensionsNegotiator(wantedOptions);
+                        extensionsNegotiator.readOffer(extensions);
+
+                        /* Todo: remove these mid string copies */
+                        std::string offer = extensionsNegotiator.generateOffer();
+                        if (offer.length()) {
+                            res->writeHeader("Sec-WebSocket-Extensions", offer);
+                        }
+
+                        /* Did we negotiate permessage-deflate? */
+                        if (extensionsNegotiator.getNegotiatedOptions() & PERMESSAGE_DEFLATE) {
+                            perMessageDeflate = true;
+                        }
+
+                        /* Is the server allowed to compress with a sliding window? */
+                        if (!(extensionsNegotiator.getNegotiatedOptions() & SERVER_NO_CONTEXT_TAKEOVER)) {
+                            slidingDeflateWindow = true;
+                        }
+                    }
+                }
+
+                /* This will add our mark */
+                res->upgrade();
+
+                /* Move any backpressure */
+                std::string backpressure(std::move(((AsyncSocketData<SSL> *) res->getHttpResponseData())->buffer));
+
+                /* Keep any fallback buffer alive until we returned from open event, keeping req valid */
+                std::string fallback(std::move(res->getHttpResponseData()->salvageFallbackBuffer()));
+
+                /* Destroy HttpResponseData */
+                res->getHttpResponseData()->~HttpResponseData();
+
+                /* Adopting a socket invalidates it, do not rely on it directly to carry any data */
+                WebSocket<SSL, true> *webSocket = (WebSocket<SSL, true> *) us_socket_context_adopt_socket(SSL,
+                            (us_socket_context_t *) webSocketContext, (us_socket_t *) res, sizeof(WebSocketData) + sizeof(UserData));
+
+                /* Update corked socket in case we got a new one (assuming we always are corked in handlers). */
+                webSocket->AsyncSocket<SSL>::cork();
+
+                /* Initialize websocket with any moved backpressure intact */
+                httpContext->upgradeToWebSocket(
+                            webSocket->init(perMessageDeflate, slidingDeflateWindow, std::move(backpressure))
+                            );
+
+                /* Emit open event and start the timeout */
+                if (behavior.open) {
+                    us_socket_timeout(SSL, (us_socket_t *) webSocket, behavior.idleTimeout);
+
+                    /* Default construct the UserData right before calling open handler */
+                    new (webSocket->getUserData()) UserData;
+
+                    behavior.open(webSocket, req);
+                }
+
+                /* We are going to get uncorked by the Http get return */
+
+                /* We do not need to check for any close or shutdown here as we immediately return from get handler */
+
+            } else {
+                /* Tell the router that we did not handle this request */
+                req->setYield(true);
+            }
+        }, true);
+        return std::move(*this);
+    }
+
+    TemplatedApp &&get(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("get", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&post(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("post", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&options(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("options", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&del(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("delete", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&patch(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("patch", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&put(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("put", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&head(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("head", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&connect(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("connect", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&trace(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("trace", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    /* This one catches any method */
+    TemplatedApp &&any(std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler) {
+        httpContext->onHttp("*", pattern, std::move(handler));
+        return std::move(*this);
+    }
+
+    /* Host, port, callback */
+    TemplatedApp &&listen(std::string host, int port, fu2::unique_function<void(us_listen_socket_t *)> &&handler) {
+        if (!host.length()) {
+            return listen(port, std::move(handler));
+        }
+        handler(httpContext->listen(host.c_str(), port, 0));
+        return std::move(*this);
+    }
+
+    /* Host, port, options, callback */
+    TemplatedApp &&listen(std::string host, int port, int options, fu2::unique_function<void(us_listen_socket_t *)> &&handler) {
+        if (!host.length()) {
+            return listen(port, options, std::move(handler));
+        }
+        handler(httpContext->listen(host.c_str(), port, options));
+        return std::move(*this);
+    }
+
+    /* Port, callback */
+    TemplatedApp &&listen(int port, fu2::unique_function<void(us_listen_socket_t *)> &&handler) {
+        handler(httpContext->listen(nullptr, port, 0));
+        return std::move(*this);
+    }
+
+    /* Port, options, callback */
+    TemplatedApp &&listen(int port, int options, fu2::unique_function<void(us_listen_socket_t *)> &&handler) {
+        handler(httpContext->listen(nullptr, port, options));
+        return std::move(*this);
+    }
+
+    TemplatedApp &&run() {
+        uWS::run();
+        return std::move(*this);
+    }
+
+};
+
+typedef TemplatedApp<false> App;
+typedef TemplatedApp<true> SSLApp;
+
+}
+
+#endif // UWS_APP_H

test/compatibility/C/uWebSockets/src/AsyncSocket.h

@@ -0,0 +1,228 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_ASYNCSOCKET_H
+#define UWS_ASYNCSOCKET_H
+
+/* This class implements async socket memory management strategies */
+
+#include "LoopData.h"
+#include "AsyncSocketData.h"
+
+namespace uWS {
+
+    template <bool, bool> struct WebSocketContext;
+
+template <bool SSL>
+struct AsyncSocket {
+    template <bool> friend struct HttpContext;
+    template <bool, bool> friend struct WebSocketContext;
+    template <bool> friend struct WebSocketContextData;
+    friend struct TopicTree;
+
+protected:
+    /* Get loop data for socket */
+    LoopData *getLoopData() {
+        return (LoopData *) us_loop_ext(us_socket_context_loop(SSL, us_socket_context(SSL, (us_socket_t *) this)));
+    }
+
+    /* Get socket extension */
+    AsyncSocketData<SSL> *getAsyncSocketData() {
+        return (AsyncSocketData<SSL> *) us_socket_ext(SSL, (us_socket_t *) this);
+    }
+
+    /* Socket timeout */
+    void timeout(unsigned int seconds) {
+        us_socket_timeout(SSL, (us_socket_t *) this, seconds);
+    }
+
+    /* Shutdown socket without any automatic drainage */
+    void shutdown() {
+        us_socket_shutdown(SSL, (us_socket_t *) this);
+    }
+
+    /* Immediately close socket */
+    us_socket_t *close() {
+        return us_socket_close(SSL, (us_socket_t *) this);
+    }
+
+    /* Cork this socket. Only one socket may ever be corked per-loop at any given time */
+    void cork() {
+        /* What if another socket is corked? */
+        getLoopData()->corkedSocket = this;
+    }
+
+    /* Returns wheter we are corked or not */
+    bool isCorked() {
+        return getLoopData()->corkedSocket == this;
+    }
+
+    /* Returns whether we could cork (it is free) */
+    bool canCork() {
+        return getLoopData()->corkedSocket == nullptr;
+    }
+
+    /* Returns a suitable buffer for temporary assemblation of send data */
+    std::pair<char *, bool> getSendBuffer(size_t size) {
+        /* If we are corked and we have room, return the cork buffer itself */
+        LoopData *loopData = getLoopData();
+        if (loopData->corkedSocket == this && loopData->corkOffset + size < LoopData::CORK_BUFFER_SIZE) {
+            char *sendBuffer = loopData->corkBuffer + loopData->corkOffset;
+            loopData->corkOffset += (int) size;
+            return {sendBuffer, false};
+        } else {
+            /* Slow path for now, we want to always be corked if possible */
+            return {(char *) malloc(size), true};
+        }
+    }
+
+    /* Returns the user space backpressure. */
+    int getBufferedAmount() {
+        return (int) getAsyncSocketData()->buffer.size();
+    }
+
+    /* Returns the remote IP address or empty string on failure */
+    std::string_view getRemoteAddress() {
+        static thread_local char buf[16];
+        int ipLength = 16;
+        us_socket_remote_address(SSL, (us_socket_t *) this, buf, &ipLength);
+        return std::string_view(buf, ipLength);
+    }
+
+    /* Write in three levels of prioritization: cork-buffer, syscall, socket-buffer. Always drain if possible.
+     * Returns pair of bytes written (anywhere) and wheter or not this call resulted in the polling for
+     * writable (or we are in a state that implies polling for writable). */
+    std::pair<int, bool> write(const char *src, int length, bool optionally = false, int nextLength = 0) {
+        /* Fake success if closed, simple fix to allow uncork of closed socket to succeed */
+        if (us_socket_is_closed(SSL, (us_socket_t *) this)) {
+            return {length, false};
+        }
+
+        LoopData *loopData = getLoopData();
+        AsyncSocketData<SSL> *asyncSocketData = getAsyncSocketData();
+
+        /* We are limited if we have a per-socket buffer */
+        if (asyncSocketData->buffer.length()) {
+            /* Write off as much as we can */
+            int written = us_socket_write(SSL, (us_socket_t *) this, asyncSocketData->buffer.data(), (int) asyncSocketData->buffer.length(), /*nextLength != 0 | */length);
+
+            /* On failure return, otherwise continue down the function */
+            if ((unsigned int) written < asyncSocketData->buffer.length()) {
+
+                /* Update buffering (todo: we can do better here if we keep track of what happens to this guy later on) */
+                asyncSocketData->buffer = asyncSocketData->buffer.substr(written);
+
+                if (optionally) {
+                    /* Thankfully we can exit early here */
+                    return {0, true};
+                } else {
+                    /* This path is horrible and points towards erroneous usage */
+                    asyncSocketData->buffer.append(src, length);
+
+                    return {length, true};
+                }
+            }
+
+            /* At this point we simply have no buffer and can continue as normal */
+            asyncSocketData->buffer.clear();
+        }
+
+        if (length) {
+            if (loopData->corkedSocket == this) {
+                /* We are corked */
+                if (LoopData::CORK_BUFFER_SIZE - loopData->corkOffset >= length) {
+                    /* If the entire chunk fits in cork buffer */
+                    memcpy(loopData->corkBuffer + loopData->corkOffset, src, length);
+                    loopData->corkOffset += length;
+                    /* Fall through to default return */
+                } else {
+                    /* Strategy differences between SSL and non-SSL regarding syscall minimizing */
+                    if constexpr (SSL) {
+                        /* Cork up as much as we can */
+                        int stripped = LoopData::CORK_BUFFER_SIZE - loopData->corkOffset;
+                        memcpy(loopData->corkBuffer + loopData->corkOffset, src, stripped);
+                        loopData->corkOffset = LoopData::CORK_BUFFER_SIZE;
+
+                        auto [written, failed] = uncork(src + stripped, length - stripped, optionally);
+                        return {written + stripped, failed};
+                    }
+
+                    /* For non-SSL we take the penalty of two syscalls */
+                    return uncork(src, length, optionally);
+                }
+            } else {
+                /* We are not corked */
+                int written = us_socket_write(SSL, (us_socket_t *) this, src, length, nextLength != 0);
+
+                /* Did we fail? */
+                if (written < length) {
+                    /* If the write was optional then just bail out */
+                    if (optionally) {
+                        return {written, true};
+                    }
+
+                    /* Fall back to worst possible case (should be very rare for HTTP) */
+                    /* At least we can reserve room for next chunk if we know it up front */
+                    if (nextLength) {
+                        asyncSocketData->buffer.reserve(asyncSocketData->buffer.length() + length - written + nextLength);
+                    }
+
+                    /* Buffer this chunk */
+                    asyncSocketData->buffer.append(src + written, length - written);
+
+                    /* Return the failure */
+                    return {length, true};
+                }
+                /* Fall through to default return */
+            }
+        }
+
+        /* Default fall through return */
+        return {length, false};
+    }
+
+    /* Uncork this socket and flush or buffer any corked and/or passed data. It is essential to remember doing this. */
+    /* It does NOT count bytes written from cork buffer (they are already accounted for in the write call responsible for its corking)! */
+    std::pair<int, bool> uncork(const char *src = nullptr, int length = 0, bool optionally = false) {
+        LoopData *loopData = getLoopData();
+
+        if (loopData->corkedSocket == this) {
+            loopData->corkedSocket = nullptr;
+
+            if (loopData->corkOffset) {
+                /* Corked data is already accounted for via its write call */
+                auto [written, failed] = write(loopData->corkBuffer, loopData->corkOffset, false, length);
+                loopData->corkOffset = 0;
+
+                if (failed) {
+                    /* We do not need to care for buffering here, write does that */
+                    return {0, true};
+                }
+            }
+
+            /* We should only return with new writes, not things written to cork already */
+            return write(src, length, optionally, 0);
+        } else {
+            /* We are not even corked! */
+            return {0, false};
+        }
+    }
+};
+
+}
+
+#endif // UWS_ASYNCSOCKET_H

test/compatibility/C/uWebSockets/src/AsyncSocketData.h

@@ -0,0 +1,43 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_ASYNCSOCKETDATA_H
+#define UWS_ASYNCSOCKETDATA_H
+
+#include <string>
+
+namespace uWS {
+
+/* Depending on how we want AsyncSocket to function, this will need to change */
+
+template <bool SSL>
+struct AsyncSocketData {
+    /* This will do for now */
+    std::string buffer;
+
+    /* Allow move constructing us */
+    AsyncSocketData(std::string &&backpressure) : buffer(std::move(backpressure)) {
+
+    }
+
+    /* Or emppty */
+    AsyncSocketData() = default;
+};
+
+}
+
+#endif // UWS_ASYNCSOCKETDATA_H

test/compatibility/C/uWebSockets/src/HttpContext.h

@@ -0,0 +1,384 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_HTTPCONTEXT_H
+#define UWS_HTTPCONTEXT_H
+
+/* This class defines the main behavior of HTTP and emits various events */
+
+#include "Loop.h"
+#include "HttpContextData.h"
+#include "HttpResponseData.h"
+#include "AsyncSocket.h"
+
+#include <string_view>
+#include <iostream>
+#include "f2/function2.hpp"
+
+namespace uWS {
+template<bool> struct HttpResponse;
+
+template <bool SSL>
+struct HttpContext {
+    template<bool> friend struct TemplatedApp;
+private:
+    HttpContext() = delete;
+
+    /* Maximum delay allowed until an HTTP connection is terminated due to outstanding request or rejected data (slow loris protection) */
+    static const int HTTP_IDLE_TIMEOUT_S = 10;
+
+    us_socket_context_t *getSocketContext() {
+        return (us_socket_context_t *) this;
+    }
+
+    static us_socket_context_t *getSocketContext(us_socket_t *s) {
+        return (us_socket_context_t *) us_socket_context(SSL, s);
+    }
+
+    HttpContextData<SSL> *getSocketContextData() {
+        return (HttpContextData<SSL> *) us_socket_context_ext(SSL, getSocketContext());
+    }
+
+    static HttpContextData<SSL> *getSocketContextDataS(us_socket_t *s) {
+        return (HttpContextData<SSL> *) us_socket_context_ext(SSL, getSocketContext(s));
+    }
+
+    /* Init the HttpContext by registering libusockets event handlers */
+    HttpContext<SSL> *init() {
+        /* Handle socket connections */
+        us_socket_context_on_open(SSL, getSocketContext(), [](us_socket_t *s, int is_client, char *ip, int ip_length) {
+            /* Any connected socket should timeout until it has a request */
+            us_socket_timeout(SSL, s, HTTP_IDLE_TIMEOUT_S);
+
+            /* Init socket ext */
+            new (us_socket_ext(SSL, s)) HttpResponseData<SSL>;
+
+            /* Call filter */
+            HttpContextData<SSL> *httpContextData = getSocketContextDataS(s);
+            for (auto &f : httpContextData->filterHandlers) {
+                f((HttpResponse<SSL> *) s, 1);
+            }
+
+            return s;
+        });
+
+        /* Handle socket disconnections */
+        us_socket_context_on_close(SSL, getSocketContext(), [](us_socket_t *s) {
+            /* Get socket ext */
+            HttpResponseData<SSL> *httpResponseData = (HttpResponseData<SSL> *) us_socket_ext(SSL, s);
+
+            /* Call filter */
+            HttpContextData<SSL> *httpContextData = getSocketContextDataS(s);
+            for (auto &f : httpContextData->filterHandlers) {
+                f((HttpResponse<SSL> *) s, -1);
+            }
+
+            /* Signal broken HTTP request only if we have a pending request */
+            if (httpResponseData->onAborted) {
+                httpResponseData->onAborted();
+            }
+
+            /* Destruct socket ext */
+            httpResponseData->~HttpResponseData<SSL>();
+
+            return s;
+        });
+
+        /* Handle HTTP data streams */
+        us_socket_context_on_data(SSL, getSocketContext(), [](us_socket_t *s, char *data, int length) {
+
+            // total overhead is about 210k down to 180k
+            // ~210k req/sec is the original perf with write in data
+            // ~200k req/sec is with cork and formatting
+            // ~190k req/sec is with http parsing
+            // ~180k - 190k req/sec is with varying routing
+
+            HttpContextData<SSL> *httpContextData = getSocketContextDataS(s);
+
+            /* Do not accept any data while in shutdown state */
+            if (us_socket_is_shut_down(SSL, (us_socket_t *) s)) {
+                return s;
+            }
+
+            HttpResponseData<SSL> *httpResponseData = (HttpResponseData<SSL> *) us_socket_ext(SSL, s);
+
+            /* Cork this socket */
+            ((AsyncSocket<SSL> *) s)->cork();
+
+            // clients need to know the cursor after http parse, not servers!
+            // how far did we read then? we need to know to continue with websocket parsing data? or?
+
+            /* The return value is entirely up to us to interpret. The HttpParser only care for whether the returned value is DIFFERENT or not from passed user */
+            void *returnedSocket = httpResponseData->consumePostPadded(data, length, s, [httpContextData](void *s, uWS::HttpRequest *httpRequest) -> void * {
+                /* For every request we reset the timeout and hang until user makes action */
+                /* Warning: if we are in shutdown state, resetting the timer is a security issue! */
+                us_socket_timeout(SSL, (us_socket_t *) s, 0);
+
+                /* Reset httpResponse */
+                HttpResponseData<SSL> *httpResponseData = (HttpResponseData<SSL> *) us_socket_ext(SSL, (us_socket_t *) s);
+                httpResponseData->offset = 0;
+
+                /* Are we not ready for another request yet? Terminate the connection. */
+                if (httpResponseData->state & HttpResponseData<SSL>::HTTP_RESPONSE_PENDING) {
+                    us_socket_close(SSL, (us_socket_t *) s);
+                    return nullptr;
+                }
+
+                /* Mark pending request and emit it */
+                httpResponseData->state = HttpResponseData<SSL>::HTTP_RESPONSE_PENDING;
+
+                /* Route the method and URL */
+                httpContextData->router.getUserData() = {(HttpResponse<SSL> *) s, httpRequest};
+                if (!httpContextData->router.route(httpRequest->getMethod(), httpRequest->getUrl())) {
+                    /* We have to force close this socket as we have no handler for it */
+                    us_socket_close(SSL, (us_socket_t *) s);
+                    return nullptr;
+                }
+
+                /* First of all we need to check if this socket was deleted due to upgrade */
+                if (httpContextData->upgradedWebSocket) {
+                    /* We differ between closed and upgraded below */
+                    return nullptr;
+                }
+
+                /* Was the socket closed? */
+                if (us_socket_is_closed(SSL, (struct us_socket_t *) s)) {
+                    return nullptr;
+                }
+
+                /* We absolutely have to terminate parsing if shutdown */
+                if (us_socket_is_shut_down(SSL, (us_socket_t *) s)) {
+                    return nullptr;
+                }
+
+                /* Returning from a request handler without responding or attaching an onAborted handler is ill-use */
+                if (!((HttpResponse<SSL> *) s)->hasResponded() && !httpResponseData->onAborted) {
+                    /* Throw exception here? */
+                    std::cerr << "Error: Returning from a request handler without responding or attaching an abort handler is forbidden!" << std::endl;
+                    std::terminate();
+                }
+
+                /* If we have not responded and we have a data handler, we need to timeout to enfore client sending the data */
+                if (!((HttpResponse<SSL> *) s)->hasResponded() && httpResponseData->inStream) {
+                    us_socket_timeout(SSL, (us_socket_t *) s, HTTP_IDLE_TIMEOUT_S);
+                }
+
+                /* Continue parsing */
+                return s;
+
+            }, [httpResponseData](void *user, std::string_view data, bool fin) -> void * {
+                /* We always get an empty chunk even if there is no data */
+                if (httpResponseData->inStream) {
+
+                    /* Todo: can this handle timeout for non-post as well? */
+                    if (fin) {
+                        /* If we just got the last chunk (or empty chunk), disable timeout */
+                        us_socket_timeout(SSL, (struct us_socket_t *) user, 0);
+                    } else {
+                        /* We still have some more data coming in later, so reset timeout */
+                        us_socket_timeout(SSL, (struct us_socket_t *) user, HTTP_IDLE_TIMEOUT_S);
+                    }
+
+                    /* We might respond in the handler, so do not change timeout after this */
+                    httpResponseData->inStream(data, fin);
+
+                    /* Was the socket closed? */
+                    if (us_socket_is_closed(SSL, (struct us_socket_t *) user)) {
+                        return nullptr;
+                    }
+
+                    /* We absolutely have to terminate parsing if shutdown */
+                    if (us_socket_is_shut_down(SSL, (us_socket_t *) user)) {
+                        return nullptr;
+                    }
+                    
+                    /* If we were given the last data chunk, reset data handler to ensure following
+                     * requests on the same socket won't trigger any previously registered behavior */
+                    if (fin) {
+                        httpResponseData->inStream = nullptr;
+                    }
+                }
+                return user;
+            }, [](void *user) {
+                 /* Close any socket on HTTP errors */
+                us_socket_close(SSL, (us_socket_t *) user);
+                return nullptr;
+            });
+
+            /* We need to uncork in all cases, except for nullptr (closed socket, or upgraded socket) */
+            if (returnedSocket != nullptr) {
+                /* Timeout on uncork failure */
+                auto [written, failed] = ((AsyncSocket<SSL> *) returnedSocket)->uncork();
+                if (failed) {
+                    /* All Http sockets timeout by this, and this behavior match the one in HttpResponse::cork */
+                    /* Warning: both HTTP_IDLE_TIMEOUT_S and HTTP_TIMEOUT_S are 10 seconds and both are used the same */
+                    ((AsyncSocket<SSL> *) s)->timeout(HTTP_IDLE_TIMEOUT_S);
+                }
+
+                return (us_socket_t *) returnedSocket;
+            }
+
+            /* If we upgraded, check here (differ between nullptr close and nullptr upgrade) */
+            if (httpContextData->upgradedWebSocket) {
+                /* This path is only for upgraded websockets */
+                AsyncSocket<SSL> *asyncSocket = (AsyncSocket<SSL> *) httpContextData->upgradedWebSocket;
+
+                /* Uncork here as well (note: what if we failed to uncork and we then pub/sub before we even upgraded?) */
+                /*auto [written, failed] = */asyncSocket->uncork();
+
+                /* Reset upgradedWebSocket before we return */
+                httpContextData->upgradedWebSocket = nullptr;
+
+                /* Return the new upgraded websocket */
+                return (us_socket_t *) asyncSocket;
+            }
+
+            /* It is okay to uncork a closed socket and we need to */
+            ((AsyncSocket<SSL> *) s)->uncork();
+
+            /* We cannot return nullptr to the underlying stack in any case */
+            return s;
+        });
+
+        /* Handle HTTP write out (note: SSL_read may trigger this spuriously, the app need to handle spurious calls) */
+        us_socket_context_on_writable(SSL, getSocketContext(), [](us_socket_t *s) {
+
+            AsyncSocket<SSL> *asyncSocket = (AsyncSocket<SSL> *) s;
+            HttpResponseData<SSL> *httpResponseData = (HttpResponseData<SSL> *) asyncSocket->getAsyncSocketData();
+
+            /* Ask the developer to write data and return success (true) or failure (false), OR skip sending anything and return success (true). */
+            if (httpResponseData->onWritable) {
+                /* We are now writable, so hang timeout again, the user does not have to do anything so we should hang until end or tryEnd rearms timeout */
+                us_socket_timeout(SSL, s, 0);
+
+                /* We expect the developer to return whether or not write was successful (true).
+                 * If write was never called, the developer should still return true so that we may drain. */
+                bool success = httpResponseData->onWritable(httpResponseData->offset);
+
+                /* The developer indicated that their onWritable failed. */
+                if (!success) {
+                    /* Skip testing if we can drain anything since that might perform an extra syscall */
+                    return s;
+                }
+
+                /* We don't want to fall through since we don't want to mess with timeout.
+                 * It makes little sense to drain any backpressure when the user has registered onWritable. */
+                return s;
+            }
+
+            /* Drain any socket buffer, this might empty our backpressure and thus finish the request */
+            /*auto [written, failed] = */asyncSocket->write(nullptr, 0, true, 0);
+
+            /* Expect another writable event, or another request within the timeout */
+            asyncSocket->timeout(HTTP_IDLE_TIMEOUT_S);
+
+            return s;
+        });
+
+        /* Handle FIN, HTTP does not support half-closed sockets, so simply close */
+        us_socket_context_on_end(SSL, getSocketContext(), [](us_socket_t *s) {
+
+            /* We do not care for half closed sockets */
+            AsyncSocket<SSL> *asyncSocket = (AsyncSocket<SSL> *) s;
+            return asyncSocket->close();
+
+        });
+
+        /* Handle socket timeouts, simply close them so to not confuse client with FIN */
+        us_socket_context_on_timeout(SSL, getSocketContext(), [](us_socket_t *s) {
+
+            /* Force close rather than gracefully shutdown and risk confusing the client with a complete download */
+            AsyncSocket<SSL> *asyncSocket = (AsyncSocket<SSL> *) s;
+            return asyncSocket->close();
+
+        });
+
+        return this;
+    }
+
+    /* Used by App in its WebSocket handler */
+    void upgradeToWebSocket(void *newSocket) {
+        HttpContextData<SSL> *httpContextData = getSocketContextData();
+
+        httpContextData->upgradedWebSocket = newSocket;
+    }
+
+public:
+    /* Construct a new HttpContext using specified loop */
+    static HttpContext *create(Loop *loop, us_socket_context_options_t options = {}) {
+        HttpContext *httpContext;
+
+        httpContext = (HttpContext *) us_create_socket_context(SSL, (us_loop_t *) loop, sizeof(HttpContextData<SSL>), options);
+
+        if (!httpContext) {
+            return nullptr;
+        }
+
+        /* Init socket context data */
+        new ((HttpContextData<SSL> *) us_socket_context_ext(SSL, (us_socket_context_t *) httpContext)) HttpContextData<SSL>();
+        return httpContext->init();
+    }
+
+    /* Destruct the HttpContext, it does not follow RAII */
+    void free() {
+        /* Destruct socket context data */
+        HttpContextData<SSL> *httpContextData = getSocketContextData();
+        httpContextData->~HttpContextData<SSL>();
+
+        /* Free the socket context in whole */
+        us_socket_context_free(SSL, getSocketContext());
+    }
+
+    void filter(fu2::unique_function<void(HttpResponse<SSL> *, int)> &&filterHandler) {
+        getSocketContextData()->filterHandlers.emplace_back(std::move(filterHandler));
+    }
+
+    /* Register an HTTP route handler acording to URL pattern */
+    void onHttp(std::string method, std::string pattern, fu2::unique_function<void(HttpResponse<SSL> *, HttpRequest *)> &&handler, bool upgrade = false) {
+        HttpContextData<SSL> *httpContextData = getSocketContextData();
+
+        /* Todo: This is ugly, fix */
+        std::vector<std::string> methods;
+        if (method == "*") {
+            methods = httpContextData->router.methods;
+        } else {
+            methods = {method};
+        }
+
+        httpContextData->router.add(methods, pattern, [handler = std::move(handler)](auto *r) mutable {
+            auto user = r->getUserData();
+            user.httpRequest->setYield(false);
+            user.httpRequest->setParameters(r->getParameters());
+            handler(user.httpResponse, user.httpRequest);
+
+            /* If any handler yielded, the router will keep looking for a suitable handler. */
+            if (user.httpRequest->getYield()) {
+                return false;
+            }
+            return true;
+        }, method == "*" ? httpContextData->router.LOW_PRIORITY : (upgrade ? httpContextData->router.HIGH_PRIORITY : httpContextData->router.MEDIUM_PRIORITY));
+    }
+
+    /* Listen to port using this HttpContext */
+    us_listen_socket_t *listen(const char *host, int port, int options) {
+        return us_socket_context_listen(SSL, getSocketContext(), host, port, options, sizeof(HttpResponseData<SSL>));
+    }
+};
+
+}
+
+#endif // UWS_HTTPCONTEXT_H

test/compatibility/C/uWebSockets/src/HttpContextData.h

@@ -0,0 +1,48 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_HTTPCONTEXTDATA_H
+#define UWS_HTTPCONTEXTDATA_H
+
+#include "HttpRouter.h"
+
+#include <vector>
+#include "f2/function2.hpp"
+
+namespace uWS {
+template<bool> struct HttpResponse;
+struct HttpRequest;
+
+template <bool SSL>
+struct alignas(16) HttpContextData {
+    template <bool> friend struct HttpContext;
+    template <bool> friend struct HttpResponse;
+private:
+    std::vector<fu2::unique_function<void(HttpResponse<SSL> *, int)>> filterHandlers;
+
+    struct RouterData {
+        HttpResponse<SSL> *httpResponse;
+        HttpRequest *httpRequest;
+    };
+
+    HttpRouter<RouterData> router;
+    void *upgradedWebSocket = nullptr;
+};
+
+}
+
+#endif // UWS_HTTPCONTEXTDATA_H

test/compatibility/C/uWebSockets/src/HttpParser.h

@@ -0,0 +1,334 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_HTTPPARSER_H
+#define UWS_HTTPPARSER_H
+
+// todo: HttpParser is in need of a few clean-ups and refactorings
+
+/* The HTTP parser is an independent module subject to unit testing / fuzz testing */
+
+#include <string>
+#include <cstring>
+#include <algorithm>
+#include "f2/function2.hpp"
+
+namespace uWS {
+
+/* We require at least this much post padding */
+static const int MINIMUM_HTTP_POST_PADDING = 32;
+
+struct HttpRequest {
+
+    friend struct HttpParser;
+
+private:
+    const static int MAX_HEADERS = 50;
+    struct Header {
+        std::string_view key, value;
+    } headers[MAX_HEADERS];
+    int querySeparator;
+    bool didYield;
+
+    std::pair<int, std::string_view *> currentParameters;
+
+public:
+    bool getYield() {
+        return didYield;
+    }
+
+    /* Iteration over headers (key, value) */
+    struct HeaderIterator {
+        Header *ptr;
+
+        bool operator!=(const HeaderIterator &other) const {
+            /* Comparison with end is a special case */
+            if (ptr != other.ptr) {
+                return other.ptr || ptr->key.length();
+            }
+            return false;
+        }
+
+        HeaderIterator &operator++() {
+            ptr++;
+            return *this;
+        }
+
+        std::pair<std::string_view, std::string_view> operator*() const {
+            return {ptr->key, ptr->value};
+        }
+    };
+
+    HeaderIterator begin() {
+        return {headers + 1};
+    }
+
+    HeaderIterator end() {
+        return {nullptr};
+    }
+
+    /* If you do not want to handle this route */
+    void setYield(bool yield) {
+        didYield = yield;
+    }
+
+    std::string_view getHeader(std::string_view lowerCasedHeader) {
+        for (Header *h = headers; (++h)->key.length(); ) {
+            if (h->key.length() == lowerCasedHeader.length() && !strncmp(h->key.data(), lowerCasedHeader.data(), lowerCasedHeader.length())) {
+                return h->value;
+            }
+        }
+        return std::string_view(nullptr, 0);
+    }
+
+    std::string_view getUrl() {
+        return std::string_view(headers->value.data(), querySeparator);
+    }
+
+    std::string_view getMethod() {
+        return std::string_view(headers->key.data(), headers->key.length());
+    }
+
+    std::string_view getQuery() {
+        if (querySeparator < (int) headers->value.length()) {
+            /* Strip the initial ? */
+            return std::string_view(headers->value.data() + querySeparator + 1, headers->value.length() - querySeparator - 1);
+        } else {
+            return std::string_view(nullptr, 0);
+        }
+    }
+
+    void setParameters(std::pair<int, std::string_view *> parameters) {
+        currentParameters = parameters;
+    }
+
+    std::string_view getParameter(unsigned int index) {
+        if (currentParameters.first < (int) index) {
+            return {};
+        } else {
+            return currentParameters.second[index];
+        }
+    }
+
+};
+
+struct HttpParser {
+
+private:
+    std::string fallback;
+    unsigned int remainingStreamingBytes = 0;
+
+    const size_t MAX_FALLBACK_SIZE = 1024 * 4;
+
+    static unsigned int toUnsignedInteger(std::string_view str) {
+        unsigned int unsignedIntegerValue = 0;
+        for (unsigned char c : str) {
+            unsignedIntegerValue = unsignedIntegerValue * 10 + (c - '0');
+        }
+        return unsignedIntegerValue;
+    }
+
+    static unsigned int getHeaders(char *postPaddedBuffer, char *end, struct HttpRequest::Header *headers) {
+        char *preliminaryKey, *preliminaryValue, *start = postPaddedBuffer;
+
+        for (unsigned int i = 0; i < HttpRequest::MAX_HEADERS; i++) {
+            for (preliminaryKey = postPaddedBuffer; (*postPaddedBuffer != ':') & (*postPaddedBuffer > 32); *(postPaddedBuffer++) |= 32);
+            if (*postPaddedBuffer == '\r') {
+                if ((postPaddedBuffer != end) & (postPaddedBuffer[1] == '\n') & (i > 0)) {
+                    headers->key = std::string_view(nullptr, 0);
+                    return (unsigned int) ((postPaddedBuffer + 2) - start);
+                } else {
+                    return 0;
+                }
+            } else {
+                headers->key = std::string_view(preliminaryKey, (size_t) (postPaddedBuffer - preliminaryKey));
+                for (postPaddedBuffer++; (*postPaddedBuffer == ':' || *postPaddedBuffer < 33) && *postPaddedBuffer != '\r'; postPaddedBuffer++);
+                preliminaryValue = postPaddedBuffer;
+                postPaddedBuffer = (char *) memchr(postPaddedBuffer, '\r', end - postPaddedBuffer);
+                if (postPaddedBuffer && postPaddedBuffer[1] == '\n') {
+                    headers->value = std::string_view(preliminaryValue, (size_t) (postPaddedBuffer - preliminaryValue));
+                    postPaddedBuffer += 2;
+                    headers++;
+                } else {
+                    return 0;
+                }
+            }
+        }
+        return 0;
+    }
+
+    // the only caller of getHeaders
+    template <int CONSUME_MINIMALLY>
+    std::pair<int, void *> fenceAndConsumePostPadded(char *data, int length, void *user, HttpRequest *req, fu2::unique_function<void *(void *, HttpRequest *)> &requestHandler, fu2::unique_function<void *(void *, std::string_view, bool)> &dataHandler) {
+        int consumedTotal = 0;
+        data[length] = '\r';
+
+        for (int consumed; length && (consumed = getHeaders(data, data + length, req->headers)); ) {
+            data += consumed;
+            length -= consumed;
+            consumedTotal += consumed;
+
+            req->headers->value = std::string_view(req->headers->value.data(), std::max<int>(0, (int) req->headers->value.length() - 9));
+
+            /* Parse query */
+            const char *querySeparatorPtr = (const char *) memchr(req->headers->value.data(), '?', req->headers->value.length());
+            req->querySeparator = (int) ((querySeparatorPtr ? querySeparatorPtr : req->headers->value.data() + req->headers->value.length()) - req->headers->value.data());
+
+            /* If returned socket is not what we put in we need
+             * to break here as we either have upgraded to
+             * WebSockets or otherwise closed the socket. */
+            void *returnedUser = requestHandler(user, req);
+            if (returnedUser != user) {
+                /* We are upgraded to WebSocket or otherwise broken */
+                return {consumedTotal, returnedUser};
+            }
+
+            // todo: do not check this for GET (get should not have a body)
+            // todo: also support reading chunked streams
+            std::string_view contentLengthString = req->getHeader("content-length");
+            if (contentLengthString.length()) {
+                remainingStreamingBytes = toUnsignedInteger(contentLengthString);
+
+                if (!CONSUME_MINIMALLY) {
+                    unsigned int emittable = std::min<unsigned int>(remainingStreamingBytes, length);
+                    dataHandler(user, std::string_view(data, emittable), emittable == remainingStreamingBytes);
+                    remainingStreamingBytes -= emittable;
+
+                    data += emittable;
+                    length -= emittable;
+                    consumedTotal += emittable;
+                }
+            } else {
+                /* Still emit an empty data chunk to signal no data */
+                dataHandler(user, {}, true);
+            }
+
+            if (CONSUME_MINIMALLY) {
+                break;
+            }
+        }
+        return {consumedTotal, user};
+    }
+
+public:
+
+    /* We do this to prolong the validity of parsed headers by keeping only the fallback buffer alive */
+    std::string &&salvageFallbackBuffer() {
+        return std::move(fallback);
+    }
+
+    void *consumePostPadded(char *data, int length, void *user, fu2::unique_function<void *(void *, HttpRequest *)> &&requestHandler, fu2::unique_function<void *(void *, std::string_view, bool)> &&dataHandler, fu2::unique_function<void *(void *)> &&errorHandler) {
+
+        HttpRequest req;
+
+        if (remainingStreamingBytes) {
+
+            // this is exactly the same as below!
+            // todo: refactor this
+            if (remainingStreamingBytes >= (unsigned int) length) {
+                void *returnedUser = dataHandler(user, std::string_view(data, length), remainingStreamingBytes == (unsigned int) length);
+                remainingStreamingBytes -= length;
+                return returnedUser;
+            } else {
+                void *returnedUser = dataHandler(user, std::string_view(data, remainingStreamingBytes), true);
+
+                data += remainingStreamingBytes;
+                length -= remainingStreamingBytes;
+
+                remainingStreamingBytes = 0;
+
+                if (returnedUser != user) {
+                    return returnedUser;
+                }
+            }
+
+        } else if (fallback.length()) {
+            int had = (int) fallback.length();
+
+            int maxCopyDistance = (int) std::min(MAX_FALLBACK_SIZE - fallback.length(), (size_t) length);
+
+            /* We don't want fallback to be short string optimized, since we want to move it */
+            fallback.reserve(fallback.length() + maxCopyDistance + std::max<int>(MINIMUM_HTTP_POST_PADDING, sizeof(std::string)));
+            fallback.append(data, maxCopyDistance);
+
+            // break here on break
+            std::pair<int, void *> consumed = fenceAndConsumePostPadded<true>(fallback.data(), (int) fallback.length(), user, &req, requestHandler, dataHandler);
+            if (consumed.second != user) {
+                return consumed.second;
+            }
+
+            if (consumed.first) {
+
+                fallback.clear();
+
+                data += consumed.first - had;
+                length -= consumed.first - had;
+
+                if (remainingStreamingBytes) {
+                    // this is exactly the same as above!
+                    if (remainingStreamingBytes >= (unsigned int) length) {
+                        void *returnedUser = dataHandler(user, std::string_view(data, length), remainingStreamingBytes == (unsigned int) length);
+                        remainingStreamingBytes -= length;
+                        return returnedUser;
+                    } else {
+                        void *returnedUser = dataHandler(user, std::string_view(data, remainingStreamingBytes), true);
+
+                        data += remainingStreamingBytes;
+                        length -= remainingStreamingBytes;
+
+                        remainingStreamingBytes = 0;
+
+                        if (returnedUser != user) {
+                            return returnedUser;
+                        }
+                    }
+                }
+
+            } else {
+                if (fallback.length() == MAX_FALLBACK_SIZE) {
+                    // note: you don't really need error handler, just return something strange!
+                    // we could have it return a constant pointer to denote error!
+                    return errorHandler(user);
+                }
+                return user;
+            }
+        }
+
+        std::pair<int, void *> consumed = fenceAndConsumePostPadded<false>(data, length, user, &req, requestHandler, dataHandler);
+        if (consumed.second != user) {
+            return consumed.second;
+        }
+
+        data += consumed.first;
+        length -= consumed.first;
+
+        if (length) {
+            if ((unsigned int) length < MAX_FALLBACK_SIZE) {
+                fallback.append(data, length);
+            } else {
+                return errorHandler(user);
+            }
+        }
+
+        // added for now
+        return user;
+    }
+};
+
+}
+
+#endif // UWS_HTTPPARSER_H

test/compatibility/C/uWebSockets/src/HttpResponse.h

@@ -0,0 +1,317 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_HTTPRESPONSE_H
+#define UWS_HTTPRESPONSE_H
+
+/* An HttpResponse is the channel on which you send back a response */
+
+#include "AsyncSocket.h"
+#include "HttpResponseData.h"
+#include "HttpContextData.h"
+#include "Utilities.h"
+
+#include "f2/function2.hpp"
+
+/* todo: tryWrite is missing currently, only send smaller segments with write */
+
+namespace uWS {
+
+/* Some pre-defined status constants to use with writeStatus */
+static const char *HTTP_200_OK = "200 OK";
+
+/* The general timeout for HTTP sockets */
+static const int HTTP_TIMEOUT_S = 10;
+
+template <bool SSL>
+struct HttpResponse : public AsyncSocket<SSL> {
+    /* Solely used for getHttpResponseData() */
+    template <bool> friend struct TemplatedApp;
+    typedef AsyncSocket<SSL> Super;
+private:
+    HttpResponseData<SSL> *getHttpResponseData() {
+        return (HttpResponseData<SSL> *) Super::getAsyncSocketData();
+    }
+
+    /* Write an unsigned 32-bit integer in hex */
+    void writeUnsignedHex(unsigned int value) {
+        char buf[10];
+        int length = utils::u32toaHex(value, buf);
+
+        /* For now we do this copy */
+        Super::write(buf, length);
+    }
+
+    /* Write an unsigned 32-bit integer */
+    void writeUnsigned(unsigned int value) {
+        char buf[10];
+        int length = utils::u32toa(value, buf);
+
+        /* For now we do this copy */
+        Super::write(buf, length);
+    }
+
+    /* When we are done with a response we mark it like so */
+    void markDone(HttpResponseData<SSL> *httpResponseData) {
+        httpResponseData->onAborted = nullptr;
+        /* Also remove onWritable so that we do not emit when draining behind the scenes. */
+        httpResponseData->onWritable = nullptr;
+
+        /* We are done with this request */
+        httpResponseData->state &= ~HttpResponseData<SSL>::HTTP_RESPONSE_PENDING;
+    }
+
+    /* Called only once per request */
+    void writeMark() {
+        writeHeader("uWebSockets", "v0.17");
+    }
+
+    /* Returns true on success, indicating that it might be feasible to write more data.
+     * Will start timeout if stream reaches totalSize or write failure. */
+    bool internalEnd(std::string_view data, int totalSize, bool optional, bool allowContentLength = true) {
+        /* Write status if not already done */
+        writeStatus(HTTP_200_OK);
+
+        /* If no total size given then assume this chunk is everything */
+        if (!totalSize) {
+            totalSize = (int) data.length();
+        }
+
+        HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
+        if (httpResponseData->state & HttpResponseData<SSL>::HTTP_WRITE_CALLED) {
+
+            /* We do not have tryWrite-like functionalities, so ignore optional in this path */
+
+            /* Do not allow sending 0 chunk here */
+            if (data.length()) {
+                Super::write("\r\n", 2);
+                writeUnsignedHex((unsigned int) data.length());
+                Super::write("\r\n", 2);
+
+                /* Ignoring optional for now */
+                Super::write(data.data(), (int) data.length());
+            }
+
+            /* Terminating 0 chunk */
+            Super::write("\r\n0\r\n\r\n", 7);
+
+            markDone(httpResponseData);
+
+            /* tryEnd can never fail when in chunked mode, since we do not have tryWrite (yet), only write */
+            Super::timeout(HTTP_TIMEOUT_S);
+            return true;
+        } else {
+            /* Write content-length on first call */
+            if (!(httpResponseData->state & HttpResponseData<SSL>::HTTP_END_CALLED)) {
+                /* Write mark, this propagates to WebSockets too */
+                writeMark();
+
+                /* WebSocket upgrades does not allow content-length */
+                if (allowContentLength) {
+                    /* Even zero is a valid content-length */
+                    Super::write("Content-Length: ", 16);
+                    writeUnsigned(totalSize);
+                    Super::write("\r\n\r\n", 4);
+                } else {
+                    Super::write("\r\n", 2);
+                }
+
+                /* Mark end called */
+                httpResponseData->state |= HttpResponseData<SSL>::HTTP_END_CALLED;
+            }
+
+            /* Even if we supply no new data to write, its failed boolean is useful to know
+             * if it failed to drain any prior failed header writes */
+
+            /* Write as much as possible without causing backpressure */
+            auto [written, failed] = Super::write(data.data(), (int) data.length(), optional);
+            httpResponseData->offset += written;
+
+            /* Success is when we wrote the entire thing without any failures */
+            bool success = (unsigned int) written == data.length() && !failed;
+
+            /* If we are now at the end, start a timeout. Also start a timeout if we failed. */
+            if (!success || httpResponseData->offset == totalSize) {
+                Super::timeout(HTTP_TIMEOUT_S);
+            }
+
+            /* Remove onAborted function if we reach the end */
+            if (httpResponseData->offset == totalSize) {
+                markDone(httpResponseData);
+            }
+
+            return success;
+        }
+    }
+
+    /* This call is identical to end, but will never write content-length and is thus suitable for upgrades */
+    void upgrade() {
+        internalEnd({nullptr, 0}, 0, false, false);
+    }
+
+public:
+    /* Immediately terminate this Http response */
+    using Super::close;
+
+    using Super::getRemoteAddress;
+
+    /* Note: Headers are not checked in regards to timeout.
+     * We only check when you actively push data or end the request */
+
+    /* Write the HTTP status */
+    HttpResponse *writeStatus(std::string_view status) {
+        HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
+
+        /* Do not allow writing more than one status */
+        if (httpResponseData->state & HttpResponseData<SSL>::HTTP_STATUS_CALLED) {
+            return this;
+        }
+
+        /* Update status */
+        httpResponseData->state |= HttpResponseData<SSL>::HTTP_STATUS_CALLED;
+
+        Super::write("HTTP/1.1 ", 9);
+        Super::write(status.data(), (int) status.length());
+        Super::write("\r\n", 2);
+        return this;
+    }
+
+    /* Write an HTTP header with string value */
+    HttpResponse *writeHeader(std::string_view key, std::string_view value) {
+        writeStatus(HTTP_200_OK);
+
+        Super::write(key.data(), (int) key.length());
+        Super::write(": ", 2);
+        Super::write(value.data(), (int) value.length());
+        Super::write("\r\n", 2);
+        return this;
+    }
+
+    /* Write an HTTP header with unsigned int value */
+    HttpResponse *writeHeader(std::string_view key, unsigned int value) {
+        Super::write(key.data(), (int) key.length());
+        Super::write(": ", 2);
+        writeUnsigned(value);
+        Super::write("\r\n", 2);
+        return this;
+    }
+
+    /* End the response with an optional data chunk. Always starts a timeout. */
+    void end(std::string_view data = {}) {
+        internalEnd(data, (int) data.length(), false);
+    }
+
+    /* Try and end the response. Returns [true, true] on success.
+     * Starts a timeout in some cases. Returns [ok, hasResponded] */
+    std::pair<bool, bool> tryEnd(std::string_view data, int totalSize = 0) {
+        return {internalEnd(data, totalSize, true), hasResponded()};
+    }
+
+    /* Write parts of the response in chunking fashion. Starts timeout if failed. */
+    bool write(std::string_view data) {
+        writeStatus(HTTP_200_OK);
+
+        /* Do not allow sending 0 chunks, they mark end of response */
+        if (!data.length()) {
+            /* If you called us, then according to you it was fine to call us so it's fine to still call us */
+            return true;
+        }
+
+        HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
+
+        if (!(httpResponseData->state & HttpResponseData<SSL>::HTTP_WRITE_CALLED)) {
+            /* Write mark on first call to write */
+            writeMark();
+
+            writeHeader("Transfer-Encoding", "chunked");
+            httpResponseData->state |= HttpResponseData<SSL>::HTTP_WRITE_CALLED;
+        }
+
+        Super::write("\r\n", 2);
+        writeUnsignedHex((unsigned int) data.length());
+        Super::write("\r\n", 2);
+
+        auto [written, failed] = Super::write(data.data(), (int) data.length());
+        if (failed) {
+            Super::timeout(HTTP_TIMEOUT_S);
+        }
+
+        /* If we did not fail the write, accept more */
+        return !failed;
+    }
+
+    /* Get the current byte write offset for this Http response */
+    int getWriteOffset() {
+        HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
+
+        return httpResponseData->offset;
+    }
+
+    /* Checking if we have fully responded and are ready for another request */
+    bool hasResponded() {
+        HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
+
+        return !(httpResponseData->state & HttpResponseData<SSL>::HTTP_RESPONSE_PENDING);
+    }
+
+    /* Corks the response if possible. Leaves already corked socket be. */
+    HttpResponse *cork(fu2::unique_function<void()> &&handler) {
+        if (!Super::isCorked() && Super::canCork()) {
+            Super::cork();
+            handler();
+
+            /* Timeout on uncork failure, since most writes will succeed while corked */
+            auto [written, failed] = Super::uncork();
+            if (failed) {
+                /* For now we only have one single timeout so let's use it */
+                /* This behavior should equal the behavior in HttpContext when uncorking fails */
+                Super::timeout(HTTP_TIMEOUT_S);
+            }
+        } else {
+            /* We are already corked, or can't cork so let's just call the handler */
+            handler();
+        }
+
+        return this;
+    }
+
+    /* Attach handler for writable HTTP response */
+    HttpResponse *onWritable(fu2::unique_function<bool(int)> &&handler) {
+        HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
+
+        httpResponseData->onWritable = std::move(handler);
+        return this;
+    }
+
+    /* Attach handler for aborted HTTP request */
+    HttpResponse *onAborted(fu2::unique_function<void()> &&handler) {
+        HttpResponseData<SSL> *httpResponseData = getHttpResponseData();
+
+        httpResponseData->onAborted = std::move(handler);
+        return this;
+    }
+
+    /* Attach a read handler for data sent. Will be called with FIN set true if last segment. */
+    void onData(fu2::unique_function<void(std::string_view, bool)> &&handler) {
+        HttpResponseData<SSL> *data = getHttpResponseData();
+        data->inStream = std::move(handler);
+    }
+};
+
+}
+
+#endif // UWS_HTTPRESPONSE_H

test/compatibility/C/uWebSockets/src/HttpResponseData.h

@@ -0,0 +1,57 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_HTTPRESPONSEDATA_H
+#define UWS_HTTPRESPONSEDATA_H
+
+/* This data belongs to the HttpResponse */
+
+#include "HttpParser.h"
+#include "AsyncSocketData.h"
+
+#include "f2/function2.hpp"
+
+namespace uWS {
+
+template <bool SSL>
+struct HttpResponseData : AsyncSocketData<SSL>, HttpParser {
+    template <bool> friend struct HttpResponse;
+    template <bool> friend struct HttpContext;
+private:
+    /* Bits of status */
+    enum {
+        HTTP_STATUS_CALLED = 1, // used
+        HTTP_WRITE_CALLED = 2, // used
+        HTTP_END_CALLED = 4, // used
+        HTTP_RESPONSE_PENDING = 8, // used
+        HTTP_ENDED_STREAM_OUT = 16 // not used
+    };
+
+    /* Per socket event handlers */
+    fu2::unique_function<bool(int)> onWritable;
+    fu2::unique_function<void()> onAborted;
+    fu2::unique_function<void(std::string_view, bool)> inStream; // onData
+    /* Outgoing offset */
+    int offset = 0;
+
+    /* Current state (content-length sent, status sent, write called, etc */
+    int state = 0;
+};
+
+}
+
+#endif // UWS_HTTPRESPONSEDATA_H

test/compatibility/C/uWebSockets/src/HttpRouter.h

@@ -0,0 +1,233 @@
+/*
+ * Authored by Alex Hultman, 2018-2019.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef UWS_HTTPROUTER_HPP
+#define UWS_HTTPROUTER_HPP
+
+#include <map>
+#include <vector>
+#include <cstring>
+#include <string_view>
+#include <string>
+#include <algorithm>
+#include <memory>
+
+#include "f2/function2.hpp"
+
+namespace uWS {
+
+template <class USERDATA>
+struct HttpRouter {
+    /* These are public for now */
+    std::vector<std::string> methods = {"get", "post", "head", "put", "delete", "connect", "options", "trace", "patch"};
+    static const uint32_t HIGH_PRIORITY = 0xd0000000, MEDIUM_PRIORITY = 0xe0000000, LOW_PRIORITY = 0xf0000000;
+
+private:
+    USERDATA userData;
+    static const unsigned int MAX_URL_SEGMENTS = 100;
+
+    /* Handler ids are 32-bit */
+    static const uint32_t HANDLER_MASK = 0x0fffffff;
+    
+    /* Methods and their respective priority */
+    std::map<std::string, int> priority;
+
+    /* List of handlers */
+    std::vector<fu2::unique_function<bool(HttpRouter *)>> handlers;
+
+    /* Current URL cache */
+    std::string_view currentUrl;
+    std::string_view urlSegmentVector[MAX_URL_SEGMENTS];
+    int urlSegmentTop;
+
+    /* The matching tree */
+    struct Node {
+        std::string name;
+        std::vector<std::unique_ptr<Node>> children;
+        std::vector<uint32_t> handlers;
+    } root = {"rootNode"};
+
+    /* Advance from parent to child, adding child if necessary */
+    Node *getNode(Node *parent, std::string child) {
+        for (std::unique_ptr<Node> &node : parent->children) {
+            if (node->name == child) {
+                return node.get();
+            }
+        }
+
+        /* Insert sorted, but keep order if parent is root (we sort methods by priority elsewhere) */
+        std::unique_ptr<Node> newNode(new Node({child}));
+        return parent->children.emplace(std::upper_bound(parent->children.begin(), parent->children.end(), newNode, [parent, this](auto &a, auto &b) {
+            return b->name.length() && (parent != &root) && (b->name < a->name);
+        }), std::move(newNode))->get();
+    }
+
+    /* Basically a pre-allocated stack */
+    struct RouteParameters {
+        friend struct HttpRouter;
+    private:
+        std::string_view params[MAX_URL_SEGMENTS];
+        int paramsTop;
+
+        void reset() {
+            paramsTop = -1;
+        }
+
+        void push(std::string_view param) {
+            /* We check these bounds indirectly via the urlSegments limit */
+            params[++paramsTop] = param;
+        }
+
+        void pop() {
+            /* Same here, we cannot pop outside */
+            paramsTop--;
+        }
+    } routeParameters;
+
+    /* Set URL for router. Will reset any URL cache */
+    inline void setUrl(std::string_view url) {
+        /* Remove / from input URL */
+        currentUrl = url.substr(std::min<unsigned int>((unsigned int) url.length(), 1));
+        urlSegmentTop = -1;
+    }
+
+    /* Lazily parse or read from cache */
+    inline std::string_view getUrlSegment(int urlSegment) {
+        if (urlSegment > urlSegmentTop) {
+            /* Return empty segment if we are out of URL or stack space, but never for first url segment */
+            if (!currentUrl.length() || urlSegment > 99) {
+                return {};
+            }
+
+            auto segmentLength = currentUrl.find('/');
+            if (segmentLength == std::string::npos) {
+                segmentLength = currentUrl.length();
+
+                /* Push to url segment vector */
+                urlSegmentVector[urlSegment] = currentUrl.substr(0, segmentLength);
+                urlSegmentTop++;
+
+                /* Update currentUrl */
+                currentUrl = currentUrl.substr(segmentLength);
+            } else {
+                /* Push to url segment vector */
+                urlSegmentVector[urlSegment] = currentUrl.substr(0, segmentLength);
+                urlSegmentTop++;
+
+                /* Update currentUrl */
+                currentUrl = currentUrl.substr(segmentLength + 1);
+            }
+        }
+        /* In any case we return it */
+        return urlSegmentVector[urlSegment];
+    }
+
+    /* Executes as many handlers it can */
+    bool executeHandlers(Node *parent, int urlSegment, USERDATA &userData) {
+        /* If we have no more URL and not on first round, return where we may stand */
+        if (urlSegment && !getUrlSegment(urlSegment).length()) {
+            /* We have reached accross the entire URL with no stoppage, execute */
+            for (int handler : parent->handlers) {
+                if (handlers[handler & HANDLER_MASK](this)) {
+                    return true;
+                }
+            }
+            /* We reached the end, so go back */
+            return false;
+        }
+
+        for (auto &p : parent->children) {
+            if (p->name.length() && p->name[0] == '*') {
+                /* Wildcard match (can be seen as a shortcut) */
+                for (int handler : p->handlers) {
+                    if (handlers[handler & HANDLER_MASK](this)) {
+                        return true;
+                    }
+                }
+            } else if (p->name.length() && p->name[0] == ':' && getUrlSegment(urlSegment).length()) {
+                /* Parameter match */
+                routeParameters.push(getUrlSegment(urlSegment));
+                if (executeHandlers(p.get(), urlSegment + 1, userData)) {
+                    return true;
+                }
+                routeParameters.pop();
+            } else if (p->name == getUrlSegment(urlSegment)) {
+                /* Static match */
+                if (executeHandlers(p.get(), urlSegment + 1, userData)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+public:
+    HttpRouter() {
+        int p = 0;
+        for (std::string &method : methods) {
+            priority[method] = p++;
+        }
+    }
+
+    std::pair<int, std::string_view *> getParameters() {
+        return {routeParameters.paramsTop, routeParameters.params};
+    }
+
+    USERDATA &getUserData() {
+        return userData;
+    }
+
+    /* Fast path */
+    bool route(std::string_view method, std::string_view url) {
+        /* Reset url parsing cache */
+        setUrl(url);
+        routeParameters.reset();
+
+        /* Begin by finding the method node */
+        for (auto &p : root.children) {
+            if (p->name == method) {
+                /* Then route the url */
+                return executeHandlers(p.get(), 0, userData);
+            }
+        }
+
+        /* We did not find any handler for this method and url */
+        return false;
+    }
+
+    /* Adds the corresponding entires in matching tree and handler list */
+    void add(std::vector<std::string> methods, std::string pattern, fu2::unique_function<bool(HttpRouter *)> &&handler, int priority = MEDIUM_PRIORITY) {
+        for (std::string method : methods) {
+            /* Lookup method */
+            Node *node = getNode(&root, method);
+            /* Iterate over all segments */
+            setUrl(pattern);
+            for (int i = 0; getUrlSegment(i).length() || i == 0; i++) {
+                node = getNode(node, std::string(getUrlSegment(i)));
+            }
+            /* Insert handler in order sorted by priority (most significant 1 byte) */
+            node->handlers.insert(std::upper_bound(node->handlers.begin(), node->handlers.end(), (uint32_t) (priority | handlers.size())), (uint32_t) (priority | handlers.size()));
+        }
+
+        /* Alloate this handler */
+        handlers.emplace_back(std::move(handler));
+    }
+};
+
+}
+
+#endif // UWS_HTTPROUTER_HPP