do not use spdlog from vcpkg

only build ws
only run windows ci
2020-04-18 04:00:42 -07:00 · 2020-04-18 03:54:34 -07:00 · 2020-04-17 17:39:36 -07:00 · 2020-04-17 17:33:55 -07:00 · 2020-04-17 17:33:32 -07:00 · 2020-04-17 16:51:45 -07:00
1711 changed files with 452856 additions and 11786 deletions
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@ -0,0 +1,21 @@
+name: unittest
+on:
+  push:
+    paths-ignore:
+    - 'docs/**'
+
+jobs:
+  windows_mbedtls:
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: seanmiddleditch/gha-setup-vsdevenv@master
+    - run: |
+        vcpkg install zlib:x64-windows
+    - run: |
+        vcpkg install mbedtls:x64-windows
+    - run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_TOOLCHAIN_FILE=c:/vcpkg/scripts/buildsystems/vcpkg.cmake -DCMAKE_CXX_COMPILER=cl.exe -DUSE_MBED_TLS=1 -DUSE_TLS=1 -DUSE_WS=1 ..
+    - run: cmake --build build
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -1,12 +1,7 @@
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.5.0
+    rev: v2.3.0
    hooks:
    -   id: check-yaml
    -   id: end-of-file-fixer
    -   id: trailing-whitespace
-   repo: https://github.com/pocc/pre-commit-hooks
-    rev: v1.1.1
-    hooks:
-    -    id: clang-format
-         args: [-i, -style=file]
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -3,7 +3,7 @@
 # Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
 #

-cmake_minimum_required(VERSION 3.4.1...3.17.2)
+cmake_minimum_required(VERSION 3.4.1)
 set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")

 project(ixwebsocket C CXX)
@ -12,10 +12,6 @@ set (CMAKE_CXX_STANDARD 14)
 set (CXX_STANDARD_REQUIRED ON)
 set (CMAKE_CXX_EXTENSIONS OFF)

-if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif()
-
 if (UNIX)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic")
 endif()
@ -53,6 +49,7 @@ set( IXWEBSOCKET_SOURCES
    ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp
    ixwebsocket/IXWebSocketServer.cpp
    ixwebsocket/IXWebSocketTransport.cpp
+    ixwebsocket/LUrlParser.cpp
 )

 set( IXWEBSOCKET_HEADERS
@ -83,7 +80,6 @@ set( IXWEBSOCKET_HEADERS
    ixwebsocket/IXWebSocketCloseInfo.h
    ixwebsocket/IXWebSocketErrorInfo.h
    ixwebsocket/IXWebSocketHandshake.h
-    ixwebsocket/IXWebSocketHandshakeKeyGen.h
    ixwebsocket/IXWebSocketHttpHeaders.h
    ixwebsocket/IXWebSocketInitResult.h
    ixwebsocket/IXWebSocketMessage.h
@ -96,6 +92,8 @@ set( IXWEBSOCKET_HEADERS
    ixwebsocket/IXWebSocketServer.h
    ixwebsocket/IXWebSocketTransport.h
    ixwebsocket/IXWebSocketVersion.h
+    ixwebsocket/LUrlParser.h
+    ixwebsocket/libwshandshake.hpp
 )

 if (UNIX)
@ -113,38 +111,31 @@ elseif (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/freebsd/IXSetThreadName_freebsd.cpp)
 else()
    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/linux/IXSetThreadName_linux.cpp)
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSelectInterruptEventFd.cpp)
+    list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSelectInterruptEventFd.h)
 endif()

 option(USE_TLS "Enable TLS support" FALSE)

 if (USE_TLS)
-    # default to securetranport on Apple if nothing is configured
-    if (APPLE)
-      if (NOT USE_MBED_TLS AND NOT USE_OPEN_SSL) # unless we want something else
-        set(USE_SECURE_TRANSPORT ON)
-      endif()
+    option(USE_MBED_TLS "Use Mbed TLS" OFF)
+    option(USE_OPEN_SSL "Use OpenSSL" OFF)
+
    # default to mbedtls on windows if nothing is configured
-    elseif (WIN32)
-      if (NOT USE_OPEN_SSL) # unless we want something else
-        set(USE_MBED_TLS ON)
-      endif()
-    else() # default to OpenSSL on all other platforms
-      if (NOT USE_MBED_TLS) # Unless mbedtls is requested
-        set(USE_OPEN_SSL ON)
-      endif()
+    if (WIN32 AND NOT USE_OPEN_SSL AND NOT USE_MBED_TLS)
+      option(USE_MBED_TLS "Use Mbed TLS" ON)
    endif()

    if (USE_MBED_TLS)
        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketMbedTLS.h)
        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketMbedTLS.cpp)
-    elseif (USE_SECURE_TRANSPORT)
+    elseif (APPLE AND NOT USE_OPEN_SSL)
        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketAppleSSL.h)
        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketAppleSSL.cpp)
-    elseif (USE_OPEN_SSL)
+    else()
+        set(USE_OPEN_SSL ON)
        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketOpenSSL.h)
        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketOpenSSL.cpp)
-    else()
-        message(FATAL_ERROR "TLS Configuration error: unknown backend")
    endif()
 endif()

@ -159,49 +150,55 @@ 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 (USE_SECURE_TRANSPORT)
-        target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_SECURE_TRANSPORT)
-    else()
-        message(FATAL_ERROR "TLS Configuration error: unknown backend")
    endif()
 endif()

-if (USE_TLS)
-  if (USE_OPEN_SSL)
-    message(STATUS "TLS configured to use openssl")
+if (APPLE AND USE_TLS AND NOT USE_MBED_TLS AND NOT USE_OPEN_SSL)
+  target_link_libraries(ixwebsocket "-framework foundation" "-framework security")
+endif()

-    # Help finding Homebrew's OpenSSL on macOS
-    if (APPLE)
-      set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /usr/local/opt/openssl/lib)
-      set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} /usr/local/opt/openssl/include)
+if (WIN32)
+  target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)
+  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()

-      # This is for MacPort OpenSSL 1.0
-      # set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /opt/local/lib/openssl-1.0)
-      # set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} /opt/local/include/openssl-1.0)
-    endif()
+if (UNIX)
+  find_package(Threads)
+  target_link_libraries(ixwebsocket ${CMAKE_THREAD_LIBS_INIT})
+endif()

-    # This OPENSSL_FOUND check is to help find a cmake manually configured OpenSSL
-    if (NOT OPENSSL_FOUND)
-      find_package(OpenSSL REQUIRED)
-    endif()
-    message(STATUS "OpenSSL: " ${OPENSSL_VERSION})
+if (USE_TLS AND USE_OPEN_SSL)

-    add_definitions(${OPENSSL_DEFINITIONS})
-    target_include_directories(ixwebsocket PUBLIC ${OPENSSL_INCLUDE_DIR})
-    target_link_libraries(ixwebsocket ${OPENSSL_LIBRARIES})
-  elseif (USE_MBED_TLS)
-    message(STATUS "TLS configured to use mbedtls")
+  # Help finding Homebrew's OpenSSL on macOS
+  if (APPLE)
+    set(CMAKE_LIBRARY_PATH ${CMAKE_LIBRARY_PATH} /usr/local/opt/openssl/lib)
+    set(CMAKE_INCLUDE_PATH ${CMAKE_INCLUDE_PATH} /usr/local/opt/openssl/include)
+  endif()

+  if(NOT OPENSSL_FOUND)
+    find_package(OpenSSL REQUIRED)
+  endif()
+  add_definitions(${OPENSSL_DEFINITIONS})
+  message(STATUS "OpenSSL: " ${OPENSSL_VERSION})
+  include_directories(${OPENSSL_INCLUDE_DIR})
+  target_link_libraries(ixwebsocket ${OPENSSL_LIBRARIES})
+endif()
+
+if (USE_TLS AND USE_MBED_TLS)
+  # FIXME I'm not too sure that this USE_VENDORED_THIRD_PARTY thing works
+  if (USE_VENDORED_THIRD_PARTY)
+    set (ENABLE_PROGRAMS OFF)
+    add_subdirectory(third_party/mbedtls)
+    include_directories(third_party/mbedtls/include)
+
+    target_link_libraries(ixwebsocket mbedtls)
+  else()
    find_package(MbedTLS REQUIRED)
    target_include_directories(ixwebsocket PUBLIC ${MBEDTLS_INCLUDE_DIRS})
    target_link_libraries(ixwebsocket ${MBEDTLS_LIBRARIES})
-  elseif (USE_SECURE_TRANSPORT)
-    message(STATUS "TLS configured to use secure transport")
-    target_link_libraries(ixwebsocket "-framework foundation" "-framework security")
  endif()
 endif()

-# This ZLIB_FOUND check is to help find a cmake manually configured zlib
 if (NOT ZLIB_FOUND)
  find_package(ZLIB)
 endif()
@ -214,21 +211,6 @@ else()
  target_link_libraries(ixwebsocket zlibstatic)
 endif()

-if (WIN32)
-  target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)
-  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-
-  if (USE_TLS)
-    target_link_libraries(ixwebsocket Crypt32)
-  endif()
-endif()
-
-if (UNIX)
-  find_package(Threads)
-  target_link_libraries(ixwebsocket ${CMAKE_THREAD_LIBS_INIT})
-endif()
-
-
 set( IXWEBSOCKET_INCLUDE_DIRS
    ${CMAKE_CURRENT_SOURCE_DIR}
 )
--- a/2
+++ b/2
@ -1 +1 @@
-docker/Dockerfile.centos7_httpd
+docker/Dockerfile.alpine
--- a/README.md
+++ b/README.md
@ -1,72 +1,37 @@
 ## Hello world

