(ixwebsocket) Handle EINTR return code in ix::poll and IXSelectInterrupt

* (http client) #ifdefs so we dont try to compress http requests with zlib

* (http client) Remove some #ifdefs for including zlib and removing fields

.github/workflows/unittest_linux.yml

@@ -9,5 +9,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v1
-    - name: make test_make
-      run: make test_make
+    - uses: seanmiddleditch/gha-setup-ninja@master
+    - name: make test
+      run: make test

.github/workflows/unittest_linux_asan.yml

@@ -0,0 +1,14 @@
+name: linux_asan
+on:
+  push:
+    paths-ignore:
+    - 'docs/**'
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - uses: seanmiddleditch/gha-setup-ninja@master
+    - name: make test_asan
+      run: make test_asan

.github/workflows/unittest_mac_tsan_mbedtls.yml

@@ -9,6 +9,7 @@ jobs:
     runs-on: macOS-latest
     steps:
     - uses: actions/checkout@v1
+    - uses: seanmiddleditch/gha-setup-ninja@master
     - name: install mbedtls
       run: brew install mbedtls
     - name: make test

.github/workflows/unittest_mac_tsan_openssl.yml

@@ -9,6 +9,7 @@ jobs:
     runs-on: macOS-latest
     steps:
     - uses: actions/checkout@v1
+    - uses: seanmiddleditch/gha-setup-ninja@master
     - name: install openssl
       run: brew install openssl@1.1
     - name: make test

.github/workflows/unittest_mac_tsan_sectransport.yml

@@ -9,5 +9,6 @@ jobs:
     runs-on: macOS-latest
     steps:
     - uses: actions/checkout@v1
-    - name: make test_tsan
-      run: make test_tsan
+    - uses: seanmiddleditch/gha-setup-ninja@master
+    - name: make test_tsan_sectransport
+      run: make test_tsan_sectransport

CMake/FindDeflate.cmake

@@ -0,0 +1,19 @@
+# Find package structure taken from libcurl
+
+include(FindPackageHandleStandardArgs)
+
+find_path(DEFLATE_INCLUDE_DIRS libdeflate.h)
+find_library(DEFLATE_LIBRARY deflate)
+
+find_package_handle_standard_args(Deflate
+    FOUND_VAR
+      DEFLATE_FOUND
+    REQUIRED_VARS
+      DEFLATE_LIBRARY
+      DEFLATE_INCLUDE_DIRS
+    FAIL_MESSAGE
+      "Could NOT find deflate"
+)
+
+set(DEFLATE_INCLUDE_DIRS ${DEFLATE_INCLUDE_DIRS})
+set(DEFLATE_LIBRARIES ${DEFLATE_LIBRARY})

CMakeLists.txt

@@ -8,7 +8,7 @@ set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")
 
 project(ixwebsocket C CXX)
 
-set (CMAKE_CXX_STANDARD 14)
+set (CMAKE_CXX_STANDARD 11)
 set (CXX_STANDARD_REQUIRED ON)
 set (CMAKE_CXX_EXTENSIONS OFF)
 
@@ -45,6 +45,7 @@ set( IXWEBSOCKET_SOURCES
     ixwebsocket/IXSocketFactory.cpp
     ixwebsocket/IXSocketServer.cpp
     ixwebsocket/IXSocketTLSOptions.cpp
+    ixwebsocket/IXStrCaseCompare.cpp
     ixwebsocket/IXUdpSocket.cpp
     ixwebsocket/IXUrlParser.cpp
     ixwebsocket/IXUserAgent.cpp
@@ -82,6 +83,7 @@ set( IXWEBSOCKET_HEADERS
     ixwebsocket/IXSocketFactory.h
     ixwebsocket/IXSocketServer.h
     ixwebsocket/IXSocketTLSOptions.h
+    ixwebsocket/IXStrCaseCompare.h
     ixwebsocket/IXUdpSocket.h
     ixwebsocket/IXUrlParser.h
     ixwebsocket/IXUtf8Validator.h
@@ -202,6 +204,14 @@ if (USE_ZLIB)
   target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_ZLIB)
 endif()
 
+# brew install libdeflate
+find_package(Deflate)
+if (DEFLATE_FOUND)
+  include_directories(${DEFLATE_INCLUDE_DIRS})
+  target_link_libraries(ixwebsocket ${DEFLATE_LIBRARIES})
+  target_compile_definitions(ixwebsocket PUBLIC IXWEBSOCKET_USE_DEFLATE)
+endif()
+
 if (WIN32)
   target_link_libraries(ixwebsocket wsock32 ws2_32 shlwapi)
   add_definitions(-D_CRT_SECURE_NO_WARNINGS)
@@ -256,18 +266,16 @@ if (USE_WS OR USE_TEST)
   include(FetchContent)
   FetchContent_Declare(spdlog
       GIT_REPOSITORY "https://github.com/gabime/spdlog"
-      GIT_TAG "v1.8.0") 
+      GIT_TAG "v1.8.0"
+      GIT_SHALLOW 1) 
 
-  FetchContent_Declare(jsoncpp
-      GIT_REPOSITORY "https://github.com/open-source-parsers/jsoncpp"
-      GIT_TAG "1.9.4") 
-
-  FetchContent_MakeAvailable(spdlog jsoncpp)
+  FetchContent_MakeAvailable(spdlog)
 
   if (USE_WS)
-      add_subdirectory(ws)
+    add_subdirectory(ws)
   endif()
   if (USE_TEST)
-      add_subdirectory(test)
+    enable_testing()
+    add_subdirectory(test)
   endif()
 endif()

README.md

@@ -4,6 +4,8 @@ IXWebSocket is a C++ library for WebSocket client and server development. It has
 
 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. Note that the MinGW compiler is not supported at this point. Two important design goals are simplicity and correctness.
 