+![Build status](https://github.com/machinezone/IXWebSocket/workflows/unittest/badge.svg)
+
 IXWebSocket is a C++ library for WebSocket client and server development. It has minimal dependencies (no boost), is very simple to use and support everything you'll likely need for websocket dev (SSL, deflate compression, compiles on most platforms, etc...). HTTP client and server code is also available, but it hasn't received as much testing.

 It is been used on big mobile video game titles sending and receiving tons of messages since 2017 (iOS and Android). It was tested on macOS, iOS, Linux, Android, Windows and FreeBSD. Two important design goals are simplicity and correctness.

 ```cpp
-/*
- *  main.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- *
- *  Super simple standalone example. See ws folder, unittest and doc/usage.md for more.
- *
- *  On macOS
- *  $ mkdir -p build ; cd build ; cmake -DUSE_TLS=1 .. ; make -j ; make install
- *  $ clang++ --std=c++14 --stdlib=libc++ main.cpp -lixwebsocket -lz -framework Security -framework Foundation
- *  $ ./a.out
- */
+// Required on Windows
+ix::initNetSystem();

-#include <ixwebsocket/IXNetSystem.h>
-#include <ixwebsocket/IXWebSocket.h>
-#include <iostream>
+// Our websocket object
+ix::WebSocket webSocket;

-int main()
-{
-    // Required on Windows
-    ix::initNetSystem();
+std::string url("ws://localhost:8080/");
+webSocket.setUrl(url);

-    // Our websocket object
-    ix::WebSocket webSocket;
-
-    std::string url("wss://echo.websocket.org");
-    webSocket.setUrl(url);
-
-    std::cout << "Connecting to " << url << "..." << std::endl;
-
-    // Setup a callback to be fired (in a background thread, watch out for race conditions !)
-    // when a message or an event (open, close, error) is received
-    webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
-        {
-            if (msg->type == ix::WebSocketMessageType::Message)
-            {
-                std::cout << "received message: " << msg->str << std::endl;
-            }
-            else if (msg->type == ix::WebSocketMessageType::Open)
-            {
-                std::cout << "Connection established" << std::endl;
-            }
-        }
-    );
-
-    // Now that our callback is setup, we can start our background thread and receive messages
-    webSocket.start();
-
-    // Send a message to the server (default to TEXT mode)
-    webSocket.send("hello world");
-
-    while (true)
+// Setup a callback to be fired (in a background thread, watch out for race conditions !)
+// when a message or an event (open, close, error) is received
+webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
    {
-        std::string text;
-        std::cout << "> " << std::flush;
-        std::getline(std::cin, text);
-
-        webSocket.send(text);
+        if (msg->type == ix::WebSocketMessageType::Message)
+        {
+            std::cout << msg->str << std::endl;
+        }
    }
+);

-    return 0;
-}
+// Now that our callback is setup, we can start our background thread and receive messages
+webSocket.start();
+
+// Send a message to the server (default to TEXT mode)
+webSocket.send("hello world");
 ```

 Interested? Go read the [docs](https://machinezone.github.io/IXWebSocket/)! If things don't work as expected, please create an issue on GitHub, or even better a pull request if you know how to fix your problem.
@ -80,27 +45,3 @@ IXWebSocket client code is autobahn compliant beginning with the 6.0.0 version.
 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)
- [Tokio](https://gitlab.com/HCInk/tokio), a discord library focused on audio playback with node bindings.
- [libDiscordBot](https://github.com/tostc/libDiscordBot/tree/master), a work in progress discord library
- [gwebsocket](https://github.com/norrbotten/gwebsocket), a websocket (lua) module for Garry's Mod
- [DisCPP](https://github.com/DisCPP/DisCPP), a simple but feature rich Discord API wrapper
-
-## Continuous Integration
-
-| OS                | TLS               | Sanitizer         | Status            |
-|-------------------|-------------------|-------------------|-------------------|
-| Linux             | OpenSSL           | None              | [![Build2][1]][7] |
-| macOS             | Secure Transport  | Thread Sanitizer  | [![Build2][2]][7] |
-| macOS             | OpenSSL           | Thread Sanitizer  | [![Build2][3]][7] |
-| macOS             | MbedTLS           | Thread Sanitizer  | [![Build2][4]][7] |
-| Windows           | Disabled          | None              | [![Build2][5]][7] |
-| UWP               | Disabled          | None              | [![Build2][6]][7] |
-
-[1]: https://github.com/machinezone/IXWebSocket/workflows/linux/badge.svg
-[2]: https://github.com/machinezone/IXWebSocket/workflows/mac_tsan_sectransport/badge.svg
-[3]: https://github.com/machinezone/IXWebSocket/workflows/mac_tsan_openssl/badge.svg
-[4]: https://github.com/machinezone/IXWebSocket/workflows/mac_tsan_mbedtls/badge.svg
-[5]: https://github.com/machinezone/IXWebSocket/workflows/windows/badge.svg
-[6]: https://github.com/machinezone/IXWebSocket/workflows/uwp/badge.svg
-[7]: https://github.com/machinezone/IXWebSocket
-
--- a/docker/Dockerfile.alpine
+++ b/docker/Dockerfile.alpine
@ -2,7 +2,7 @@ FROM alpine:3.11 as build

 RUN apk add --no-cache \
    gcc g++ musl-dev linux-headers \
-    cmake mbedtls-dev make zlib-dev ninja
+    cmake mbedtls-dev make zlib-dev

 RUN addgroup -S app && \
    adduser -S -G app app && \
--- a/docker/Dockerfile.centos7_httpd
+++ b/docker/Dockerfile.centos7_httpd
@ -1,33 +0,0 @@
-FROM centos:7 as build
-
-RUN yum install -y gcc-c++ make zlib-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", "httpd_linux" ]
-RUN [ "rm", "-rf", "build" ]
-
-FROM centos:8 as runtime
-
-RUN groupadd app && useradd -g app app
-COPY --chown=app:app --from=build /usr/local/bin/ixhttpd /usr/local/bin/ixhttpd
-RUN chmod +x /usr/local/bin/ixhttpd
-RUN ldd /usr/local/bin/ixhttpd
-
-# Copy source code for gcc
-COPY --chown=app:app --from=build /opt /opt
-
-# Now run in usermode
-USER app
-WORKDIR /home/app
-
-ENTRYPOINT ["ixhttpd"]
-EXPOSE 9999
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@ -1,78 +1,6 @@
 # Changelog
 All changes to this project will be documented in this file.

-## [9.6.5] - 2020-05-29
-
-(http server) support gzip compression
-
-## [9.6.4] - 2020-05-20
-
-(compiler fix) support clang 5 and earlier (contributed by @LunarWatcher)
-
-## [9.6.3] - 2020-05-18
-
-(cmake) revert CMake changes to fix #203 and be able to use an external OpenSSL
-
-## [9.6.2] - 2020-05-17
-
-(cmake) make install cmake files optional to not conflict with vcpkg
-
-## [9.6.1] - 2020-05-17
-
-(windows + tls) mbedtls is the default windows tls backend + add ability to load system certificates with mbdetls on windows
-
-## [9.6.0] - 2020-05-12
-
-(ixbots) add options to limit how many messages per minute should be processed
-
-## [9.5.9] - 2020-05-12
-
-(ixbots) add new class to configure a bot to simplify passing options around
-
-## [9.5.8] - 2020-05-08
-
-(openssl tls) (openssl < 1.1) logic inversion - crypto locking callback are not registered properly
-
-## [9.5.7] - 2020-05-08
-
-(cmake) default TLS back to mbedtls on Windows Universal Platform
-
-## [9.5.6] - 2020-05-06
-
-(cobra bots) add a --heartbeat_timeout option to specify when the bot should terminate because no events are received
-
-## [9.5.5] - 2020-05-06
-
-(openssl tls) when OpenSSL is older than 1.1, register the crypto locking callback to be thread safe. Should fix lots of CI failures
-
-## [9.5.4] - 2020-05-04
-
-(cobra bots) do not use a queue to store messages pending processing, let the bot handle queuing
-
-## [9.5.3] - 2020-04-29
-
-(http client) better current request cancellation support when the HttpClient destructor is invoked (see #189)
-
-## [9.5.2] - 2020-04-27
-
-(cmake) fix cmake broken tls option parsing
-
-## [9.5.1] - 2020-04-27
-
-(http client) Set default values for most HttpRequestArgs struct members (fix #185)
-
-## [9.5.0] - 2020-04-25
-
-(ssl) Default to OpenSSL on Windows, since it can load the system certificates by default
-
-## [9.4.1] - 2020-04-25
-
-(header) Add a space between header name and header value since most http parsers expects it, although it it not required. Cf #184 and #155
-
-## [9.4.0] - 2020-04-24
-
-(ssl) Add support for supplying SSL CA from memory, for OpenSSL and MbedTLS backends
-
 ## [9.3.3] - 2020-04-17

 (ixbots) display sent/receive message, per seconds as accumulated
--- a/docs/build.md
+++ b/docs/build.md
@ -18,12 +18,10 @@ There is a unittest which can be executed by typing `make test`.
 Options for building:

 * `-DUSE_TLS=1` will enable TLS support
-* `-DUSE_OPEN_SSL=1` will use [openssl](https://www.openssl.org/) for the TLS support (default on Linux and Windows)
-* `-DUSE_MBED_TLS=1` will use [mbedlts](https://tls.mbed.org/) for the TLS support
+* `-DUSE_MBED_TLS=1` will use [mbedlts](https://tls.mbed.org/) for the TLS support (default on Windows)
 * `-DUSE_WS=1` will build the ws interactive command line tool
-* `-DUSE_TEST=1` will build the unittest

-If you are on Windows, look at the [appveyor](https://github.com/machinezone/IXWebSocket/blob/master/appveyor.yml) file (not maintained much though) or rather the [github actions](https://github.com/machinezone/IXWebSocket/blob/master/.github/workflows/ccpp.yml#L40) which have instructions for building dependencies.
+If you are on Windows, look at the [appveyor](https://github.com/machinezone/IXWebSocket/blob/master/appveyor.yml) file that has instructions for building dependencies.

 It is also possible to externally include the project, so that everything is fetched over the wire when you build like so:

@ -42,19 +40,6 @@ It is possible to get IXWebSocket through Microsoft [vcpkg](https://github.com/m
 ```
 vcpkg install ixwebsocket
 ```
-To use the installed package within a cmake project, use the following:
-```cmake
- set(CMAKE_TOOLCHAIN_FILE "$ENV{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake" CACHE STRING "") # this is super important in order for cmake to include the vcpkg search/lib paths!
-
- # find library and its headers
- find_path(IXWEBSOCKET_INCLUDE_DIR ixwebsocket/IXWebSocket.h)
- find_library(IXWEBSOCKET_LIBRARY ixwebsocket)
- # include headers
- include_directories(${IXWEBSOCKET_INCLUDE_DIR})
- # ...
- target_link_libraries(${PROJECT_NAME} ... ${IXWEBSOCKET_LIBRARY}) # Cmake will automatically fail the generation if the lib was not found, i.e is set to NOTFOUNS
-
-```

 ### Conan

@ -74,7 +59,7 @@ Note that the version listed here might not be the latest one. See Bintray or th
 There is a Dockerfile for running the unittest on Linux, and to run the `ws` tool. It is also available on the docker registry.

 ```
-docker run docker.pkg.github.com/machinezone/ixwebsocket/ws:latest --help
+docker run bsergean/ws
 ```

 To use docker-compose you must make a docker container first.
--- a/docs/design.md
+++ b/docs/design.md
@ -38,7 +38,8 @@ The regression test is running after each commit on github actions for multiple

 ## Limitations

-* On some configuration (mostly Android) certificate validation needs to be setup so that SocketTLSOptions.caFile point to a pem file, such as the one distributed by Firefox. Unless that setup is done connecting to a wss endpoint will display an error. With mbedtls the message will contain `error in handshake : X509 - Certificate verification failed, e.g. CRL, CA or signature check failed`.
+* On Windows and Android certificate validation needs to be setup so that SocketTLSOptions.caFile point to a pem file, such as the one distributed by Firefox. Unless that setup is done connecting to a wss endpoint will display an error. On Windows with mbedtls the message will contain `error in handshake : X509 - Certificate verification failed, e.g. CRL, CA or signature check failed`.
+* There is no convenient way to embed a ca cert.
 * Automatic reconnection works at the TCP socket level, and will detect remote end disconnects. However, if the device/computer network become unreachable (by turning off wifi), it is quite hard to reliably and timely detect it at the socket level using `recv` and `send` error codes. [Here](https://stackoverflow.com/questions/14782143/linux-socket-how-to-detect-disconnected-network-in-a-client-program) is a good discussion on the subject. This behavior is consistent with other runtimes such as node.js. One way to detect a disconnected device with low level C code is to do a name resolution with DNS but this can be expensive. Mobile devices have good and reliable API to do that.
 * The server code is using select to detect incoming data, and creates one OS thread per connection. This is not as scalable as strategies using epoll or kqueue.

--- a/docs/index.md
+++ b/docs/index.md
@ -1,3 +1,5 @@
+![Build status](https://github.com/machinezone/IXWebSocket/workflows/unittest/badge.svg)
+
 ## Introduction

 [*WebSocket*](https://en.wikipedia.org/wiki/WebSocket) is a computer communications protocol, providing full-duplex and bi-directionnal communication channels over a single TCP connection. *IXWebSocket* is a C++ library for client and server Websocket communication, and for client and server HTTP communication. *TLS* aka *SSL* is supported. The code is derived from [easywsclient](https://github.com/dhbaird/easywsclient) and from the [Satori C SDK](https://github.com/satori-com/satori-rtm-sdk-c). It has been tested on the following platforms.
--- a/docs/packages.md
+++ b/docs/packages.md
@ -4,7 +4,7 @@ Notes on how we can update the different packages for ixwebsocket.

 Visit the [releases](https://github.com/machinezone/IXWebSocket/releases) page on Github. A tag must have been made first.

-Download the latest entry.
+Download the latest entry. 

 ```
 $ cd /tmp
--- a/docs/usage.md
+++ b/docs/usage.md
@ -392,8 +392,6 @@ bool ok = httpClient.performRequest(args, [](const HttpResponsePtr& response)
 // ok will be false if your httpClient is not async
 ```

-See this [issue](https://github.com/machinezone/IXWebSocket/issues/209) for links about uploading files with HTTP multipart.
-
 ## HTTP server API

 ```cpp
@ -449,7 +447,7 @@ Additional TLS options can be configured by passing a `ix::SocketTLSOptions` ins
 webSocket.setTLSOptions({
    .certFile = "path/to/cert/file.pem",
    .keyFile = "path/to/key/file.pem",
-    .caFile = "path/to/trust/bundle/file.pem", // as a file, or in memory buffer in PEM format
+    .caFile = "path/to/trust/bundle/file.pem",
    .tls = true // required in server mode
 });
 ```
@ -463,7 +461,6 @@ On a server, this is necessary for TLS support.
 Specifying `caFile` configures the trusted roots bundle file (in PEM format) that will be used to verify peer certificates.
 - The special value of `SYSTEM` (the default) indicates that the system-configured trust bundle should be used; this is generally what you want when connecting to any publicly exposed API/server.
 - The special value of `NONE` can be used to disable peer verification; this is only recommended to rule out certificate verification when testing connectivity.
- - If the value contain the special value `-----BEGIN CERTIFICATE-----`, the value will be read from memory, and not from a file. This is convenient on platforms like Android where reading / writing to the file system can be challenging without proper permissions, or without knowing the location of a temp directory.

 For a client, specifying `caFile` can be used if connecting to a server that uses a self-signed cert, or when using a custom CA in an internal environment.

--- a/httpd.cpp
+++ b/httpd.cpp
@ -1,46 +0,0 @@
-/*
- *  httpd.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- *
- *  Buid with make httpd
- */
-
-#include "IXHttpServer.h"
-#include <sstream>
-#include <iostream>
-
-int main(int argc, char** argv)
-{
-    if (argc != 3)
-    {
-        std::cerr << "Usage: " << argv[0]
-                  << " <port> <host>" << std::endl;
-        std::cerr << " " << argv[0] << " 9090 127.0.0.1" << std::endl;
-        std::cerr << " " << argv[0] << " 9090 0.0.0.0" << std::endl;
-        return 1;
-    }
-
-    int port;
-    std::stringstream ss;
-    ss << argv[1];
-    ss >> port;
-    std::string hostname(argv[2]);
-
-    std::cout << "Listening on " << hostname
-              << ":" << port << std::endl;
-
-    ix::HttpServer server(port, hostname);
-
-    auto res = server.listen();
-    if (!res.first)
-    {
-        std::cout << res.second << std::endl;
-        return 1;
-    }
-
-    server.start();
-    server.wait();
-
-    return 0;
-}
--- a/ixbots/CMakeLists.txt
+++ b/ixbots/CMakeLists.txt
@ -8,15 +8,16 @@ set (IXBOTS_SOURCES
    ixbots/IXCobraToSentryBot.cpp
    ixbots/IXCobraToStatsdBot.cpp
    ixbots/IXCobraToStdoutBot.cpp
+    ixbots/IXQueueManager.cpp
    ixbots/IXStatsdClient.cpp
 )

 set (IXBOTS_HEADERS
    ixbots/IXCobraBot.h
-    ixbots/IXCobraBotConfig.h
    ixbots/IXCobraToSentryBot.h
    ixbots/IXCobraToStatsdBot.h
    ixbots/IXCobraToStdoutBot.h
+    ixbots/IXQueueManager.h
    ixbots/IXStatsdClient.h
 )

@ -30,6 +31,11 @@ if (NOT JSONCPP_FOUND)
  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
 endif()

+find_package(SpdLog)
+if (NOT SPDLOG_FOUND)
+  set(SPDLOG_INCLUDE_DIRS ../third_party/spdlog/include)
+endif()
+
 set(IXBOTS_INCLUDE_DIRS
    .
    ..
--- a/ixbots/ixbots/IXCobraBot.cpp
+++ b/ixbots/ixbots/IXCobraBot.cpp
@ -5,45 +5,44 @@
 */

 #include "IXCobraBot.h"
-
-#include <ixcobra/IXCobraConnection.h>
-#include <ixcore/utils/IXCoreLogger.h>
+#include "IXQueueManager.h"

 #include <algorithm>
 #include <chrono>
+#include <ixcobra/IXCobraConnection.h>
+#include <spdlog/spdlog.h>
 #include <sstream>
 #include <thread>
 #include <vector>

 namespace ix
 {
-    int64_t CobraBot::run(const CobraBotConfig& botConfig)
+    int64_t CobraBot::run(const CobraConfig& config,
+                          const std::string& channel,
+                          const std::string& filter,
+                          const std::string& position,
+                          bool verbose,
+                          size_t maxQueueSize,
+                          bool useQueue,
+                          bool enableHeartbeat,
+                          int runtime)
    {
-        auto config = botConfig.cobraConfig;
-        auto channel = botConfig.channel;
-        auto filter = botConfig.filter;
-        auto position = botConfig.position;
-        auto enableHeartbeat = botConfig.enableHeartbeat;
-        auto heartBeatTimeout = botConfig.heartBeatTimeout;
-        auto runtime = botConfig.runtime;
-        auto maxEventsPerMinute = botConfig.maxEventsPerMinute;
-        auto limitReceivedEvents = botConfig.limitReceivedEvents;
-
        ix::CobraConnection conn;
        conn.configure(config);
        conn.connect();

+        Json::FastWriter jsonWriter;
        std::atomic<uint64_t> sentCount(0);
        std::atomic<uint64_t> receivedCount(0);
-        uint64_t sentCountTotal(0);
-        uint64_t receivedCountTotal(0);
-        uint64_t sentCountPerSecs(0);
-        uint64_t receivedCountPerSecs(0);
-        std::atomic<int> receivedCountPerMinutes(0);
+        std::atomic<uint64_t> sentCountTotal(0);
+        std::atomic<uint64_t> receivedCountTotal(0);
+        std::atomic<uint64_t> sentCountPerSecs(0);
+        std::atomic<uint64_t> receivedCountPerSecs(0);
        std::atomic<bool> stop(false);
        std::atomic<bool> throttled(false);
        std::atomic<bool> fatalCobraError(false);
-        int minuteCounter = 0;
+
+        QueueManager queueManager(maxQueueSize);

        auto timer = [&sentCount,
                      &receivedCount,
@ -51,8 +50,6 @@ namespace ix
                      &receivedCountTotal,
                      &sentCountPerSecs,
                      &receivedCountPerSecs,
-                      &receivedCountPerMinutes,
-                      &minuteCounter,
                      &stop] {
            while (!stop)
            {
@ -61,39 +58,27 @@ namespace ix
                // as those are used externally, so we need to introduce
                // our own counters
                //
-                std::stringstream ss;
-                ss << "messages received "
-                   << receivedCountPerSecs
-                   << " "
-                   << receivedCountTotal
-                   << " sent " 
-                   << sentCountPerSecs
-                   << " "
-                   << sentCountTotal;
-                CoreLogger::info(ss.str());
-
+                spdlog::info("messages received {} {} sent {} {}",
+                             receivedCountPerSecs,
+                             receivedCountTotal,
+                             sentCountPerSecs,
+                             sentCountTotal);
                receivedCountPerSecs = receivedCount - receivedCountTotal;
-                sentCountPerSecs = sentCount - sentCountTotal;
+                sentCountPerSecs = sentCount - receivedCountTotal;

                receivedCountTotal += receivedCountPerSecs;
                sentCountTotal += sentCountPerSecs;

                auto duration = std::chrono::seconds(1);
                std::this_thread::sleep_for(duration);
-
-                if (minuteCounter++ == 60)
-                {
-                    receivedCountPerMinutes = 0;
-                    minuteCounter = 0;
-                }
            }

-            CoreLogger::info("timer thread done");
+            spdlog::info("timer thread done");
        };

        std::thread t1(timer);

-        auto heartbeat = [&sentCount, &receivedCount, &stop, &enableHeartbeat, &heartBeatTimeout, &fatalCobraError] {
+        auto heartbeat = [&sentCount, &receivedCount, &stop, &enableHeartbeat] {
            std::string state("na");

            if (!enableHeartbeat) return;
@ -108,21 +93,54 @@ namespace ix

                if (currentState == state)
                {
-                    CoreLogger::error("no messages received or sent for 1 minute, exiting");
-                    fatalCobraError = true;
-                    break;
+                    spdlog::error("no messages received or sent for 1 minute, exiting");
+                    exit(1);
                }
                state = currentState;

-                auto duration = std::chrono::seconds(heartBeatTimeout);
+                auto duration = std::chrono::minutes(1);
                std::this_thread::sleep_for(duration);
            }

-            CoreLogger::info("heartbeat thread done");
+            spdlog::info("heartbeat thread done");
        };

        std::thread t2(heartbeat);

+        auto sender =
+            [this, &queueManager, verbose, &sentCount, &stop, &throttled, &fatalCobraError] {
+
+                while (true)
+                {
+                    auto data = queueManager.pop();
+                    Json::Value msg = data.first;
+                    std::string position = data.second;
+
+                    if (stop) break;
+                    if (msg.isNull()) continue;
+
+                    if (_onBotMessageCallback && _onBotMessageCallback(msg, position, verbose, throttled, fatalCobraError))
+                    {
+                        // That might be too noisy
+                        if (verbose)
+                        {
+                            spdlog::info("cobra bot: sending succesfull");
+                        }
+                        ++sentCount;
+                    }
+                    else
+                    {
+                        spdlog::error("cobra bot: error sending");
+                    }
+
+                    if (stop) break;
+                }
+
+                spdlog::info("sender thread done");
+            };
+
+        std::thread t3(sender);
+
        std::string subscriptionPosition(position);

        conn.setEventCallback([this,
@ -130,94 +148,108 @@ namespace ix
                               &channel,
                               &filter,
                               &subscriptionPosition,
+                               &jsonWriter,
+                               verbose,
                               &throttled,
                               &receivedCount,
-                               &receivedCountPerMinutes,
-                               maxEventsPerMinute,
-                               limitReceivedEvents,
                               &fatalCobraError,
-                               &sentCount](const CobraEventPtr& event) {
+                               &useQueue,
+                               &queueManager,
+                               &sentCount](const CobraEventPtr& event)
+       {
            if (event->type == ix::CobraEventType::Open)
            {
-                CoreLogger::info("Subscriber connected");
+                spdlog::info("Subscriber connected");

                for (auto&& it : event->headers)
                {
-                    CoreLogger::info(it.first + "::" + it.second);
+                    spdlog::info("{}: {}", it.first, it.second);
                }
            }
            else if (event->type == ix::CobraEventType::Closed)
            {
-                CoreLogger::info("Subscriber closed: {}" + event->errMsg);
+                spdlog::info("Subscriber closed: {}", event->errMsg);
            }
            else if (event->type == ix::CobraEventType::Authenticated)
            {
-                CoreLogger::info("Subscriber authenticated");
-                CoreLogger::info("Subscribing to " + channel);
-                CoreLogger::info("Subscribing at position " + subscriptionPosition);
-                CoreLogger::info("Subscribing with filter " + filter);
-                conn.subscribe(channel, filter, subscriptionPosition,
-                    [&sentCount, &receivedCountPerMinutes,
-                     maxEventsPerMinute, limitReceivedEvents,
-                     &throttled, &receivedCount,
-                     &subscriptionPosition, &fatalCobraError,
-                     this](const Json::Value& msg, const std::string& position) {
-                        subscriptionPosition = position;
-                        ++receivedCount;
+                spdlog::info("Subscriber authenticated");
+                spdlog::info("Subscribing to {} at position {}", channel, subscriptionPosition);
+                spdlog::info("Using filter: {}", filter);
+                conn.subscribe(channel,
+                               filter,
+                               subscriptionPosition,
+                               [this, &jsonWriter, verbose, &throttled, &receivedCount, &queueManager, &useQueue, &subscriptionPosition, &fatalCobraError, &sentCount](
+                                   const Json::Value& msg, const std::string& position) {
+                                   if (verbose)
+                                   {
+                                       spdlog::info("Subscriber received message {} -> {}", position, jsonWriter.write(msg));
+                                   }

-                        ++receivedCountPerMinutes;
-                        if (limitReceivedEvents)
-                        {
-                            if (receivedCountPerMinutes > maxEventsPerMinute)
-                            {
-                                return;
-                            }
-                        }
+                                   subscriptionPosition = position;

-                        // If we cannot send to sentry fast enough, drop the message
-                        if (throttled)
-                        {
-                            return;
-                        }
+                                   // If we cannot send to sentry fast enough, drop the message
+                                   if (throttled)
+                                   {
+                                       return;
+                                   }

-                        _onBotMessageCallback(
-                            msg, position, throttled,
-                            fatalCobraError, sentCount);
-                    });
+                                   ++receivedCount;
+
+                                   if (useQueue)
+                                   {
+                                       queueManager.add(msg, position);
+                                   }
+                                   else
+                                   {
+                                       if (_onBotMessageCallback && _onBotMessageCallback(msg, position, verbose, throttled, fatalCobraError))
+                                       {
+                                           // That might be too noisy
+                                           if (verbose)
+                                           {
+                                               spdlog::info("cobra bot: sending succesfull");
+                                           }
+                                           ++sentCount;
+                                       }
+                                       else
+                                       {
+                                           spdlog::error("cobra bot: error sending");
+                                       }
+                                   }
+                               });
            }
            else if (event->type == ix::CobraEventType::Subscribed)
            {
-                CoreLogger::info("Subscriber: subscribed to channel " + event->subscriptionId);
+                spdlog::info("Subscriber: subscribed to channel {}", event->subscriptionId);
            }
            else if (event->type == ix::CobraEventType::UnSubscribed)
            {
-                CoreLogger::info("Subscriber: unsubscribed from channel " + event->subscriptionId);
+                spdlog::info("Subscriber: unsubscribed from channel {}", event->subscriptionId);
            }
            else if (event->type == ix::CobraEventType::Error)
            {
-                CoreLogger::error("Subscriber: error " + event->errMsg);
+                spdlog::error("Subscriber: error {}", event->errMsg);
            }
            else if (event->type == ix::CobraEventType::Published)
            {
-                CoreLogger::error("Published message hacked: " + std::to_string(event->msgId));
+                spdlog::error("Published message hacked: {}", event->msgId);
            }
            else if (event->type == ix::CobraEventType::Pong)
            {
-                CoreLogger::info("Received websocket pong: " + event->errMsg);
+                spdlog::info("Received websocket pong: {}", event->errMsg);
            }
            else if (event->type == ix::CobraEventType::HandshakeError)
            {
-                CoreLogger::error("Subscriber: Handshake error: " + event->errMsg);
+                spdlog::error("Subscriber: Handshake error: {}", event->errMsg);
                fatalCobraError = true;
            }
            else if (event->type == ix::CobraEventType::AuthenticationError)
            {
-                CoreLogger::error("Subscriber: Authentication error: " + event->errMsg);
+                spdlog::error("Subscriber: Authentication error: {}", event->errMsg);
                fatalCobraError = true;
            }
            else if (event->type == ix::CobraEventType::SubscriptionError)
            {
-                CoreLogger::error("Subscriber: Subscription error: " + event->errMsg);
+                spdlog::error("Subscriber: Subscription error: {}", event->errMsg);
                fatalCobraError = true;
            }
        });
@ -236,7 +268,7 @@ namespace ix
        // Run for a duration, used by unittesting now
        else
        {
-            for (int i = 0; i < runtime; ++i)
+            for (int i = 0 ; i < runtime; ++i)
            {
                auto duration = std::chrono::seconds(1);
                std::this_thread::sleep_for(duration);
@ -258,6 +290,9 @@ namespace ix
        // heartbeat thread
        if (t2.joinable()) t2.join();

+        // sentry sender thread
+        t3.join();
+
        return fatalCobraError ? -1 : (int64_t) sentCount;
    }

@ -265,4 +300,4 @@ namespace ix
    {
        _onBotMessageCallback = callback;
    }
-} // namespace ix
+}
--- a/ixbots/ixbots/IXCobraBot.h
+++ b/ixbots/ixbots/IXCobraBot.h
@ -6,29 +6,38 @@

 #pragma once

-#include <atomic>
-#include <functional>
-#include "IXCobraBotConfig.h"
-#include <json/json.h>
+#include <ixcobra/IXCobraConfig.h>
 #include <stddef.h>
+#include <json/json.h>
+#include <functional>
+#include <atomic>

 namespace ix
 {
-    using OnBotMessageCallback = std::function<void(const Json::Value&,
+    using OnBotMessageCallback = std::function<bool(const Json::Value&,
                                                    const std::string&,
+                                                    const bool verbose,
                                                    std::atomic<bool>&,
-                                                    std::atomic<bool>&,
-                                                    std::atomic<uint64_t>&)>;
+                                                    std::atomic<bool>&)>;

    class CobraBot
    {
    public:
        CobraBot() = default;

-        int64_t run(const CobraBotConfig& botConfig);
+        int64_t run(const CobraConfig& config,
+                    const std::string& channel,
+                    const std::string& filter,
+                    const std::string& position,
+                    bool verbose,
+                    size_t maxQueueSize,
+                    bool useQueue,
+                    bool enableHeartbeat,
+                    int runtime);
+
        void setOnBotMessageCallback(const OnBotMessageCallback& callback);

    private:
        OnBotMessageCallback _onBotMessageCallback;
    };
-} // namespace ix
+}
--- a/ixbots/ixbots/IXCobraBotConfig.h
+++ b/ixbots/ixbots/IXCobraBotConfig.h
@ -1,31 +0,0 @@
-/*
- *  IXCobraBotConfig.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include <string>
-#include <limits>
-#include <ixcobra/IXCobraConfig.h>
-
-#ifdef max
-#undef max
-#endif
-
-namespace ix
-{
-    struct CobraBotConfig
-    {
-        CobraConfig cobraConfig;
-        std::string channel;
-        std::string filter;
-        std::string position = std::string("$");
-        bool enableHeartbeat = true;
-        int heartBeatTimeout = 60;
-        int runtime = -1;
-        int maxEventsPerMinute = std::numeric_limits<int>::max();
-        bool limitReceivedEvents = false;
-    };
-} // namespace ix
--- a/ixbots/ixbots/IXCobraToSentryBot.cpp
+++ b/ixbots/ixbots/IXCobraToSentryBot.cpp
@ -5,72 +5,113 @@
 */

 #include "IXCobraToSentryBot.h"
-
 #include "IXCobraBot.h"
-#include <ixcobra/IXCobraConnection.h>
-#include <ixcore/utils/IXCoreLogger.h>
+#include "IXQueueManager.h"

 #include <chrono>
+#include <ixcobra/IXCobraConnection.h>
+#include <spdlog/spdlog.h>
 #include <sstream>
 #include <vector>

 namespace ix
 {
-    int64_t cobra_to_sentry_bot(const CobraBotConfig& config,
+    int64_t cobra_to_sentry_bot(const CobraConfig& config,
+                                const std::string& channel,
+                                const std::string& filter,
+                                const std::string& position,
                                SentryClient& sentryClient,
-                                bool verbose)
+                                bool verbose,
+                                size_t maxQueueSize,
+                                bool enableHeartbeat,
+                                int runtime)
    {
        CobraBot bot;
-        bot.setOnBotMessageCallback([&sentryClient, &verbose](const Json::Value& msg,
+        bot.setOnBotMessageCallback([&sentryClient](const Json::Value& msg,
                                                    const std::string& /*position*/,
+                                                    const bool verbose,
                                                    std::atomic<bool>& throttled,
-                                                    std::atomic<bool>& /*fatalCobraError*/,
-                                                    std::atomic<uint64_t>& sentCount) -> void {
-            sentryClient.send(msg, verbose,
-                [&sentCount, &throttled](const HttpResponsePtr& response) {
-                if (!response)
+                                                    std::atomic<bool>& /*fatalCobraError*/) -> bool {
+            auto ret = sentryClient.send(msg, verbose);
+            HttpResponsePtr response = ret.first;
+
+            if (!response)
+            {
+                spdlog::warn("Null HTTP Response");
+                return false;
+            }
+
+            if (verbose)
+            {
+                for (auto it : response->headers)
                {
-                    CoreLogger::warn("Null HTTP Response");
-                    return;
+                    spdlog::info("{}: {}", it.first, it.second);
                }

-                if (response->statusCode == 200)
-                {
-                    sentCount++;
-                }
-                else
-                {
-                    CoreLogger::error("Error sending data to sentry: " + std::to_string(response->statusCode));
-                    CoreLogger::error("Response: " + response->payload);
+                spdlog::info("Upload size: {}", response->uploadSize);
+                spdlog::info("Download size: {}", response->downloadSize);

-                    // Error 429 Too Many Requests
-                    if (response->statusCode == 429)
+                spdlog::info("Status: {}", response->statusCode);
+                if (response->errorCode != HttpErrorCode::Ok)
+                {
+                    spdlog::info("error message: {}", response->errorMsg);
+                }
+
+                if (response->headers["Content-Type"] != "application/octet-stream")
+                {
+                    spdlog::info("payload: {}", response->payload);
+                }
+            }
+
+            bool success = response->statusCode == 200;
+
+            if (!success)
+            {
+                spdlog::error("Error sending data to sentry: {}", response->statusCode);
+                spdlog::error("Body: {}", ret.second);
+                spdlog::error("Response: {}", response->payload);
+
+                // Error 429 Too Many Requests
+                if (response->statusCode == 429)
+                {
+                    auto retryAfter = response->headers["Retry-After"];
+                    std::stringstream ss;
+                    ss << retryAfter;
+                    int seconds;
+                    ss >> seconds;
+
+                    if (!ss.eof() || ss.fail())
                    {
-                        auto retryAfter = response->headers["Retry-After"];
-                        std::stringstream ss;
-                        ss << retryAfter;
-                        int seconds;
-                        ss >> seconds;
-
-                        if (!ss.eof() || ss.fail())
-                        {
-                            seconds = 30;
-                            CoreLogger::warn("Error parsing Retry-After header. "
-                                             "Using " + retryAfter + " for the sleep duration");
-                        }
-
-                        CoreLogger::warn("Error 429 - Too Many Requests. ws will sleep "
-                                         "and retry after " + retryAfter + " seconds");
-
-                        throttled = true;
-                        auto duration = std::chrono::seconds(seconds);
-                        std::this_thread::sleep_for(duration);
-                        throttled = false;
+                        seconds = 30;
+                        spdlog::warn("Error parsing Retry-After header. "
+                                     "Using {} for the sleep duration",
+                                     seconds);
                    }
+
+                    spdlog::warn("Error 429 - Too Many Requests. ws will sleep "
+                                 "and retry after {} seconds",
+                                 retryAfter);
+
+                    throttled = true;
+                    auto duration = std::chrono::seconds(seconds);
+                    std::this_thread::sleep_for(duration);
+                    throttled = false;
                }
-            });
+            }
+
+            return success;
        });

-        return bot.run(config);
+        bool useQueue = true;
+
+        return bot.run(config,
+                       channel,
+                       filter,
+                       position,
+                       verbose,
+                       maxQueueSize,
+                       useQueue,
+                       enableHeartbeat,
+                       runtime);
    }
 } // namespace ix
--- a/ixbots/ixbots/IXCobraToSentryBot.h
+++ b/ixbots/ixbots/IXCobraToSentryBot.h
@ -5,14 +5,20 @@
 */
 #pragma once

-#include <cstdint>
-#include "IXCobraBotConfig.h"
+#include <ixcobra/IXCobraConfig.h>
 #include <ixsentry/IXSentryClient.h>
 #include <string>
+#include <cstdint>

 namespace ix
 {
-    int64_t cobra_to_sentry_bot(const CobraBotConfig& config,
+    int64_t cobra_to_sentry_bot(const CobraConfig& config,
+                                const std::string& channel,
+                                const std::string& filter,
+                                const std::string& position,
                                SentryClient& sentryClient,
-                                bool verbose);
+                                bool verbose,
+                                size_t maxQueueSize,
+                                bool enableHeartbeat,
+                                int runtime);
 } // namespace ix
--- a/ixbots/ixbots/IXCobraToStatsdBot.cpp
+++ b/ixbots/ixbots/IXCobraToStatsdBot.cpp
@ -5,12 +5,13 @@
 */

 #include "IXCobraToStatsdBot.h"
-
-#include "IXCobraBot.h"
+#include "IXQueueManager.h"
 #include "IXStatsdClient.h"
+#include "IXCobraBot.h"
+
 #include <chrono>
 #include <ixcobra/IXCobraConnection.h>
-#include <ixcore/utils/IXCoreLogger.h>
+#include <spdlog/spdlog.h>
 #include <sstream>
 #include <vector>

@ -53,85 +54,104 @@ namespace ix
        return val;
    }

-    int64_t cobra_to_statsd_bot(const ix::CobraBotConfig& config,
+    int64_t cobra_to_statsd_bot(const ix::CobraConfig& config,
+                                const std::string& channel,
+                                const std::string& filter,
+                                const std::string& position,
                                StatsdClient& statsdClient,
                                const std::string& fields,
                                const std::string& gauge,
                                const std::string& timer,
-                                bool verbose)
+                                bool verbose,
+                                size_t maxQueueSize,
+                                bool enableHeartbeat,
+                                int runtime)
    {
+        ix::CobraConnection conn;
+        conn.configure(config);
+        conn.connect();
+
        auto tokens = parseFields(fields);

        CobraBot bot;
-        bot.setOnBotMessageCallback(
-            [&statsdClient, &tokens, &gauge, &timer, &verbose](const Json::Value& msg,
-                                                     const std::string& /*position*/,
-                                                     std::atomic<bool>& /*throttled*/,
-                                                     std::atomic<bool>& fatalCobraError,
-                                                     std::atomic<uint64_t>& sentCount) -> void {
-                std::string id;
-                for (auto&& attr : tokens)
-                {
-                    id += ".";
-                    auto val = extractAttr(attr, msg);
-                    id += val.asString();
-                }
+        bot.setOnBotMessageCallback([&statsdClient, &tokens, &gauge, &timer](const Json::Value& msg,
+                                                                             const std::string& /*position*/,
+                                                                             const bool verbose,
+                                                                             std::atomic<bool>& /*throttled*/,
+                                                                             std::atomic<bool>& fatalCobraError) -> bool {
+            std::string id;
+            for (auto&& attr : tokens)
+            {
+                id += ".";
+                auto val = extractAttr(attr, msg);
+                id += val.asString();
+            }

-                if (gauge.empty() && timer.empty())
+            if (gauge.empty() && timer.empty())
+            {
+                statsdClient.count(id, 1);
+            }
+            else
+            {
+                std::string attrName = (!gauge.empty()) ? gauge : timer;
+                auto val = extractAttr(attrName, msg);
+                size_t x;
+
+                if (val.isInt())
                {
-                    statsdClient.count(id, 1);
+                    x = (size_t) val.asInt();
+                }
+                else if (val.isInt64())
+                {
+                    x = (size_t) val.asInt64();
+                }
+                else if (val.isUInt())
+                {
+                    x = (size_t) val.asUInt();
+                }
+                else if (val.isUInt64())
+                {
+                    x = (size_t) val.asUInt64();
+                }
+                else if (val.isDouble())
+                {
+                    x = (size_t) val.asUInt64();
                }
                else
                {
-                    std::string attrName = (!gauge.empty()) ? gauge : timer;
-                    auto val = extractAttr(attrName, msg);
-                    size_t x;
-
-                    if (val.isInt())
-                    {
-                        x = (size_t) val.asInt();
-                    }
-                    else if (val.isInt64())
-                    {
-                        x = (size_t) val.asInt64();
-                    }
-                    else if (val.isUInt())
-                    {
-                        x = (size_t) val.asUInt();
-                    }
-                    else if (val.isUInt64())
-                    {
-                        x = (size_t) val.asUInt64();
-                    }
-                    else if (val.isDouble())
-                    {
-                        x = (size_t) val.asUInt64();
-                    }
-                    else
-                    {
-                        CoreLogger::error("Gauge " + gauge + " is not a numeric type");
-                        fatalCobraError = true;
-                        return;
-                    }
-
-                    if (verbose)
-                    {
-                        CoreLogger::info(id + " - " + attrName + " -> " + std::to_string(x));
-                    }
-
-                    if (!gauge.empty())
-                    {
-                        statsdClient.gauge(id, x);
-                    }
-                    else
-                    {
-                        statsdClient.timing(id, x);
-                    }
+                    spdlog::error("Gauge {} is not a numeric type", gauge);
+                    fatalCobraError = true;
+                    return false;
                }

-                sentCount++;
-            });
+                if (verbose)
+                {
+                    spdlog::info("{} - {} -> {}", id, attrName, x);
+                }

-        return bot.run(config);
+                if (!gauge.empty())
+                {
+                    statsdClient.gauge(id, x);
+                }
+                else
+                {
+                    statsdClient.timing(id, x);
+                }
+            }
+
+            return true;
+        });
+
+        bool useQueue = true;
+
+        return bot.run(config,
+                       channel,
+                       filter,
+                       position,
+                       verbose,
+                       maxQueueSize,
+                       useQueue,
+                       enableHeartbeat,
+                       runtime);
    }
 } // namespace ix
--- a/ixbots/ixbots/IXCobraToStatsdBot.h
+++ b/ixbots/ixbots/IXCobraToStatsdBot.h
@ -5,18 +5,24 @@
 */
 #pragma once

-#include <cstdint>
+#include <ixcobra/IXCobraConfig.h>
 #include <ixbots/IXStatsdClient.h>
-#include "IXCobraBotConfig.h"
-#include <stddef.h>
 #include <string>
+#include <stddef.h>
+#include <cstdint>

 namespace ix
 {
-    int64_t cobra_to_statsd_bot(const ix::CobraBotConfig& config,
+    int64_t cobra_to_statsd_bot(const ix::CobraConfig& config,
+                                const std::string& channel,
+                                const std::string& filter,
+                                const std::string& position,
                                StatsdClient& statsdClient,
                                const std::string& fields,
                                const std::string& gauge,
                                const std::string& timer,
-                                bool verbose);
+                                bool verbose,
+                                size_t maxQueueSize,
+                                bool enableHeartbeat,
+                                int runtime);
 } // namespace ix
--- a/ixbots/ixbots/IXCobraToStdoutBot.cpp
+++ b/ixbots/ixbots/IXCobraToStdoutBot.cpp
@ -5,11 +5,13 @@
 */

 #include "IXCobraToStdoutBot.h"
-
 #include "IXCobraBot.h"
+#include "IXQueueManager.h"
+
 #include <chrono>
-#include <iostream>
+#include <spdlog/spdlog.h>
 #include <sstream>
+#include <iostream>

 namespace ix
 {
@ -63,26 +65,42 @@ namespace ix
        }
    }

-    int64_t cobra_to_stdout_bot(const ix::CobraBotConfig& config,
+    int64_t cobra_to_stdout_bot(const CobraConfig& config,
+                                const std::string& channel,
+                                const std::string& filter,
+                                const std::string& position,
                                bool fluentd,
-                                bool quiet)
+                                bool quiet,
+                                bool verbose,
+                                size_t maxQueueSize,
+                                bool enableHeartbeat,
+                                int runtime)
    {
        CobraBot bot;
        auto jsonWriter = makeStreamWriter();

-        bot.setOnBotMessageCallback(
-            [&fluentd, &quiet, &jsonWriter](const Json::Value& msg,
-                                            const std::string& position,
-                                            std::atomic<bool>& /*throttled*/,
-                                            std::atomic<bool>& /*fatalCobraError*/,
-                                            std::atomic<uint64_t>& sentCount) -> void {
-                if (!quiet)
-                {
-                    writeToStdout(fluentd, jsonWriter, msg, position);
-                }
-                sentCount++;
-            });
+        bot.setOnBotMessageCallback([&fluentd, &quiet, &jsonWriter](const Json::Value& msg,
+                                                                    const std::string& position,
+                                                                    const bool /*verbose*/,
+                                                                    std::atomic<bool>& /*throttled*/,
+                                                                    std::atomic<bool>& /*fatalCobraError*/) -> bool {
+            if (!quiet)
+            {
+                writeToStdout(fluentd, jsonWriter, msg, position);
+            }
+            return true;
+        });

-        return bot.run(config);
+        bool useQueue = false;
+
+        return bot.run(config,
+                       channel,
+                       filter,
+                       position,
+                       verbose,
+                       maxQueueSize,
+                       useQueue,
+                       enableHeartbeat,
+                       runtime);
    }
 } // namespace ix
--- a/ixbots/ixbots/IXCobraToStdoutBot.h
+++ b/ixbots/ixbots/IXCobraToStdoutBot.h
@ -5,14 +5,21 @@
 */
 #pragma once

-#include <cstdint>
-#include "IXCobraBotConfig.h"
-#include <stddef.h>
+#include <ixcobra/IXCobraConfig.h>
 #include <string>
+#include <stddef.h>
+#include <cstdint>

 namespace ix
 {
-    int64_t cobra_to_stdout_bot(const ix::CobraBotConfig& config,
+    int64_t cobra_to_stdout_bot(const ix::CobraConfig& config,
+                                const std::string& channel,
+                                const std::string& filter,
+                                const std::string& position,
                                bool fluentd,
-                                bool quiet);
+                                bool quiet,
+                                bool verbose,
+                                size_t maxQueueSize,
+                                bool enableHeartbeat,
+                                int runtime);
 } // namespace ix
--- a/ixbots/ixbots/IXQueueManager.cpp
+++ b/ixbots/ixbots/IXQueueManager.cpp
@ -0,0 +1,66 @@
+/*
+ *  IXQueueManager.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXQueueManager.h"
+#include <vector>
+#include <algorithm>
+
+namespace ix
+{
+    std::pair<Json::Value, std::string> QueueManager::pop()
+    {
+        std::unique_lock<std::mutex> lock(_mutex);
+
+        if (_queues.empty())
+        {
+            Json::Value val;
+            return std::make_pair(val, std::string());
+        }
+
+        std::vector<std::string> games;
+        for (auto it : _queues)
+        {
+            games.push_back(it.first);
+        }
+
+        std::random_shuffle(games.begin(), games.end());
+        std::string game = games[0];
+
+        auto duration = std::chrono::seconds(1);
+        _condition.wait_for(lock, duration);
+
+        if (_queues[game].empty())
+        {
+            Json::Value val;
+            return std::make_pair(val, std::string());
+        }
+
+        auto msg = _queues[game].front();
+        _queues[game].pop();
+        return msg;
+    }
+
+    void QueueManager::add(const Json::Value& msg, const std::string& position)
+    {
+        std::unique_lock<std::mutex> lock(_mutex);
+
+        std::string game;
+        if (msg.isMember("device") && msg["device"].isMember("game"))
+        {
+            game = msg["device"]["game"].asString();
+        }
+
+        if (game.empty()) return;
+
+        // if the sending is not fast enough there is no point
+        // in queuing too many events.
+        if (_queues[game].size() < _maxQueueSize)
+        {
+            _queues[game].push(std::make_pair(msg, position));
+            _condition.notify_one();
+        }
+    }
+}
--- a/ixbots/ixbots/IXQueueManager.h
+++ b/ixbots/ixbots/IXQueueManager.h
@ -0,0 +1,35 @@
+/*
+ *  IXQueueManager.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include <json/json.h>
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+#include <map>
+
+namespace ix
+{
+    class QueueManager
+    {
+    public:
+        QueueManager(size_t maxQueueSize)
+            : _maxQueueSize(maxQueueSize)
+        {
+        }
+
+        std::pair<Json::Value, std::string> pop();
+        void add(const Json::Value& msg, const std::string& position);
+
+    private:
+        std::map<std::string, std::queue<std::pair<Json::Value, std::string>>> _queues;
+        std::mutex _mutex;
+        std::condition_variable _condition;
+        size_t _maxQueueSize;
+    };
+}
--- a/ixbots/ixbots/IXStatsdClient.cpp
+++ b/ixbots/ixbots/IXStatsdClient.cpp
@ -39,21 +39,24 @@

 #include "IXStatsdClient.h"

-#include <iostream>
 #include <ixwebsocket/IXNetSystem.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
+#include <iostream>

 namespace ix
 {
-    StatsdClient::StatsdClient(const std::string& host, int port, const std::string& prefix)
-        : _host(host)
-        , _port(port)
-        , _prefix(prefix)
-        , _stop(false)
+    StatsdClient::StatsdClient(const std::string& host,
+                               int port,
+                               const std::string& prefix)
+    : _host(host)
+      , _port(port)
+      , _prefix(prefix)
+      , _stop(false)
    {
-        _thread = std::thread([this] {
+        _thread = std::thread([this]
+        {
            while (!_stop)
            {
                flushQueue();
@ -116,8 +119,8 @@ namespace ix
        cleanup(key);

        char buf[256];
-        snprintf(
-            buf, sizeof(buf), "%s%s:%zd|%s\n", _prefix.c_str(), key.c_str(), value, type.c_str());
+        snprintf(buf, sizeof(buf), "%s%s:%zd|%s\n",
+                 _prefix.c_str(), key.c_str(), value, type.c_str());

        enqueue(buf);
        return 0;
@ -139,7 +142,9 @@ namespace ix
            auto ret = _socket.sendto(message);
            if (ret != 0)
            {
-                std::cerr << "error: " << strerror(UdpSocket::getErrno()) << std::endl;
+                std::cerr << "error: "
+                          << strerror(UdpSocket::getErrno())
+                          << std::endl;
            }
            _queue.pop_front();
        }
--- a/ixbots/ixbots/IXStatsdClient.h
+++ b/ixbots/ixbots/IXStatsdClient.h
@ -6,20 +6,21 @@

 #pragma once

-#include <atomic>
-#include <deque>
 #include <ixwebsocket/IXUdpSocket.h>
-#include <mutex>
+
 #include <string>
 #include <thread>
+#include <deque>
+#include <mutex>
+#include <atomic>

 namespace ix
 {
    class StatsdClient
    {
    public:
-        StatsdClient(const std::string& host = "127.0.0.1",
-                     int port = 8125,
+        StatsdClient(const std::string& host="127.0.0.1",
+                     int port=8125,
                     const std::string& prefix = "");
        ~StatsdClient();

--- a/ixcobra/ixcobra/IXCobraConfig.h
+++ b/ixcobra/ixcobra/IXCobraConfig.h
@ -6,8 +6,8 @@

 #pragma once

-#include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocketPerMessageDeflateOptions.h>
+#include <ixwebsocket/IXSocketTLSOptions.h>

 namespace ix
 {
--- a/ixcobra/ixcobra/IXCobraConnection.cpp
+++ b/ixcobra/ixcobra/IXCobraConnection.cpp
@ -5,17 +5,17 @@
 */

 #include "IXCobraConnection.h"
+#include <ixcrypto/IXHMac.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <ixwebsocket/IXSocketTLSOptions.h>

 #include <algorithm>
-#include <cassert>
+#include <stdexcept>
 #include <cmath>
+#include <cassert>
 #include <cstring>
 #include <iostream>
-#include <ixcrypto/IXHMac.h>
-#include <ixwebsocket/IXSocketTLSOptions.h>
-#include <ixwebsocket/IXWebSocket.h>
 #include <sstream>
-#include <stdexcept>


 namespace ix
@ -26,12 +26,12 @@ namespace ix
    constexpr CobraConnection::MsgId CobraConnection::kInvalidMsgId;
    constexpr int CobraConnection::kPingIntervalSecs;

-    CobraConnection::CobraConnection()
-        : _webSocket(new WebSocket())
-        , _publishMode(CobraConnection_PublishMode_Immediate)
-        , _authenticated(false)
-        , _eventCallback(nullptr)
-        , _id(1)
+    CobraConnection::CobraConnection() :
+        _webSocket(new WebSocket()),
+        _publishMode(CobraConnection_PublishMode_Immediate),
+        _authenticated(false),
+        _eventCallback(nullptr),
+        _id(1)
    {
        _pdu["action"] = "rtm/publish";

@ -97,7 +97,11 @@ namespace ix
        if (_eventCallback)
        {
            _eventCallback(
-                std::make_unique<CobraEvent>(eventType, errorMsg, headers, subscriptionId, msgId));
+                std::make_unique<CobraEvent>(eventType,
+                                             errorMsg,
+                                             headers,
+                                             subscriptionId,
+                                             msgId));
        }
    }

@ -117,119 +121,126 @@ namespace ix

    void CobraConnection::initWebSocketOnMessageCallback()
    {
-        _webSocket->setOnMessageCallback([this](const ix::WebSocketMessagePtr& msg) {
-            CobraConnection::invokeTrafficTrackerCallback(msg->wireSize, true);
-
-            std::stringstream ss;
-            if (msg->type == ix::WebSocketMessageType::Open)
+        _webSocket->setOnMessageCallback(
+            [this](const ix::WebSocketMessagePtr& msg)
            {
-                invokeEventCallback(ix::CobraEventType::Open, std::string(), msg->openInfo.headers);
-                sendHandshakeMessage();
-            }
-            else if (msg->type == ix::WebSocketMessageType::Close)
-            {
-                _authenticated = false;
+                CobraConnection::invokeTrafficTrackerCallback(msg->wireSize, true);

                std::stringstream ss;
-                ss << "Close code " << msg->closeInfo.code;
-                ss << " reason " << msg->closeInfo.reason;
-                invokeEventCallback(ix::CobraEventType::Closed, ss.str());
-            }
-            else if (msg->type == ix::WebSocketMessageType::Message)
-            {
-                Json::Value data;
-                Json::Reader reader;
-                if (!reader.parse(msg->str, data))
+                if (msg->type == ix::WebSocketMessageType::Open)
                {
-                    invokeErrorCallback("Invalid json", msg->str);
-                    return;
+                    invokeEventCallback(ix::CobraEventType::Open,
+                                        std::string(),
+                                        msg->openInfo.headers);
+                    sendHandshakeMessage();
                }
-
-                if (!data.isMember("action"))
+                else if (msg->type == ix::WebSocketMessageType::Close)
                {
-                    invokeErrorCallback("Missing action", msg->str);
-                    return;
+                    _authenticated = false;
+
+                    std::stringstream ss;
+                    ss << "Close code " << msg->closeInfo.code;
+                    ss << " reason " << msg->closeInfo.reason;
+                    invokeEventCallback(ix::CobraEventType::Closed,
+                                        ss.str());
                }
-
-                auto action = data["action"].asString();
-
-                if (action == "auth/handshake/ok")
+                else if (msg->type == ix::WebSocketMessageType::Message)
                {
-                    if (!handleHandshakeResponse(data))
+                    Json::Value data;
+                    Json::Reader reader;
+                    if (!reader.parse(msg->str, data))
                    {
-                        invokeErrorCallback("Error extracting nonce from handshake response",
+                        invokeErrorCallback("Invalid json", msg->str);
+                        return;
+                    }
+
+                    if (!data.isMember("action"))
+                    {
+                        invokeErrorCallback("Missing action", msg->str);
+                        return;
+                    }
+
+                    auto action = data["action"].asString();
+
+                    if (action == "auth/handshake/ok")
+                    {
+                        if (!handleHandshakeResponse(data))
+                        {
+                            invokeErrorCallback("Error extracting nonce from handshake response", msg->str);
+                        }
+                    }
+                    else if (action == "auth/handshake/error")
+                    {
+                        invokeEventCallback(ix::CobraEventType::HandshakeError,
                                            msg->str);
                    }
-                }
-                else if (action == "auth/handshake/error")
-                {
-                    invokeEventCallback(ix::CobraEventType::HandshakeError, msg->str);
-                }
-                else if (action == "auth/authenticate/ok")
-                {
-                    _authenticated = true;
-                    invokeEventCallback(ix::CobraEventType::Authenticated);
-                    flushQueue();
-                }
-                else if (action == "auth/authenticate/error")
-                {
-                    invokeEventCallback(ix::CobraEventType::AuthenticationError, msg->str);
-                }
-                else if (action == "rtm/subscription/data")
-                {
-                    handleSubscriptionData(data);
-                }
-                else if (action == "rtm/subscribe/ok")
-                {
-                    if (!handleSubscriptionResponse(data))
+                    else if (action == "auth/authenticate/ok")
                    {
-                        invokeErrorCallback("Error processing subscribe response", msg->str);
+                        _authenticated = true;
+                        invokeEventCallback(ix::CobraEventType::Authenticated);
+                        flushQueue();
+                    }
+                    else if (action == "auth/authenticate/error")
+                    {
+                        invokeEventCallback(ix::CobraEventType::AuthenticationError,
+                                            msg->str);
+                    }
+                    else if (action == "rtm/subscription/data")
+                    {
+                        handleSubscriptionData(data);
+                    }
+                    else if (action == "rtm/subscribe/ok")
+                    {
+                        if (!handleSubscriptionResponse(data))
+                        {
+                            invokeErrorCallback("Error processing subscribe response", msg->str);
+                        }
+                    }
+                    else if (action == "rtm/subscribe/error")
+                    {
+                        invokeEventCallback(ix::CobraEventType::SubscriptionError,
+                                            msg->str);
+                    }
+                    else if (action == "rtm/unsubscribe/ok")
+                    {
+                        if (!handleUnsubscriptionResponse(data))
+                        {
+                            invokeErrorCallback("Error processing unsubscribe response", msg->str);
+                        }
+                    }
+                    else if (action == "rtm/unsubscribe/error")
+                    {
+                        invokeErrorCallback("Unsubscription error", msg->str);
+                    }
+                    else if (action == "rtm/publish/ok")
+                    {
+                        if (!handlePublishResponse(data))
+                        {
+                            invokeErrorCallback("Error processing publish response", msg->str);
+                        }
+                    }
+                    else if (action == "rtm/publish/error")
+                    {
+                        invokeErrorCallback("Publish error", msg->str);
+                    }
+                    else
+                    {
+                        invokeErrorCallback("Un-handled message type", msg->str);
                    }
                }
-                else if (action == "rtm/subscribe/error")
+                else if (msg->type == ix::WebSocketMessageType::Error)
                {
-                    invokeEventCallback(ix::CobraEventType::SubscriptionError, msg->str);
+                    std::stringstream ss;
+                    ss << "Connection error: " << msg->errorInfo.reason      << std::endl;
+                    ss << "#retries: "         << msg->errorInfo.retries     << std::endl;
+                    ss << "Wait time(ms): "    << msg->errorInfo.wait_time   << std::endl;
+                    ss << "HTTP Status: "      << msg->errorInfo.http_status << std::endl;
+                    invokeErrorCallback(ss.str(), std::string());
                }
-                else if (action == "rtm/unsubscribe/ok")
+                else if (msg->type == ix::WebSocketMessageType::Pong)
                {
-                    if (!handleUnsubscriptionResponse(data))
-                    {
-                        invokeErrorCallback("Error processing unsubscribe response", msg->str);
-                    }
+                    invokeEventCallback(ix::CobraEventType::Pong, msg->str);
                }
-                else if (action == "rtm/unsubscribe/error")
-                {
-                    invokeErrorCallback("Unsubscription error", msg->str);
-                }
-                else if (action == "rtm/publish/ok")
-                {
-                    if (!handlePublishResponse(data))
-                    {
-                        invokeErrorCallback("Error processing publish response", msg->str);
-                    }
-                }
-                else if (action == "rtm/publish/error")
-                {
-                    invokeErrorCallback("Publish error", msg->str);
-                }
-                else
-                {
-                    invokeErrorCallback("Un-handled message type", msg->str);
-                }
-            }
-            else if (msg->type == ix::WebSocketMessageType::Error)
-            {
-                std::stringstream ss;
-                ss << "Connection error: " << msg->errorInfo.reason << std::endl;
-                ss << "#retries: " << msg->errorInfo.retries << std::endl;
-                ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
-                ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
-                invokeErrorCallback(ss.str(), std::string());
-            }
-            else if (msg->type == ix::WebSocketMessageType::Pong)
-            {
-                invokeEventCallback(ix::CobraEventType::Pong, msg->str);
-            }
        });
    }

@ -243,13 +254,12 @@ namespace ix
        return _publishMode;
    }

-    void CobraConnection::configure(
-        const std::string& appkey,
-        const std::string& endpoint,
-        const std::string& rolename,
-        const std::string& rolesecret,
-        const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions,
-        const SocketTLSOptions& socketTLSOptions)
+    void CobraConnection::configure(const std::string& appkey,
+                                    const std::string& endpoint,
+                                    const std::string& rolename,
+                                    const std::string& rolesecret,
+                                    const WebSocketPerMessageDeflateOptions& webSocketPerMessageDeflateOptions,
+                                    const SocketTLSOptions& socketTLSOptions)
    {
        _roleName = rolename;
        _roleSecret = rolesecret;
@ -392,8 +402,7 @@ namespace ix
        if (!subscriptionId.isString()) return false;

        invokeEventCallback(ix::CobraEventType::Subscribed,
-                            std::string(),
-                            WebSocketHttpHeaders(),
+                            std::string(), WebSocketHttpHeaders(),
                            subscriptionId.asString());
        return true;
    }
@ -411,8 +420,7 @@ namespace ix
        if (!subscriptionId.isString()) return false;

        invokeEventCallback(ix::CobraEventType::UnSubscribed,
-                            std::string(),
-                            WebSocketHttpHeaders(),
+                            std::string(), WebSocketHttpHeaders(),
                            subscriptionId.asString());
        return true;
    }
@ -460,10 +468,8 @@ namespace ix
        uint64_t msgId = id.asUInt64();

        invokeEventCallback(ix::CobraEventType::Published,
-                            std::string(),
-                            WebSocketHttpHeaders(),
-                            std::string(),
-                            msgId);
+                            std::string(), WebSocketHttpHeaders(),
+                            std::string(), msgId);

        invokePublishTrackerCallback(false, true);

@ -493,7 +499,9 @@ namespace ix
    }

    std::pair<CobraConnection::MsgId, std::string> CobraConnection::prePublish(
-        const Json::Value& channels, const Json::Value& msg, bool addToQueue)
+        const Json::Value& channels,
+        const Json::Value& msg,
+        bool addToQueue)
    {
        std::lock_guard<std::mutex> lock(_prePublishMutex);

@ -659,7 +667,8 @@ namespace ix
    bool CobraConnection::publishMessage(const std::string& serializedJson)
    {
        auto webSocketSendInfo = _webSocket->send(serializedJson);
-        CobraConnection::invokeTrafficTrackerCallback(webSocketSendInfo.wireSize, false);
+        CobraConnection::invokeTrafficTrackerCallback(webSocketSendInfo.wireSize,
+                                                      false);
        return webSocketSendInfo.success;
    }

--- a/ixcobra/ixcobra/IXCobraConnection.h
+++ b/ixcobra/ixcobra/IXCobraConnection.h
@ -6,19 +6,20 @@

 #pragma once

-#include "IXCobraConfig.h"
-#include "IXCobraEvent.h"
-#include "IXCobraEventType.h"
 #include <ixwebsocket/IXWebSocketHttpHeaders.h>
 #include <ixwebsocket/IXWebSocketPerMessageDeflateOptions.h>
+#include "IXCobraEventType.h"
+#include "IXCobraEvent.h"
 #include <json/json.h>
-#include <limits>
 #include <memory>
 #include <mutex>
 #include <queue>
 #include <string>
 #include <thread>
 #include <unordered_map>
+#include <limits>
+
+#include "IXCobraConfig.h"

 #ifdef max
 #undef max
@ -120,9 +121,10 @@ namespace ix

        /// Prepare a message for transmission
        /// (update the pdu, compute a msgId, serialize json to a string)
-        std::pair<CobraConnection::MsgId, std::string> prePublish(const Json::Value& channels,
-                                                                  const Json::Value& msg,
-                                                                  bool addToQueue);
+        std::pair<CobraConnection::MsgId, std::string> prePublish(
+            const Json::Value& channels,
+            const Json::Value& msg,
+            bool addToQueue);

        /// Attempt to send next message from the internal queue
        bool publishNext();
--- a/ixcobra/ixcobra/IXCobraEvent.h
+++ b/ixcobra/ixcobra/IXCobraEvent.h
@ -7,10 +7,10 @@
 #pragma once

 #include "IXCobraEventType.h"
-#include <cstdint>
 #include <ixwebsocket/IXWebSocketHttpHeaders.h>
 #include <memory>
 #include <string>
+#include <cstdint>

 namespace ix
 {
@ -38,4 +38,4 @@ namespace ix
    };

    using CobraEventPtr = std::unique_ptr<CobraEvent>;
-} // namespace ix
+}
--- a/ixcobra/ixcobra/IXCobraMetricsPublisher.cpp
+++ b/ixcobra/ixcobra/IXCobraMetricsPublisher.cpp
@ -5,9 +5,9 @@
 */

 #include "IXCobraMetricsPublisher.h"
+#include <ixwebsocket/IXSocketTLSOptions.h>

 #include <algorithm>
-#include <ixwebsocket/IXSocketTLSOptions.h>
 #include <stdexcept>


@ -17,8 +17,8 @@ namespace ix
    const std::string CobraMetricsPublisher::kSetRateControlId = "sms_set_rate_control_id";
    const std::string CobraMetricsPublisher::kSetBlacklistId = "sms_set_blacklist_id";

-    CobraMetricsPublisher::CobraMetricsPublisher()
-        : _enabled(true)
+    CobraMetricsPublisher::CobraMetricsPublisher() :
+        _enabled(true)
    {
    }

@ -27,7 +27,8 @@ namespace ix
        ;
    }

-    void CobraMetricsPublisher::configure(const CobraConfig& config, const std::string& channel)
+    void CobraMetricsPublisher::configure(const CobraConfig& config,
+                                          const std::string& channel)
    {
        // Configure the satori connection and start its publish background thread
        _cobra_metrics_theaded_publisher.configure(config, channel);
@ -41,7 +42,7 @@ namespace ix
    }

    void CobraMetricsPublisher::setGenericAttributes(const std::string& attrName,
-                                                     const Json::Value& value)
+                                                      const Json::Value& value)
    {
        std::lock_guard<std::mutex> lock(_device_mutex);
        _device[attrName] = value;
@ -106,7 +107,8 @@ namespace ix
        auto last_update = _last_update.find(id);
        if (last_update == _last_update.end()) return false;

-        auto timeDeltaFromLastSend = std::chrono::steady_clock::now() - last_update->second;
+        auto timeDeltaFromLastSend =
+            std::chrono::steady_clock::now() - last_update->second;

        return timeDeltaFromLastSend < std::chrono::seconds(rate_control_it->second);
    }
@ -121,7 +123,8 @@ namespace ix
    {
        auto now = std::chrono::system_clock::now();
        auto ms =
-            std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
+            std::chrono::duration_cast<std::chrono::milliseconds>(
+                now.time_since_epoch()).count();

        return ms;
    }
@ -162,9 +165,10 @@ namespace ix
        return true;
    }

-    CobraConnection::MsgId CobraMetricsPublisher::push(const std::string& id,
-                                                       const Json::Value& data,
-                                                       bool shouldPushTest)
+    CobraConnection::MsgId CobraMetricsPublisher::push(
+        const std::string& id,
+        const Json::Value& data,
+        bool shouldPushTest)
    {
        if (shouldPushTest && !shouldPush(id)) return CobraConnection::kInvalidMsgId;

--- a/ixcobra/ixcobra/IXCobraMetricsPublisher.h
+++ b/ixcobra/ixcobra/IXCobraMetricsPublisher.h
@ -40,7 +40,8 @@ namespace ix

        /// Configuration / set keys, etc...
        /// All input data but the channel name is encrypted with rc4
-        void configure(const CobraConfig& config, const std::string& channel);
+        void configure(const CobraConfig& config,
+                       const std::string& channel);

        /// Setter for the list of blacklisted metrics ids.
        /// That list is sorted internally for fast lookups
@ -67,14 +68,10 @@ namespace ix
        /// shouldPush method for places where we want to be as lightweight as possible when
        /// collecting metrics. When set to false, it is used so that we don't do double work when
        /// computing whether a metrics should be sent or not.
-        CobraConnection::MsgId push(const std::string& id,
-                                    const Json::Value& data,
-                                    bool shouldPushTest = true);
+        CobraConnection::MsgId push(const std::string& id, const Json::Value& data, bool shouldPushTest = true);

        /// Interface used by lua. msg is a json encoded string.
-        CobraConnection::MsgId push(const std::string& id,
-                                    const std::string& data,
-                                    bool shouldPushTest = true);
+        CobraConnection::MsgId push(const std::string& id, const std::string& data, bool shouldPushTest = true);

        /// Tells whether a metric can be pushed.
        /// A metric can be pushed if it satisfies those conditions:
@ -92,16 +89,10 @@ namespace ix
        void setGenericAttributes(const std::string& attrName, const Json::Value& value);

        /// Set a unique id for the session. A uuid can be used.
-        void setSession(const std::string& session)
-        {
-            _session = session;
-        }
+        void setSession(const std::string& session) { _session = session; }

        /// Get the unique id used to identify the current session
-        const std::string& getSession() const
-        {
-            return _session;
-        }
+        const std::string& getSession() const { return _session; }

        /// Return the number of milliseconds since the epoch (~1970)
        uint64_t getMillisecondsSinceEpoch() const;
--- a/ixcobra/ixcobra/IXCobraMetricsThreadedPublisher.cpp
+++ b/ixcobra/ixcobra/IXCobraMetricsThreadedPublisher.cpp
@ -5,77 +5,78 @@
 */

 #include "IXCobraMetricsThreadedPublisher.h"
-
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <iostream>
-#include <ixcore/utils/IXCoreLogger.h>
 #include <ixwebsocket/IXSetThreadName.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
-#include <sstream>
+#include <ixcore/utils/IXCoreLogger.h>
+
+#include <algorithm>
 #include <stdexcept>
+#include <cmath>
+#include <cassert>
+#include <iostream>
+#include <sstream>


 namespace ix
 {
-    CobraMetricsThreadedPublisher::CobraMetricsThreadedPublisher()
-        : _stop(false)
+    CobraMetricsThreadedPublisher::CobraMetricsThreadedPublisher() :
+        _stop(false)
    {
-        _cobra_connection.setEventCallback([](const CobraEventPtr& event) {
-            std::stringstream ss;
-
-            if (event->type == ix::CobraEventType::Open)
+        _cobra_connection.setEventCallback([](const CobraEventPtr& event)
            {
-                ss << "Handshake headers" << std::endl;
+                std::stringstream ss;

-                for (auto&& it : event->headers)
+                if (event->type == ix::CobraEventType::Open)
                {
-                    ss << it.first << ": " << it.second << std::endl;
-                }
-            }
-            else if (event->type == ix::CobraEventType::Authenticated)
-            {
-                ss << "Authenticated";
-            }
-            else if (event->type == ix::CobraEventType::Error)
-            {
-                ss << "Error: " << event->errMsg;
-            }
-            else if (event->type == ix::CobraEventType::Closed)
-            {
-                ss << "Connection closed: " << event->errMsg;
-            }
-            else if (event->type == ix::CobraEventType::Subscribed)
-            {
-                ss << "Subscribed through subscription id: " << event->subscriptionId;
-            }
-            else if (event->type == ix::CobraEventType::UnSubscribed)
-            {
-                ss << "Unsubscribed through subscription id: " << event->subscriptionId;
-            }
-            else if (event->type == ix::CobraEventType::Published)
-            {
-                ss << "Published message " << event->msgId << " acked";
-            }
-            else if (event->type == ix::CobraEventType::Pong)
-            {
-                ss << "Received websocket pong";
-            }
-            else if (event->type == ix::CobraEventType::HandshakeError)
-            {
-                ss << "Handshake error: " << event->errMsg;
-            }
-            else if (event->type == ix::CobraEventType::AuthenticationError)
-            {
-                ss << "Authentication error: " << event->errMsg;
-            }
-            else if (event->type == ix::CobraEventType::SubscriptionError)
-            {
-                ss << "Subscription error: " << event->errMsg;
-            }
+                    ss << "Handshake headers" << std::endl;

-            CoreLogger::log(ss.str().c_str());
+                    for (auto&& it : event->headers)
+                    {
+                        ss << it.first << ": " << it.second << std::endl;
+                    }
+                }
+                else if (event->type == ix::CobraEventType::Authenticated)
+                {
+                    ss << "Authenticated";
+                }
+                else if (event->type == ix::CobraEventType::Error)
+                {
+                    ss << "Error: " << event->errMsg;
+                }
+                else if (event->type == ix::CobraEventType::Closed)
+                {
+                    ss << "Connection closed: " << event->errMsg;
+                }
+                else if (event->type == ix::CobraEventType::Subscribed)
+                {
+                    ss << "Subscribed through subscription id: " << event->subscriptionId;
+                }
+                else if (event->type == ix::CobraEventType::UnSubscribed)
+                {
+                    ss << "Unsubscribed through subscription id: " << event->subscriptionId;
+                }
+                else if (event->type == ix::CobraEventType::Published)
+                {
+                    ss << "Published message " << event->msgId << " acked";
+                }
+                else if (event->type == ix::CobraEventType::Pong)
+                {
+                    ss << "Received websocket pong";
+                }
+                else if (event->type == ix::CobraEventType::HandshakeError)
+                {
+                    ss << "Handshake error: " << event->errMsg;
+                }
+                else if (event->type == ix::CobraEventType::AuthenticationError)
+                {
+                    ss << "Authentication error: " << event->errMsg;
+                }
+                else if (event->type == ix::CobraEventType::SubscriptionError)
+                {
+                    ss << "Subscription error: " << event->errMsg;
+                }
+
+                ix::IXCoreLogger::Log(ss.str().c_str());
        });
    }

@ -100,10 +101,11 @@ namespace ix
    void CobraMetricsThreadedPublisher::configure(const CobraConfig& config,
                                                  const std::string& channel)
    {
-        CoreLogger::log(config.socketTLSOptions.getDescription().c_str());
+        ix::IXCoreLogger::Log(config.socketTLSOptions.getDescription().c_str());

        _channel = channel;
        _cobra_connection.configure(config);
+
    }

    void CobraMetricsThreadedPublisher::pushMessage(MessageKind messageKind)
@ -161,15 +163,13 @@ namespace ix
                {
                    _cobra_connection.suspend();
                    continue;
-                };
-                break;
+                }; break;

                case MessageKind::Resume:
                {
                    _cobra_connection.resume();
                    continue;
-                };
-                break;
+                }; break;

                case MessageKind::Message:
                {
@ -177,8 +177,7 @@ namespace ix
                    {
                        _cobra_connection.publishNext();
                    }
-                };
-                break;
+                }; break;
            }
        }
    }
--- a/ixcobra/ixcobra/IXCobraMetricsThreadedPublisher.h
+++ b/ixcobra/ixcobra/IXCobraMetricsThreadedPublisher.h
@ -27,7 +27,8 @@ namespace ix
        ~CobraMetricsThreadedPublisher();

        /// Configuration / set keys, etc...
-        void configure(const CobraConfig& config, const std::string& channel);
+        void configure(const CobraConfig& config,
+                       const std::string& channel);

        /// Start the worker thread, used for background publishing
        void start();
--- a/ixcore/ixcore/utils/IXCoreLogger.cpp
+++ b/ixcore/ixcore/utils/IXCoreLogger.cpp
@ -1,44 +1,14 @@
-/*
- *  IXCoreLogger.cpp
- *  Author: Thomas Wells, Benjamin Sergeant
- *  Copyright (c) 2019-2020 Machine Zone, Inc. All rights reserved.
- */
-
 #include "ixcore/utils/IXCoreLogger.h"

+
 namespace ix
 {
-    // Default do a no-op logger
-    CoreLogger::LogFunc CoreLogger::_currentLogger = [](const char*, LogLevel) {};
+// Default do nothing logger
+IXCoreLogger::LogFunc IXCoreLogger::_currentLogger = [](const char* /*msg*/){};

-    void CoreLogger::log(const char* msg, LogLevel level)
-    {
-        _currentLogger(msg, level);
-    }
+void IXCoreLogger::Log(const char* msg)
+{
+    _currentLogger(msg);
+}

-    void CoreLogger::debug(const std::string& msg)
-    {
-        _currentLogger(msg.c_str(), LogLevel::Debug);
-    }
-
-    void CoreLogger::info(const std::string& msg)
-    {
-        _currentLogger(msg.c_str(), LogLevel::Info);
-    }
-
-    void CoreLogger::warn(const std::string& msg)
-    {
-        _currentLogger(msg.c_str(), LogLevel::Warning);
-    }
-
-    void CoreLogger::error(const std::string& msg)
-    {
-        _currentLogger(msg.c_str(), LogLevel::Error);
-    }
-
-    void CoreLogger::critical(const std::string& msg)
-    {
-        _currentLogger(msg.c_str(), LogLevel::Critical);
-    }
-
-} // namespace ix
+} // ix
--- a/ixcore/ixcore/utils/IXCoreLogger.h
+++ b/ixcore/ixcore/utils/IXCoreLogger.h
@ -1,41 +1,15 @@
-/*
- *  IXCoreLogger.h
- *  Author: Thomas Wells, Benjamin Sergeant
- *  Copyright (c) 2019-2020 Machine Zone, Inc. All rights reserved.
- */
-
 #pragma once
 #include <functional>
-#include <string>

 namespace ix
 {
-    enum class LogLevel
-    {
-        Debug = 0,
-        Info = 1,
-        Warning = 2,
-        Error = 3,
-        Critical = 4
-    };
-
-    class CoreLogger
+    class IXCoreLogger
    {
    public:
-        using LogFunc = std::function<void(const char*, LogLevel level)>;
+        using LogFunc = std::function<void(const char*)>;
+        static void Log(const char* msg);

-        static void log(const char* msg, LogLevel level = LogLevel::Debug);
-
-        static void debug(const std::string& msg);
-        static void info(const std::string& msg);
-        static void warn(const std::string& msg);
-        static void error(const std::string& msg);
-        static void critical(const std::string& msg);
-
-        static void setLogFunction(LogFunc& func)
-        {
-            _currentLogger = func;
-        }
+        static void setLogFunction(LogFunc& func) { _currentLogger = func; }

    private:
        static LogFunc _currentLogger;
--- a/ixcrypto/CMakeLists.txt
+++ b/ixcrypto/CMakeLists.txt
@ -37,7 +37,9 @@ if (USE_MBED_TLS)
    target_include_directories(ixcrypto PUBLIC ${MBEDTLS_INCLUDE_DIRS})
    target_link_libraries(ixcrypto ${MBEDTLS_LIBRARIES})
    target_compile_definitions(ixcrypto PUBLIC IXCRYPTO_USE_MBED_TLS)
-elseif (USE_OPEN_SSL)
+elseif (APPLE)
+elseif (WIN32)
+else()
    find_package(OpenSSL REQUIRED)
    add_definitions(${OPENSSL_DEFINITIONS})
    message(STATUS "OpenSSL: " ${OPENSSL_VERSION})
--- a/ixcrypto/ixcrypto/IXBase64.cpp
+++ b/ixcrypto/ixcrypto/IXBase64.cpp
@ -29,9 +29,10 @@

 namespace ix
 {
-    static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                            "abcdefghijklmnopqrstuvwxyz"
-                                            "0123456789+/";
+    static const std::string base64_chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz"
+    "0123456789+/";

    std::string base64_encode(const std::string& data, size_t len)
    {
@ -49,26 +50,26 @@ namespace ix
        unsigned char char_array_3[3];
        unsigned char char_array_4[4];

-        while (len--)
+        while(len--)
        {
            char_array_3[i++] = *(bytes_to_encode++);
-            if (i == 3)
+            if(i == 3)
            {
                char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
                char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
                char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
                char_array_4[3] = char_array_3[2] & 0x3f;

-                for (i = 0; (i < 4); i++)
+                for(i = 0; (i <4) ; i++)
                    ret += base64_chars[char_array_4[i]];

                i = 0;
            }
        }

-        if (i)
+        if(i)
        {
-            for (j = i; j < 3; j++)
+            for(j = i; j < 3; j++)
                char_array_3[j] = '\0';

            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
@ -76,11 +77,12 @@ namespace ix
            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
            char_array_4[3] = char_array_3[2] & 0x3f;

-            for (j = 0; (j < i + 1); j++)
+            for(j = 0; (j < i + 1); j++)
                ret += base64_chars[char_array_4[j]];

-            while ((i++ < 3))
+            while((i++ < 3))
                ret += '=';
+
        }

        return ret;
@ -93,7 +95,7 @@ namespace ix

    std::string base64_decode(const std::string& encoded_string)
    {
-        int in_len = (int) encoded_string.size();
+        int in_len = (int)encoded_string.size();
        int i = 0;
        int j = 0;
        int in_ = 0;
@ -101,42 +103,40 @@ namespace ix
        std::string ret;
        ret.reserve(((in_len + 3) / 4) * 3);

-        while (in_len-- && (encoded_string[in_] != '=') && is_base64(encoded_string[in_]))
+        while(in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_]))
        {
-            char_array_4[i++] = encoded_string[in_];
-            in_++;
-            if (i == 4)
+            char_array_4[i++] = encoded_string[in_]; in_++;
+            if(i ==4)
            {
-                for (i = 0; i < 4; i++)
+                for(i = 0; i <4; i++)
                    char_array_4[i] = base64_chars.find(char_array_4[i]);

                char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
                char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
                char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

-                for (i = 0; (i < 3); i++)
+                for(i = 0; (i < 3); i++)
                    ret += char_array_3[i];

                i = 0;
            }
        }

-        if (i)
+        if(i)
        {
-            for (j = i; j < 4; j++)
+            for(j = i; j <4; j++)
                char_array_4[j] = 0;

-            for (j = 0; j < 4; j++)
+            for(j = 0; j <4; j++)
                char_array_4[j] = base64_chars.find(char_array_4[j]);

            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

-            for (j = 0; (j < i - 1); j++)
-                ret += char_array_3[j];
+            for(j = 0; (j < i - 1); j++) ret += char_array_3[j];
        }

        return ret;
    }
-} // namespace ix
+}
--- a/ixcrypto/ixcrypto/IXHMac.cpp
+++ b/ixcrypto/ixcrypto/IXHMac.cpp
@ -5,17 +5,16 @@
 */

 #include "IXHMac.h"
-
 #include "IXBase64.h"

 #if defined(IXCRYPTO_USE_MBED_TLS)
-#include <mbedtls/md.h>
+# include <mbedtls/md.h>
 #elif defined(__APPLE__)
-#include <CommonCrypto/CommonHMAC.h>
+# include <CommonCrypto/CommonHMAC.h>
 #elif defined(IXCRYPTO_USE_OPEN_SSL)
-#include <openssl/hmac.h>
+# include <openssl/hmac.h>
 #else
-#include <assert.h>
+# include <assert.h>
 #endif

 namespace ix
@ -27,21 +26,19 @@ namespace ix

 #if defined(IXCRYPTO_USE_MBED_TLS)
        mbedtls_md_hmac(mbedtls_md_info_from_type(MBEDTLS_MD_MD5),
-                        (unsigned char*) key.c_str(),
-                        key.size(),
-                        (unsigned char*) data.c_str(),
-                        data.size(),
-                        (unsigned char*) &hash);
+               (unsigned char *) key.c_str(), key.size(),
+               (unsigned char *) data.c_str(), data.size(),
+               (unsigned char *) &hash);
 #elif defined(__APPLE__)
-        CCHmac(kCCHmacAlgMD5, key.c_str(), key.size(), data.c_str(), data.size(), &hash);
+        CCHmac(kCCHmacAlgMD5,
+               key.c_str(), key.size(),
+               data.c_str(), data.size(),
+               &hash);
 #elif defined(IXCRYPTO_USE_OPEN_SSL)
        HMAC(EVP_md5(),
-             key.c_str(),
-             (int) key.size(),
-             (unsigned char*) data.c_str(),
-             (int) data.size(),
-             (unsigned char*) hash,
-             nullptr);
+             key.c_str(), (int) key.size(),
+             (unsigned char *) data.c_str(), (int) data.size(),
+             (unsigned char *) hash, nullptr);
 #else
        assert(false && "hmac not implemented on this platform");
 #endif
@ -50,4 +47,4 @@ namespace ix

        return base64_encode(hashString, (uint32_t) hashString.size());
    }
-} // namespace ix
+}
--- a/ixcrypto/ixcrypto/IXHash.cpp
+++ b/ixcrypto/ixcrypto/IXHash.cpp
@ -19,4 +19,4 @@ namespace ix

        return hashAddress;
    }
-} // namespace ix
+}
--- a/ixcrypto/ixcrypto/IXUuid.cpp
+++ b/ixcrypto/ixcrypto/IXUuid.cpp
@ -16,23 +16,23 @@

 #include "IXUuid.h"

-#include <iomanip>
-#include <random>
 #include <sstream>
 #include <string>
+#include <iomanip>
+#include <random>


 namespace ix
 {
    class Uuid
    {
-    public:
-        Uuid();
-        std::string toString() const;
+        public:
+            Uuid();
+            std::string toString() const;

-    private:
-        uint64_t _ab;
-        uint64_t _cd;
+        private:
+            uint64_t _ab;
+            uint64_t _cd;
    };

    Uuid::Uuid()
@ -60,7 +60,7 @@ namespace ix
        ss << std::setw(8) << (a);
        ss << std::setw(4) << (b >> 16);
        ss << std::setw(4) << (b & 0xFFFF);
-        ss << std::setw(4) << (c >> 16);
+        ss << std::setw(4) << (c >> 16 );
        ss << std::setw(4) << (c & 0xFFFF);
        ss << std::setw(8) << d;

@ -72,4 +72,4 @@ namespace ix
        Uuid id;
        return id.toString();
    }
-} // namespace ix
+}
--- a/ixsentry/ixsentry/IXSentryClient.cpp
+++ b/ixsentry/ixsentry/IXSentryClient.cpp
@ -7,12 +7,12 @@
 #include "IXSentryClient.h"

 #include <chrono>