+A bad security bug affecting users compiling with SSL enabled and OpenSSL as the backend was just fixed in newly released version 11.0.0. Please upgrade ! (more details in the [https://github.com/machinezone/IXWebSocket/pull/250](PR).
+
 ```cpp
 /*
  *  main.cpp
@@ -84,23 +86,26 @@ If your company or project is using this library, feel free to open an issue or
 - [libDiscordBot](https://github.com/tostc/libDiscordBot/tree/master), an easy to use Discord-bot framework.
 - [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
+- [discord.cpp](https://github.com/luccanunes/discord.cpp), a discord library for making bots
 
 ## 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] |
+| Linux             | OpenSSL           | None              | [![Build2][1]][0] |
+| macOS             | Secure Transport  | Thread Sanitizer  | [![Build2][2]][0] |
+| macOS             | OpenSSL           | Thread Sanitizer  | [![Build2][3]][0] |
+| macOS             | MbedTLS           | Thread Sanitizer  | [![Build2][4]][0] |
+| Windows           | Disabled          | None              | [![Build2][5]][0] |
+| UWP               | Disabled          | None              | [![Build2][6]][0] |
+| Linux             | OpenSSL           | Address Sanitizer | [![Build2][7]][0] |
 
+[0]: https://github.com/machinezone/IXWebSocket
 [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
+[7]: https://github.com/machinezone/IXWebSocket/workflows/linux_asan/badge.svg
 

docker/Dockerfile.centos7

@@ -0,0 +1,26 @@
+FROM centos:7 as build
+
+RUN yum install -y gcc-c++ make zlib-devel openssl-devel redhat-rpm-config
+
+RUN groupadd app && useradd -g app app
+RUN chown -R app:app /opt
+RUN chown -R app:app /usr/local
+
+WORKDIR /tmp
+RUN curl -O https://cmake.org/files/v3.14/cmake-3.14.0-Linux-x86_64.tar.gz
+RUN tar zxvf cmake-3.14.0-Linux-x86_64.tar.gz
+RUN cp -rf cmake-3.14.0-Linux-x86_64/* /usr/
+
+RUN yum install -y git
+
+# There is a bug in CMake where we cannot build from the root top folder
+# So we build from /opt
+COPY --chown=app:app . /opt
+WORKDIR /opt
+
+USER app
+RUN [ "make", "ws_no_python" ]
+RUN [ "rm", "-rf", "build" ]
+
+ENTRYPOINT ["ws"]
+CMD ["--help"]

docker/Dockerfile.ubuntu_precise

@@ -0,0 +1,27 @@
+# Build time
+FROM ubuntu:precise as build
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+RUN apt-get -y install wget
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget --no-check-certificate https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+RUN apt-get -y install g++
+RUN apt-get -y install libssl-dev
+RUN apt-get -y install libz-dev
+RUN apt-get -y install make
+RUN apt-get -y install python
+RUN apt-get -y install git
+
+COPY . .
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+RUN ["make", "ws_no_python"]
+
+ENTRYPOINT ["ws"]
+CMD ["--help"]

docker/Dockerfile.ubuntu_trusty

@@ -0,0 +1,22 @@
+# Build time
+FROM ubuntu:trusty as build
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update
+RUN apt-get -y install wget
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget --no-check-certificate https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+RUN apt-get -y install g++ libssl-dev libz-dev make python git
+
+COPY . .
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+RUN ["make", "ws_no_python"]
+
+ENTRYPOINT ["ws"]
+CMD ["--help"]

docs/CHANGELOG.md

@@ -2,6 +2,66 @@
 
 All changes to this project will be documented in this file.
 
+## [11.0.4] - 2020-11-16
+
+(ixwebsocket) Handle EINTR return code in ix::poll and IXSelectInterrupt
+
+## [11.0.3] - 2020-11-16
+
+(ixwebsocket) Fix #252 / regression in 11.0.2 with string comparisons
+
+## [11.0.2] - 2020-11-15
+
+(ixwebsocket) use a C++11 compatible make_unique shim
+
+## [11.0.1] - 2020-11-11
+
+(socket) replace a std::vector with an std::array used as a tmp buffer in Socket::readBytes
+
+## [11.0.0] - 2020-11-11
+
+(openssl security fix) in the client to server connection, peer verification is not done in all cases. See https://github.com/machinezone/IXWebSocket/pull/250
+
+## [10.5.7] - 2020-11-07
+
+(docker) build docker container with zlib disabled
+
+## [10.5.6] - 2020-11-07
+
+(cmake) DEFLATE -> Deflate in CMake to stop warnings about casing
+
+## [10.5.5] - 2020-11-07
+
+(ws autoroute) Display result in compliant way (AUTOROUTE IXWebSocket :: N ms) so that result can be parsed easily
+
+## [10.5.4] - 2020-10-30
+
+(ws gunzip + IXGZipCodec) Can decompress gziped data with libdeflate. ws gunzip computed output filename was incorrect (was the extension aka gz) instead of the file without the extension. Also check whether the output file is writeable.
+
+## [10.5.3] - 2020-10-19
+
+(http code) With zlib disabled, some code should not be reached
+
+## [10.5.2] - 2020-10-12
+
+(ws curl) Add support for --data-binary option, to set the request body. When present the request will be sent with the POST verb
+
+## [10.5.1] - 2020-10-09
+
+(http client + server + ws) Add support for compressing http client requests with gzip. --compress_request argument is used in ws to enable this. The Content-Encoding is set to gzip, and decoded on the server side if present.
+
+## [10.5.0] - 2020-09-30
+
+(http client + server + ws) Add support for uploading files with ws -F foo=@filename, new -D http server option to debug incoming client requests, internal api changed for http POST, PUT and PATCH to supply an HttpFormDataParameters
+
+## [10.4.9] - 2020-09-30
+
+(http server + utility code) Add support for doing gzip compression with libdeflate library, if available
+
+## [10.4.8] - 2020-09-30
+
+(cmake) Stop using FetchContent cmake module to retrieve jsoncpp third party dependency
+
 ## [10.4.7] - 2020-09-28
 
 (ws) add gzip and gunzip ws sub commands

docs/usage.md

@@ -458,11 +458,18 @@ out = httpClient.get(url, args);
 // POST request with parameters
 HttpParameters httpParameters;
 httpParameters["foo"] = "bar";
-out = httpClient.post(url, httpParameters, args);
+
+// HTTP form data can be passed in as well, for multi-part upload of files
+HttpFormDataParameters httpFormDataParameters;
+httpParameters["baz"] = "booz";
+
+out = httpClient.post(url, httpParameters, httpFormDataParameters, args);
 
 // POST request with a body
 out = httpClient.post(url, std::string("foo=bar"), args);
 
+// PUT and PATCH are available too.
+
 //
 // Result
 //

ixbots/CMakeLists.txt

@@ -31,6 +31,11 @@ add_library(ixbots STATIC
     ${IXBOTS_HEADERS}
 )
 
+find_package(JsonCpp)
+if (NOT JSONCPP_FOUND)
+  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
+endif()
+
 if (USE_PYTHON)
   target_compile_definitions(ixbots PUBLIC IXBOTS_USE_PYTHON)
   find_package(Python COMPONENTS Development)
@@ -43,11 +48,12 @@ set(IXBOTS_INCLUDE_DIRS
     ../ixwebsocket
     ../ixcobra
     ../ixredis
-    ../ixsentry)
+    ../ixsentry
+    ${JSONCPP_INCLUDE_DIRS}
+    ${SPDLOG_INCLUDE_DIRS})
 
 if (USE_PYTHON)
   set(IXBOTS_INCLUDE_DIRS ${IXBOTS_INCLUDE_DIRS} ${Python_INCLUDE_DIRS})
 endif()
 
 target_include_directories( ixbots PUBLIC ${IXBOTS_INCLUDE_DIRS} )
-target_link_libraries( ixbots jsoncpp_static )

ixcobra/CMakeLists.txt

@@ -22,11 +22,16 @@ add_library(ixcobra STATIC
     ${IXCOBRA_HEADERS}
 )
 
+find_package(JsonCpp)
+if (NOT JSONCPP_FOUND)
+  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
+endif()
+
 set(IXCOBRA_INCLUDE_DIRS
     .
     ..
     ../ixcore
-    ../ixcrypto)
+    ../ixcrypto
+    ${JSONCPP_INCLUDE_DIRS})
 
 target_include_directories( ixcobra PUBLIC ${IXCOBRA_INCLUDE_DIRS} )
-target_link_libraries( ixcobra jsoncpp_static )

ixcobra/ixcobra/IXCobraConnection.cpp

@@ -14,6 +14,7 @@
 #include <ixcrypto/IXHMac.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocket.h>
+#include <ixwebsocket/IXUniquePtr.h>
 #include <sstream>
 #include <stdexcept>
 
@@ -98,7 +99,7 @@ namespace ix
         if (_eventCallback)
         {
             _eventCallback(
-                std::make_unique<CobraEvent>(eventType, errorMsg, headers, subscriptionId, msgId, connectionId));
+                ix::make_unique<CobraEvent>(eventType, errorMsg, headers, subscriptionId, msgId, connectionId));
         }
     }
 

ixredis/ixredis/IXRedisClient.h

@@ -10,6 +10,7 @@
 #include <functional>
 #include <memory>
 #include <string>
+#include <vector>
 #include <ixwebsocket/IXSocket.h>
 
 namespace ix

ixredis/ixredis/IXRedisServer.h

@@ -16,6 +16,7 @@
 #include <string>
 #include <thread>
 #include <utility> // pair
+#include <vector> // pair
 
 namespace ix
 {

ixsentry/CMakeLists.txt

@@ -16,10 +16,29 @@ add_library(ixsentry STATIC
   ${IXSENTRY_HEADERS}
 )
 
+#
+# Using try_compile or other techniques to detect std::regex
+# availability is hard, so resorting to an ugly compiler and compiler
+# version check.
+#
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9.0")
+  else()
+    target_compile_definitions( ixsentry PUBLIC HAVE_STD_REGEX=1 )
+  endif()
+else()
+  target_compile_definitions( ixsentry PUBLIC HAVE_STD_REGEX=1 )
+endif()
+
+find_package(JsonCpp)
+if (NOT JSONCPP_FOUND)
+  set(JSONCPP_INCLUDE_DIRS ../third_party/jsoncpp)
+endif()
+
 set(IXSENTRY_INCLUDE_DIRS
     .
     ..
-    ../ixcore)
+    ../ixcore
+    ${JSONCPP_INCLUDE_DIRS})
 
 target_include_directories( ixsentry PUBLIC ${IXSENTRY_INCLUDE_DIRS} )
-target_link_libraries( ixsentry jsoncpp_static )

ixsentry/ixsentry/IXSentryClient.cpp

@@ -20,9 +20,12 @@ namespace ix
     SentryClient::SentryClient(const std::string& dsn)
         : _dsn(dsn)
         , _validDsn(false)
+#ifdef HAVE_STD_REGEX
         , _luaFrameRegex("\t([^/]+):([0-9]+): in function ['<]([^/]+)['>]")
+#endif
         , _httpClient(std::make_shared<HttpClient>(true))
     {
+#ifdef HAVE_STD_REGEX
         const std::regex dsnRegex("(http[s]?)://([^:]+):([^@]+)@([^/]+)/([0-9]+)");
         std::smatch group;
 
@@ -38,6 +41,7 @@ namespace ix
             _publicKey = group.str(2);
             _secretKey = group.str(3);
         }
+#endif
     }
 
     void SentryClient::setTLSOptions(const SocketTLSOptions& tlsOptions)
@@ -77,6 +81,7 @@ namespace ix
     {
         Json::Value frames;
 
+#ifdef HAVE_STD_REGEX
         // Split by lines
         std::string line;
         std::stringstream tokenStream(stack);
@@ -107,6 +112,7 @@ namespace ix
         }
 
         std::reverse(frames.begin(), frames.end());
+#endif
 
         return frames;
     }

ixsentry/ixsentry/IXSentryClient.h

@@ -11,7 +11,9 @@
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <json/json.h>
 #include <memory>
+#ifdef HAVE_STD_REGEX
 #include <regex>
+#endif
 
 namespace ix
 {
@@ -62,7 +64,9 @@ namespace ix
 
         Json::FastWriter _jsonWriter;
 
+#ifdef HAVE_STD_REGEX
         std::regex _luaFrameRegex;
+#endif
 
         std::shared_ptr<HttpClient> _httpClient;
     };

ixsnake/ixsnake/IXSnakeProtocol.cpp

@@ -13,6 +13,7 @@
 #include <ixcore/utils/IXCoreLogger.h>
 #include <ixcrypto/IXHMac.h>
 #include <ixwebsocket/IXWebSocket.h>
+#include <ixwebsocket/IXUniquePtr.h>
 #include <sstream>
 
 namespace snake
@@ -196,7 +197,7 @@ namespace snake
         {
             std::string filterStr = pdu["body"]["filter"];
         }
-        state->streamSql = std::make_unique<StreamSql>(filterStr);
+        state->streamSql = ix::make_unique<StreamSql>(filterStr);
         state->id = 0;
         state->onRedisSubscribeCallback = [&ws, state](const std::string& messageStr) {
             auto msg = nlohmann::json::parse(messageStr);

ixwebsocket/IXBench.cpp

@@ -33,16 +33,29 @@ namespace ix
     void Bench::report()
     {
         auto now = std::chrono::high_resolution_clock::now();
-        auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(now - _start);
+        auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(now - _start);
 
-        _ms = milliseconds.count();
-        std::cerr << _description << " completed in " << _ms << "ms" << std::endl;
+        _duration = microseconds.count();
+        std::cerr << _description << " completed in " << _duration << " us" << std::endl;
 
+        setReported();
+    }
+
+    void Bench::record()
+    {
+        auto now = std::chrono::high_resolution_clock::now();
+        auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(now - _start);
+
+        _duration = microseconds.count();
+    }
+
+    void Bench::setReported()
+    {
         _reported = true;
     }
 
     uint64_t Bench::getDuration() const
     {
-        return _ms;
+        return _duration;
     }
 } // namespace ix

ixwebsocket/IXBench.h

@@ -18,13 +18,15 @@ namespace ix
         ~Bench();
 
         void reset();
+        void record();
         void report();
+        void setReported();
         uint64_t getDuration() const;
 
     private:
         std::string _description;
         std::chrono::time_point<std::chrono::high_resolution_clock> _start;
-        uint64_t _ms;
+        uint64_t _duration;
         bool _reported;
     };
 } // namespace ix

ixwebsocket/IXDNSLookup.cpp

@@ -68,6 +68,11 @@ namespace ix
                            : resolveUnCancellable(errMsg, isCancellationRequested);
     }
 
+    void DNSLookup::release(struct addrinfo* addr)
+    {
+        freeaddrinfo(addr);
+    }
+
     struct addrinfo* DNSLookup::resolveUnCancellable(
         std::string& errMsg, const CancellationRequest& isCancellationRequested)
     {

ixwebsocket/IXDNSLookup.h

@@ -31,6 +31,8 @@ namespace ix
                                  const CancellationRequest& isCancellationRequested,
                                  bool cancellable = true);
 
+        void release(struct addrinfo* addr);
+
     private:
         struct addrinfo* resolveCancellable(std::string& errMsg,
                                             const CancellationRequest& isCancellationRequested);

ixwebsocket/IXExponentialBackoff.cpp

@@ -1,5 +1,5 @@
 /*
- *  IXExponentialBackoff.h
+ *  IXExponentialBackoff.cpp
  *  Author: Benjamin Sergeant
  *  Copyright (c) 2017-2019 Machine Zone, Inc. All rights reserved.
  */

ixwebsocket/IXGzipCodec.cpp

@@ -6,6 +6,7 @@
 
 #include "IXGzipCodec.h"
 
+#include "IXBench.h"
 #include <array>
 #include <string.h>
 
@@ -13,11 +14,54 @@
 #include <zlib.h>
 #endif
 
+#ifdef IXWEBSOCKET_USE_DEFLATE
+#include <libdeflate.h>
+#endif
+
 namespace ix
 {
-#ifdef IXWEBSOCKET_USE_ZLIB
     std::string gzipCompress(const std::string& str)
     {
+#ifndef IXWEBSOCKET_USE_ZLIB
+        return std::string();
+#else
+#ifdef IXWEBSOCKET_USE_DEFLATE
+        int compressionLevel = 6;
+        struct libdeflate_compressor* compressor;
+
+        compressor = libdeflate_alloc_compressor(compressionLevel);
+
+        const void* uncompressed_data = str.data();
+        size_t uncompressed_size = str.size();
+        void* compressed_data;
+        size_t actual_compressed_size;
+        size_t max_compressed_size;
+
+        max_compressed_size = libdeflate_gzip_compress_bound(compressor, uncompressed_size);
+        compressed_data = malloc(max_compressed_size);
+
+        if (compressed_data == NULL)
+        {
+            return std::string();
+        }
+
+        actual_compressed_size = libdeflate_gzip_compress(
+            compressor, uncompressed_data, uncompressed_size, compressed_data, max_compressed_size);
+
+        libdeflate_free_compressor(compressor);
+
+        if (actual_compressed_size == 0)
+        {
+            free(compressed_data);
+            return std::string();
+        }
+
+        std::string out;
+        out.assign(reinterpret_cast<char*>(compressed_data), actual_compressed_size);
+        free(compressed_data);
+
+        return out;
+#else
         z_stream zs; // z_stream is zlib's control structure
         memset(&zs, 0, sizeof(zs));
 
@@ -57,10 +101,43 @@ namespace ix
         deflateEnd(&zs);
 
         return outstring;
+#endif // IXWEBSOCKET_USE_DEFLATE
+#endif // IXWEBSOCKET_USE_ZLIB
     }
 
+#ifdef IXWEBSOCKET_USE_DEFLATE
+    static uint32_t loadDecompressedGzipSize(const uint8_t* p)
+    {
+        return ((uint32_t) p[0] << 0) | ((uint32_t) p[1] << 8) | ((uint32_t) p[2] << 16) |
+               ((uint32_t) p[3] << 24);
+    }
+#endif
+
     bool gzipDecompress(const std::string& in, std::string& out)
     {
+#ifndef IXWEBSOCKET_USE_ZLIB
+        return false;
+#else
+#ifdef IXWEBSOCKET_USE_DEFLATE
+        struct libdeflate_decompressor* decompressor;
+        decompressor = libdeflate_alloc_decompressor();
+
+        const void* compressed_data = in.data();
+        size_t compressed_size = in.size();
+
+        // Retrieve uncompressed size from the trailer of the gziped data
+        const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&in.front());
+        auto uncompressed_size = loadDecompressedGzipSize(&ptr[compressed_size - 4]);
+
+        // Use it to redimension our output buffer
+        out.resize(uncompressed_size);
+
+        libdeflate_result result = libdeflate_gzip_decompress(
+            decompressor, compressed_data, compressed_size, &out.front(), uncompressed_size, NULL);
+
+        libdeflate_free_decompressor(decompressor);
+        return result == LIBDEFLATE_SUCCESS;
+#else
         z_stream inflateState;
         memset(&inflateState, 0, sizeof(inflateState));
 
@@ -100,6 +177,7 @@ namespace ix
 
         inflateEnd(&inflateState);
         return true;
+#endif // IXWEBSOCKET_USE_DEFLATE
+#endif // IXWEBSOCKET_USE_ZLIB
     }
-#endif
 } // namespace ix

ixwebsocket/IXHttp.cpp

@@ -7,6 +7,7 @@
 #include "IXHttp.h"
 
 #include "IXCancellationRequest.h"
+#include "IXGzipCodec.h"
 #include "IXSocket.h"
 #include <sstream>
 #include <vector>
@@ -157,6 +158,23 @@ namespace ix
             body = res.second;
         }
 
+        // If the content was compressed with gzip, decode it
+        if (headers["Content-Encoding"] == "gzip")
+        {
+#ifdef IXWEBSOCKET_USE_ZLIB
+            std::string decompressedPayload;
+            if (!gzipDecompress(body, decompressedPayload))
+            {
+                return std::make_tuple(
+                    false, std::string("Error during gzip decompression of the body"), httpRequest);
+            }
+            body = decompressedPayload;
+#else
+            std::string errorMsg("ixwebsocket was not compiled with gzip support on");
+            return std::make_tuple(false, errorMsg, httpRequest);
+#endif
+        }
+
         httpRequest = std::make_shared<HttpRequest>(uri, method, httpVersion, body, headers);
         return std::make_tuple(true, "", httpRequest);
     }

ixwebsocket/IXHttp.h

@@ -84,6 +84,7 @@ namespace ix
         int maxRedirects = 5;
         bool verbose = false;
         bool compress = true;
+        bool compressRequest = false;
         Logger logger;
         OnProgressCallback onProgressCallback;
     };

ixwebsocket/IXHttpClient.cpp

@@ -203,6 +203,15 @@ namespace ix
 
         if (verb == kPost || verb == kPut || verb == kPatch || _forceBody)
         {
+            // Set request compression header
+#ifdef IXWEBSOCKET_USE_ZLIB
+            if (args->compressRequest)
+            {
+                ss << "Content-Encoding: gzip"
+                   << "\r\n";
+            }
+#endif
+
             ss << "Content-Length: " << body.size() << "\r\n";
 
             // Set default Content-Type if unspecified
@@ -553,11 +562,42 @@ namespace ix
         return request(url, kDel, std::string(), args);
     }
 
+    HttpResponsePtr HttpClient::request(const std::string& url,
+                                        const std::string& verb,
+                                        const HttpParameters& httpParameters,
+                                        const HttpFormDataParameters& httpFormDataParameters,
+                                        HttpRequestArgsPtr args)
+    {
+        std::string body;
+
+        if (httpFormDataParameters.empty())
+        {
+            body = serializeHttpParameters(httpParameters);
+        }
+        else
+        {
+            std::string multipartBoundary = generateMultipartBoundary();
+            args->multipartBoundary = multipartBoundary;
+            body = serializeHttpFormDataParameters(
+                multipartBoundary, httpFormDataParameters, httpParameters);
+        }
+
+#ifdef IXWEBSOCKET_USE_ZLIB
+        if (args->compressRequest)
+        {
+            body = gzipCompress(body);
+        }
+#endif
+
+        return request(url, verb, body, args);
+    }
+
     HttpResponsePtr HttpClient::post(const std::string& url,
                                      const HttpParameters& httpParameters,
+                                     const HttpFormDataParameters& httpFormDataParameters,
                                      HttpRequestArgsPtr args)
     {
-        return request(url, kPost, serializeHttpParameters(httpParameters), args);
+        return request(url, kPost, httpParameters, httpFormDataParameters, args);
     }
 
     HttpResponsePtr HttpClient::post(const std::string& url,
@@ -569,9 +609,10 @@ namespace ix
 
     HttpResponsePtr HttpClient::put(const std::string& url,
                                     const HttpParameters& httpParameters,
+                                    const HttpFormDataParameters& httpFormDataParameters,
                                     HttpRequestArgsPtr args)
     {
-        return request(url, kPut, serializeHttpParameters(httpParameters), args);
+        return request(url, kPut, httpParameters, httpFormDataParameters, args);
     }
 
     HttpResponsePtr HttpClient::put(const std::string& url,
@@ -583,9 +624,10 @@ namespace ix
 
     HttpResponsePtr HttpClient::patch(const std::string& url,
                                       const HttpParameters& httpParameters,
+                                      const HttpFormDataParameters& httpFormDataParameters,
                                       HttpRequestArgsPtr args)
     {
-        return request(url, kPatch, serializeHttpParameters(httpParameters), args);
+        return request(url, kPatch, httpParameters, httpFormDataParameters, args);
     }
 
     HttpResponsePtr HttpClient::patch(const std::string& url,

ixwebsocket/IXHttpClient.h

@@ -34,6 +34,7 @@ namespace ix
 
         HttpResponsePtr post(const std::string& url,
                              const HttpParameters& httpParameters,
+                             const HttpFormDataParameters& httpFormDataParameters,
                              HttpRequestArgsPtr args);
         HttpResponsePtr post(const std::string& url,
                              const std::string& body,
@@ -41,6 +42,7 @@ namespace ix
 
         HttpResponsePtr put(const std::string& url,
                             const HttpParameters& httpParameters,
+                            const HttpFormDataParameters& httpFormDataParameters,
                             HttpRequestArgsPtr args);
         HttpResponsePtr put(const std::string& url,
                             const std::string& body,
@@ -48,6 +50,7 @@ namespace ix
 
         HttpResponsePtr patch(const std::string& url,
                               const HttpParameters& httpParameters,
+                              const HttpFormDataParameters& httpFormDataParameters,
                               HttpRequestArgsPtr args);
         HttpResponsePtr patch(const std::string& url,
                               const std::string& body,
@@ -58,7 +61,15 @@ namespace ix
                                 const std::string& body,
                                 HttpRequestArgsPtr args,
                                 int redirects = 0);
+
+        HttpResponsePtr request(const std::string& url,
+                                const std::string& verb,
+                                const HttpParameters& httpParameters,
+                                const HttpFormDataParameters& httpFormDataParameters,
+                                HttpRequestArgsPtr args);
+
         void setForceBody(bool value);
+
         // Async API
         HttpRequestArgsPtr createRequest(const std::string& url = std::string(),
                                          const std::string& verb = HttpClient::kGet);

ixwebsocket/IXHttpServer.cpp

@@ -190,4 +190,40 @@ namespace ix
                     301, "OK", HttpErrorCode::Ok, headers, std::string());
             });
     }
+
+    //
+    // Display the client parameter and body on the console
+    //
+    void HttpServer::makeDebugServer()
+    {
+        setOnConnectionCallback(
+            [this](HttpRequestPtr request,
+                   std::shared_ptr<ConnectionState> connectionState) -> HttpResponsePtr {
+                WebSocketHttpHeaders headers;
+                headers["Server"] = userAgent();
+
+                // Log request
+                std::stringstream ss;
+                ss << connectionState->getRemoteIp() << ":" << connectionState->getRemotePort()
+                   << " " << request->method << " " << request->headers["User-Agent"] << " "
+                   << request->uri;
+                logInfo(ss.str());
+
+                logInfo("== Headers == ");
+                for (auto&& it : request->headers)
+                {
+                    std::ostringstream oss;
+                    oss << it.first << ": " << it.second;
+                    logInfo(oss.str());
+                }
+                logInfo("");
+
+                logInfo("== Body == ");
+                logInfo(request->body);
+                logInfo("");
+
+                return std::make_shared<HttpResponse>(
+                    200, "OK", HttpErrorCode::Ok, headers, std::string("OK"));
+            });
+    }
 } // namespace ix

ixwebsocket/IXHttpServer.h

@@ -38,6 +38,8 @@ namespace ix
 
         void makeRedirectServer(const std::string& redirectUrl);
 
+        void makeDebugServer();
+
     private:
         // Member variables
         OnConnectionCallback _onConnectionCallback;

ixwebsocket/IXNetSystem.cpp

@@ -105,7 +105,22 @@ namespace ix
 
         return ret;
 #else
-        return ::poll(fds, nfds, timeout);
+        //
+        // It was reported that on Android poll can fail and return -1 with
+        // errno == EINTR, which should be a temp error and should typically
+        // be handled by retrying in a loop.
+        // Maybe we need to put all syscall / C functions in
+        // a new IXSysCalls.cpp and wrap them all.
+        //
+        // The style from libuv is as such.
+        //
+        int ret = -1;
+        do
+        {
+            ret = ::poll(fds, nfds, timeout);
+        } while (ret == -1 && errno == EINTR);
+
+        return ret;
 #endif
     }
 

ixwebsocket/IXSelectInterruptFactory.cpp

@@ -6,6 +6,7 @@
 
 #include "IXSelectInterruptFactory.h"
 
+#include "IXUniquePtr.h"
 #if defined(__linux__) || defined(__APPLE__)
 #include "IXSelectInterruptPipe.h"
 #else
@@ -17,9 +18,9 @@ namespace ix
     SelectInterruptPtr createSelectInterrupt()
     {
 #if defined(__linux__) || defined(__APPLE__)
-        return std::make_unique<SelectInterruptPipe>();
+        return ix::make_unique<SelectInterruptPipe>();
 #else
-        return std::make_unique<SelectInterrupt>();
+        return ix::make_unique<SelectInterrupt>();
 #endif
     }
 } // namespace ix

ixwebsocket/IXSelectInterruptPipe.cpp

@@ -117,8 +117,14 @@ namespace ix
         int fd = _fildes[kPipeWriteIndex];
         if (fd == -1) return false;
 
+        ssize_t ret = -1;
+        do
+        {
+            ret = ::write(fd, &value, sizeof(value));
+        } while (ret == -1 && errno == EINTR);
+
         // we should write 8 bytes for an uint64_t
-        return write(fd, &value, sizeof(value)) == 8;
+        return ret == 8;
     }
 
     // TODO: return max uint64_t for errors ?
@@ -129,7 +135,12 @@ namespace ix
         int fd = _fildes[kPipeReadIndex];
 
         uint64_t value = 0;
-        ::read(fd, &value, sizeof(value));
+
+        ssize_t ret = -1;
+        do
+        {
+            ret = ::read(fd, &value, sizeof(value));
+        } while (ret == -1 && errno == EINTR);
 
         return value;
     }

ixwebsocket/IXSocket.cpp

@@ -11,6 +11,7 @@
 #include "IXSelectInterruptFactory.h"
 #include "IXSocketConnect.h"
 #include <algorithm>
+#include <array>
 #include <assert.h>
 #include <fcntl.h>
 #include <stdint.h>
@@ -18,6 +19,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
+#include <vector>
 
 #ifdef min
 #undef min
@@ -27,7 +29,6 @@ namespace ix
 {
     const int Socket::kDefaultPollNoTimeout = -1; // No poll timeout by default
     const int Socket::kDefaultPollTimeout = kDefaultPollNoTimeout;
-    constexpr size_t Socket::kChunkSize;
 
     Socket::Socket(int fd)
         : _sockfd(fd)
@@ -364,10 +365,7 @@ namespace ix
         const OnProgressCallback& onProgressCallback,
         const CancellationRequest& isCancellationRequested)
     {
-        if (_readBuffer.empty())
-        {
-            _readBuffer.resize(kChunkSize);
-        }
+        std::array<uint8_t, 1 << 14> readBuffer;
 
         std::vector<uint8_t> output;
         while (output.size() != length)
@@ -378,12 +376,12 @@ namespace ix
                 return std::make_pair(false, errorMsg);
             }
 
-            size_t size = std::min(kChunkSize, length - output.size());
-            ssize_t ret = recv((char*) &_readBuffer[0], size);
+            size_t size = std::min(readBuffer.size(), length - output.size());
+            ssize_t ret = recv((char*) &readBuffer[0], size);
 
             if (ret > 0)
             {
-                output.insert(output.end(), _readBuffer.begin(), _readBuffer.begin() + ret);
+                output.insert(output.end(), readBuffer.begin(), readBuffer.begin() + ret);
             }
             else if (ret <= 0 && !Socket::isWaitNeeded())
             {

ixwebsocket/IXSocket.h

@@ -11,7 +11,6 @@
 #include <memory>
 #include <mutex>
 #include <string>
-#include <vector>
 
 #ifdef _WIN32
 #include <BaseTsd.h>
@@ -102,10 +101,6 @@ namespace ix
         static const int kDefaultPollTimeout;
         static const int kDefaultPollNoTimeout;
 
-        // Buffer for reading from our socket. That buffer is never resized.
-        std::vector<uint8_t> _readBuffer;
-        static constexpr size_t kChunkSize = 1 << 15;
-
         SelectInterruptPtr _selectInterrupt;
     };
 } // namespace ix

ixwebsocket/IXSocketConnect.cpp

@@ -10,6 +10,7 @@
 #include "IXNetSystem.h"
 #include "IXSelectInterrupt.h"
 #include "IXSocket.h"
+#include "IXUniquePtr.h"
 #include <fcntl.h>
 #include <string.h>
 #include <sys/types.h>
@@ -65,7 +66,7 @@ namespace ix
 
             int timeoutMs = 10;
             bool readyToRead = false;
-            auto selectInterrupt = std::make_unique<SelectInterrupt>();
+            auto selectInterrupt = ix::make_unique<SelectInterrupt>();
             PollResultType pollResult = Socket::poll(readyToRead, timeoutMs, fd, selectInterrupt);
 
             if (pollResult == PollResultType::Timeout)

ixwebsocket/IXSocketFactory.cpp

@@ -6,6 +6,7 @@
 
 #include "IXSocketFactory.h"
 
+#include "IXUniquePtr.h"
 #ifdef IXWEBSOCKET_USE_TLS
 
 #ifdef IXWEBSOCKET_USE_MBED_TLS
@@ -35,17 +36,17 @@ namespace ix
 
         if (!tls)
         {
-            socket = std::make_unique<Socket>(fd);
+            socket = ix::make_unique<Socket>(fd);
         }
         else
         {
 #ifdef IXWEBSOCKET_USE_TLS
 #if defined(IXWEBSOCKET_USE_MBED_TLS)
-            socket = std::make_unique<SocketMbedTLS>(tlsOptions, fd);
+            socket = ix::make_unique<SocketMbedTLS>(tlsOptions, fd);
 #elif defined(IXWEBSOCKET_USE_OPEN_SSL)
-            socket = std::make_unique<SocketOpenSSL>(tlsOptions, fd);
+            socket = ix::make_unique<SocketOpenSSL>(tlsOptions, fd);
 #elif defined(__APPLE__)
-            socket = std::make_unique<SocketAppleSSL>(tlsOptions, fd);
+            socket = ix::make_unique<SocketAppleSSL>(tlsOptions, fd);
 #endif
 #else
             errorMsg = "TLS support is not enabled on this platform.";

ixwebsocket/IXSocketOpenSSL.cpp

@@ -10,8 +10,10 @@
 #include "IXSocketOpenSSL.h"
 
 #include "IXSocketConnect.h"
+#include "IXUniquePtr.h"
 #include <cassert>
 #include <errno.h>
+#include <vector>
 #ifdef _WIN32
 #include <Shlwapi.h>
 #else
@@ -85,8 +87,7 @@ 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());
+    std::vector<std::unique_ptr<std::mutex>> openSSLMutexes;
 
     SocketOpenSSL::SocketOpenSSL(const SocketTLSOptions& tlsOptions, int fd)
         : Socket(fd)
@@ -111,6 +112,11 @@ namespace ix
 
         if (CRYPTO_get_locking_callback() == nullptr)
         {
+            openSSLMutexes.clear();
+            for (int i = 0; i < CRYPTO_num_locks(); ++i)
+            {
+                openSSLMutexes.push_back(ix::make_unique<std::mutex>());
+            }
             CRYPTO_set_locking_callback(SocketOpenSSL::openSSLLockingCallback);
         }
 #endif
@@ -128,11 +134,11 @@ namespace ix
     {
         if (mode & CRYPTO_LOCK)
         {
-            _openSSLMutexes[type].lock();
+            openSSLMutexes[type]->lock();
         }
         else
         {
-            _openSSLMutexes[type].unlock();
+            openSSLMutexes[type]->unlock();
         }
     }
 
@@ -503,14 +509,13 @@ namespace ix
                         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);
                 }
             }
+
+            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
         {

ixwebsocket/IXSocketOpenSSL.h

@@ -61,7 +61,6 @@ namespace ix
 
         static std::once_flag _openSSLInitFlag;
         static std::atomic<bool> _openSSLInitializationSuccessful;
-        static std::unique_ptr<std::mutex[]> _openSSLMutexes;
     };
 
 } // namespace ix

ixwebsocket/IXStrCaseCompare.cpp

@@ -0,0 +1,37 @@
+/*
+ *  IXStrCaseCompare.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone. All rights reserved.
+ */
+
+#include "IXStrCaseCompare.h"
+
+#include <algorithm>
+#include <locale>
+
+namespace ix
+{
+    bool CaseInsensitiveLess::NocaseCompare::operator()(const unsigned char& c1,
+                                                        const unsigned char& c2) const
+    {
+#ifdef _WIN32
+        return std::tolower(c1, std::locale()) < std::tolower(c2, std::locale());
+#else
+        return std::tolower(c1) < std::tolower(c2);
+#endif
+    }
+
+    bool CaseInsensitiveLess::cmp(const std::string& s1, const std::string& s2)
+    {
+        return std::lexicographical_compare(s1.begin(),
+                                            s1.end(), // source range
+                                            s2.begin(),
+                                            s2.end(),         // dest range
+                                            NocaseCompare()); // comparison
+    }
+
+    bool CaseInsensitiveLess::operator()(const std::string& s1, const std::string& s2) const
+    {
+        return CaseInsensitiveLess::cmp(s1, s2);
+    }
+} // namespace ix

ixwebsocket/IXStrCaseCompare.h

@@ -0,0 +1,25 @@
+/*
+ *  IXStrCaseCompare.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone. All rights reserved.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ix
+{
+    struct CaseInsensitiveLess
+    {
+        // Case Insensitive compare_less binary function
+        struct NocaseCompare
+        {
+            bool operator()(const unsigned char& c1, const unsigned char& c2) const;
+        };
+
+        static bool cmp(const std::string& s1, const std::string& s2);
+
+        bool operator()(const std::string& s1, const std::string& s2) const;
+    };
+} // namespace ix

ixwebsocket/IXUniquePtr.h

@@ -0,0 +1,18 @@
+/*
+ *  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)...));
+    }
+} // namespace ix

ixwebsocket/IXWebSocket.cpp

@@ -8,6 +8,7 @@
 
 #include "IXExponentialBackoff.h"
 #include "IXSetThreadName.h"
+#include "IXUniquePtr.h"
 #include "IXUtf8Validator.h"
 #include "IXWebSocketHandshake.h"
 #include <cassert>
@@ -34,12 +35,12 @@ namespace ix
         _ws.setOnCloseCallback(
             [this](uint16_t code, const std::string& reason, size_t wireSize, bool remote) {
                 _onMessageCallback(
-                    std::make_unique<WebSocketMessage>(WebSocketMessageType::Close,
-                                                       "",
-                                                       wireSize,
-                                                       WebSocketErrorInfo(),
-                                                       WebSocketOpenInfo(),
-                                                       WebSocketCloseInfo(code, reason, remote)));
+                    ix::make_unique<WebSocketMessage>(WebSocketMessageType::Close,
+                                                      "",
+                                                      wireSize,
+                                                      WebSocketErrorInfo(),
+                                                      WebSocketOpenInfo(),
+                                                      WebSocketCloseInfo(code, reason, remote)));
             });
     }
 
@@ -195,7 +196,7 @@ namespace ix
             return status;
         }
 
-        _onMessageCallback(std::make_unique<WebSocketMessage>(
+        _onMessageCallback(ix::make_unique<WebSocketMessage>(
             WebSocketMessageType::Open,
             "",
             0,
@@ -227,12 +228,12 @@ namespace ix
         }
 
         _onMessageCallback(
-            std::make_unique<WebSocketMessage>(WebSocketMessageType::Open,
-                                               "",
-                                               0,
-                                               WebSocketErrorInfo(),
-                                               WebSocketOpenInfo(status.uri, status.headers),
-                                               WebSocketCloseInfo()));
+            ix::make_unique<WebSocketMessage>(WebSocketMessageType::Open,
+                                              "",
+                                              0,
+                                              WebSocketErrorInfo(),
+                                              WebSocketOpenInfo(status.uri, status.headers),
+                                              WebSocketCloseInfo()));
 
         if (_pingIntervalSecs > 0)
         {
@@ -312,12 +313,12 @@ namespace ix
                 connectErr.reason = status.errorStr;
                 connectErr.http_status = status.http_status;
 
-                _onMessageCallback(std::make_unique<WebSocketMessage>(WebSocketMessageType::Error,
-                                                                      "",
-                                                                      0,
-                                                                      connectErr,
-                                                                      WebSocketOpenInfo(),
-                                                                      WebSocketCloseInfo()));
+                _onMessageCallback(ix::make_unique<WebSocketMessage>(WebSocketMessageType::Error,
+                                                                     "",
+                                                                     0,
+                                                                     connectErr,
+                                                                     WebSocketOpenInfo(),
+                                                                     WebSocketCloseInfo()));
             }
         }
     }
@@ -388,13 +389,13 @@ namespace ix
 
                     bool binary = messageKind == WebSocketTransport::MessageKind::MSG_BINARY;
 
-                    _onMessageCallback(std::make_unique<WebSocketMessage>(webSocketMessageType,
-                                                                          msg,
-                                                                          wireSize,
-                                                                          webSocketErrorInfo,
-                                                                          WebSocketOpenInfo(),
-                                                                          WebSocketCloseInfo(),
-                                                                          binary));
+                    _onMessageCallback(ix::make_unique<WebSocketMessage>(webSocketMessageType,
+                                                                         msg,
+                                                                         wireSize,
+                                                                         webSocketErrorInfo,
+                                                                         WebSocketOpenInfo(),
+                                                                         WebSocketCloseInfo(),
+                                                                         binary));
 
                     WebSocket::invokeTrafficTrackerCallback(wireSize, true);
                 });

ixwebsocket/IXWebSocketHandshake.cpp

@@ -8,6 +8,7 @@
 
 #include "IXHttp.h"
 #include "IXSocketConnect.h"
+#include "IXStrCaseCompare.h"
 #include "IXUrlParser.h"
 #include "IXUserAgent.h"
 #include "IXWebSocketHandshakeKeyGen.h"
@@ -35,9 +36,7 @@ namespace ix
 
     bool WebSocketHandshake::insensitiveStringCompare(const std::string& a, const std::string& b)
     {
-        return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](char a, char b) {
-            return tolower(a) == tolower(b);
-        });
+        return CaseInsensitiveLess::cmp(a, b) == 0;
     }
 
     std::string WebSocketHandshake::genRandomString(const int len)

ixwebsocket/IXWebSocketHttpHeaders.cpp

@@ -12,25 +12,6 @@
 
 namespace ix
 {
-    bool CaseInsensitiveLess::NocaseCompare::operator()(const unsigned char& c1,
-                                                        const unsigned char& c2) const
-    {
-#ifdef _WIN32
-        return std::tolower(c1, std::locale()) < std::tolower(c2, std::locale());
-#else
-        return std::tolower(c1) < std::tolower(c2);
-#endif
-    }
-
-    bool CaseInsensitiveLess::operator()(const std::string& s1, const std::string& s2) const
-    {
-        return std::lexicographical_compare(s1.begin(),
-                                            s1.end(), // source range
-                                            s2.begin(),
-                                            s2.end(),         // dest range
-                                            NocaseCompare()); // comparison
-    }
-
     std::pair<bool, WebSocketHttpHeaders> parseHttpHeaders(
         std::unique_ptr<Socket>& socket, const CancellationRequest& isCancellationRequested)
     {

ixwebsocket/IXWebSocketHttpHeaders.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include "IXCancellationRequest.h"
+#include "IXStrCaseCompare.h"
 #include <map>
 #include <memory>
 #include <string>
@@ -15,17 +16,6 @@ namespace ix
 {
     class Socket;
 
-    struct CaseInsensitiveLess
-    {
-        // Case Insensitive compare_less binary function
-        struct NocaseCompare
-        {
-            bool operator()(const unsigned char& c1, const unsigned char& c2) const;
-        };
-
-        bool operator()(const std::string& s1, const std::string& s2) const;
-    };
-
     using WebSocketHttpHeaders = std::map<std::string, std::string, CaseInsensitiveLess>;
 
     std::pair<bool, WebSocketHttpHeaders> parseHttpHeaders(

ixwebsocket/IXWebSocketPerMessageDeflate.cpp

@@ -48,14 +48,15 @@
 
 #include "IXWebSocketPerMessageDeflate.h"
 
+#include "IXUniquePtr.h"
 #include "IXWebSocketPerMessageDeflateCodec.h"
 #include "IXWebSocketPerMessageDeflateOptions.h"
 
 namespace ix
 {
     WebSocketPerMessageDeflate::WebSocketPerMessageDeflate()
-        : _compressor(std::make_unique<WebSocketPerMessageDeflateCompressor>())
-        , _decompressor(std::make_unique<WebSocketPerMessageDeflateDecompressor>())
+        : _compressor(ix::make_unique<WebSocketPerMessageDeflateCompressor>())
+        , _decompressor(ix::make_unique<WebSocketPerMessageDeflateDecompressor>())
     {
         ;
     }

ixwebsocket/IXWebSocketTransport.cpp

@@ -36,6 +36,7 @@
 
 #include "IXSocketFactory.h"
 #include "IXSocketTLSOptions.h"
+#include "IXUniquePtr.h"
 #include "IXUrlParser.h"
 #include "IXUtf8Validator.h"
 #include "IXWebSocketHandshake.h"
@@ -124,7 +125,7 @@ namespace ix
             std::string errorMsg;
             bool tls = protocol == "wss";
             _socket = createSocket(tls, -1, errorMsg, _socketTLSOptions);
-            _perMessageDeflate = std::make_unique<WebSocketPerMessageDeflate>();
+            _perMessageDeflate = ix::make_unique<WebSocketPerMessageDeflate>();
 
             if (!_socket)
             {
@@ -177,7 +178,7 @@ namespace ix
         _blockingSend = true;
 
         _socket = std::move(socket);
-        _perMessageDeflate = std::make_unique<WebSocketPerMessageDeflate>();
+        _perMessageDeflate = ix::make_unique<WebSocketPerMessageDeflate>();
 
         WebSocketHandshake webSocketHandshake(_requestInitCancellation,
                                               _socket,

ixwebsocket/IXWebSocketVersion.h

@@ -6,4 +6,4 @@
 
 #pragma once
 
-#define IX_WEBSOCKET_VERSION "10.4.7"
+#define IX_WEBSOCKET_VERSION "11.0.4"

makefile

@@ -28,11 +28,14 @@ brew:
 # 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_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; ninja install)
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_ZLIB=OFF -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_MBED_TLS=1 .. ; ninja install)
 
 ws:
 	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. && ninja install)
 
+ws_unity:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_UNITY_BUILD=ON -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. && ninja install)
+
 ws_install:
 	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 .. -DUSE_TEST=0 && ninja install)
 
@@ -49,7 +52,7 @@ ws_no_ssl:
 	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_WS=1 .. ; make -j 4)
 
 ws_no_python:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 .. ; ninja install)
+	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=MinSizeRel -DUSE_TLS=1 -DUSE_WS=1 .. ; make -j4 install)
 
 uninstall:
 	xargs rm -fv < build/install_manifest.txt
@@ -107,71 +110,30 @@ format:
 test_server:
 	(cd test && npm i ws && node broadcast-server.js)
 
-# env TEST=Websocket_server make test
-# env TEST=Websocket_chat make test
-# env TEST=heartbeat make test
-build_test:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_TLS=1 -DUSE_TEST=1 .. ; ninja install)
+test:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 ..)
+	(cd build ; ninja)
+	(cd build ; ninja test)
 
-test: build_test
-	(cd test ; python2.7 run.py -r)
-
-test_make:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_WS=1 -DUSE_TEST=1 .. ; make -j 4)
-	(cd test ; python2.7 run.py -r)
-
-test_tsan:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
-	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
-	(cd test ; python2.7 run.py -r)
-
-test_ubsan:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
-	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
-	(cd test ; python2.7 run.py -r)
-
-test_asan: build_test_asan
-	(cd test ; python2.7 run.py -r)
-
-build_test_asan:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableAddressSanitizer YES)
-	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
-
-test_tsan_openssl:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
-	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
-	(cd test ; python2.7 run.py -r)
-
-test_ubsan_openssl:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableUndefinedBehaviorSanitizer YES)
-	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
-	(cd test ; python2.7 run.py -r)
-
-test_tsan_openssl_release:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Release -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_OPEN_SSL=1 .. && xcodebuild -project ixwebsocket.xcodeproj -configuration Release -target ixwebsocket_unittest -enableThreadSanitizer YES)
-	(cd build/test ; ln -sf Release/ixwebsocket_unittest)
-	(cd test ; python2.7 run.py -r)
+test_asan:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 .. -DCMAKE_C_FLAGS="-fsanitize=address -fno-omit-frame-pointer" -DCMAKE_CXX_FLAGS="-fsanitize=address -fno-omit-frame-pointer")
+	(cd build ; ninja)
+	(cd build ; ctest -V .)
 
 test_tsan_mbedtls:
-	mkdir -p build && (cd build && cmake -GXcode -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_TEST=1 -DUSE_MBED_TLS=1 .. && xcodebuild -project ixwebsocket.xcodeproj -target ixwebsocket_unittest -enableThreadSanitizer YES)
-	(cd build/test ; ln -sf Debug/ixwebsocket_unittest)
-	(cd test ; python2.7 run.py -r)
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_MBED_TLS=1 -DUSE_TEST=1 .. -DCMAKE_C_FLAGS="-fsanitize=thread -fno-omit-frame-pointer" -DCMAKE_CXX_FLAGS="-fsanitize=thread -fno-omit-frame-pointer")
+	(cd build ; ninja)
+	(cd build ; ninja test)
 
-build_test_openssl:
-	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_OPEN_SSL=1 -DUSE_TEST=1 .. ; ninja install)
+test_tsan_openssl:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_OPENS_SSL=1 -DUSE_TEST=1 .. -DCMAKE_C_FLAGS="-fsanitize=thread -fno-omit-frame-pointer" -DCMAKE_CXX_FLAGS="-fsanitize=thread -fno-omit-frame-pointer")
+	(cd build ; ninja)
+	(cd build ; ninja test)
 
-test_openssl: build_test_openssl
-	(cd test ; python2.7 run.py -r)
-
-build_test_mbedtls:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_MBED_TLS=1 -DUSE_TEST=1 .. ; make -j 4)
-
-test_mbedtls: build_test_mbedtls
-	(cd test ; python2.7 run.py -r)
-
-test_no_ssl:
-	mkdir -p build && (cd build ; cmake -DCMAKE_BUILD_TYPE=Debug -DUSE_TEST=1 .. ; make -j 4)
-	(cd test ; python2.7 run.py -r)
+test_tsan_sectransport:
+	mkdir -p build && (cd build ; cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DUSE_PYTHON=1 -DUSE_TLS=1 -DUSE_OPENS_SSL=1 -DUSE_TEST=1 .. -DCMAKE_C_FLAGS="-fsanitize=thread -fno-omit-frame-pointer" -DCMAKE_CXX_FLAGS="-fsanitize=thread -fno-omit-frame-pointer")
+	(cd build ; ninja)
+	(cd build ; ninja test)
 
 ws_test: ws
 	(cd ws ; env DEBUG=1 PATH=../ws/build:$$PATH bash test_ws.sh)
@@ -247,6 +209,9 @@ doc:
 change: format
 	vim ixwebsocket/IXWebSocketVersion.h docs/CHANGELOG.md
 
+change_no_format:
+	vim ixwebsocket/IXWebSocketVersion.h docs/CHANGELOG.md
+
 commit:
 	git commit -am "`sh tools/extract_latest_change.sh`"
 

test/CMakeLists.txt

@@ -5,53 +5,41 @@
 cmake_minimum_required (VERSION 3.14)
 project (ixwebsocket_unittest)
 
-set (CMAKE_CXX_STANDARD 14)
+set (CMAKE_CXX_STANDARD 11)
 
 option(USE_TLS "Add TLS support" ON)
 
-include_directories(
-  ${PROJECT_SOURCE_DIR}/Catch2/single_include
-  ../third_party
-  ../third_party/msgpack11
-  ../ws
-)
-
 # Shared sources
-set (SOURCES
-  test_runner.cpp
-  IXTest.cpp
-  ../third_party/msgpack11/msgpack11.cpp
-
-  IXSocketTest.cpp
-  IXSocketConnectTest.cpp
-  # IXWebSocketLeakTest.cpp # commented until we have a fix for #224
-  IXWebSocketServerTest.cpp
-  IXWebSocketTestConnectionDisconnection.cpp
-  IXUrlParserTest.cpp
-  IXWebSocketServerTest.cpp
-  IXHttpClientTest.cpp
-  IXHttpServerTest.cpp
-  IXUnityBuildsTest.cpp
-  IXHttpTest.cpp
-  IXDNSLookupTest.cpp
-  IXWebSocketSubProtocolTest.cpp
-  IXSentryClientTest.cpp
-  IXWebSocketChatTest.cpp
-  IXWebSocketBroadcastTest.cpp
-  IXWebSocketPerMessageDeflateCompressorTest.cpp
-  IXStreamSqlTest.cpp
+set (TEST_TARGET_NAMES
+  IXSocketTest
+  IXSocketConnectTest
+  IXWebSocketServerTest
+  IXWebSocketTestConnectionDisconnection
+  IXUrlParserTest
+  IXHttpClientTest
+  IXHttpServerTest
+  IXUnityBuildsTest
+  IXHttpTest
+  IXDNSLookupTest
+  IXWebSocketSubProtocolTest
+  IXSentryClientTest
+  IXWebSocketChatTest
+  IXWebSocketBroadcastTest
+  IXWebSocketPerMessageDeflateCompressorTest
+  IXStreamSqlTest
+  IXStrCaseCompareTest
 )
 
 # Some unittest don't work on windows yet
 # Windows without TLS does not have hmac yet
 if (UNIX)
-  list(APPEND SOURCES
-    IXWebSocketCloseTest.cpp
-    IXCobraChatTest.cpp
-    IXCobraMetricsPublisherTest.cpp
-    IXCobraToSentryBotTest.cpp
-    IXCobraToStatsdBotTest.cpp
-    IXCobraToStdoutBotTest.cpp
+  list(APPEND TEST_TARGET_NAMES
+    IXWebSocketCloseTest
+    IXCobraChatTest
+    IXCobraMetricsPublisherTest
+    IXCobraToSentryBotTest
+    IXCobraToStatsdBotTest
+    IXCobraToStdoutBotTest
   )
 endif()
 
@@ -59,21 +47,14 @@ endif()
 # IXWebSocketPingTest.cpp
 # IXWebSocketPingTimeoutTest.cpp
 
+# IXWebSocketLeakTest.cpp # commented until we have a fix for #224 /
+# that was was fixed but now the test does not compile
+
 # Disable tests for now that are failing or not reliable
 
-add_executable(ixwebsocket_unittest ${SOURCES})
-
-if (MAC)
-  add_sanitizers(ixwebsocket_unittest)
-endif()
-
-if (APPLE AND USE_TLS)
-  target_link_libraries(ixwebsocket_unittest "-framework foundation" "-framework security")
-endif()
-
-if (JSONCPP_FOUND)
-  target_include_directories(ixwebsocket_unittest PUBLIC ${JSONCPP_INCLUDE_DIRS})
-  target_link_libraries(ixwebsocket_unittest ${JSONCPP_LIBRARIES})
+find_package(JsonCpp)
+if (NOT JSONCPP_FOUND)
+  set(JSONCPP_SOURCES ../third_party/jsoncpp/jsoncpp.cpp)
 endif()
 
 if (USE_PYTHON)
@@ -87,20 +68,69 @@ if (USE_PYTHON)
   message("Python_LIBRARIES:${Python_LIBRARIES}")
 endif()
 
-# library with the most dependencies come first
-target_link_libraries(ixwebsocket_unittest ixbots)
-target_link_libraries(ixwebsocket_unittest ixsnake)
-target_link_libraries(ixwebsocket_unittest ixcobra)
-target_link_libraries(ixwebsocket_unittest ixsentry)
-target_link_libraries(ixwebsocket_unittest ixredis)
-target_link_libraries(ixwebsocket_unittest ixwebsocket)
-target_link_libraries(ixwebsocket_unittest ixcrypto)
-target_link_libraries(ixwebsocket_unittest ixcore)
+add_library(ixwebsocket_test)
+target_sources(ixwebsocket_test PRIVATE 
+    ${JSONCPP_SOURCES}
+    test_runner.cpp
+    IXTest.cpp
+    ../third_party/msgpack11/msgpack11.cpp
+)
+target_compile_definitions(ixwebsocket_test PRIVATE ${TEST_PROGRAMS_DEFINITIONS})
+target_include_directories(ixwebsocket_test PRIVATE
+  ${PROJECT_SOURCE_DIR}/Catch2/single_include
+  ../third_party
+)
+target_link_libraries(ixwebsocket_test ixsnake)
+target_link_libraries(ixwebsocket_test ixcobra)
+target_link_libraries(ixwebsocket_test ixwebsocket)
+target_link_libraries(ixwebsocket_test ixcrypto)
+target_link_libraries(ixwebsocket_test spdlog)
 
-target_link_libraries(ixwebsocket_unittest spdlog)
-target_link_libraries(ixwebsocket_unittest jsoncpp_static)
-if (USE_PYTHON)
-  target_link_libraries(ixwebsocket_unittest ${Python_LIBRARIES})
-endif()
+foreach(TEST_TARGET_NAME ${TEST_TARGET_NAMES})
+  add_executable(${TEST_TARGET_NAME}
+    ${TEST_TARGET_NAME}.cpp
+  )
 
-install(TARGETS ixwebsocket_unittest DESTINATION bin)
+  target_include_directories(${TEST_TARGET_NAME} PRIVATE
+    ${PROJECT_SOURCE_DIR}/Catch2/single_include
+    ../third_party
+    ../third_party/msgpack11
+  )
+
+  target_compile_definitions(${TEST_TARGET_NAME} PRIVATE SPDLOG_COMPILED_LIB=1)
+
+  if (NOT JSONCPP_FOUND)
+    target_include_directories(${TEST_TARGET_NAME} PRIVATE ../third_party/jsoncpp)
+  endif()
+
+  if (APPLE AND USE_TLS)
+    target_link_libraries(${TEST_TARGET_NAME} "-framework foundation" "-framework security")
+  endif()
+
+  # library with the most dependencies come first
+  target_link_libraries(${TEST_TARGET_NAME} ixwebsocket_test)
+  target_link_libraries(${TEST_TARGET_NAME} ixbots)
+  target_link_libraries(${TEST_TARGET_NAME} ixsnake)
+  target_link_libraries(${TEST_TARGET_NAME} ixcobra)
+  target_link_libraries(${TEST_TARGET_NAME} ixsentry)
+
+  if (JSONCPP_FOUND)
+    target_include_directories(${TEST_TARGET_NAME} PRIVATE ${JSONCPP_INCLUDE_DIRS})
+    target_link_libraries(${TEST_TARGET_NAME} ${JSONCPP_LIBRARIES})
+  endif()
+
+  target_link_libraries(${TEST_TARGET_NAME} ixredis)
+  target_link_libraries(${TEST_TARGET_NAME} ixwebsocket)
+  target_link_libraries(${TEST_TARGET_NAME} ixcrypto)
+  target_link_libraries(${TEST_TARGET_NAME} ixcore)
+
+  target_link_libraries(${TEST_TARGET_NAME} spdlog)
+  if (USE_PYTHON)
+    target_link_libraries(${TEST_TARGET_NAME} ${Python_LIBRARIES})
+  endif()
+
+  add_test(NAME ${TEST_TARGET_NAME}
+           COMMAND ${TEST_TARGET_NAME}
+           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+endforeach()

test/IXCobraToSentryBotTest.cpp

@@ -38,35 +38,6 @@ namespace
             }
         });
     }
-
-    void runPublisher(const ix::CobraConfig& config, const std::string& channel)
-    {
-        ix::CobraMetricsPublisher cobraMetricsPublisher;
-        cobraMetricsPublisher.configure(config, channel);
-        cobraMetricsPublisher.setSession(uuid4());
-        cobraMetricsPublisher.enable(true);
-
-        Json::Value msg;
-        msg["fps"] = 60;
-
-        cobraMetricsPublisher.setGenericAttributes("game", "ody");
-
-        // Wait a bit
-        ix::msleep(500);
-
-        // publish some messages
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #1)
-        cobraMetricsPublisher.push("sms_metric_B_id", msg); // (msg #2)
-        ix::msleep(500);
-
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #3)
-        cobraMetricsPublisher.push("sms_metric_D_id", msg); // (msg #4)
-        ix::msleep(500);
-
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #4)
-        cobraMetricsPublisher.push("sms_metric_F_id", msg); // (msg #5)
-        ix::msleep(500);
-    }
 } // namespace
 
 TEST_CASE("Cobra_to_sentry_bot", "[cobra_bots]")

test/IXCobraToStatsdBotTest.cpp

@@ -20,38 +20,6 @@
 
 using namespace ix;
 
-namespace
-{
-    void runPublisher(const ix::CobraConfig& config, const std::string& channel)
-    {
-        ix::CobraMetricsPublisher cobraMetricsPublisher;
-        cobraMetricsPublisher.configure(config, channel);
-        cobraMetricsPublisher.setSession(uuid4());
-        cobraMetricsPublisher.enable(true);
-
-        Json::Value msg;
-        msg["fps"] = 60;
-
-        cobraMetricsPublisher.setGenericAttributes("game", "ody");
-
-        // Wait a bit
-        ix::msleep(500);
-
-        // publish some messages
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #1)
-        cobraMetricsPublisher.push("sms_metric_B_id", msg); // (msg #2)
-        ix::msleep(500);
-
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #3)
-        cobraMetricsPublisher.push("sms_metric_D_id", msg); // (msg #4)
-        ix::msleep(500);
-
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #4)
-        cobraMetricsPublisher.push("sms_metric_F_id", msg); // (msg #5)
-        ix::msleep(500);
-    }
-} // namespace
-
 TEST_CASE("Cobra_to_statsd_bot", "[cobra_bots]")
 {
     SECTION("Exchange and count sent/received messages.")

test/IXCobraToStdoutBotTest.cpp

@@ -10,7 +10,6 @@
 #include <iostream>
 #include <ixbots/IXCobraToStdoutBot.h>
 #include <ixcobra/IXCobraConnection.h>
-#include <ixcobra/IXCobraMetricsPublisher.h>
 #include <ixcrypto/IXUuid.h>
 #include <ixredis/IXRedisServer.h>
 #include <ixsentry/IXSentryClient.h>
@@ -20,38 +19,6 @@
 
 using namespace ix;
 
-namespace
-{
-    void runPublisher(const ix::CobraConfig& config, const std::string& channel)
-    {
-        ix::CobraMetricsPublisher cobraMetricsPublisher;
-        cobraMetricsPublisher.configure(config, channel);
-        cobraMetricsPublisher.setSession(uuid4());
-        cobraMetricsPublisher.enable(true);
-
-        Json::Value msg;
-        msg["fps"] = 60;
-
-        cobraMetricsPublisher.setGenericAttributes("game", "ody");
-
-        // Wait a bit
-        ix::msleep(500);
-
-        // publish some messages
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #1)
-        cobraMetricsPublisher.push("sms_metric_B_id", msg); // (msg #2)
-        ix::msleep(500);
-
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #3)
-        cobraMetricsPublisher.push("sms_metric_D_id", msg); // (msg #4)
-        ix::msleep(500);
-
-        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #4)
-        cobraMetricsPublisher.push("sms_metric_F_id", msg); // (msg #5)
-        ix::msleep(500);
-    }
-} // namespace
-
 TEST_CASE("Cobra_to_stdout_bot", "[cobra_bots]")
 {
     SECTION("Exchange and count sent/received messages.")

test/IXDNSLookupTest.cpp

@@ -24,6 +24,8 @@ TEST_CASE("dns", "[net]")
         res = dnsLookup->resolve(errMsg, [] { return false; });
         std::cerr << "Error message: " << errMsg << std::endl;
         REQUIRE(res != nullptr);
+
+        dnsLookup->release(res);
     }
 
     SECTION("Test resolving a non-existing hostname")

test/IXStrCaseCompareTest.cpp

@@ -0,0 +1,46 @@
+/*
+ *  IXStrCaseCompareTest.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2020 Machine Zone. All rights reserved.
+ */
+
+#include "IXTest.h"
+#include "catch.hpp"
+#include <iostream>
+#include <ixwebsocket/IXUrlParser.h>
+#include <string.h>
+
+using namespace ix;
+
+namespace ix
+{
+    TEST_CASE("str_case_compare", "[str_case_compare]")
+    {
+        SECTION("1")
+        {
+            using HttpHeaders = std::map<std::string, std::string, CaseInsensitiveLess>;
+
+            HttpHeaders httpHeaders;
+
+            httpHeaders["foo"] = "foo";
+
+            REQUIRE(httpHeaders["foo"] == "foo");
+            REQUIRE(httpHeaders["missing"] == "");
+
+            // Comparison should be case insensitive
+            REQUIRE(httpHeaders["Foo"] == "foo");
+        }
+
+        SECTION("2")
+        {
+            using HttpHeaders = std::map<std::string, std::string, CaseInsensitiveLess>;
+
+            HttpHeaders headers;
+
+            headers["Upgrade"] = "webSocket";
+
+            REQUIRE(CaseInsensitiveLess::cmp(headers["upgrade"], "WebSocket") == 0);
+        }
+    }
+
+} // namespace ix

test/IXTest.cpp

@@ -10,6 +10,8 @@
 #include <fstream>
 #include <iomanip>
 #include <iostream>
+#include <ixcobra/IXCobraMetricsPublisher.h>
+#include <ixcrypto/IXUuid.h>
 #include <ixwebsocket/IXNetSystem.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <mutex>
@@ -243,4 +245,33 @@ namespace ix
 
         return endpoint;
     }
+
+    void runPublisher(const ix::CobraConfig& config, const std::string& channel)
+    {
+        ix::CobraMetricsPublisher cobraMetricsPublisher;
+        cobraMetricsPublisher.configure(config, channel);
+        cobraMetricsPublisher.setSession(uuid4());
+        cobraMetricsPublisher.enable(true);
+
+        Json::Value msg;
+        msg["fps"] = 60;
+
+        cobraMetricsPublisher.setGenericAttributes("game", "ody");
+
+        // Wait a bit
+        ix::msleep(500);
+
+        // publish some messages
+        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #1)
+        cobraMetricsPublisher.push("sms_metric_B_id", msg); // (msg #2)
+        ix::msleep(500);
+
+        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #3)
+        cobraMetricsPublisher.push("sms_metric_D_id", msg); // (msg #4)
+        ix::msleep(500);
+
+        cobraMetricsPublisher.push("sms_metric_A_id", msg); // (msg #4)
+        cobraMetricsPublisher.push("sms_metric_F_id", msg); // (msg #5)
+        ix::msleep(500);
+    }
 } // namespace ix

test/IXTest.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <iostream>
+#include <ixcobra/IXCobraConfig.h>
 #include <ixsnake/IXAppConfig.h>
 #include <ixwebsocket/IXGetFreePort.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
@@ -59,4 +60,6 @@ namespace ix
     std::string getWsScheme(bool preferTLS);
 
     std::string makeCobraEndpoint(int port, bool preferTLS);
+
+    void runPublisher(const ix::CobraConfig& config, const std::string& channel);
 } // namespace ix

test/IXWebSocketBroadcastTest.cpp

@@ -18,10 +18,10 @@ using namespace ix;
 
 namespace
 {
-    class WebSocketChat
+    class WebSocketBroadcastChat
     {
     public:
-        WebSocketChat(const std::string& user, const std::string& session, int port);
+        WebSocketBroadcastChat(const std::string& user, const std::string& session, int port);
 
         void subscribe(const std::string& channel);
         void start();
@@ -47,7 +47,9 @@ namespace
         mutable std::mutex _mutex;
     };
 
-    WebSocketChat::WebSocketChat(const std::string& user, const std::string& session, int port)
+    WebSocketBroadcastChat::WebSocketBroadcastChat(const std::string& user,
+                                                   const std::string& session,
+                                                   int port)
         : _user(user)
         , _session(session)
         , _port(port)
@@ -55,35 +57,35 @@ namespace
         _webSocket.setTLSOptions(makeClientTLSOptions());
     }
 
-    size_t WebSocketChat::getReceivedMessagesCount() const
+    size_t WebSocketBroadcastChat::getReceivedMessagesCount() const
     {
         std::lock_guard<std::mutex> lock(_mutex);
         return _receivedMessages.size();
     }
 
-    const std::vector<std::string>& WebSocketChat::getReceivedMessages() const
+    const std::vector<std::string>& WebSocketBroadcastChat::getReceivedMessages() const
     {
         std::lock_guard<std::mutex> lock(_mutex);
         return _receivedMessages;
     }
 
-    void WebSocketChat::appendMessage(const std::string& message)
+    void WebSocketBroadcastChat::appendMessage(const std::string& message)
     {
         std::lock_guard<std::mutex> lock(_mutex);
         _receivedMessages.push_back(message);
     }
 
-    bool WebSocketChat::isReady() const
+    bool WebSocketBroadcastChat::isReady() const
     {
         return _webSocket.getReadyState() == ix::ReadyState::Open;
     }
 
-    void WebSocketChat::stop()
+    void WebSocketBroadcastChat::stop()
     {
         _webSocket.stop();
     }
 
-    void WebSocketChat::start()
+    void WebSocketBroadcastChat::start()
     {
         std::string url;
         {
@@ -156,7 +158,8 @@ namespace
         _webSocket.start();
     }
 
-    std::pair<std::string, std::string> WebSocketChat::decodeMessage(const std::string& str)
+    std::pair<std::string, std::string> WebSocketBroadcastChat::decodeMessage(
+        const std::string& str)
     {
         std::string errMsg;
         MsgPack msg = MsgPack::parse(str, errMsg);
@@ -167,7 +170,7 @@ namespace
         return std::pair<std::string, std::string>(msg_user, msg_text);
     }
 
-    std::string WebSocketChat::encodeMessage(const std::string& text)
+    std::string WebSocketBroadcastChat::encodeMessage(const std::string& text)
     {
         std::map<MsgPack, MsgPack> obj;
         obj["user"] = _user;
@@ -179,7 +182,7 @@ namespace
         return output;
     }
 
-    void WebSocketChat::sendMessage(const std::string& text)
+    void WebSocketBroadcastChat::sendMessage(const std::string& text)
     {
         _webSocket.sendBinary(encodeMessage(text));
     }
@@ -248,11 +251,11 @@ TEST_CASE("Websocket_broadcast_server", "[websocket_server]")
         REQUIRE(startServer(server, connectionId));
 
         std::string session = ix::generateSessionId();
-        std::vector<std::shared_ptr<WebSocketChat>> chatClients;
+        std::vector<std::shared_ptr<WebSocketBroadcastChat>> chatClients;
         for (int i = 0; i < 10; ++i)
         {
             std::string user("user_" + std::to_string(i));
-            chatClients.push_back(std::make_shared<WebSocketChat>(user, session, port));
+            chatClients.push_back(std::make_shared<WebSocketBroadcastChat>(user, session, port));
             chatClients[i]->start();
             ix::msleep(50);
         }

third_party/jsoncpp/json/json-forwards.h

@@ -0,0 +1,316 @@
+/// Json-cpp amalgamated forward header (http://jsoncpp.sourceforge.net/).
+/// It is intended to be used with #include "json/json-forwards.h"
+/// This header provides forward declaration for all JsonCpp types.
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+/*
+The JsonCpp library's source code, including accompanying documentation,
+tests and demonstration applications, are licensed under the following
+conditions...
+
+Baptiste Lepilleur and The JsonCpp Authors explicitly disclaim copyright in all
+jurisdictions which recognize such a disclaimer. In such jurisdictions,
+this software is released into the Public Domain.
+
+In jurisdictions which do not recognize Public Domain property (e.g. Germany as of
+2010), this software is Copyright (c) 2007-2010 by Baptiste Lepilleur and
+The JsonCpp Authors, and is released under the terms of the MIT License (see below).
+
+In jurisdictions which recognize Public Domain property, the user of this
+software may choose to accept it either as 1) Public Domain, 2) under the
+conditions of the MIT License (see below), or 3) under the terms of dual
+Public Domain/MIT License conditions described here, as they choose.
+
+The MIT License is about as close to Public Domain as a license can get, and is
+described in clear, concise terms at:
+
+   http://en.wikipedia.org/wiki/MIT_License
+
+The full text of the MIT License follows:
+
+========================================================================
+Copyright (c) 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+
+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.
+========================================================================
+(END LICENSE TEXT)
+
+The MIT license is compatible with both the GPL and commercial
+software, affording one all of the rights of Public Domain with the
+minor nuisance of being required to keep the above copyright notice
+and license text in the source code. Note also that by accepting the
+Public Domain "license" you can re-license your copy using whatever
+license you like.
+
+*/
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: LICENSE
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED
+# define JSON_FORWARD_AMALGAMATED_H_INCLUDED
+/// If defined, indicates that the source file is amalgamated
+/// to prevent private header inclusion.
+#define JSON_IS_AMALGAMATION
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/config.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_CONFIG_H_INCLUDED
+#define JSON_CONFIG_H_INCLUDED
+#include <cstddef>
+#include <cstdint>
+#include <istream>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+// If non-zero, the library uses exceptions to report bad input instead of C
+// assertion macros. The default is to use exceptions.
+#ifndef JSON_USE_EXCEPTION
+#define JSON_USE_EXCEPTION 1
+#endif
+
+// Temporary, tracked for removal with issue #982.
+#ifndef JSON_USE_NULLREF
+#define JSON_USE_NULLREF 1
+#endif
+
+/// If defined, indicates that the source file is amalgamated
+/// to prevent private header inclusion.
+/// Remarks: it is automatically defined in the generated amalgamated header.
+// #define JSON_IS_AMALGAMATION
+
+// Export macros for DLL visibility
+#if defined(JSON_DLL_BUILD)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllexport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#elif defined(__GNUC__) || defined(__clang__)
+#define JSON_API __attribute__((visibility("default")))
+#endif // if defined(_MSC_VER)
+
+#elif defined(JSON_DLL)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllimport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#endif // if defined(_MSC_VER)
+#endif // ifdef JSON_DLL_BUILD
+
+#if !defined(JSON_API)
+#define JSON_API
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1800
+#error                                                                         \
+    "ERROR:  Visual Studio 12 (2013) with _MSC_VER=1800 is the oldest supported compiler with sufficient C++11 capabilities"
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+// As recommended at
+// https://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
+extern JSON_API int msvc_pre1900_c99_snprintf(char* outBuf, size_t size,
+                                              const char* format, ...);
+#define jsoncpp_snprintf msvc_pre1900_c99_snprintf
+#else
+#define jsoncpp_snprintf std::snprintf
+#endif
+
+// If JSON_NO_INT64 is defined, then Json only support C++ "int" type for
+// integer
+// Storages, and 64 bits integer support is disabled.
+// #define JSON_NO_INT64 1
+
+// JSONCPP_OVERRIDE is maintained for backwards compatibility of external tools.
+// C++11 should be used directly in JSONCPP.
+#define JSONCPP_OVERRIDE override
+
+#if __cplusplus >= 201103L
+#define JSONCPP_NOEXCEPT noexcept
+#define JSONCPP_OP_EXPLICIT explicit
+#elif defined(_MSC_VER) && _MSC_VER < 1900
+#define JSONCPP_NOEXCEPT throw()
+#define JSONCPP_OP_EXPLICIT explicit
+#elif defined(_MSC_VER) && _MSC_VER >= 1900
+#define JSONCPP_NOEXCEPT noexcept
+#define JSONCPP_OP_EXPLICIT explicit
+#else
+#define JSONCPP_NOEXCEPT throw()
+#define JSONCPP_OP_EXPLICIT
+#endif
+
+#ifdef __clang__
+#if __has_extension(attribute_deprecated_with_message)
+#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
+#endif
+#elif defined(__GNUC__) // not clang (gcc comes later since clang emulates gcc)
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5))
+#define JSONCPP_DEPRECATED(message) __attribute__((deprecated(message)))
+#elif (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+#define JSONCPP_DEPRECATED(message) __attribute__((__deprecated__))
+#endif                  // GNUC version
+#elif defined(_MSC_VER) // MSVC (after clang because clang on Windows emulates
+                        // MSVC)
+#define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#endif // __clang__ || __GNUC__ || _MSC_VER
+
+#if !defined(JSONCPP_DEPRECATED)
+#define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 6))
+#define JSON_USE_INT64_DOUBLE_CONVERSION 1
+#endif
+
+#if !defined(JSON_IS_AMALGAMATION)
+
+#include "allocator.h"
+#include "version.h"
+
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+using Int = int;
+using UInt = unsigned int;
+#if defined(JSON_NO_INT64)
+using LargestInt = int;
+using LargestUInt = unsigned int;
+#undef JSON_HAS_INT64
+#else                 // if defined(JSON_NO_INT64)
+// For Microsoft Visual use specific types as long long is not supported
+#if defined(_MSC_VER) // Microsoft Visual Studio
+using Int64 = __int64;
+using UInt64 = unsigned __int64;
+#else                 // if defined(_MSC_VER) // Other platforms, use long long
+using Int64 = int64_t;
+using UInt64 = uint64_t;
+#endif                // if defined(_MSC_VER)
+using LargestInt = Int64;
+using LargestUInt = UInt64;
+#define JSON_HAS_INT64
+#endif // if defined(JSON_NO_INT64)
+
+template <typename T>
+using Allocator =
+    typename std::conditional<JSONCPP_USING_SECURE_MEMORY, SecureAllocator<T>,
+                              std::allocator<T>>::type;
+using String = std::basic_string<char, std::char_traits<char>, Allocator<char>>;
+using IStringStream =
+    std::basic_istringstream<String::value_type, String::traits_type,
+                             String::allocator_type>;
+using OStringStream =
+    std::basic_ostringstream<String::value_type, String::traits_type,
+                             String::allocator_type>;
+using IStream = std::istream;
+using OStream = std::ostream;
+} // namespace Json
+
+// Legacy names (formerly macros).
+using JSONCPP_STRING = Json::String;
+using JSONCPP_ISTRINGSTREAM = Json::IStringStream;
+using JSONCPP_OSTRINGSTREAM = Json::OStringStream;
+using JSONCPP_ISTREAM = Json::IStream;
+using JSONCPP_OSTREAM = Json::OStream;
+
+#endif // JSON_CONFIG_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/config.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+
+// //////////////////////////////////////////////////////////////////////
+// Beginning of content of file: include/json/forwards.h
+// //////////////////////////////////////////////////////////////////////
+
+// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
+// Distributed under MIT license, or public domain if desired and
+// recognized in your jurisdiction.
+// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
+
+#ifndef JSON_FORWARDS_H_INCLUDED
+#define JSON_FORWARDS_H_INCLUDED
+
+#if !defined(JSON_IS_AMALGAMATION)
+#include "config.h"
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+
+// writer.h
+class StreamWriter;
+class StreamWriterBuilder;
+class Writer;
+class FastWriter;
+class StyledWriter;
+class StyledStreamWriter;
+
+// reader.h
+class Reader;
+class CharReader;
+class CharReaderBuilder;
+
+// json_features.h
+class Features;
+
+// value.h
+using ArrayIndex = unsigned int;
+class StaticString;
+class Path;
+class PathArgument;
+class Value;
+class ValueIteratorBase;
+class ValueIterator;
+class ValueConstIterator;
+
+} // namespace Json
+
+#endif // JSON_FORWARDS_H_INCLUDED
+
+// //////////////////////////////////////////////////////////////////////
+// End of content of file: include/json/forwards.h
+// //////////////////////////////////////////////////////////////////////
+
+
+
+
+
+#endif //ifndef JSON_FORWARD_AMALGAMATED_H_INCLUDED

ws/CMakeLists.txt

@@ -14,7 +14,7 @@ endif()
 # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
 # set(CMAKE_LD_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
 
-set (CMAKE_CXX_STANDARD 14)
+set (CMAKE_CXX_STANDARD 11)
 
 option(USE_TLS "Add TLS support" ON)
 
@@ -22,6 +22,12 @@ include_directories(ws .)
 include_directories(ws ..)
 include_directories(ws ../third_party/cpp-linenoise)
 
+find_package(JsonCpp)
+if (NOT JSONCPP_FOUND)
+  include_directories(../third_party/jsoncpp)
+  set(JSONCPP_SOURCES ../third_party/jsoncpp/jsoncpp.cpp)
+endif()
+
 if (USE_PYTHON)
   find_package(Python COMPONENTS Development)
   if (NOT Python_FOUND)
@@ -50,9 +56,13 @@ target_link_libraries(ws ixcrypto)
 target_link_libraries(ws ixcore)
 
 target_link_libraries(ws spdlog)
-target_link_libraries(ws jsoncpp_static)
 if (USE_PYTHON)
   target_link_libraries(ws ${Python_LIBRARIES})
 endif()
 
+if (JSONCPP_FOUND)
+  target_include_directories(ws PUBLIC ${JSONCPP_INCLUDE_DIRS})
+  target_link_libraries(ws ${JSONCPP_LIBRARIES})
+endif()
+
 install(TARGETS ws RUNTIME DESTINATION bin)

ws/ws.cpp

@@ -152,7 +152,7 @@ namespace
         idx = path.rfind('.');
         if (idx != std::string::npos)
         {
-            std::string filename = path.substr(idx + 1);
+            std::string filename = path.substr(0, idx);
             return filename;
         }
         else
@@ -1136,7 +1136,7 @@ namespace ix
         return 0;
     }
 
-    int ws_gzip(const std::string& filename)
+    int ws_gzip(const std::string& filename, int runCount)
     {
         auto res = readAsString(filename);
         bool found = res.first;
@@ -1146,13 +1146,30 @@ namespace ix
             return 1;
         }
 
-        spdlog::info("gzip input: {} cksum {}", filename, ix::djb2HashStr(res.second));
+        spdlog::info("gzip input: {} size {} cksum {}",
+                     filename,
+                     res.second.size(),
+                     ix::djb2HashStr(res.second));
 
         std::string compressedBytes;
 
+        spdlog::info("compressing {} times", runCount);
+        std::vector<uint64_t> durations;
         {
             Bench bench("compressing file");
-            compressedBytes = gzipCompress(res.second);
+            bench.setReported();
+
+            for (int i = 0; i < runCount; ++i)
+            {
+                bench.reset();
+                compressedBytes = gzipCompress(res.second);
+                bench.record();
+                durations.push_back(bench.getDuration());
+            }
+
+            size_t medianIdx = durations.size() / 2;
+            uint64_t medianRuntime = durations[medianIdx];
+            spdlog::info("median runtime to compress file: {}", medianRuntime);
         }
 
         std::string outputFilename(filename);
@@ -1163,7 +1180,10 @@ namespace ix
         f << compressedBytes;
         f.close();
 
-        spdlog::info("gzip output: {} cksum {}", outputFilename, ix::djb2HashStr(compressedBytes));
+        spdlog::info("gzip output: {} size {} cksum {}",
+                     outputFilename,
+                     compressedBytes.size(),
+                     ix::djb2HashStr(compressedBytes));
 
         return 0;
     }
@@ -1180,7 +1200,10 @@ namespace ix
             return 1;
         }
 
-        spdlog::info("gunzip input: {} cksum {}", filename, ix::djb2HashStr(res.second));
+        spdlog::info("gunzip input: {} size {} cksum {}",
+                     filename,
+                     res.second.size(),
+                     ix::djb2HashStr(res.second));
 
         std::string decompressedBytes;
 
@@ -1197,11 +1220,18 @@ namespace ix
 
         std::ofstream f;
         f.open(outputFilename);
+        if (!f.is_open())
+        {
+            spdlog::error("Cannot open {} for writing", outputFilename);
+            return 1;
+        }
         f << decompressedBytes;
         f.close();
 
-        spdlog::info(
-            "gunzip output: {} cksum {}", outputFilename, ix::djb2HashStr(decompressedBytes));
+        spdlog::info("gunzip output: {} size {} cksum {}",
+                     outputFilename,
+                     decompressedBytes.size(),
+                     ix::djb2HashStr(decompressedBytes));
 
         return 0;
     }
@@ -1243,11 +1273,12 @@ namespace ix
         std::condition_variable condition;
 
         std::atomic<bool> stop(false);
+        std::chrono::time_point<std::chrono::high_resolution_clock> start;
 
         // Setup a callback to be fired
         // when a message or an event (open, close, ping, pong, error) is received
         webSocket.setOnMessageCallback(
-            [&webSocket, &receivedCountPerSecs, &target, &stop, &condition, &bench](
+            [&receivedCountPerSecs, &target, &stop, &condition, &bench, &start](
                 const ix::WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Message)
                 {
@@ -1260,6 +1291,13 @@ namespace ix
                         condition.notify_one();
 
                         bench.report();
+
+                        auto now = std::chrono::high_resolution_clock::now();
+                        auto milliseconds =
+                            std::chrono::duration_cast<std::chrono::milliseconds>(now - start);
+                        auto duration = milliseconds.count();
+
+                        spdlog::info("AUTOROUTE IXWebSocket :: {} ms", duration);
                     }
                 }
                 else if (msg->type == ix::WebSocketMessageType::Open)
@@ -1273,6 +1311,8 @@ namespace ix
                     {
                         spdlog::info("{}: {}", it.first, it.second);
                     }
+
+                    start = std::chrono::high_resolution_clock::now();
                 }
                 else if (msg->type == ix::WebSocketMessageType::Pong)
                 {
@@ -1437,7 +1477,7 @@ namespace ix
     // Useful endpoint to test HTTP post
     // https://postman-echo.com/post
     //
-    HttpParameters parsePostParameters(const std::string& data)
+    HttpParameters parseHttpParameters(const std::string& data)
     {
         HttpParameters httpParameters;
 
@@ -1462,9 +1502,52 @@ namespace ix
         return httpParameters;
     }
 
+    HttpFormDataParameters parseHttpFormDataParameters(const std::string& data)
+    {
+        HttpFormDataParameters httpFormDataParameters;
+
+        // Split by \n
+        std::string token;
+        std::stringstream tokenStream(data);
+
+        while (std::getline(tokenStream, token))
+        {
+            std::size_t pos = token.rfind('=');
+
+            // Bail out if last '.' is found
+            if (pos == std::string::npos) continue;
+
+            auto key = token.substr(0, pos);
+            auto val = token.substr(pos + 1);
+
+            spdlog::info("{}: {}", key, val);
+
+            if (val[0] == '@')
+            {
+                std::string filename = token.substr(pos + 2);
+
+                auto res = readAsString(filename);
+                bool found = res.first;
+                if (!found)
+                {
+                    spdlog::error("Cannot read content of {}", filename);
+                    continue;
+                }
+
+                val = res.second;
+            }
+
+            httpFormDataParameters[key] = val;
+        }
+
+        return httpFormDataParameters;
+    }
+
     int ws_http_client_main(const std::string& url,
                             const std::string& headersData,
                             const std::string& data,
+                            const std::string& formData,
+                            const std::string& dataBinary,
                             bool headersOnly,
                             int connectTimeout,
                             int transferTimeout,
@@ -1474,6 +1557,7 @@ namespace ix
                             bool save,
                             const std::string& output,
                             bool compress,
+                            bool compressRequest,
                             const ix::SocketTLSOptions& tlsOptions)
     {
         HttpClient httpClient;
@@ -1487,6 +1571,7 @@ namespace ix
         args->maxRedirects = maxRedirects;
         args->verbose = verbose;
         args->compress = compress;
+        args->compressRequest = compressRequest;
         args->logger = [](const std::string& msg) { spdlog::info(msg); };
         args->onProgressCallback = [verbose](int current, int total) -> bool {
             if (verbose)
@@ -1496,20 +1581,30 @@ namespace ix
             return true;
         };
 
-        HttpParameters httpParameters = parsePostParameters(data);
+        HttpParameters httpParameters = parseHttpParameters(data);
+        HttpFormDataParameters httpFormDataParameters = parseHttpFormDataParameters(formData);
 
         HttpResponsePtr response;
         if (headersOnly)
         {
             response = httpClient.head(url, args);
         }
-        else if (data.empty())
+        else if (data.empty() && formData.empty() && dataBinary.empty())
         {
             response = httpClient.get(url, args);
         }
+        else if (!dataBinary.empty())
+        {
+            std::string body = dataBinary;
+            if (compressRequest)
+            {
+                body = gzipCompress(dataBinary);
+            }
+            response = httpClient.request(url, "POST", body, args, 0);
+        }
         else
         {
-            response = httpClient.post(url, httpParameters, args);
+            response = httpClient.post(url, httpParameters, httpFormDataParameters, args);
         }
 
         spdlog::info("");
@@ -1566,6 +1661,7 @@ namespace ix
                       const std::string& hostname,
                       bool redirect,
                       const std::string& redirectUrl,
+                      bool debug,
                       const ix::SocketTLSOptions& tlsOptions)
     {
         spdlog::info("Listening on {}:{}", hostname, port);
@@ -1578,6 +1674,11 @@ namespace ix
             server.makeRedirectServer(redirectUrl);
         }
 
+        if (debug)
+        {
+            server.makeDebugServer();
+        }
+
         auto res = server.listen();
         if (!res.first)
         {
@@ -2905,6 +3006,8 @@ int main(int argc, char** argv)
     std::string path;
     std::string user;
     std::string data;
+    std::string formData;
+    std::string binaryData;
     std::string headers;
     std::string output;
     std::string hostname("127.0.0.1");
@@ -2948,6 +3051,7 @@ int main(int argc, char** argv)
     bool quiet = false;
     bool fluentd = false;
     bool compress = false;
+    bool compressRequest = false;
     bool stress = false;
     bool disableAutomaticReconnection = false;
     bool disablePerMessageDeflate = false;
@@ -2958,6 +3062,7 @@ int main(int argc, char** argv)
     bool version = false;
     bool verifyNone = false;
     bool disablePong = false;
+    bool debug = false;
     int port = 8008;
     int redisPort = 6379;
     int statsdPort = 8125;
@@ -2969,6 +3074,7 @@ int main(int argc, char** argv)
     int msgCount = 1000 * 1000;
     uint32_t maxWaitBetweenReconnectionRetries;
     int pingIntervalSecs = 30;
+    int runCount = 1;
 
     auto addGenericOptions = [&pidfile](CLI::App* app) {
         app->add_option("--pidfile", pidfile, "Pid file");
@@ -3113,7 +3219,8 @@ int main(int argc, char** argv)
     httpClientApp->fallthrough();
     httpClientApp->add_option("url", url, "Connection url")->required();
     httpClientApp->add_option("-d", data, "Form data")->join();
-    httpClientApp->add_option("-F", data, "Form data")->join();
+    httpClientApp->add_option("-F", formData, "Form data")->join();
+    httpClientApp->add_option("--data-binary", binaryData, "Body binary data")->join();
     httpClientApp->add_option("-H", headers, "Header")->join();
     httpClientApp->add_option("--output", output, "Output file");
     httpClientApp->add_flag("-I", headersOnly, "Send a HEAD request");
@@ -3121,7 +3228,8 @@ int main(int argc, char** argv)
     httpClientApp->add_option("--max-redirects", maxRedirects, "Max Redirects");
     httpClientApp->add_flag("-v", verbose, "Verbose");
     httpClientApp->add_flag("-O", save, "Save output to disk");
-    httpClientApp->add_flag("--compress", compress, "Enable gzip compression");
+    httpClientApp->add_flag("--compressed", compress, "Enable gzip compression");
+    httpClientApp->add_flag("--compress_request", compressRequest, "Compress request with gzip");
     httpClientApp->add_option("--connect-timeout", connectTimeOut, "Connection timeout");
     httpClientApp->add_option("--transfer-timeout", transferTimeout, "Transfer timeout");
     addTLSOptions(httpClientApp);
@@ -3255,6 +3363,7 @@ int main(int argc, char** argv)
     httpServerApp->add_option("--host", hostname, "Hostname");
     httpServerApp->add_flag("-L", redirect, "Redirect all request to redirect_url");
     httpServerApp->add_option("--redirect_url", redirectUrl, "Url to redirect to");
+    httpServerApp->add_flag("-D", debug, "Debug server");
     addTLSOptions(httpServerApp);
 
     CLI::App* autobahnApp = app.add_subcommand("autobahn", "Test client Autobahn compliance");
@@ -3297,6 +3406,7 @@ int main(int argc, char** argv)
     CLI::App* gzipApp = app.add_subcommand("gzip", "Gzip compressor");
     gzipApp->fallthrough();
     gzipApp->add_option("filename", filename, "Filename")->required();
+    gzipApp->add_option("--run_count", runCount, "Number of time to run the compression");
 
     CLI::App* gunzipApp = app.add_subcommand("gunzip", "Gzip decompressor");
     gunzipApp->fallthrough();
@@ -3435,6 +3545,8 @@ int main(int argc, char** argv)
         ret = ix::ws_http_client_main(url,
                                       headers,
                                       data,
+                                      formData,
+                                      binaryData,
                                       headersOnly,
                                       connectTimeOut,
                                       transferTimeout,
@@ -3444,6 +3556,7 @@ int main(int argc, char** argv)
                                       save,
                                       output,
                                       compress,
+                                      compressRequest,
                                       tlsOptions);
     }
     else if (app.got_subcommand("redis_cli"))
@@ -3553,7 +3666,7 @@ int main(int argc, char** argv)
     }
     else if (app.got_subcommand("httpd"))
     {
-        ret = ix::ws_httpd_main(port, hostname, redirect, redirectUrl, tlsOptions);
+        ret = ix::ws_httpd_main(port, hostname, redirect, redirectUrl, debug, tlsOptions);
     }
     else if (app.got_subcommand("autobahn"))
     {
@@ -3600,7 +3713,7 @@ int main(int argc, char** argv)
     }
     else if (app.got_subcommand("gzip"))
     {
-        ret = ix::ws_gzip(filename);
+        ret = ix::ws_gzip(filename, runCount);
     }
     else if (app.got_subcommand("gunzip"))
     {