-#include <fstream>
 #include <iostream>
-#include <ixcore/utils/IXCoreLogger.h>
+#include <fstream>
+#include <sstream>
 #include <ixwebsocket/IXWebSocketHttpHeaders.h>
 #include <ixwebsocket/IXWebSocketVersion.h>
-#include <sstream>
+#include <ixcore/utils/IXCoreLogger.h>


 namespace ix
@ -226,44 +226,44 @@ namespace ix
        return _jsonWriter.write(payload);
    }

-    void SentryClient::send(
-        const Json::Value& msg,
-        bool verbose,
-        const OnResponseCallback& onResponseCallback)
+    std::pair<HttpResponsePtr, std::string> SentryClient::send(const Json::Value& msg, bool verbose)
    {
        auto args = _httpClient->createRequest();
-        args->url = _url;
-        args->verb = HttpClient::kPost;
        args->extraHeaders["X-Sentry-Auth"] = SentryClient::computeAuthHeader();
        args->connectTimeout = 60;
        args->transferTimeout = 5 * 60;
        args->followRedirects = true;
        args->verbose = verbose;
-        args->logger = [](const std::string& msg) { CoreLogger::log(msg.c_str()); };
-        args->body = computePayload(msg);
+        args->logger = [](const std::string& msg) { ix::IXCoreLogger::Log(msg.c_str()); };

-        _httpClient->performRequest(args, onResponseCallback);
+        std::string body = computePayload(msg);
+        HttpResponsePtr response = _httpClient->post(_url, body, args);
+
+        return std::make_pair(response, body);
    }

    // https://sentry.io/api/12345/minidump?sentry_key=abcdefgh");
    std::string SentryClient::computeUrl(const std::string& project, const std::string& key)
    {
        std::stringstream ss;
-        ss << "https://sentry.io/api/" << project << "/minidump?sentry_key=" << key;
+        ss << "https://sentry.io/api/"
+           << project
+           << "/minidump?sentry_key="
+           << key;

        return ss.str();
    }

    //
-    // curl -v -X POST -F upload_file_minidump=@ws/crash.dmp
-    // 'https://sentry.io/api/123456/minidump?sentry_key=12344567890'
+    // curl -v -X POST -F upload_file_minidump=@ws/crash.dmp 'https://sentry.io/api/123456/minidump?sentry_key=12344567890'
    //
-    void SentryClient::uploadMinidump(const std::string& sentryMetadata,
-                                      const std::string& minidumpBytes,
-                                      const std::string& project,
-                                      const std::string& key,
-                                      bool verbose,
-                                      const OnResponseCallback& onResponseCallback)
+    void SentryClient::uploadMinidump(
+        const std::string& sentryMetadata,
+        const std::string& minidumpBytes,
+        const std::string& project,
+        const std::string& key,
+        bool verbose,
+        const OnResponseCallback& onResponseCallback)
    {
        std::string multipartBoundary = _httpClient->generateMultipartBoundary();

@ -274,7 +274,7 @@ namespace ix
        args->followRedirects = true;
        args->verbose = verbose;
        args->multipartBoundary = multipartBoundary;
-        args->logger = [](const std::string& msg) { CoreLogger::log(msg.c_str()); };
+        args->logger = [](const std::string& msg) { ix::IXCoreLogger::Log(msg.c_str()); };

        HttpFormDataParameters httpFormDataParameters;
        httpFormDataParameters["upload_file_minidump"] = minidumpBytes;
@ -283,15 +283,15 @@ namespace ix
        httpParameters["sentry"] = sentryMetadata;

        args->url = computeUrl(project, key);
-        args->body = _httpClient->serializeHttpFormDataParameters(
-            multipartBoundary, httpFormDataParameters, httpParameters);
+        args->body = _httpClient->serializeHttpFormDataParameters(multipartBoundary, httpFormDataParameters, httpParameters);

        _httpClient->performRequest(args, onResponseCallback);
    }

-    void SentryClient::uploadPayload(const Json::Value& payload,
-                                     bool verbose,
-                                     const OnResponseCallback& onResponseCallback)
+    void SentryClient::uploadPayload(
+        const Json::Value& payload,
+        bool verbose,
+        const OnResponseCallback& onResponseCallback)
    {
        auto args = _httpClient->createRequest();
        args->extraHeaders["X-Sentry-Auth"] = SentryClient::computeAuthHeader();
@ -300,7 +300,7 @@ namespace ix
        args->transferTimeout = 5 * 60;
        args->followRedirects = true;
        args->verbose = verbose;
-        args->logger = [](const std::string& msg) { CoreLogger::log(msg.c_str()); };
+        args->logger = [](const std::string& msg) { ix::IXCoreLogger::Log(msg.c_str()); };

        args->url = _url;
        args->body = _jsonWriter.write(payload);
--- a/ixsentry/ixsentry/IXSentryClient.h
+++ b/ixsentry/ixsentry/IXSentryClient.h
@ -10,8 +10,8 @@
 #include <ixwebsocket/IXHttpClient.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <json/json.h>
-#include <memory>
 #include <regex>
+#include <memory>

 namespace ix
 {
@ -21,26 +21,25 @@ namespace ix
        SentryClient(const std::string& dsn);
        ~SentryClient() = default;

-        void send(const Json::Value& msg,
-                  bool verbose,
-                  const OnResponseCallback& onResponseCallback);
-
-        void uploadMinidump(const std::string& sentryMetadata,
-                            const std::string& minidumpBytes,
-                            const std::string& project,
-                            const std::string& key,
-                            bool verbose,
-                            const OnResponseCallback& onResponseCallback);
-
-        void uploadPayload(const Json::Value& payload,
-                           bool verbose,
-                           const OnResponseCallback& onResponseCallback);
+        std::pair<HttpResponsePtr, std::string> send(const Json::Value& msg, bool verbose);

        Json::Value parseLuaStackTrace(const std::string& stack);

        // Mostly for testing
        void setTLSOptions(const SocketTLSOptions& tlsOptions);

+        void uploadMinidump(
+            const std::string& sentryMetadata,
+            const std::string& minidumpBytes,
+            const std::string& project,
+            const std::string& key,
+            bool verbose,
+            const OnResponseCallback& onResponseCallback);
+
+        void uploadPayload(
+            const Json::Value& payload,
+            bool verbose,
+            const OnResponseCallback& onResponseCallback);

    private:
        int64_t getTimestamp();
--- a/ixsnake/ixsnake/IXAppConfig.h
+++ b/ixsnake/ixsnake/IXAppConfig.h
@ -6,10 +6,10 @@

 #pragma once

-#include <ixwebsocket/IXSocketTLSOptions.h>
 #include <nlohmann/json.hpp>
 #include <string>
 #include <vector>
+#include <ixwebsocket/IXSocketTLSOptions.h>

 namespace snake
 {
--- a/ixsnake/ixsnake/IXRedisClient.cpp
+++ b/ixsnake/ixsnake/IXRedisClient.cpp
@ -28,7 +28,10 @@ namespace ix
            return false;
        }

-        CancellationRequest cancellationRequest = []() -> bool { return false; };
+        CancellationRequest cancellationRequest = []() -> bool
+        {
+            return false;
+        };

        std::string errMsg;
        return _socket->connect(hostname, port, errMsg, cancellationRequest);
@ -249,8 +252,9 @@ namespace ix
        return true;
    }

-    std::string RedisClient::prepareXaddCommand(const std::string& stream,
-                                                const std::string& message)
+    std::string RedisClient::prepareXaddCommand(
+        const std::string& stream,
+        const std::string& message)
    {
        std::stringstream ss;
        ss << "*5\r\n";
@ -324,9 +328,7 @@ namespace ix
        return streamId;
    }

-    bool RedisClient::sendCommand(const std::string& commands,
-                                  int commandsCount,
-                                  std::string& errMsg)
+    bool RedisClient::sendCommand(const std::string& commands, int commandsCount, std::string& errMsg)
    {
        bool sent = _socket->writeBytes(commands, nullptr);
        if (!sent)
--- a/ixsnake/ixsnake/IXRedisClient.h
+++ b/ixsnake/ixsnake/IXRedisClient.h
@ -8,10 +8,11 @@

 #include <atomic>
 #include <functional>
-#include <ixwebsocket/IXSocket.h>
 #include <memory>
 #include <string>

+#include <ixwebsocket/IXSocket.h>
+
 namespace ix
 {
    class RedisClient
@ -38,11 +39,14 @@ namespace ix
                       const OnRedisSubscribeCallback& callback);

        // XADD
-        std::string xadd(const std::string& channel,
-                         const std::string& message,
-                         std::string& errMsg);
+        std::string xadd(
+            const std::string& channel,
+            const std::string& message,
+            std::string& errMsg);

-        std::string prepareXaddCommand(const std::string& stream, const std::string& message);
+        std::string prepareXaddCommand(
+            const std::string& stream,
+            const std::string& message);

        std::string readXaddReply(std::string& errMsg);

--- a/ixsnake/ixsnake/IXRedisServer.cpp
+++ b/ixsnake/ixsnake/IXRedisServer.cpp
@ -6,18 +6,17 @@

 #include "IXRedisServer.h"

-#include <fstream>
-#include <ixwebsocket/IXCancellationRequest.h>
 #include <ixwebsocket/IXNetSystem.h>
-#include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXSocketConnect.h>
+#include <ixwebsocket/IXSocket.h>
+#include <ixwebsocket/IXCancellationRequest.h>
+#include <fstream>
 #include <sstream>
 #include <vector>

 namespace ix
 {
-    RedisServer::RedisServer(
-        int port, const std::string& host, int backlog, size_t maxConnections, int addressFamily)
+    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)
@ -115,7 +114,8 @@ namespace ix
        for (auto it : _subscribers)
        {
            std::stringstream ss;
-            ss << "Subscription id: " << it.first << " #subscribers: " << it.second.size();
+            ss << "Subscription id: " << it.first
+               << " #subscribers: " << it.second.size();

            logInfo(ss.str());
        }
@ -126,7 +126,8 @@ namespace ix
        return _connectedClientsCount;
    }

-    bool RedisServer::startsWith(const std::string& str, const std::string& start)
+    bool RedisServer::startsWith(const std::string& str,
+                                 const std::string& start)
    {
        return str.compare(0, start.length(), start) == 0;
    }
@ -143,8 +144,9 @@ namespace ix
        return ss.str();
    }

-    bool RedisServer::parseRequest(std::unique_ptr<Socket>& socket,
-                                   std::vector<std::string>& tokens)
+    bool RedisServer::parseRequest(
+        std::unique_ptr<Socket>& socket,
+        std::vector<std::string>& tokens)
    {
        // Parse first line
        auto cb = makeCancellationRequestWithTimeout(30, _stopHandlingConnections);
@ -188,8 +190,9 @@ namespace ix
        return true;
    }

-    bool RedisServer::handleCommand(std::unique_ptr<Socket>& socket,
-                                    const std::vector<std::string>& tokens)
+    bool RedisServer::handleCommand(
+        std::unique_ptr<Socket>& socket,
+        const std::vector<std::string>& tokens)
    {
        if (tokens.size() != 1) return false;

@ -204,30 +207,31 @@ namespace ix
        //
        ss << "*6\r\n";
        ss << writeString("publish"); // 1
-        ss << ":3\r\n";               // 2
-        ss << "*0\r\n";               // 3
-        ss << ":1\r\n";               // 4
-        ss << ":2\r\n";               // 5
-        ss << ":1\r\n";               // 6
+        ss << ":3\r\n"; // 2
+        ss << "*0\r\n"; // 3
+        ss << ":1\r\n"; // 4
+        ss << ":2\r\n"; // 5
+        ss << ":1\r\n"; // 6

        //
        // subscribe
        //
        ss << "*6\r\n";
        ss << writeString("subscribe"); // 1
-        ss << ":2\r\n";                 // 2
-        ss << "*0\r\n";                 // 3
-        ss << ":1\r\n";                 // 4
-        ss << ":1\r\n";                 // 5
-        ss << ":1\r\n";                 // 6
+        ss << ":2\r\n"; // 2
+        ss << "*0\r\n"; // 3
+        ss << ":1\r\n"; // 4
+        ss << ":1\r\n"; // 5
+        ss << ":1\r\n"; // 6

        socket->writeBytes(ss.str(), cb);

        return true;
    }

-    bool RedisServer::handleSubscribe(std::unique_ptr<Socket>& socket,
-                                      const std::vector<std::string>& tokens)
+    bool RedisServer::handleSubscribe(
+        std::unique_ptr<Socket>& socket,
+        const std::vector<std::string>& tokens)
    {
        if (tokens.size() != 2) return false;

@ -246,8 +250,9 @@ namespace ix
        return true;
    }

-    bool RedisServer::handlePublish(std::unique_ptr<Socket>& socket,
-                                    const std::vector<std::string>& tokens)
+    bool RedisServer::handlePublish(
+        std::unique_ptr<Socket>& socket,
+        const std::vector<std::string>& tokens)
    {
        if (tokens.size() != 3) return false;

@ -276,7 +281,9 @@ namespace ix

        // return the number of clients that received the message.
        std::stringstream ss;
-        ss << ":" << std::to_string(subscribers.size()) << "\r\n";
+        ss << ":"
+           << std::to_string(subscribers.size())
+           << "\r\n";
        socket->writeBytes(ss.str(), cb);

        return true;
--- a/ixsnake/ixsnake/IXRedisServer.h
+++ b/ixsnake/ixsnake/IXRedisServer.h
@ -6,13 +6,13 @@

 #pragma once

-#include "IXSocket.h"
 #include "IXSocketServer.h"
+#include "IXSocket.h"
 #include <functional>
-#include <map>
 #include <memory>
 #include <mutex>
 #include <set>
+#include <map>
 #include <string>
 #include <thread>
 #include <utility> // pair
@ -50,14 +50,18 @@ namespace ix
        bool startsWith(const std::string& str, const std::string& start);
        std::string writeString(const std::string& str);

-        bool parseRequest(std::unique_ptr<Socket>& socket, std::vector<std::string>& tokens);
+        bool parseRequest(
+            std::unique_ptr<Socket>& socket,
+            std::vector<std::string>& tokens);

-        bool handlePublish(std::unique_ptr<Socket>& socket, const std::vector<std::string>& tokens);
+        bool handlePublish(std::unique_ptr<Socket>& socket,
+                           const std::vector<std::string>& tokens);

        bool handleSubscribe(std::unique_ptr<Socket>& socket,
                             const std::vector<std::string>& tokens);

-        bool handleCommand(std::unique_ptr<Socket>& socket, const std::vector<std::string>& tokens);
+        bool handleCommand(std::unique_ptr<Socket>& socket,
+                           const std::vector<std::string>& tokens);

        void cleanupSubscribers(std::unique_ptr<Socket>& socket);
    };
--- a/ixsnake/ixsnake/IXSnakeProtocol.cpp
+++ b/ixsnake/ixsnake/IXSnakeProtocol.cpp
@ -10,9 +10,9 @@
 #include "IXSnakeConnectionState.h"
 #include "nlohmann/json.hpp"
 #include <iostream>
-#include <ixcore/utils/IXCoreLogger.h>
 #include <ixcrypto/IXHMac.h>
 #include <ixwebsocket/IXWebSocket.h>
+#include <ixcore/utils/IXCoreLogger.h>
 #include <sstream>

 namespace snake
@ -189,8 +189,7 @@ namespace snake
            nlohmann::json response = {
                {"action", "rtm/subscription/data"},
                {"id", id++},
-                {"body",
-                 {{"subscription_id", subscriptionId}, {"position", "0-0"}, {"messages", {msg}}}}};
+                {"body", {{"subscription_id", subscriptionId}, {"position", "0-0"}, {"messages", {msg}}}}};

            ws->sendText(response.dump());
        };
@ -198,7 +197,7 @@ namespace snake
        auto responseCallback = [ws, pdu, &subscriptionId](const std::string& redisResponse) {
            std::stringstream ss;
            ss << "Redis Response: " << redisResponse << "...";
-            ix::CoreLogger::log(ss.str().c_str());
+            ix::IXCoreLogger::Log(ss.str().c_str());

            // Success
            nlohmann::json response = {{"action", "rtm/subscribe/ok"},
@ -210,7 +209,7 @@ namespace snake
        {
            std::stringstream ss;
            ss << "Subscribing to " << appChannel << "...";
-            ix::CoreLogger::log(ss.str().c_str());
+            ix::IXCoreLogger::Log(ss.str().c_str());
        }

        if (!redisClient.subscribe(appChannel, responseCallback, callback))
@ -262,7 +261,8 @@ namespace snake
            std::stringstream ss;
            ss << "malformed json pdu: " << e.what() << " -> " << str << "";

-            nlohmann::json response = {{"body", {{"error", "invalid_json"}, {"reason", ss.str()}}}};
+            nlohmann::json response = {{"body", {{"error", "invalid_json"},
+                                                 {"reason", ss.str()}}}};
            ws->sendText(response.dump());
            return;
        }
--- a/ixsnake/ixsnake/IXSnakeServer.cpp
+++ b/ixsnake/ixsnake/IXSnakeServer.cpp
@ -10,8 +10,8 @@
 #include "IXSnakeConnectionState.h"
 #include "IXSnakeProtocol.h"
 #include <iostream>
-#include <ixcore/utils/IXCoreLogger.h>
 #include <sstream>
+#include <ixcore/utils/IXCoreLogger.h>


 namespace snake
@ -29,7 +29,7 @@ namespace snake

        std::stringstream ss;
        ss << "Listening on " << appConfig.hostname << ":" << appConfig.port;
-        ix::CoreLogger::log(ss.str().c_str());
+        ix::IXCoreLogger::Log(ss.str().c_str());
    }

    //
@ -67,7 +67,6 @@ namespace snake
                webSocket->setOnMessageCallback(
                    [this, webSocket, state](const ix::WebSocketMessagePtr& msg) {
                        std::stringstream ss;
-                        ix::LogLevel logLevel = ix::LogLevel::Debug;
                        if (msg->type == ix::WebSocketMessageType::Open)
                        {
                            ss << "New connection" << std::endl;
@ -87,7 +86,6 @@ namespace snake
                                                              _appConfig.redisPort))
                            {
                                ss << "Cannot connect to redis host" << std::endl;
-                                logLevel = ix::LogLevel::Error;
                            }
                        }
                        else if (msg->type == ix::WebSocketMessageType::Close)
@ -103,7 +101,6 @@ namespace snake
                            ss << "#retries: " << msg->errorInfo.retries << std::endl;
                            ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
                            ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
-                            logLevel = ix::LogLevel::Error;
                        }
                        else if (msg->type == ix::WebSocketMessageType::Fragment)
                        {
@ -115,7 +112,7 @@ namespace snake
                            processCobraMessage(state, webSocket, _appConfig, msg->str);
                        }

-                        ix::CoreLogger::log(ss.str().c_str(), logLevel);
+                        ix::IXCoreLogger::Log(ss.str().c_str());
                    });
            });

--- a/ixwebsocket/IXCancellationRequest.cpp
+++ b/ixwebsocket/IXCancellationRequest.cpp
@ -6,7 +6,6 @@

 #include "IXCancellationRequest.h"

-#include <cassert>
 #include <chrono>

 namespace ix
@ -14,8 +13,6 @@ namespace ix
    CancellationRequest makeCancellationRequestWithTimeout(
        int secs, std::atomic<bool>& requestInitCancellation)
    {
-        assert(secs > 0);
-
        auto start = std::chrono::system_clock::now();
        auto timeout = std::chrono::seconds(secs);

--- a/ixwebsocket/IXDNSLookup.cpp
+++ b/ixwebsocket/IXDNSLookup.cpp
@ -4,19 +4,6 @@
 *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
 */

-//
-// On Windows Universal Platform (uwp), gai_strerror defaults behavior is to returns wchar_t
-// which is different from all other platforms. We want the non unicode version.
-// See https://github.com/microsoft/vcpkg/pull/11030
-// We could do this in IXNetSystem.cpp but so far we are only using gai_strerror in here.
-//
-#ifdef _UNICODE
-#undef _UNICODE
-#endif
-#ifdef UNICODE
-#undef UNICODE
-#endif
-
 #include "IXDNSLookup.h"

 #include "IXNetSystem.h"
--- a/ixwebsocket/IXHttp.h
+++ b/ixwebsocket/IXHttp.h
@ -78,12 +78,12 @@ namespace ix
        WebSocketHttpHeaders extraHeaders;
        std::string body;
        std::string multipartBoundary;
-        int connectTimeout = 60;
-        int transferTimeout = 1800;
-        bool followRedirects = true;
-        int maxRedirects = 5;
-        bool verbose = false;
-        bool compress = true;
+        int connectTimeout;
+        int transferTimeout;
+        bool followRedirects;
+        int maxRedirects;
+        bool verbose;
+        bool compress;
        Logger logger;
        OnProgressCallback onProgressCallback;
    };
--- a/ixwebsocket/IXHttpClient.cpp
+++ b/ixwebsocket/IXHttpClient.cpp
@ -25,12 +25,10 @@ namespace ix
    const std::string HttpClient::kHead = "HEAD";
    const std::string HttpClient::kDel = "DEL";
    const std::string HttpClient::kPut = "PUT";
-    const std::string HttpClient::kPatch = "PATCH";

    HttpClient::HttpClient(bool async)
        : _async(async)
        , _stop(false)
-        , _forceBody(false)
    {
        if (!_async) return;

@ -51,11 +49,6 @@ namespace ix
        _tlsOptions = tlsOptions;
    }

-    void HttpClient::setForceBody(bool value)
-    {
-        _forceBody = value;
-    }
-
    HttpRequestArgsPtr HttpClient::createRequest(const std::string& url, const std::string& verb)
    {
        auto request = std::make_shared<HttpRequestArgs>();
@ -199,7 +192,7 @@ namespace ix
            ss << "User-Agent: " << userAgent() << "\r\n";
        }

-        if (verb == kPost || verb == kPut || verb == kPatch || _forceBody)
+        if (verb == kPost || verb == kPut)
        {
            ss << "Content-Length: " << body.size() << "\r\n";

@ -227,10 +220,11 @@ namespace ix

        std::string req(ss.str());
        std::string errMsg;
+        std::atomic<bool> requestInitCancellation(false);

        // Make a cancellation object dealing with connection timeout
        auto isCancellationRequested =
-            makeCancellationRequestWithTimeout(args->connectTimeout, _stop);
+            makeCancellationRequestWithTimeout(args->connectTimeout, requestInitCancellation);

        bool success = _socket->connect(host, port, errMsg, isCancellationRequested);
        if (!success)
@ -248,7 +242,8 @@ namespace ix
        }

        // Make a new cancellation object dealing with transfer timeout
-        isCancellationRequested = makeCancellationRequestWithTimeout(args->transferTimeout, _stop);
+        isCancellationRequested =
+            makeCancellationRequestWithTimeout(args->transferTimeout, requestInitCancellation);

        if (args->verbose)
        {
@ -567,20 +562,6 @@ namespace ix
        return request(url, kPut, body, args);
    }

-    HttpResponsePtr HttpClient::patch(const std::string& url,
-                                      const HttpParameters& httpParameters,
-                                      HttpRequestArgsPtr args)
-    {
-        return request(url, kPatch, serializeHttpParameters(httpParameters), args);
-    }
-
-    HttpResponsePtr HttpClient::patch(const std::string& url,
-                                      const std::string& body,
-                                      const HttpRequestArgsPtr args)
-    {
-        return request(url, kPatch, body, args);
-    }
-
    std::string HttpClient::urlEncode(const std::string& value)
    {
        std::ostringstream escaped;
--- a/ixwebsocket/IXHttpClient.h
+++ b/ixwebsocket/IXHttpClient.h
@ -46,19 +46,12 @@ namespace ix
                            const std::string& body,
                            HttpRequestArgsPtr args);

-        HttpResponsePtr patch(const std::string& url,
-                              const HttpParameters& httpParameters,
-                              HttpRequestArgsPtr args);
-        HttpResponsePtr patch(const std::string& url,
-                              const std::string& body,
-                              HttpRequestArgsPtr args);
-
        HttpResponsePtr request(const std::string& url,
                                const std::string& verb,
                                const std::string& body,
                                HttpRequestArgsPtr args,
                                int redirects = 0);
-        void setForceBody(bool value);
+
        // Async API
        HttpRequestArgsPtr createRequest(const std::string& url = std::string(),
                                         const std::string& verb = HttpClient::kGet);
@ -85,7 +78,6 @@ namespace ix
        const static std::string kHead;
        const static std::string kDel;
        const static std::string kPut;
-        const static std::string kPatch;

    private:
        void log(const std::string& msg, HttpRequestArgsPtr args);
@ -94,6 +86,7 @@ namespace ix

        // Async API background thread runner
        void run();
+
        // Async API
        bool _async;
        std::queue<std::pair<HttpRequestArgsPtr, OnResponseCallback>> _queue;
@ -106,7 +99,5 @@ namespace ix
        std::mutex _mutex; // to protect accessing the _socket (only one socket per client)

        SocketTLSOptions _tlsOptions;
-
-        bool _forceBody;
    };
 } // namespace ix
--- a/ixwebsocket/IXHttpServer.cpp
+++ b/ixwebsocket/IXHttpServer.cpp
@ -12,8 +12,6 @@
 #include <fstream>
 #include <sstream>
 #include <vector>
-#include <zlib.h>
-#include <cstring>

 namespace
 {
@ -40,47 +38,6 @@ namespace
        auto vec = res.second;
        return std::make_pair(res.first, std::string(vec.begin(), vec.end()));
    }
-
-    std::string gzipCompress(const std::string& str)
-    {
-        z_stream zs; // z_stream is zlib's control structure
-        memset(&zs, 0, sizeof(zs));
-
-        // deflateInit2 configure the file format: request gzip instead of deflate
-        const int windowBits = 15;
-        const int GZIP_ENCODING = 16;
-
-        deflateInit2(&zs, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
-                     windowBits | GZIP_ENCODING, 8,
-                     Z_DEFAULT_STRATEGY);
-
-        zs.next_in = (Bytef*) str.data();
-        zs.avail_in = (uInt) str.size(); // set the z_stream's input
-
-        int ret;
-        char outbuffer[32768];
-        std::string outstring;
-
-        // retrieve the compressed bytes blockwise
-        do
-        {
-            zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
-            zs.avail_out = sizeof(outbuffer);
-
-            ret = deflate(&zs, Z_FINISH);
-
-            if(outstring.size() < zs.total_out)
-            {
-                // append the block to the output string
-                outstring.append(outbuffer,
-                                 zs.total_out - outstring.size());
-            }
-        } while(ret == Z_OK);
-
-        deflateEnd(&zs);
-
-        return outstring;
-    }
 } // namespace

 namespace ix
@ -163,12 +120,6 @@ namespace ix

                std::string content = res.second;

-                std::string acceptEncoding = request->headers["Accept-encoding"];
-                if (acceptEncoding == "gzip" || acceptEncoding == "*")
-                {
-                    content = gzipCompress(content);
-                }
-
                // Log request
                std::stringstream ss;
                ss << request->method << " " << request->headers["User-Agent"] << " "
--- a/ixwebsocket/IXNetSystem.h
+++ b/ixwebsocket/IXNetSystem.h
@ -19,7 +19,6 @@ typedef unsigned long int nfds_t;
 #else
 #include <arpa/inet.h>
 #include <errno.h>
-#include <fcntl.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/ip.h>
--- a/ixwebsocket/IXSelectInterruptEventFd.cpp
+++ b/ixwebsocket/IXSelectInterruptEventFd.cpp
@ -0,0 +1,115 @@
+/*
+ *  IXSelectInterruptEventFd.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+//
+// On Linux we use eventd to wake up select.
+//
+
+//
+// Linux/Android has a special type of virtual files. select(2) will react
+// when reading/writing to those files, unlike closing sockets.
+//
+// https://linux.die.net/man/2/eventfd
+// http://www.sourcexr.com/articles/2013/10/26/lightweight-inter-process-signaling-with-eventfd
+//
+// eventfd was added in Linux kernel 2.x, and our oldest Android (Kitkat 4.4)
+// is on Kernel 3.x
+//
+// cf Android/Kernel table here
+// https://android.stackexchange.com/questions/51651/which-android-runs-which-linux-kernel
+//
+// On macOS we use UNIX pipes to wake up select.
+//
+
+#include "IXSelectInterruptEventFd.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sstream>
+#include <string.h> // for strerror
+#include <sys/eventfd.h>
+#include <unistd.h> // for write
+
+namespace ix
+{
+    SelectInterruptEventFd::SelectInterruptEventFd()
+    {
+        _eventfd = -1;
+    }
+
+    SelectInterruptEventFd::~SelectInterruptEventFd()
+    {
+        ::close(_eventfd);
+    }
+
+    bool SelectInterruptEventFd::init(std::string& errorMsg)
+    {
+        // calling init twice is a programming error
+        assert(_eventfd == -1);
+
+        _eventfd = eventfd(0, 0);
+        if (_eventfd < 0)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptEventFd::init() failed in eventfd()"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+
+            _eventfd = -1;
+            return false;
+        }
+
+        if (fcntl(_eventfd, F_SETFL, O_NONBLOCK) == -1)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptEventFd::init() failed in fcntl() call"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+
+            _eventfd = -1;
+            return false;
+        }
+
+        return true;
+    }
+
+    bool SelectInterruptEventFd::notify(uint64_t value)
+    {
+        int fd = _eventfd;
+
+        if (fd == -1) return false;
+
+        // we should write 8 bytes for an uint64_t
+        return write(fd, &value, sizeof(value)) == 8;
+    }
+
+    // TODO: return max uint64_t for errors ?
+    uint64_t SelectInterruptEventFd::read()
+    {
+        int fd = _eventfd;
+
+        uint64_t value = 0;
+        ::read(fd, &value, sizeof(value));
+        return value;
+    }
+
+    bool SelectInterruptEventFd::clear()
+    {
+        if (_eventfd == -1) return false;
+
+        // 0 is a special value ; select will not wake up
+        uint64_t value = 0;
+
+        // we should write 8 bytes for an uint64_t
+        return write(_eventfd, &value, sizeof(value)) == 8;
+    }
+
+    int SelectInterruptEventFd::getFd() const
+    {
+        return _eventfd;
+    }
+} // namespace ix
--- a/ixwebsocket/IXSelectInterruptEventFd.h
+++ b/ixwebsocket/IXSelectInterruptEventFd.h
@ -0,0 +1,31 @@
+/*
+ *  IXSelectInterruptEventFd.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include "IXSelectInterrupt.h"
+#include <stdint.h>
+#include <string>
+
+namespace ix
+{
+    class SelectInterruptEventFd final : public SelectInterrupt
+    {
+    public:
+        SelectInterruptEventFd();
+        virtual ~SelectInterruptEventFd();
+
+        bool init(std::string& errorMsg) final;
+
+        bool notify(uint64_t value) final;
+        bool clear() final;
+        uint64_t read() final;
+        int getFd() const final;
+
+    private:
+        int _eventfd;
+    };
+} // namespace ix
--- a/ixwebsocket/IXSelectInterruptFactory.cpp
+++ b/ixwebsocket/IXSelectInterruptFactory.cpp
@ -6,7 +6,6 @@

 #include "IXSelectInterruptFactory.h"

-#include "IXUniquePtr.h"
 #if defined(__linux__) || defined(__APPLE__)
 #include "IXSelectInterruptPipe.h"
 #else
@ -18,9 +17,9 @@ namespace ix
    SelectInterruptPtr createSelectInterrupt()
    {
 #if defined(__linux__) || defined(__APPLE__)
-        return ix::make_unique<SelectInterruptPipe>();
+        return std::make_unique<SelectInterruptPipe>();
 #else
-        return ix::make_unique<SelectInterrupt>();
+        return std::make_unique<SelectInterrupt>();
 #endif
    }
 } // namespace ix
--- a/ixwebsocket/IXSocketAppleSSL.cpp
+++ b/ixwebsocket/IXSocketAppleSSL.cpp
@ -1,12 +1,10 @@
 /*
 *  IXSocketAppleSSL.cpp
 *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2020 Machine Zone, Inc. All rights reserved.
+ *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
 *
 *  Adapted from Satori SDK Apple SSL code.
 */
-#ifdef IXWEBSOCKET_USE_SECURE_TRANSPORT
-
 #include "IXSocketAppleSSL.h"

 #include "IXSocketConnect.h"
@ -309,5 +307,3 @@ namespace ix
    }

 } // namespace ix
-
-#endif // IXWEBSOCKET_USE_SECURE_TRANSPORT
--- a/ixwebsocket/IXSocketAppleSSL.h
+++ b/ixwebsocket/IXSocketAppleSSL.h
@ -1,9 +1,8 @@
 /*
 *  IXSocketAppleSSL.h
 *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2020 Machine Zone, Inc. All rights reserved.
+ *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
 */
-#ifdef IXWEBSOCKET_USE_SECURE_TRANSPORT

 #pragma once

@ -48,5 +47,3 @@ namespace ix
    };

 } // namespace ix
-
-#endif // IXWEBSOCKET_USE_SECURE_TRANSPORT
--- a/ixwebsocket/IXSocketConnect.cpp
+++ b/ixwebsocket/IXSocketConnect.cpp
@ -10,7 +10,6 @@
 #include "IXNetSystem.h"
 #include "IXSelectInterrupt.h"
 #include "IXSocket.h"
-#include "IXUniquePtr.h"
 #include <fcntl.h>
 #include <string.h>
 #include <sys/types.h>
@ -66,7 +65,7 @@ namespace ix

            int timeoutMs = 10;
            bool readyToRead = false;
-            auto selectInterrupt = ix::make_unique<SelectInterrupt>();
+            auto selectInterrupt = std::make_unique<SelectInterrupt>();
            PollResultType pollResult = Socket::poll(readyToRead, timeoutMs, fd, selectInterrupt);

            if (pollResult == PollResultType::Timeout)
--- a/ixwebsocket/IXSocketFactory.cpp
+++ b/ixwebsocket/IXSocketFactory.cpp
@ -5,7 +5,6 @@
 */

 #include "IXSocketFactory.h"
-#include "IXUniquePtr.h"

 #ifdef IXWEBSOCKET_USE_TLS

@ -36,17 +35,17 @@ namespace ix

        if (!tls)
        {
-            socket = ix::make_unique<Socket>(fd);
+            socket = std::make_unique<Socket>(fd);
        }
        else
        {
 #ifdef IXWEBSOCKET_USE_TLS
 #if defined(IXWEBSOCKET_USE_MBED_TLS)
-            socket = ix::make_unique<SocketMbedTLS>(tlsOptions, fd);
+            socket = std::make_unique<SocketMbedTLS>(tlsOptions, fd);
 #elif defined(IXWEBSOCKET_USE_OPEN_SSL)
-            socket = ix::make_unique<SocketOpenSSL>(tlsOptions, fd);
+            socket = std::make_unique<SocketOpenSSL>(tlsOptions, fd);
 #elif defined(__APPLE__)
-            socket = ix::make_unique<SocketAppleSSL>(tlsOptions, fd);
+            socket = std::make_unique<SocketAppleSSL>(tlsOptions, fd);
 #endif
 #else
            errorMsg = "TLS support is not enabled on this platform.";
--- a/ixwebsocket/IXSocketMbedTLS.cpp
+++ b/ixwebsocket/IXSocketMbedTLS.cpp
@ -1,13 +1,12 @@
 /*
 *  IXSocketMbedTLS.cpp
- *  Author: Benjamin Sergeant, Max Weisel
- *  Copyright (c) 2019-2020 Machine Zone, Inc. All rights reserved.
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
 *
 *  Some code taken from
 *  https://github.com/rottor12/WsClientLib/blob/master/lib/src/WsClientLib.cpp
 *  and mini_client.c example from mbedtls
 */
-#ifdef IXWEBSOCKET_USE_MBED_TLS

 #include "IXSocketMbedTLS.h"

@ -43,55 +42,6 @@ namespace ix
        mbedtls_pk_init(&_pkey);
    }

-    bool SocketMbedTLS::loadSystemCertificates(std::string& errorMsg)
-    {
-#ifdef _WIN32
-        DWORD flags = CERT_STORE_READONLY_FLAG | CERT_STORE_OPEN_EXISTING_FLAG |
-                      CERT_SYSTEM_STORE_CURRENT_USER;
-        HCERTSTORE systemStore = CertOpenStore(CERT_STORE_PROV_SYSTEM, 0, 0, flags, L"Root");
-
-        if (!systemStore)
-        {
-            errorMsg = "CertOpenStore failed with ";
-            errorMsg += std::to_string(GetLastError());
-            return false;
-        }
-
-        PCCERT_CONTEXT certificateIterator = NULL;
-
-        int certificateCount = 0;
-        while (certificateIterator = CertEnumCertificatesInStore(systemStore, certificateIterator))
-        {
-            if (certificateIterator->dwCertEncodingType & X509_ASN_ENCODING)
-            {
-                int ret = mbedtls_x509_crt_parse(&_cacert,
-                                                 certificateIterator->pbCertEncoded,
-                                                 certificateIterator->cbCertEncoded);
-                if (ret == 0)
-                {
-                    ++certificateCount;
-                }
-            }
-        }
-
-        CertFreeCertificateContext(certificateIterator);
-        CertCloseStore(systemStore, 0);
-
-        if (certificateCount == 0)
-        {
-            errorMsg = "No certificates found";
-            return false;
-        }
-
-        return true;
-#else
-        // On macOS we can query the system cert location from the keychain
-        // On Linux we could try to fetch some local files based on the distribution
-        // On Android we could use JNI to get to the system certs
-        return false;
-#endif
-    }
-
    bool SocketMbedTLS::init(const std::string& host, bool isClient, std::string& errMsg)
    {
        initMBedTLS();
@ -145,36 +95,18 @@ namespace ix
        }
        else
        {
-            // FIXME: should we call mbedtls_ssl_conf_verify ?
            mbedtls_ssl_conf_authmode(&_conf, MBEDTLS_SSL_VERIFY_REQUIRED);

+            // FIXME: should we call mbedtls_ssl_conf_verify ?
+
            if (_tlsOptions.isUsingSystemDefaults())
            {
-                if (!loadSystemCertificates(errMsg))
-                {
-                    return false;
-                }
+                ; // FIXME
            }
-            else
+            else if (mbedtls_x509_crt_parse_file(&_cacert, _tlsOptions.caFile.c_str()) < 0)
            {
-                if (_tlsOptions.isUsingInMemoryCAs())
-                {
-                    const char* buffer = _tlsOptions.caFile.c_str();
-                    size_t bufferSize =
-                        _tlsOptions.caFile.size() + 1; // Needs to include null terminating
-                                                       // character otherwise mbedtls will fail.
-                    if (mbedtls_x509_crt_parse(
-                            &_cacert, (const unsigned char*) buffer, bufferSize) < 0)
-                    {
-                        errMsg = "Cannot parse CA from memory.";
-                        return false;
-                    }
-                }
-                else if (mbedtls_x509_crt_parse_file(&_cacert, _tlsOptions.caFile.c_str()) < 0)
-                {
-                    errMsg = "Cannot parse CA file '" + _tlsOptions.caFile + "'";
-                    return false;
-                }
+                errMsg = "Cannot parse CA file '" + _tlsOptions.caFile + "'";
+                return false;
            }

            mbedtls_ssl_conf_ca_chain(&_conf, &_cacert, NULL);
@ -348,5 +280,3 @@ namespace ix
    }

 } // namespace ix
-
-#endif // IXWEBSOCKET_USE_MBED_TLS
--- a/ixwebsocket/IXSocketMbedTLS.h
+++ b/ixwebsocket/IXSocketMbedTLS.h
@ -1,9 +1,8 @@
 /*
 *  IXSocketMbedTLS.h
 *  Author: Benjamin Sergeant
- *  Copyright (c) 2019-2020 Machine Zone, Inc. All rights reserved.
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
 */
-#ifdef IXWEBSOCKET_USE_MBED_TLS

 #pragma once

@ -52,9 +51,6 @@ namespace ix

        bool init(const std::string& host, bool isClient, std::string& errMsg);
        void initMBedTLS();
-        bool loadSystemCertificates(std::string& errMsg);
    };

 } // namespace ix
-
-#endif // IXWEBSOCKET_USE_MBED_TLS
--- a/ixwebsocket/IXSocketOpenSSL.cpp
+++ b/ixwebsocket/IXSocketOpenSSL.cpp
@ -1,11 +1,10 @@
 /*
 *  IXSocketOpenSSL.cpp
- *  Author: Benjamin Sergeant, Matt DeBoer, Max Weisel
- *  Copyright (c) 2017-2020 Machine Zone, Inc. All rights reserved.
+ *  Author: Benjamin Sergeant, Matt DeBoer
+ *  Copyright (c) 2017-2019 Machine Zone, Inc. All rights reserved.
 *
 *  Adapted from Satori SDK OpenSSL code.
 */
-#ifdef IXWEBSOCKET_USE_OPEN_SSL

 #include "IXSocketOpenSSL.h"

@ -85,8 +84,6 @@ namespace ix

    std::atomic<bool> SocketOpenSSL::_openSSLInitializationSuccessful(false);
    std::once_flag SocketOpenSSL::_openSSLInitFlag;
-    std::unique_ptr<std::mutex[]> SocketOpenSSL::_openSSLMutexes =
-        std::make_unique<std::mutex[]>(CRYPTO_num_locks());

    SocketOpenSSL::SocketOpenSSL(const SocketTLSOptions& tlsOptions, int fd)
        : Socket(fd)
@ -108,11 +105,6 @@ namespace ix
        if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, nullptr)) return;
 #else
        (void) OPENSSL_config(nullptr);
-
-        if (CRYPTO_get_locking_callback() == nullptr)
-        {
-            CRYPTO_set_locking_callback(SocketOpenSSL::openSSLLockingCallback);
-        }
 #endif

        (void) OpenSSL_add_ssl_algorithms();
@ -121,21 +113,6 @@ namespace ix
        _openSSLInitializationSuccessful = true;
    }

-    void SocketOpenSSL::openSSLLockingCallback(int mode,
-                                               int type,
-                                               const char* /*file*/,
-                                               int /*line*/)
-    {
-        if (mode & CRYPTO_LOCK)
-        {
-            _openSSLMutexes[type].lock();
-        }
-        else
-        {
-            _openSSLMutexes[type].unlock();
-        }
-    }
-
    std::string SocketOpenSSL::getSSLError(int ret)
    {
        unsigned long e;
@ -217,66 +194,6 @@ namespace ix
        return ctx;
    }

-    bool SocketOpenSSL::openSSLAddCARootsFromString(const std::string roots)
-    {
-        // Create certificate store
-        X509_STORE* certificate_store = SSL_CTX_get_cert_store(_ssl_context);
-        if (certificate_store == nullptr) return false;
-
-        // Configure to allow intermediate certs
-        X509_STORE_set_flags(certificate_store,
-                             X509_V_FLAG_TRUSTED_FIRST | X509_V_FLAG_PARTIAL_CHAIN);
-
-        // Create a new buffer and populate it with the roots
-        BIO* buffer = BIO_new_mem_buf((void*) roots.c_str(), static_cast<int>(roots.length()));
-        if (buffer == nullptr) return false;
-
-        // Read each root in the buffer and add to the certificate store
-        bool success = true;
-        size_t number_of_roots = 0;
-
-        while (true)
-        {
-            // Read the next root in the buffer
-            X509* root = PEM_read_bio_X509_AUX(buffer, nullptr, nullptr, (void*) "");
-            if (root == nullptr)
-            {
-                // No more certs left in the buffer, we're done.
-                ERR_clear_error();
-                break;
-            }
-
-            // Try adding the root to the certificate store
-            ERR_clear_error();
-            if (!X509_STORE_add_cert(certificate_store, root))
-            {
-                // Failed to add. If the error is unrelated to the x509 lib or the cert already
-                // exists, we're safe to continue.
-                unsigned long error = ERR_get_error();
-                if (ERR_GET_LIB(error) != ERR_LIB_X509 ||
-                    ERR_GET_REASON(error) != X509_R_CERT_ALREADY_IN_HASH_TABLE)
-                {
-                    // Failed. Clean up and bail.
-                    success = false;
-                    X509_free(root);
-                    break;
-                }
-            }
-
-            // Clean up and loop
-            X509_free(root);
-            number_of_roots++;
-        }
-
-        // Clean up buffer
-        BIO_free(buffer);
-
-        // Make sure we loaded at least one certificate.
-        if (number_of_roots == 0) success = false;
-
-        return success;
-    }
-
    /**
     * Check whether a hostname matches a pattern
     */
@ -485,32 +402,20 @@ namespace ix
                }
 #endif
            }
-            else
+            else if (SSL_CTX_load_verify_locations(
+                         _ssl_context, _tlsOptions.caFile.c_str(), NULL) != 1)
            {
-                if (_tlsOptions.isUsingInMemoryCAs())
-                {
-                    // Load from memory
-                    openSSLAddCARootsFromString(_tlsOptions.caFile);
-                }
-                else
-                {
-                    if (SSL_CTX_load_verify_locations(
-                            _ssl_context, _tlsOptions.caFile.c_str(), NULL) != 1)
-                    {
-                        auto sslErr = ERR_get_error();
-                        errMsg = "OpenSSL failed - SSL_CTX_load_verify_locations(\"" +
-                                 _tlsOptions.caFile + "\") failed: ";
-                        errMsg += ERR_error_string(sslErr, nullptr);
-                        return false;
-                    }
-
-                    SSL_CTX_set_verify(
-                        _ssl_context, SSL_VERIFY_PEER, [](int preverify, X509_STORE_CTX*) -> int {
-                            return preverify;
-                        });
-                    SSL_CTX_set_verify_depth(_ssl_context, 4);
-                }
+                auto sslErr = ERR_get_error();
+                errMsg = "OpenSSL failed - SSL_CTX_load_verify_locations(\"" + _tlsOptions.caFile +
+                         "\") failed: ";
+                errMsg += ERR_error_string(sslErr, nullptr);
+                return false;
            }
+
+            SSL_CTX_set_verify(_ssl_context,
+                               SSL_VERIFY_PEER,
+                               [](int preverify, X509_STORE_CTX*) -> int { return preverify; });
+            SSL_CTX_set_verify_depth(_ssl_context, 4);
        }
        else
        {
@ -620,35 +525,26 @@ namespace ix
                }
                else
                {
-                    if (_tlsOptions.isUsingInMemoryCAs())
+                    const char* root_ca_file = _tlsOptions.caFile.c_str();
+                    STACK_OF(X509_NAME) * rootCAs;
+                    rootCAs = SSL_load_client_CA_file(root_ca_file);
+                    if (rootCAs == NULL)
                    {
-                        // Load from memory
-                        openSSLAddCARootsFromString(_tlsOptions.caFile);
+                        auto sslErr = ERR_get_error();
+                        errMsg = "OpenSSL failed - SSL_load_client_CA_file('" + _tlsOptions.caFile +
+                                 "') failed: ";
+                        errMsg += ERR_error_string(sslErr, nullptr);
                    }
                    else
                    {
-                        const char* root_ca_file = _tlsOptions.caFile.c_str();
-                        STACK_OF(X509_NAME) * rootCAs;
-                        rootCAs = SSL_load_client_CA_file(root_ca_file);
-                        if (rootCAs == NULL)
+                        SSL_CTX_set_client_CA_list(_ssl_context, rootCAs);
+                        if (SSL_CTX_load_verify_locations(_ssl_context, root_ca_file, nullptr) != 1)
                        {
                            auto sslErr = ERR_get_error();
-                            errMsg = "OpenSSL failed - SSL_load_client_CA_file('" +
-                                     _tlsOptions.caFile + "') failed: ";
+                            errMsg = "OpenSSL failed - SSL_CTX_load_verify_locations(\"" +
+                                     _tlsOptions.caFile + "\") failed: ";
                            errMsg += ERR_error_string(sslErr, nullptr);
                        }
-                        else
-                        {
-                            SSL_CTX_set_client_CA_list(_ssl_context, rootCAs);
-                            if (SSL_CTX_load_verify_locations(
-                                    _ssl_context, root_ca_file, nullptr) != 1)
-                            {
-                                auto sslErr = ERR_get_error();
-                                errMsg = "OpenSSL failed - SSL_CTX_load_verify_locations(\"" +
-                                         _tlsOptions.caFile + "\") failed: ";
-                                errMsg += ERR_error_string(sslErr, nullptr);
-                            }
-                        }
                    }
                }

@ -835,5 +731,3 @@ namespace ix
    }

 } // namespace ix
-
-#endif // IXWEBSOCKET_USE_OPEN_SSL
--- a/ixwebsocket/IXSocketOpenSSL.h
+++ b/ixwebsocket/IXSocketOpenSSL.h
@ -1,9 +1,8 @@
 /*
 *  IXSocketOpenSSL.h
 *  Author: Benjamin Sergeant, Matt DeBoer
- *  Copyright (c) 2017-2020 Machine Zone, Inc. All rights reserved.
+ *  Copyright (c) 2017-2019 Machine Zone, Inc. All rights reserved.
 */
-#ifdef IXWEBSOCKET_USE_OPEN_SSL

 #pragma once

@ -40,7 +39,6 @@ namespace ix
        void openSSLInitialize();
        std::string getSSLError(int ret);
        SSL_CTX* openSSLCreateContext(std::string& errMsg);
-        bool openSSLAddCARootsFromString(const std::string roots);
        bool openSSLClientHandshake(const std::string& hostname,
                                    std::string& errMsg,
                                    const CancellationRequest& isCancellationRequested);
@ -49,9 +47,6 @@ namespace ix
        bool handleTLSOptions(std::string& errMsg);
        bool openSSLServerHandshake(std::string& errMsg);

-        // Required for OpenSSL < 1.1
-        static void openSSLLockingCallback(int mode, int type, const char* /*file*/, int /*line*/);
-
        SSL* _ssl_connection;
        SSL_CTX* _ssl_context;
        const SSL_METHOD* _ssl_method;
@ -61,9 +56,6 @@ namespace ix

        static std::once_flag _openSSLInitFlag;
        static std::atomic<bool> _openSSLInitializationSuccessful;
-        static std::unique_ptr<std::mutex[]> _openSSLMutexes;
    };

 } // namespace ix
-
-#endif // IXWEBSOCKET_USE_OPEN_SSL
--- a/ixwebsocket/IXSocketServer.cpp
+++ b/ixwebsocket/IXSocketServer.cpp
@ -12,7 +12,6 @@
 #include "IXSocket.h"
 #include "IXSocketConnect.h"
 #include "IXSocketFactory.h"
-#include "IXUniquePtr.h"
 #include <assert.h>
 #include <sstream>
 #include <stdio.h>
@ -259,7 +258,7 @@ namespace ix
            // Use poll to check whether a new connection is in progress
            int timeoutMs = 10;
            bool readyToRead = true;
-            auto selectInterrupt = ix::make_unique<SelectInterrupt>();
+            auto selectInterrupt = std::make_unique<SelectInterrupt>();
            PollResultType pollResult =
                Socket::poll(readyToRead, timeoutMs, _serverFd, selectInterrupt);

--- a/ixwebsocket/IXSocketTLSOptions.cpp
+++ b/ixwebsocket/IXSocketTLSOptions.cpp
@ -15,7 +15,6 @@ namespace ix
    const char* kTLSCAFileUseSystemDefaults = "SYSTEM";
    const char* kTLSCAFileDisableVerify = "NONE";
    const char* kTLSCiphersUseDefault = "DEFAULT";
-    const char* kTLSInMemoryMarker = "-----BEGIN CERTIFICATE-----";

    bool SocketTLSOptions::isValid() const
    {
@ -59,11 +58,6 @@ namespace ix
        return caFile == kTLSCAFileUseSystemDefaults;
    }

-    bool SocketTLSOptions::isUsingInMemoryCAs() const
-    {
-        return caFile.find(kTLSInMemoryMarker) != std::string::npos;
-    }
-
    bool SocketTLSOptions::isPeerVerifyDisabled() const
    {
        return caFile == kTLSCAFileDisableVerify;
--- a/ixwebsocket/IXSocketTLSOptions.h
+++ b/ixwebsocket/IXSocketTLSOptions.h
@ -37,8 +37,6 @@ namespace ix

        bool isUsingSystemDefaults() const;

-        bool isUsingInMemoryCAs() const;
-
        bool isPeerVerifyDisabled() const;

        bool isUsingDefaultCiphers() const;
--- a/ixwebsocket/IXUdpSocket.cpp
+++ b/ixwebsocket/IXUdpSocket.cpp
@ -44,18 +44,6 @@ namespace ix
        return err;
    }

-    bool UdpSocket::isWaitNeeded()
-    {
-        int err = getErrno();
-
-        if (err == EWOULDBLOCK || err == EAGAIN || err == EINPROGRESS)
-        {
-            return true;
-        }
-
-        return false;
-    }
-
    void UdpSocket::closeSocket(int fd)
    {
 #ifdef _WIN32
@ -74,13 +62,6 @@ namespace ix
            return false;
        }

-#ifdef _WIN32
-        unsigned long nonblocking = 1;
-        ioctlsocket(_sockfd, FIONBIO, &nonblocking);
-#else
-        fcntl(_sockfd, F_SETFL, O_NONBLOCK); // make socket non blocking
-#endif
-
        memset(&_server, 0, sizeof(_server));
        _server.sin_family = AF_INET;
        _server.sin_port = htons(port);
@ -112,15 +93,4 @@ namespace ix
        return (ssize_t)::sendto(
            _sockfd, buffer.data(), buffer.size(), 0, (struct sockaddr*) &_server, sizeof(_server));
    }
-
-    ssize_t UdpSocket::recvfrom(char* buffer, size_t length)
-    {
-#ifdef _WIN32
-        int addressLen = (int) sizeof(_server);
-#else
-        socklen_t addressLen = (socklen_t) sizeof(_server);
-#endif
-        return (ssize_t)::recvfrom(
-            _sockfd, buffer, length, 0, (struct sockaddr*) &_server, &addressLen);
-    }
 } // namespace ix
--- a/ixwebsocket/IXUdpSocket.h
+++ b/ixwebsocket/IXUdpSocket.h
@ -28,12 +28,9 @@ namespace ix
        // Virtual methods
        bool init(const std::string& host, int port, std::string& errMsg);
        ssize_t sendto(const std::string& buffer);
-        ssize_t recvfrom(char* buffer, size_t length);
-
        void close();

        static int getErrno();
-        static bool isWaitNeeded();
        static void closeSocket(int fd);

    private:
--- a/ixwebsocket/IXUniquePtr.h
+++ b/ixwebsocket/IXUniquePtr.h
@ -1,18 +0,0 @@
-/*
- *  IXUniquePtr.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- */
-
-#pragma once
-
-#include <memory>
-
-namespace ix
-{
-    template<typename T, typename... Args>
-    std::unique_ptr<T> make_unique(Args&&... args)
-    {
-        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
-    }
-}
--- a/ixwebsocket/IXUrlParser.cpp
+++ b/ixwebsocket/IXUrlParser.cpp
@ -1,29 +1,4 @@
 /*
- * Lightweight URL & URI parser (RFC 1738, RFC 3986)
- * https://github.com/corporateshark/LUrlParser
- *
- * The MIT License (MIT)
- *
- * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
 *  IXUrlParser.cpp
 *  Author: Benjamin Sergeant
 *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
@ -31,309 +6,7 @@

 #include "IXUrlParser.h"

-#include <algorithm>
-#include <cstring>
-#include <cstdlib>
-
-namespace
-{
-    enum LUrlParserError
-    {
-        LUrlParserError_Ok = 0,
-        LUrlParserError_Uninitialized = 1,
-        LUrlParserError_NoUrlCharacter = 2,
-        LUrlParserError_InvalidSchemeName = 3,
-        LUrlParserError_NoDoubleSlash = 4,
-        LUrlParserError_NoAtSign = 5,
-        LUrlParserError_UnexpectedEndOfLine = 6,
-        LUrlParserError_NoSlash = 7,
-    };
-
-    class clParseURL
-    {
-    public:
-        LUrlParserError m_ErrorCode;
-        std::string m_Scheme;
-        std::string m_Host;
-        std::string m_Port;
-        std::string m_Path;
-        std::string m_Query;
-        std::string m_Fragment;
-        std::string m_UserName;
-        std::string m_Password;
-
-        clParseURL()
-            : m_ErrorCode(LUrlParserError_Uninitialized)
-        {
-        }
-
-        /// return 'true' if the parsing was successful
-        bool IsValid() const
-        {
-            return m_ErrorCode == LUrlParserError_Ok;
-        }
-
-        /// helper to convert the port number to int, return 'true' if the port is valid (within the
-        /// 0..65535 range)
-        bool GetPort(int* OutPort) const;
-
-        /// parse the URL
-        static clParseURL ParseURL(const std::string& URL);
-
-    private:
-        explicit clParseURL(LUrlParserError ErrorCode)
-            : m_ErrorCode(ErrorCode)
-        {
-        }
-    };
-
-    static bool IsSchemeValid(const std::string& SchemeName)
-    {
-        for (auto c : SchemeName)
-        {
-            if (!isalpha(c) && c != '+' && c != '-' && c != '.') return false;
-        }
-
-        return true;
-    }
-
-    bool clParseURL::GetPort(int* OutPort) const
-    {
-        if (!IsValid())
-        {
-            return false;
-        }
-
-        int Port = atoi(m_Port.c_str());
-
-        if (Port <= 0 || Port > 65535)
-        {
-            return false;
-        }
-
-        if (OutPort)
-        {
-            *OutPort = Port;
-        }
-
-        return true;
-    }
-
-    // based on RFC 1738 and RFC 3986
-    clParseURL clParseURL::ParseURL(const std::string& URL)
-    {
-        clParseURL Result;
-
-        const char* CurrentString = URL.c_str();
-
-        /*
-         *	<scheme>:<scheme-specific-part>
-         *	<scheme> := [a-z\+\-\.]+
-         *	For resiliency, programs interpreting URLs should treat upper case letters as
-         *equivalent to lower case in scheme names
-         */
-
-        // try to read scheme
-        {
-            const char* LocalString = strchr(CurrentString, ':');
-
-            if (!LocalString)
-            {
-                return clParseURL(LUrlParserError_NoUrlCharacter);
-            }
-
-            // save the scheme name
-            Result.m_Scheme = std::string(CurrentString, LocalString - CurrentString);
-
-            if (!IsSchemeValid(Result.m_Scheme))
-            {
-                return clParseURL(LUrlParserError_InvalidSchemeName);
-            }
-
-            // scheme should be lowercase
-            std::transform(
-                Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower);
-
-            // skip ':'
-            CurrentString = LocalString + 1;
-        }
-
-        /*
-         *	//<user>:<password>@<host>:<port>/<url-path>
-         *	any ":", "@" and "/" must be normalized
-         */
-
-        // skip "//"
-        if (*CurrentString++ != '/') return clParseURL(LUrlParserError_NoDoubleSlash);
-        if (*CurrentString++ != '/') return clParseURL(LUrlParserError_NoDoubleSlash);
-
-        // check if the user name and password are specified
-        bool bHasUserName = false;
-
-        const char* LocalString = CurrentString;
-
-        while (*LocalString)
-        {
-            if (*LocalString == '@')
-            {
-                // user name and password are specified
-                bHasUserName = true;
-                break;
-            }
-            else if (*LocalString == '/')
-            {
-                // end of <host>:<port> specification
-                bHasUserName = false;
-                break;
-            }
-
-            LocalString++;
-        }
-
-        // user name and password
-        LocalString = CurrentString;
-
-        if (bHasUserName)
-        {
-            // read user name
-            while (*LocalString && *LocalString != ':' && *LocalString != '@')
-                LocalString++;
-
-            Result.m_UserName = std::string(CurrentString, LocalString - CurrentString);
-
-            // proceed with the current pointer
-            CurrentString = LocalString;
-
-            if (*CurrentString == ':')
-            {
-                // skip ':'
-                CurrentString++;
-
-                // read password
-                LocalString = CurrentString;
-
-                while (*LocalString && *LocalString != '@')
-                    LocalString++;
-
-                Result.m_Password = std::string(CurrentString, LocalString - CurrentString);
-
-                CurrentString = LocalString;
-            }
-
-            // skip '@'
-            if (*CurrentString != '@')
-            {
-                return clParseURL(LUrlParserError_NoAtSign);
-            }
-
-            CurrentString++;
-        }
-
-        bool bHasBracket = (*CurrentString == '[');
-
-        // go ahead, read the host name
-        LocalString = CurrentString;
-
-        while (*LocalString)
-        {
-            if (bHasBracket && *LocalString == ']')
-            {
-                // end of IPv6 address
-                LocalString++;
-                break;
-            }
-            else if (!bHasBracket && (*LocalString == ':' || *LocalString == '/'))
-            {
-                // port number is specified
-                break;
-            }
-
-            LocalString++;
-        }
-
-        Result.m_Host = std::string(CurrentString, LocalString - CurrentString);
-
-        CurrentString = LocalString;
-
-        // is port number specified?
-        if (*CurrentString == ':')
-        {
-            CurrentString++;
-
-            // read port number
-            LocalString = CurrentString;
-
-            while (*LocalString && *LocalString != '/')
-                LocalString++;
-
-            Result.m_Port = std::string(CurrentString, LocalString - CurrentString);
-
-            CurrentString = LocalString;
-        }
-
-        // end of string
-        if (!*CurrentString)
-        {
-            Result.m_ErrorCode = LUrlParserError_Ok;
-
-            return Result;
-        }
-
-        // skip '/'
-        if (*CurrentString != '/')
-        {
-            return clParseURL(LUrlParserError_NoSlash);
-        }
-
-        CurrentString++;
-
-        // parse the path
-        LocalString = CurrentString;
-
-        while (*LocalString && *LocalString != '#' && *LocalString != '?')
-            LocalString++;
-
-        Result.m_Path = std::string(CurrentString, LocalString - CurrentString);
-
-        CurrentString = LocalString;
-
-        // check for query
-        if (*CurrentString == '?')
-        {
-            // skip '?'
-            CurrentString++;
-
-            // read query
-            LocalString = CurrentString;
-
-            while (*LocalString && *LocalString != '#')
-                LocalString++;
-
-            Result.m_Query = std::string(CurrentString, LocalString - CurrentString);
-
-            CurrentString = LocalString;
-        }
-
-        // check for fragment
-        if (*CurrentString == '#')
-        {
-            // skip '#'
-            CurrentString++;
-
-            // read fragment
-            LocalString = CurrentString;
-
-            while (*LocalString)
-                LocalString++;
-
-            Result.m_Fragment = std::string(CurrentString, LocalString - CurrentString);
-        }
-
-        Result.m_ErrorCode = LUrlParserError_Ok;
-
-        return Result;
-    }
-} // namespace
+#include "LUrlParser.h"

 namespace ix
 {
@ -344,7 +17,7 @@ namespace ix
                          std::string& query,
                          int& port)
    {
-        clParseURL res = clParseURL::ParseURL(url);
+        LUrlParser::clParseURL res = LUrlParser::clParseURL::ParseURL(url);

        if (!res.IsValid())
        {
--- a/ixwebsocket/IXWebSocketHandshake.cpp
+++ b/ixwebsocket/IXWebSocketHandshake.cpp
@ -10,7 +10,7 @@
 #include "IXSocketConnect.h"
 #include "IXUrlParser.h"
 #include "IXUserAgent.h"
-#include "IXWebSocketHandshakeKeyGen.h"
+#include "libwshandshake.hpp"
 #include <algorithm>
 #include <iostream>
 #include <random>
@ -133,7 +133,7 @@ namespace ix

        for (auto& it : extraHeaders)
        {
-            ss << it.first << ": " << it.second << "\r\n";
+            ss << it.first << ":" << it.second << "\r\n";
        }

        if (_enablePerMessageDeflate)
--- a/ixwebsocket/IXWebSocketHandshakeKeyGen.h
+++ b/ixwebsocket/IXWebSocketHandshakeKeyGen.h
@ -1,171 +0,0 @@
-// Copyright (c) 2016 Alex Hultman and contributors
-
-// This software is provided 'as-is', without any express or implied
-// warranty. In no event will the authors be held liable for any damages
-// arising from the use of this software.
-
-// Permission is granted to anyone to use this software for any purpose,
-// including commercial applications, and to alter it and redistribute it
-// freely, subject to the following restrictions:
-
-// 1. The origin of this software must not be misrepresented; you must not
-//    claim that you wrote the original software. If you use this software
-//    in a product, an acknowledgement in the product documentation would be
-//    appreciated but is not required.
-// 2. Altered source versions must be plainly marked as such, and must not be
-//    misrepresented as being the original software.
-// 3. This notice may not be removed or altered from any source distribution.
-
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-#include <string.h>
-#include <string>
-
-class WebSocketHandshakeKeyGen
-{
-    template<int N, typename T>
-    struct static_for
-    {
-        void operator()(uint32_t* a, uint32_t* b)
-        {
-            static_for<N - 1, T>()(a, b);
-            T::template f<N - 1>(a, b);
-        }
-    };
-
-    template<typename T>
-    struct static_for<0, T>
-    {
-        void operator()(uint32_t* /*a*/, uint32_t* /*hash*/)
-        {
-        }
-    };
-
-    template<int state>
-    struct Sha1Loop
-    {
-        static inline uint32_t rol(uint32_t value, size_t bits)
-        {
-            return (value << bits) | (value >> (32 - bits));
-        }
-        static inline uint32_t blk(uint32_t b[16], size_t i)
-        {
-            return rol(b[(i + 13) & 15] ^ b[(i + 8) & 15] ^ b[(i + 2) & 15] ^ b[i], 1);
-        }
-
-        template<int i>
-        static inline void f(uint32_t* a, uint32_t* b)
-        {
-            switch (state)
-            {
-                case 1:
-                    a[i % 5] +=
-                        ((a[(3 + i) % 5] & (a[(2 + i) % 5] ^ a[(1 + i) % 5])) ^ a[(1 + i) % 5]) +
-                        b[i] + 0x5a827999 + rol(a[(4 + i) % 5], 5);
-                    a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30);
-                    break;
-                case 2:
-                    b[i] = blk(b, i);
-                    a[(1 + i) % 5] +=
-                        ((a[(4 + i) % 5] & (a[(3 + i) % 5] ^ a[(2 + i) % 5])) ^ a[(2 + i) % 5]) +
-                        b[i] + 0x5a827999 + rol(a[(5 + i) % 5], 5);
-                    a[(4 + i) % 5] = rol(a[(4 + i) % 5], 30);
-                    break;
-                case 3:
-                    b[(i + 4) % 16] = blk(b, (i + 4) % 16);
-                    a[i % 5] += (a[(3 + i) % 5] ^ a[(2 + i) % 5] ^ a[(1 + i) % 5]) +
-                                b[(i + 4) % 16] + 0x6ed9eba1 + rol(a[(4 + i) % 5], 5);
-                    a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30);
-                    break;
-                case 4:
-                    b[(i + 8) % 16] = blk(b, (i + 8) % 16);
-                    a[i % 5] += (((a[(3 + i) % 5] | a[(2 + i) % 5]) & a[(1 + i) % 5]) |
-                                 (a[(3 + i) % 5] & a[(2 + i) % 5])) +
-                                b[(i + 8) % 16] + 0x8f1bbcdc + rol(a[(4 + i) % 5], 5);
-                    a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30);
-                    break;
-                case 5:
-                    b[(i + 12) % 16] = blk(b, (i + 12) % 16);
-                    a[i % 5] += (a[(3 + i) % 5] ^ a[(2 + i) % 5] ^ a[(1 + i) % 5]) +
-                                b[(i + 12) % 16] + 0xca62c1d6 + rol(a[(4 + i) % 5], 5);
-                    a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30);
-                    break;
-                case 6: b[i] += a[4 - i];
-            }
-        }
-    };
-
-    static inline void sha1(uint32_t hash[5], uint32_t b[16])
-    {
-        uint32_t a[5] = {hash[4], hash[3], hash[2], hash[1], hash[0]};
-        static_for<16, Sha1Loop<1>>()(a, b);
-        static_for<4, Sha1Loop<2>>()(a, b);
-        static_for<20, Sha1Loop<3>>()(a, b);
-        static_for<20, Sha1Loop<4>>()(a, b);
-        static_for<20, Sha1Loop<5>>()(a, b);
-        static_for<5, Sha1Loop<6>>()(a, hash);
-    }
-
-    static inline void base64(unsigned char* src, char* dst)
-    {
-        const char* b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-        for (int i = 0; i < 18; i += 3)
-        {
-            *dst++ = b64[(src[i] >> 2) & 63];
-            *dst++ = b64[((src[i] & 3) << 4) | ((src[i + 1] & 240) >> 4)];
-            *dst++ = b64[((src[i + 1] & 15) << 2) | ((src[i + 2] & 192) >> 6)];
-            *dst++ = b64[src[i + 2] & 63];
-        }
-        *dst++ = b64[(src[18] >> 2) & 63];
-        *dst++ = b64[((src[18] & 3) << 4) | ((src[19] & 240) >> 4)];
-        *dst++ = b64[((src[19] & 15) << 2)];
-        *dst++ = '=';
-    }
-
-public:
-    static inline void generate(const std::string& inputStr, char output[28])
-    {
-        char input[25] = {};
-        strncpy(input, inputStr.c_str(), 25 - 1);
-        input[25 - 1] = '\0';
-
-        uint32_t b_output[5] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0};
-        uint32_t b_input[16] = {0,
-                                0,
-                                0,
-                                0,
-                                0,
-                                0,
-                                0x32353845,
-                                0x41464135,
-                                0x2d453931,
-                                0x342d3437,
-                                0x44412d39,
-                                0x3543412d,
-                                0x43354142,
-                                0x30444338,
-                                0x35423131,
-                                0x80000000};
-
-        for (int i = 0; i < 6; i++)
-        {
-            b_input[i] = (input[4 * i + 3] & 0xff) | (input[4 * i + 2] & 0xff) << 8 |
-                         (input[4 * i + 1] & 0xff) << 16 | (input[4 * i + 0] & 0xff) << 24;
-        }
-        sha1(b_output, b_input);
-        uint32_t last_b[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 480};
-        sha1(b_output, last_b);
-        for (int i = 0; i < 5; i++)
-        {
-            uint32_t tmp = b_output[i];
-            char* bytes = (char*) &b_output[i];
-            bytes[3] = tmp & 0xff;
-            bytes[2] = (tmp >> 8) & 0xff;
-            bytes[1] = (tmp >> 16) & 0xff;
-            bytes[0] = (tmp >> 24) & 0xff;
-        }
-        base64((unsigned char*) b_output, output);
-    }
-};
--- a/ixwebsocket/IXWebSocketVersion.h
+++ b/ixwebsocket/IXWebSocketVersion.h
@ -6,4 +6,4 @@

 #pragma once

-#define IX_WEBSOCKET_VERSION "9.6.5"
+#define IX_WEBSOCKET_VERSION "9.3.3"
--- a/ixwebsocket/LUrlParser.cpp
+++ b/ixwebsocket/LUrlParser.cpp
@ -0,0 +1,280 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "LUrlParser.h"
+
+#include <algorithm>
+#include <cstring>
+#include <stdlib.h>
+
+// check if the scheme name is valid
+static bool IsSchemeValid(const std::string& SchemeName)
+{
+    for (auto c : SchemeName)
+    {
+        if (!isalpha(c) && c != '+' && c != '-' && c != '.') return false;
+    }
+
+    return true;
+}
+
+bool LUrlParser::clParseURL::GetPort(int* OutPort) const
+{
+    if (!IsValid())
+    {
+        return false;
+    }
+
+    int Port = atoi(m_Port.c_str());
+
+    if (Port <= 0 || Port > 65535)
+    {
+        return false;
+    }
+
+    if (OutPort)
+    {
+        *OutPort = Port;
+    }
+
+    return true;
+}
+
+// based on RFC 1738 and RFC 3986
+LUrlParser::clParseURL LUrlParser::clParseURL::ParseURL(const std::string& URL)
+{
+    LUrlParser::clParseURL Result;
+
+    const char* CurrentString = URL.c_str();
+
+    /*
+     *	<scheme>:<scheme-specific-part>
+     *	<scheme> := [a-z\+\-\.]+
+     *	For resiliency, programs interpreting URLs should treat upper case letters as equivalent to
+     *lower case in scheme names
+     */
+
+    // try to read scheme
+    {
+        const char* LocalString = strchr(CurrentString, ':');
+
+        if (!LocalString)
+        {
+            return clParseURL(LUrlParserError_NoUrlCharacter);
+        }
+
+        // save the scheme name
+        Result.m_Scheme = std::string(CurrentString, LocalString - CurrentString);
+
+        if (!IsSchemeValid(Result.m_Scheme))
+        {
+            return clParseURL(LUrlParserError_InvalidSchemeName);
+        }
+
+        // scheme should be lowercase
+        std::transform(
+            Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower);
+
+        // skip ':'
+        CurrentString = LocalString + 1;
+    }
+
+    /*
+     *	//<user>:<password>@<host>:<port>/<url-path>
+     *	any ":", "@" and "/" must be normalized
+     */
+
+    // skip "//"
+    if (*CurrentString++ != '/') return clParseURL(LUrlParserError_NoDoubleSlash);
+    if (*CurrentString++ != '/') return clParseURL(LUrlParserError_NoDoubleSlash);
+
+    // check if the user name and password are specified
+    bool bHasUserName = false;
+
+    const char* LocalString = CurrentString;
+
+    while (*LocalString)
+    {
+        if (*LocalString == '@')
+        {
+            // user name and password are specified
+            bHasUserName = true;
+            break;
+        }
+        else if (*LocalString == '/')
+        {
+            // end of <host>:<port> specification
+            bHasUserName = false;
+            break;
+        }
+
+        LocalString++;
+    }
+
+    // user name and password
+    LocalString = CurrentString;
+
+    if (bHasUserName)
+    {
+        // read user name
+        while (*LocalString && *LocalString != ':' && *LocalString != '@')
+            LocalString++;
+
+        Result.m_UserName = std::string(CurrentString, LocalString - CurrentString);
+
+        // proceed with the current pointer
+        CurrentString = LocalString;
+
+        if (*CurrentString == ':')
+        {
+            // skip ':'
+            CurrentString++;
+
+            // read password
+            LocalString = CurrentString;
+
+            while (*LocalString && *LocalString != '@')
+                LocalString++;
+
+            Result.m_Password = std::string(CurrentString, LocalString - CurrentString);
+
+            CurrentString = LocalString;
+        }
+
+        // skip '@'
+        if (*CurrentString != '@')
+        {
+            return clParseURL(LUrlParserError_NoAtSign);
+        }
+
+        CurrentString++;
+    }
+
+    bool bHasBracket = (*CurrentString == '[');
+
+    // go ahead, read the host name
+    LocalString = CurrentString;
+
+    while (*LocalString)
+    {
+        if (bHasBracket && *LocalString == ']')
+        {
+            // end of IPv6 address
+            LocalString++;
+            break;
+        }
+        else if (!bHasBracket && (*LocalString == ':' || *LocalString == '/'))
+        {
+            // port number is specified
+            break;
+        }
+
+        LocalString++;
+    }
+
+    Result.m_Host = std::string(CurrentString, LocalString - CurrentString);
+
+    CurrentString = LocalString;
+
+    // is port number specified?
+    if (*CurrentString == ':')
+    {
+        CurrentString++;
+
+        // read port number
+        LocalString = CurrentString;
+
+        while (*LocalString && *LocalString != '/')
+            LocalString++;
+
+        Result.m_Port = std::string(CurrentString, LocalString - CurrentString);
+
+        CurrentString = LocalString;
+    }
+
+    // end of string
+    if (!*CurrentString)
+    {
+        Result.m_ErrorCode = LUrlParserError_Ok;
+
+        return Result;
+    }
+
+    // skip '/'
+    if (*CurrentString != '/')
+    {
+        return clParseURL(LUrlParserError_NoSlash);
+    }
+
+    CurrentString++;
+
+    // parse the path
+    LocalString = CurrentString;
+
+    while (*LocalString && *LocalString != '#' && *LocalString != '?')
+        LocalString++;
+
+    Result.m_Path = std::string(CurrentString, LocalString - CurrentString);
+
+    CurrentString = LocalString;
+
+    // check for query
+    if (*CurrentString == '?')
+    {
+        // skip '?'
+        CurrentString++;
+
+        // read query
+        LocalString = CurrentString;
+
+        while (*LocalString && *LocalString != '#')
+            LocalString++;
+
+        Result.m_Query = std::string(CurrentString, LocalString - CurrentString);
+
+        CurrentString = LocalString;
+    }
+
+    // check for fragment
+    if (*CurrentString == '#')
+    {
+        // skip '#'
+        CurrentString++;
+
+        // read fragment
+        LocalString = CurrentString;
+
+        while (*LocalString)
+            LocalString++;
+
+        Result.m_Fragment = std::string(CurrentString, LocalString - CurrentString);
+    }
+
+    Result.m_ErrorCode = LUrlParserError_Ok;
+
+    return Result;
+}
--- a/ixwebsocket/LUrlParser.h
+++ b/ixwebsocket/LUrlParser.h
@ -0,0 +1,84 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace LUrlParser
+{
+    enum LUrlParserError
+    {
+        LUrlParserError_Ok = 0,
+        LUrlParserError_Uninitialized = 1,
+        LUrlParserError_NoUrlCharacter = 2,
+        LUrlParserError_InvalidSchemeName = 3,
+        LUrlParserError_NoDoubleSlash = 4,
+        LUrlParserError_NoAtSign = 5,
+        LUrlParserError_UnexpectedEndOfLine = 6,
+        LUrlParserError_NoSlash = 7,
+    };
+
+    class clParseURL
+    {
+    public:
+        LUrlParserError m_ErrorCode;
+        std::string m_Scheme;
+        std::string m_Host;
+        std::string m_Port;
+        std::string m_Path;
+        std::string m_Query;
+        std::string m_Fragment;
+        std::string m_UserName;
+        std::string m_Password;
+
+        clParseURL()
+            : m_ErrorCode(LUrlParserError_Uninitialized)
+        {
+        }
+
+        /// return 'true' if the parsing was successful
+        bool IsValid() const
+        {
+            return m_ErrorCode == LUrlParserError_Ok;
+        }
+
+        /// helper to convert the port number to int, return 'true' if the port is valid (within the
+        /// 0..65535 range)
+        bool GetPort(int* OutPort) const;
+
+        /// parse the URL
+        static clParseURL ParseURL(const std::string& URL);
+
+    private:
+        explicit clParseURL(LUrlParserError ErrorCode)
+            : m_ErrorCode(ErrorCode)
+        {
+        }
+    };
+
+} // namespace LUrlParser
--- a/ixwebsocket/libwshandshake.hpp
+++ b/ixwebsocket/libwshandshake.hpp
@ -0,0 +1,135 @@
+// Copyright (c) 2016 Alex Hultman and contributors
+
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgement in the product documentation would be
+//    appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+//    misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+
+#pragma once
+
+#include <cstdint>
+#include <cstddef>
+#include <string>
+#include <string.h>
+
+class WebSocketHandshakeKeyGen {
+    template <int N, typename T>
+    struct static_for {
+        void operator()(uint32_t *a, uint32_t *b) {
+            static_for<N - 1, T>()(a, b);
+            T::template f<N - 1>(a, b);
+        }
+    };
+
+    template <typename T>
+    struct static_for<0, T> {
+        void operator()(uint32_t * /*a*/, uint32_t * /*hash*/) {}
+    };
+
+    template <int state>
+    struct Sha1Loop {
+        static inline uint32_t rol(uint32_t value, size_t bits) {return (value << bits) | (value >> (32 - bits));}
+        static inline uint32_t blk(uint32_t b[16], size_t i) {
+            return rol(b[(i + 13) & 15] ^ b[(i + 8) & 15] ^ b[(i + 2) & 15] ^ b[i], 1);
+        }
+
+        template <int i>
+        static inline void f(uint32_t *a, uint32_t *b) {
+            switch (state) {
+            case 1:
+                a[i % 5] += ((a[(3 + i) % 5] & (a[(2 + i) % 5] ^ a[(1 + i) % 5])) ^ a[(1 + i) % 5]) + b[i] + 0x5a827999 + rol(a[(4 + i) % 5], 5);
+                a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30);
+                break;
+            case 2:
+                b[i] = blk(b, i);
+                a[(1 + i) % 5] += ((a[(4 + i) % 5] & (a[(3 + i) % 5] ^ a[(2 + i) % 5])) ^ a[(2 + i) % 5]) + b[i] + 0x5a827999 + rol(a[(5 + i) % 5], 5);
+                a[(4 + i) % 5] = rol(a[(4 + i) % 5], 30);
+                break;
+            case 3:
+                b[(i + 4) % 16] = blk(b, (i + 4) % 16);
+                a[i % 5] += (a[(3 + i) % 5] ^ a[(2 + i) % 5] ^ a[(1 + i) % 5]) + b[(i + 4) % 16] + 0x6ed9eba1 + rol(a[(4 + i) % 5], 5);
+                a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30);
+                break;
+            case 4:
+                b[(i + 8) % 16] = blk(b, (i + 8) % 16);
+                a[i % 5] += (((a[(3 + i) % 5] | a[(2 + i) % 5]) & a[(1 + i) % 5]) | (a[(3 + i) % 5] & a[(2 + i) % 5])) + b[(i + 8) % 16] + 0x8f1bbcdc + rol(a[(4 + i) % 5], 5);
+                a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30);
+                break;
+            case 5:
+                b[(i + 12) % 16] = blk(b, (i + 12) % 16);
+                a[i % 5] += (a[(3 + i) % 5] ^ a[(2 + i) % 5] ^ a[(1 + i) % 5]) + b[(i + 12) % 16] + 0xca62c1d6 + rol(a[(4 + i) % 5], 5);
+                a[(3 + i) % 5] = rol(a[(3 + i) % 5], 30);
+                break;
+            case 6:
+                b[i] += a[4 - i];
+            }
+        }
+    };
+
+    static inline void sha1(uint32_t hash[5], uint32_t b[16]) {
+        uint32_t a[5] = {hash[4], hash[3], hash[2], hash[1], hash[0]};
+        static_for<16, Sha1Loop<1>>()(a, b);
+        static_for<4, Sha1Loop<2>>()(a, b);
+        static_for<20, Sha1Loop<3>>()(a, b);
+        static_for<20, Sha1Loop<4>>()(a, b);
+        static_for<20, Sha1Loop<5>>()(a, b);
+        static_for<5, Sha1Loop<6>>()(a, hash);
+    }
+
+    static inline void base64(unsigned char *src, char *dst) {
+        const char *b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+        for (int i = 0; i < 18; i += 3) {
+            *dst++ = b64[(src[i] >> 2) & 63];
+            *dst++ = b64[((src[i] & 3) << 4) | ((src[i + 1] & 240) >> 4)];
+            *dst++ = b64[((src[i + 1] & 15) << 2) | ((src[i + 2] & 192) >> 6)];
+            *dst++ = b64[src[i + 2] & 63];
+        }
+        *dst++ = b64[(src[18] >> 2) & 63];
+        *dst++ = b64[((src[18] & 3) << 4) | ((src[19] & 240) >> 4)];
+        *dst++ = b64[((src[19] & 15) << 2)];
+        *dst++ = '=';
+    }
+
+public:
+    static inline void generate(const std::string& inputStr, char output[28]) {
+
+        char input[25] = {};
+        strncpy(input, inputStr.c_str(), 25 - 1);
+        input[25 - 1] = '\0';
+
+        uint32_t b_output[5] = {
+            0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0
+        };
+        uint32_t b_input[16] = {
+            0, 0, 0, 0, 0, 0, 0x32353845, 0x41464135, 0x2d453931, 0x342d3437, 0x44412d39,
+            0x3543412d, 0x43354142, 0x30444338, 0x35423131, 0x80000000
+        };
+
+        for (int i = 0; i < 6; i++) {
+            b_input[i] = (input[4 * i + 3] & 0xff) | (input[4 * i + 2] & 0xff) << 8 | (input[4 * i + 1] & 0xff) << 16 | (input[4 * i + 0] & 0xff) << 24;
+        }
+        sha1(b_output, b_input);
+        uint32_t last_b[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 480};
+        sha1(b_output, last_b);
+        for (int i = 0; i < 5; i++) {
+            uint32_t tmp = b_output[i];
+            char *bytes = (char *) &b_output[i];
+            bytes[3] = tmp & 0xff;
+            bytes[2] = (tmp >> 8) & 0xff;
+            bytes[1] = (tmp >> 16) & 0xff;
+            bytes[0] = (tmp >> 24) & 0xff;
+        }
+        base64((unsigned char *) b_output, output);
+    }
+};
--- a/main.cpp
+++ b/main.cpp
@ -1,62 +0,0 @@
-/*
- *  main.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2020 Machine Zone, Inc. All rights reserved.
- *
- *  Super simple standalone example. See ws folder, unittest and doc/usage.md for more.
- *
- *  On macOS
- *  $ mkdir -p build ; cd build ; cmake -DUSE_TLS=1 .. ; make -j ; make install
- *  $ clang++ --std=c++14 --stdlib=libc++ main.cpp -lixwebsocket -lz -framework Security -framework Foundation
- *  $ ./a.out
- */
-
-#include <ixwebsocket/IXNetSystem.h>
-#include <ixwebsocket/IXWebSocket.h>
-#include <iostream>
-
-int main()
-{
-    // Required on Windows
-    ix::initNetSystem();
-
-    // Our websocket object
-    ix::WebSocket webSocket;
-
-    std::string url("wss://echo.websocket.org");
-    webSocket.setUrl(url);
-
-    std::cout << "Connecting to " << url << "..." << std::endl;
-
-    // Setup a callback to be fired (in a background thread, watch out for race conditions !)
-    // when a message or an event (open, close, error) is received
-    webSocket.setOnMessageCallback([](const ix::WebSocketMessagePtr& msg)
-        {
-            if (msg->type == ix::WebSocketMessageType::Message)
-            {
-                std::cout << "received message: " << msg->str << std::endl;
-            }
-            else if (msg->type == ix::WebSocketMessageType::Open)
-            {
-                std::cout << "Connection established" << std::endl;
-            }
-        }
-    );
-
-    // Now that our callback is setup, we can start our background thread and receive messages
-    webSocket.start();
-
-    // Send a message to the server (default to TEXT mode)
-    webSocket.send("hello world");
-
-    while (true)
-    {
-        std::string text;
-        std::cout << "> " << std::flush;
-        std::getline(std::cin, text);
-
-        webSocket.send(text);
-    }
-
-    return 0;
-}
--- a/59
+++ b/59
@ -20,16 +20,16 @@ install: brew
 # Release, Debug, MinSizeRel, RelWithDebInfo are the build types
 #
 brew:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; ninja install)
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; make -j 4 install)

 # Docker default target. We've add problem with OpenSSL and TLS 1.3 (on the
 # server side ?) and I can't work-around it easily, so we're using mbedtls on
 # Linux for the SSL backend, which works great.
 ws_mbedtls_install:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; ninja install)
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; make -j 4 install)

 ws:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 .. ; ninja install)
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 .. ; make -j 4)

 ws_install:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 .. ; make -j 4 install)
@ -103,10 +103,6 @@ test_server:
 # env TEST=Websocket_chat make test
 # env TEST=heartbeat make test
 test:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; ninja install)
-	(cd test ; python2.7 run.py -r)
-
-test_make:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; make -j 4)
 	(cd test ; python2.7 run.py -r)

@ -148,7 +144,7 @@ test_tsan_mbedtls:
 	(cd test ; python2.7 run.py -r)

 build_test_openssl:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_OPEN_SSL=1 -DUSE_TEST=1 .. ; ninja install)
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_OPEN_SSL=1 -DUSE_TEST=1 .. ; make -j 4)

 test_openssl: build_test_openssl
 	(cd test ; python2.7 run.py -r)
@ -169,53 +165,6 @@ ws_test: ws
 autobahn_report:
 	cp -rvf ~/sandbox/reports/clients/* ../bsergean.github.io/IXWebSocket/autobahn/

-httpd:
-	clang++ --std=c++11 --stdlib=libc++ -Iixwebsocket httpd.cpp \
-		ixwebsocket/IXSelectInterruptFactory.cpp \
-		ixwebsocket/IXCancellationRequest.cpp \
-		ixwebsocket/IXSocketTLSOptions.cpp \
-		ixwebsocket/IXUserAgent.cpp \
-		ixwebsocket/IXDNSLookup.cpp \
-		ixwebsocket/IXBench.cpp \
-		ixwebsocket/IXWebSocketHttpHeaders.cpp \
-		ixwebsocket/IXSelectInterruptPipe.cpp \
-		ixwebsocket/IXHttp.cpp \
-		ixwebsocket/IXSocketConnect.cpp \
-		ixwebsocket/IXSocket.cpp \
-		ixwebsocket/IXSocketServer.cpp \
-		ixwebsocket/IXNetSystem.cpp \
-		ixwebsocket/IXHttpServer.cpp \
-		ixwebsocket/IXSocketFactory.cpp \
-		ixwebsocket/IXConnectionState.cpp \
-		ixwebsocket/IXUrlParser.cpp \
-		ixwebsocket/IXSelectInterrupt.cpp \
-		ixwebsocket/apple/IXSetThreadName_apple.cpp \
-		-lz
-
-httpd_linux:
-	g++ --std=c++11 -o ixhttpd httpd.cpp -Iixwebsocket \
-		ixwebsocket/IXSelectInterruptFactory.cpp \
-		ixwebsocket/IXCancellationRequest.cpp \
-		ixwebsocket/IXSocketTLSOptions.cpp \
-		ixwebsocket/IXUserAgent.cpp \
-		ixwebsocket/IXDNSLookup.cpp \
-		ixwebsocket/IXBench.cpp \
-		ixwebsocket/IXWebSocketHttpHeaders.cpp \
-		ixwebsocket/IXSelectInterruptPipe.cpp \
-		ixwebsocket/IXHttp.cpp \
-		ixwebsocket/IXSocketConnect.cpp \
-		ixwebsocket/IXSocket.cpp \
-		ixwebsocket/IXSocketServer.cpp \
-		ixwebsocket/IXNetSystem.cpp \
-		ixwebsocket/IXHttpServer.cpp \
-		ixwebsocket/IXSocketFactory.cpp \
-		ixwebsocket/IXConnectionState.cpp \
-		ixwebsocket/IXUrlParser.cpp \
-		ixwebsocket/IXSelectInterrupt.cpp \
-		ixwebsocket/linux/IXSetThreadName_linux.cpp \
-		-lz -lpthread
-	cp -f ixhttpd /usr/local/bin
-
 # For the fork that is configured with appveyor
 rebase_upstream:
 	git fetch upstream
--- a/test/IXCobraToSentryBotTest.cpp
+++ b/test/IXCobraToSentryBotTest.cpp
@ -138,12 +138,11 @@ TEST_CASE("Cobra_to_sentry_bot", "[cobra_bots]")

        std::thread publisherThread(runPublisher, config, channel);

-        ix::CobraBotConfig cobraBotConfig;
-        cobraBotConfig.cobraConfig = config;
-        cobraBotConfig.channel = channel;
-        cobraBotConfig.runtime = 3; // Only run the bot for 3 seconds
-        cobraBotConfig.enableHeartbeat = false;
+        std::string filter;
+        std::string position("$");
        bool verbose = true;
+        size_t maxQueueSize = 10;
+        bool enableHeartbeat = false;

        // FIXME: try to get this working with https instead of http
        //        to regress the TLS 1.3 OpenSSL bug
@ -158,7 +157,18 @@ TEST_CASE("Cobra_to_sentry_bot", "[cobra_bots]")
        SentryClient sentryClient(dsn);
        sentryClient.setTLSOptions(tlsOptionsClient);

-        int64_t sentCount = cobra_to_sentry_bot(cobraBotConfig, sentryClient, verbose);
+        // Only run the bot for 3 seconds
+        int runtime = 3;
+
+        int64_t sentCount = cobra_to_sentry_bot(config,
+                                                channel,
+                                                filter,
+                                                position,
+                                                sentryClient,
+                                                verbose,
+                                                maxQueueSize,
+                                                enableHeartbeat,
+                                                runtime);
        //
        // We want at least 2 messages to be sent
        //
--- a/test/IXCobraToStatsdBotTest.cpp
+++ b/test/IXCobraToStatsdBotTest.cpp
@ -87,11 +87,14 @@ TEST_CASE("Cobra_to_statsd_bot", "[cobra_bots]")

        std::thread publisherThread(runPublisher, config, channel);

-        ix::CobraBotConfig cobraBotConfig;
-        cobraBotConfig.cobraConfig = config;
-        cobraBotConfig.channel = channel;
-        cobraBotConfig.runtime = 3; // Only run the bot for 3 seconds
-        cobraBotConfig.enableHeartbeat = false;
+        std::string filter;
+        std::string position("$");
+        bool verbose = true;
+        size_t maxQueueSize = 10;
+        bool enableHeartbeat = false;
+
+        // Only run the bot for 3 seconds
+        int runtime = 3;

        std::string hostname("127.0.0.1");
        // std::string hostname("www.google.com");
@ -110,10 +113,19 @@ TEST_CASE("Cobra_to_statsd_bot", "[cobra_bots]")
        std::string fields("device.game\ndevice.os_name");
        std::string gauge;
        std::string timer;
-        bool verbose = true;

-        int64_t sentCount =
-            ix::cobra_to_statsd_bot(cobraBotConfig, statsdClient, fields, gauge, timer, verbose);
+        int64_t sentCount = ix::cobra_to_statsd_bot(config,
+                                                    channel,
+                                                    filter,
+                                                    position,
+                                                    statsdClient,
+                                                    fields,
+                                                    gauge,
+                                                    timer,
+                                                    verbose,
+                                                    maxQueueSize,
+                                                    enableHeartbeat,
+                                                    runtime);
        //
        // We want at least 2 messages to be sent
        //
--- a/test/IXCobraToStdoutBotTest.cpp
+++ b/test/IXCobraToStdoutBotTest.cpp
@ -85,17 +85,29 @@ TEST_CASE("Cobra_to_stdout_bot", "[cobra_bots]")

        std::thread publisherThread(runPublisher, config, channel);

-        ix::CobraBotConfig cobraBotConfig;
-        cobraBotConfig.cobraConfig = config;
-        cobraBotConfig.channel = channel;
-        cobraBotConfig.runtime = 3; // Only run the bot for 3 seconds
-        cobraBotConfig.enableHeartbeat = false;
+        std::string filter;
+        std::string position("$");
+        bool verbose = true;
        bool quiet = false;
+        size_t maxQueueSize = 10;
+        bool enableHeartbeat = false;
+
+        // Only run the bot for 3 seconds
+        int runtime = 3;

        // We could try to capture the output ... not sure how.
        bool fluentd = true;

-        int64_t sentCount = ix::cobra_to_stdout_bot(cobraBotConfig, fluentd, quiet);
+        int64_t sentCount = ix::cobra_to_stdout_bot(config,
+                                                    channel,
+                                                    filter,
+                                                    position,
+                                                    fluentd,
+                                                    quiet,
+                                                    verbose,
+                                                    maxQueueSize,
+                                                    enableHeartbeat,
+                                                    runtime);
        //
        // We want at least 2 messages to be sent
        //
--- a/test/IXGetFreePort.cpp
+++ b/test/IXGetFreePort.cpp
@ -4,14 +4,6 @@
 *  Copyright (c) 2019 Machine Zone. All rights reserved.
 */

-// Using inet_addr will trigger an error on uwp without this
-// FIXME: use a different api
-#ifdef _WIN32
-#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS
-#define _WINSOCK_DEPRECATED_NO_WARNINGS
-#endif
-#endif
-
 #include "IXGetFreePort.h"

 #include <ixwebsocket/IXNetSystem.h>
--- a/test/IXUnityBuildsTest.cpp
+++ b/test/IXUnityBuildsTest.cpp
@ -17,11 +17,8 @@
 #include <ixwebsocket/IXSelectInterruptFactory.h>
 #include <ixwebsocket/IXSetThreadName.h>
 #include <ixwebsocket/IXSocket.h>
-#include <ixwebsocket/IXSocketAppleSSL.h>
 #include <ixwebsocket/IXSocketConnect.h>
 #include <ixwebsocket/IXSocketFactory.h>
-#include <ixwebsocket/IXSocketMbedTLS.h>
-#include <ixwebsocket/IXSocketOpenSSL.h>
 #include <ixwebsocket/IXSocketServer.h>
 #include <ixwebsocket/IXUrlParser.h>
 #include <ixwebsocket/IXWebSocket.h>
@ -29,7 +26,6 @@
 #include <ixwebsocket/IXWebSocketCloseInfo.h>
 #include <ixwebsocket/IXWebSocketErrorInfo.h>
 #include <ixwebsocket/IXWebSocketHandshake.h>
-#include <ixwebsocket/IXWebSocketHandshakeKeyGen.h>
 #include <ixwebsocket/IXWebSocketHttpHeaders.h>
 #include <ixwebsocket/IXWebSocketMessage.h>
 #include <ixwebsocket/IXWebSocketMessageType.h>
@ -40,6 +36,8 @@
 #include <ixwebsocket/IXWebSocketSendInfo.h>
 #include <ixwebsocket/IXWebSocketServer.h>
 #include <ixwebsocket/IXWebSocketTransport.h>
+#include <ixwebsocket/LUrlParser.h>
+#include <ixwebsocket/libwshandshake.hpp>

 using namespace ix;

--- a/test/IXWebSocketSubProtocolTest.cpp
+++ b/test/IXWebSocketSubProtocolTest.cpp
@ -93,11 +93,10 @@ TEST_CASE("subprotocol", "[websocket_subprotocol]")
        webSocket.setUrl(url);
        webSocket.start();

-        // Give us 3 seconds to connect
        int attempts = 0;
        while (!connected)
        {
-            REQUIRE(attempts++ < 300);
+            REQUIRE(attempts++ < 10);
            ix::msleep(10);
        }

--- a/test/test_runner.cpp
+++ b/test/test_runner.cpp
@ -14,41 +14,8 @@ int main(int argc, char* argv[])
 {
    ix::initNetSystem();

-    ix::CoreLogger::LogFunc logFunc = [](const char* msg, ix::LogLevel level) {
-        switch (level)
-        {
-            case ix::LogLevel::Debug:
-            {
-                spdlog::debug(msg);
-            }
-            break;
-
-            case ix::LogLevel::Info:
-            {
-                spdlog::info(msg);
-            }
-            break;
-
-            case ix::LogLevel::Warning:
-            {
-                spdlog::warn(msg);
-            }
-            break;
-
-            case ix::LogLevel::Error:
-            {
-                spdlog::error(msg);
-            }
-            break;
-
-            case ix::LogLevel::Critical:
-            {
-                spdlog::critical(msg);
-            }
-            break;
-        }
-    };
-    ix::CoreLogger::setLogFunction(logFunc);
+    ix::IXCoreLogger::LogFunc logFunc = [](const char* msg) { spdlog::info(msg); };
+    ix::IXCoreLogger::setLogFunction(logFunc);

    int result = Catch::Session().run(argc, argv);

--- a/third_party/.clang-format
+++ b/third_party/.clang-format
@ -1,2 +1,4 @@
-DisableFormat: true
-SortIncludes: false
+{
+    "DisableFormat": true,
+    "SortIncludes": false
+}
--- a/third_party/mbedtls/.github/issue_template.md
+++ b/third_party/mbedtls/.github/issue_template.md
@ -0,0 +1,41 @@
+Note: This is just a template, so feel free to use/remove the unnecessary things
+
+### Description
+- Type: Bug | Enhancement\Feature Request | Question
+- Priority: Blocker | Major | Minor
+
+---------------------------------------------------------------
+## Bug
+
+**OS**
+Mbed OS|linux|windows|
+
+**mbed TLS build:**
+Version: x.x.x or git commit id
+OS version: x.x.x
+Configuration: please attach config.h file where possible
+Compiler and options (if you used a pre-built binary, please indicate how you obtained it):
+Additional environment information:
+
+**Peer device TLS stack and version**
+OpenSSL|GnuTls|Chrome|NSS(Firefox)|SecureChannel (IIS/Internet Explorer/Edge)|Other
+Version:
+
+**Expected behavior**
+
+**Actual behavior**
+
+**Steps to reproduce**
+
+----------------------------------------------------------------
+## Enhancement\Feature Request
+
+**Justification - why does the library need this feature?**
+
+**Suggested enhancement**
+
+-----------------------------------------------------------------
+
+## Question
+
+**Please first check for answers in the [Mbed TLS knowledge Base](https://tls.mbed.org/kb), and preferably file an issue in the [Mbed TLS support forum](https://forums.mbed.com/c/mbed-tls)**
--- a/third_party/mbedtls/.github/pull_request_template.md
+++ b/third_party/mbedtls/.github/pull_request_template.md
@ -0,0 +1,39 @@
+Notes:
+* Pull requests cannot be accepted until:
+-  The submitter has [accepted the online agreement here with a click through](https://developer.mbed.org/contributor_agreement/)
+   or for companies or those that do not wish to create an mbed account, a slightly different agreement can be found [here](https://www.mbed.com/en/about-mbed/contributor-license-agreements/)
+- The PR follows the [mbed TLS coding standards](https://tls.mbed.org/kb/development/mbedtls-coding-standards)
+* This is just a template, so feel free to use/remove the unnecessary things
+## Description
+A few sentences describing the overall goals of the pull request's commits.
+
+
+## Status
+**READY/IN DEVELOPMENT/HOLD**
+
+## Requires Backporting
+When there is a bug fix, it should be backported to all maintained and supported branches.
+Changes do not have to be backported if:
+- This PR is a new feature\enhancement
+- This PR contains changes in the API. If this is true, and there is a need for the fix to be backported, the fix should be handled differently in the legacy branch
+
+Yes | NO
+Which branch?
+
+## Migrations
+If there is any API change, what's the incentive and logic for it.
+
+YES | NO
+
+## Additional comments
+Any additional information that could be of interest
+
+## Todos
+- [ ] Tests
+- [ ] Documentation
+- [ ] Changelog updated
+- [ ] Backported
+
+
+## Steps to test or reproduce
+Outline the steps to test or reproduce the PR here.
--- a/third_party/mbedtls/.gitignore
+++ b/third_party/mbedtls/.gitignore
@ -0,0 +1,43 @@
+# Random seed file created by test scripts and sample programs
+seedfile
+
+# CMake build artifacts:
+CMakeCache.txt
+CMakeFiles
+CTestTestfile.cmake
+cmake_install.cmake
+Testing
+# CMake generates *.dir/ folders for in-tree builds (used by MSVC projects), ignore all of those:
+*.dir/
+# MSVC files generated by CMake:
+/*.sln
+/*.vcxproj
+/*.filters
+
+# Test coverage build artifacts:
+Coverage
+*.gcno
+*.gcda
+
+# generated by scripts/memory.sh
+massif-*
+
+# MSVC build artifacts:
+*.exe
+*.pdb
+*.ilk
+*.lib
+
+# Python build artifacts:
+*.pyc
+
+# Generated documentation:
+/apidoc
+
+# Editor navigation files:
+/GPATH
+/GRTAGS
+/GSYMS
+/GTAGS
+/TAGS
+/tags
--- a/third_party/mbedtls/.globalrc
+++ b/third_party/mbedtls/.globalrc
@ -0,0 +1,3 @@
+default:\
+    :langmap=c\:.c.h.function:\
+
--- a/third_party/mbedtls/.pylintrc
+++ b/third_party/mbedtls/.pylintrc
@ -0,0 +1,52 @@
+[BASIC]
+# We're ok with short funtion argument names.
+# [invalid-name]
+argument-rgx=[a-z_][a-z0-9_]*$
+
+# Allow filter and map.
+# [bad-builtin]
+bad-functions=input
+
+# We prefer docstrings, but we don't require them on all functions.
+# Require them only on long functions (for some value of long).
+# [missing-docstring]
+docstring-min-length=10
+
+# Allow longer methods than the default.
+# [invalid-name]
+method-rgx=[a-z_][a-z0-9_]{2,35}$
+
+# Allow module names containing a dash (but no underscore or uppercase letter).
+# They are whole programs, not meant to be included by another module.
+# [invalid-name]
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+)|[a-z][-0-9a-z]+)$
+
+# Some functions don't need docstrings.
+# [missing-docstring]
+no-docstring-rgx=(run_)?main$
+
+# We're ok with short local or global variable names.
+# [invalid-name]
+variable-rgx=[a-z_][a-z0-9_]*$
+
+[DESIGN]
+# Allow more than the default 7 attributes.
+# [too-many-instance-attributes]
+max-attributes=15
+
+[FORMAT]
+# Allow longer modules than the default recommended maximum.
+# [too-many-lines]
+max-module-lines=2000
+
+[MESSAGES CONTROL]
+disable=
+
+[REPORTS]
+# Don't diplay statistics. Just the facts.
+reports=no
+
+[VARIABLES]
+# Allow unused variables if their name starts with an underscore.
+# [unused-argument]
+dummy-variables-rgx=_.*
--- a/third_party/mbedtls/.travis.yml
+++ b/third_party/mbedtls/.travis.yml
@ -0,0 +1,48 @@
+language: c
+compiler:
+- clang
+- gcc
+sudo: false
+cache: ccache
+
+# blocklist
+branches:
+  except:
+  - development-psa
+  - coverity_scan
+
+script:
+- tests/scripts/recursion.pl library/*.c
+- tests/scripts/check-generated-files.sh
+- tests/scripts/check-doxy-blocks.pl
+- tests/scripts/check-names.sh
+- tests/scripts/check-files.py
+- tests/scripts/doxygen.sh
+- cmake -D CMAKE_BUILD_TYPE:String="Check" .
+- make
+- make test
+- programs/test/selftest
+- OSSL_NO_DTLS=1 tests/compat.sh
+- tests/ssl-opt.sh -e '\(DTLS\|SCSV\).*openssl'
+- tests/scripts/test-ref-configs.pl
+- tests/scripts/curves.pl
+- tests/scripts/key-exchanges.pl
+after_failure:
+- tests/scripts/travis-log-failure.sh
+env:
+  global:
+    - SEED=1
+    - secure: "barHldniAfXyoWOD/vcO+E6/Xm4fmcaUoC9BeKW+LwsHqlDMLvugaJnmLXkSpkbYhVL61Hzf3bo0KPJn88AFc5Rkf8oYHPjH4adMnVXkf3B9ghHCgznqHsAH3choo6tnPxaFgOwOYmLGb382nQxfE5lUdvnM/W/psQjWt66A1+k="
+
+addons:
+  apt:
+    packages:
+    - doxygen
+    - graphviz
+  coverity_scan:
+    project:
+      name: "ARMmbed/mbedtls"
+    notification_email: simon.butcher@arm.com
+    build_command_prepend:
+    build_command: make
+    branch_pattern: coverity_scan
--- a/third_party/mbedtls/CMakeLists.txt
+++ b/third_party/mbedtls/CMakeLists.txt
@ -0,0 +1,246 @@
+cmake_minimum_required(VERSION 2.6)
+if(TEST_CPP)
+    project("mbed TLS" C CXX)
+else()
+    project("mbed TLS" C)
+endif()
+
+set(MBEDTLS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+option(USE_PKCS11_HELPER_LIBRARY "Build mbed TLS with the pkcs11-helper library." OFF)
+option(ENABLE_ZLIB_SUPPORT "Build mbed TLS with zlib library." OFF)
+
+option(ENABLE_PROGRAMS "Build mbed TLS programs." OFF)
+
+option(UNSAFE_BUILD "Allow unsafe builds. These builds ARE NOT SECURE." OFF)
+
+# export the submodule flag so that crypto knows it's being built as a submodule
+set( USE_CRYPTO_SUBMODULE ON )
+
+string(REGEX MATCH "Clang" CMAKE_COMPILER_IS_CLANG "${CMAKE_C_COMPILER_ID}")
+string(REGEX MATCH "GNU" CMAKE_COMPILER_IS_GNU "${CMAKE_C_COMPILER_ID}")
+string(REGEX MATCH "IAR" CMAKE_COMPILER_IS_IAR "${CMAKE_C_COMPILER_ID}")
+string(REGEX MATCH "MSVC" CMAKE_COMPILER_IS_MSVC "${CMAKE_C_COMPILER_ID}")
+
+# the test suites currently have compile errors with MSVC
+if(CMAKE_COMPILER_IS_MSVC)
+    option(ENABLE_TESTING "Build mbed TLS tests." OFF)
+else()
+    option(ENABLE_TESTING "Build mbed TLS tests." OFF)
+endif()
+
+# Warning string - created as a list for compatibility with CMake 2.8
+set(WARNING_BORDER "*******************************************************\n")
+set(NULL_ENTROPY_WARN_L1 "****  WARNING!  MBEDTLS_TEST_NULL_ENTROPY defined!\n")
+set(NULL_ENTROPY_WARN_L2 "****  THIS BUILD HAS NO DEFINED ENTROPY SOURCES\n")
+set(NULL_ENTROPY_WARN_L3 "****  AND IS *NOT* SUITABLE FOR PRODUCTION USE\n")
+
+set(NULL_ENTROPY_WARNING "${WARNING_BORDER}"
+                         "${NULL_ENTROPY_WARN_L1}"
+                         "${NULL_ENTROPY_WARN_L2}"
+                         "${NULL_ENTROPY_WARN_L3}"
+                         "${WARNING_BORDER}")
+
+set(CTR_DRBG_128_BIT_KEY_WARN_L1 "****  WARNING!  MBEDTLS_CTR_DRBG_USE_128_BIT_KEY defined!\n")
+set(CTR_DRBG_128_BIT_KEY_WARN_L2 "****  Using 128-bit keys for CTR_DRBG limits the security of generated\n")
+set(CTR_DRBG_128_BIT_KEY_WARN_L3 "****  keys and operations that use random values generated to 128-bit security\n")
+
+set(CTR_DRBG_128_BIT_KEY_WARNING "${WARNING_BORDER}"
+                         "${CTR_DRBG_128_BIT_KEY_WARN_L1}"
+                         "${CTR_DRBG_128_BIT_KEY_WARN_L2}"
+                         "${CTR_DRBG_128_BIT_KEY_WARN_L3}"
+                         "${WARNING_BORDER}")
+
+find_package(PythonInterp)
+find_package(Perl)
+if(PERL_FOUND)
+
+    # If 128-bit keys are configured for CTR_DRBG, display an appropriate warning
+    execute_process(COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/config.pl -f ${CMAKE_CURRENT_SOURCE_DIR}/include/mbedtls/config.h get MBEDTLS_CTR_DRBG_USE_128_BIT_KEY
+                        RESULT_VARIABLE result)
+    if(${result} EQUAL 0)
+        message(WARNING ${CTR_DRBG_128_BIT_KEY_WARNING})
+    endif()
+
+    # If NULL Entropy is configured, display an appropriate warning
+    execute_process(COMMAND ${PERL_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/scripts/config.pl -f ${CMAKE_CURRENT_SOURCE_DIR}/include/mbedtls/config.h get MBEDTLS_TEST_NULL_ENTROPY
+                        RESULT_VARIABLE result)
+    if(${result} EQUAL 0)
+        message(WARNING ${NULL_ENTROPY_WARNING})
+
+        if(NOT UNSAFE_BUILD)
+            message(FATAL_ERROR "\
+\n\
+Warning! You have enabled MBEDTLS_TEST_NULL_ENTROPY. \
+This option is not safe for production use and negates all security \
+It is intended for development use only. \
+\n\
+To confirm you want to build with this option, re-run cmake with the \
+option: \n\
+  cmake -DUNSAFE_BUILD=ON ")
+
+            return()
+        endif()
+    endif()
+endif()
+
+set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}
+    CACHE STRING "Choose the type of build: None Debug Release Coverage ASan ASanDbg MemSan MemSanDbg Check CheckFull"
+    FORCE)
+
+# Create a symbolic link from ${base_name} in the binary directory
+# to the corresponding path in the source directory.
+function(link_to_source base_name)
+    # Get OS dependent path to use in `execute_process`
+    if (CMAKE_HOST_WIN32)
+        #mklink is an internal command of cmd.exe it can only work with \
+        string(REPLACE "/" "\\" link "${CMAKE_CURRENT_BINARY_DIR}/${base_name}")
+        string(REPLACE "/" "\\" target "${CMAKE_CURRENT_SOURCE_DIR}/${base_name}")
+    else()
+        set(link "${CMAKE_CURRENT_BINARY_DIR}/${base_name}")
+        set(target "${CMAKE_CURRENT_SOURCE_DIR}/${base_name}")
+    endif()
+
+    if (NOT EXISTS ${link})
+        if (CMAKE_HOST_UNIX)
+            set(command ln -s ${target} ${link})
+        else()
+            if (IS_DIRECTORY ${target})
+                set(command cmd.exe /c mklink /j ${link} ${target})
+            else()
+                set(command cmd.exe /c mklink /h ${link} ${target})
+            endif()
+        endif()
+
+        execute_process(COMMAND ${command}
+            RESULT_VARIABLE result
+            ERROR_VARIABLE output)
+
+        if (NOT ${result} EQUAL 0)
+            message(FATAL_ERROR "Could not create symbolic link for: ${target} --> ${output}")
+        endif()
+    endif()
+endfunction(link_to_source)
+
+string(REGEX MATCH "Clang" CMAKE_COMPILER_IS_CLANG "${CMAKE_C_COMPILER_ID}")
+
+if(CMAKE_COMPILER_IS_GNU)
+    # some warnings we want are not available with old GCC versions
+    # note: starting with CMake 2.8 we could use CMAKE_C_COMPILER_VERSION
+    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion
+                    OUTPUT_VARIABLE GCC_VERSION)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -W -Wdeclaration-after-statement -Wwrite-strings")
+    if (GCC_VERSION VERSION_GREATER 4.5 OR GCC_VERSION VERSION_EQUAL 4.5)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wlogical-op")
+    endif()
+    if (GCC_VERSION VERSION_GREATER 4.8 OR GCC_VERSION VERSION_EQUAL 4.8)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wshadow")
+    endif()
+    set(CMAKE_C_FLAGS_RELEASE     "-O2")
+    set(CMAKE_C_FLAGS_DEBUG       "-O0 -g3")
+    set(CMAKE_C_FLAGS_COVERAGE    "-O0 -g3 --coverage")
+    set(CMAKE_C_FLAGS_ASAN        "-Werror -fsanitize=address -fno-common -O3")
+    set(CMAKE_C_FLAGS_ASANDBG     "-Werror -fsanitize=address -fno-common -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls ")
+    set(CMAKE_C_FLAGS_CHECK       "-Werror -Os")
+    set(CMAKE_C_FLAGS_CHECKFULL   "${CMAKE_C_FLAGS_CHECK} -Wcast-qual")
+endif(CMAKE_COMPILER_IS_GNU)
+
+if(CMAKE_COMPILER_IS_CLANG)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -W -Wdeclaration-after-statement -Wwrite-strings -Wpointer-arith -Wimplicit-fallthrough -Wshadow")
+    set(CMAKE_C_FLAGS_RELEASE     "-O2")
+    set(CMAKE_C_FLAGS_DEBUG       "-O0 -g3")
+    set(CMAKE_C_FLAGS_COVERAGE    "-O0 -g3 --coverage")
+    set(CMAKE_C_FLAGS_ASAN        "-Werror -fsanitize=address -fno-common -fsanitize=undefined -fno-sanitize-recover=all -O3")
+    set(CMAKE_C_FLAGS_ASANDBG     "-Werror -fsanitize=address -fno-common -fsanitize=undefined -fno-sanitize-recover=all -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls ")
+    set(CMAKE_C_FLAGS_MEMSAN      "-Werror -fsanitize=memory -O3")
+    set(CMAKE_C_FLAGS_MEMSANDBG   "-Werror -fsanitize=memory -O1 -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls -fsanitize-memory-track-origins=2")
+    set(CMAKE_C_FLAGS_CHECK       "-Werror -Os")
+endif(CMAKE_COMPILER_IS_CLANG)
+
+if(CMAKE_COMPILER_IS_IAR)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --warn_about_c_style_casts --warnings_are_errors -Ohz")
+endif(CMAKE_COMPILER_IS_IAR)
+
+if(CMAKE_COMPILER_IS_MSVC)
+    # Strictest warnings, and treat as errors
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W3")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX")
+endif(CMAKE_COMPILER_IS_MSVC)
+
+if(CMAKE_BUILD_TYPE STREQUAL "Coverage")
+    if(CMAKE_COMPILER_IS_GNU OR CMAKE_COMPILER_IS_CLANG)
+        set(CMAKE_SHARED_LINKER_FLAGS "--coverage")
+    endif(CMAKE_COMPILER_IS_GNU OR CMAKE_COMPILER_IS_CLANG)
+endif(CMAKE_BUILD_TYPE STREQUAL "Coverage")
+
+if(LIB_INSTALL_DIR)
+else()
+    set(LIB_INSTALL_DIR lib)
+endif()
+
+if(ENABLE_ZLIB_SUPPORT)
+    find_package(ZLIB)
+
+    if(ZLIB_FOUND)
+        include_directories(${ZLIB_INCLUDE_DIR})
+    endif(ZLIB_FOUND)
+endif(ENABLE_ZLIB_SUPPORT)
+
+add_subdirectory(library)
+add_subdirectory(include)
+add_subdirectory(crypto/library)
+add_subdirectory(crypto/include)
+
+if(ENABLE_PROGRAMS)
+    add_subdirectory(programs)
+endif()
+
+ADD_CUSTOM_TARGET(apidoc
+    COMMAND doxygen mbedtls.doxyfile
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doxygen)
+
+if(ENABLE_TESTING)
+    enable_testing()
+
+    add_subdirectory(tests)
+    add_subdirectory(crypto/tests)
+
+    # additional convenience targets for Unix only
+    if(UNIX)
+
+        ADD_CUSTOM_TARGET(covtest
+            COMMAND make test
+            COMMAND programs/test/selftest
+            COMMAND tests/compat.sh
+            COMMAND tests/ssl-opt.sh
+        )
+
+        ADD_CUSTOM_TARGET(lcov
+            COMMAND rm -rf Coverage
+            COMMAND lcov --capture --initial --directory library/CMakeFiles/mbedtls.dir -o files.info
+            COMMAND lcov --capture --directory library/CMakeFiles/mbedtls.dir -o tests.info
+            COMMAND lcov --add-tracefile files.info --add-tracefile tests.info -o all.info
+            COMMAND lcov --remove all.info -o final.info '*.h'
+            COMMAND gendesc tests/Descriptions.txt -o descriptions
+            COMMAND genhtml --title "mbed TLS" --description-file descriptions --keep-descriptions --legend --no-branch-coverage -o Coverage final.info
+            COMMAND rm -f files.info tests.info all.info final.info descriptions
+        )
+
+        ADD_CUSTOM_TARGET(memcheck
+            COMMAND sed -i.bak s+/usr/bin/valgrind+`which valgrind`+ DartConfiguration.tcl
+            COMMAND ctest -O memcheck.log -D ExperimentalMemCheck
+            COMMAND tail -n1 memcheck.log | grep 'Memory checking results:' > /dev/null
+            COMMAND rm -f memcheck.log
+            COMMAND mv DartConfiguration.tcl.bak DartConfiguration.tcl
+        )
+    endif(UNIX)
+endif()
+
+# Make scripts needed for testing available in an out-of-source build.
+if (NOT ${CMAKE_CURRENT_BINARY_DIR} STREQUAL ${CMAKE_CURRENT_SOURCE_DIR})
+    link_to_source(scripts)
+    # Copy (don't link) DartConfiguration.tcl, needed for memcheck, to
+    # keep things simple with the sed commands in the memcheck target.
+    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/DartConfiguration.tcl
+                   ${CMAKE_CURRENT_BINARY_DIR}/DartConfiguration.tcl COPYONLY)
+endif()
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Benjamin Sergeant	cce7bb6a3e	do not use spdlog from vcpkg	2020-04-18 04:00:42 -07:00
Benjamin Sergeant	90eae2b403	only build ws	2020-04-18 03:54:34 -07:00
Benjamin Sergeant	b044a1d119	only run windows ci	2020-04-17 17:39:36 -07:00
Benjamin Sergeant	5184d5d985	Revert "try to fix windows link" This reverts commit `8db688b818`.	2020-04-17 17:33:55 -07:00
Benjamin Sergeant	aac9386f62	add spdlog through vcpkg	2020-04-17 17:33:32 -07:00
Benjamin Sergeant	8db688b818	try to fix windows link	2020-04-17 16:51:45 -07:00