add target for building with homebrew

* New command line tool for transfering files / still very beta.

* add readme

* use cli11 for argument parsing

* json -> msgpack

* stop using base64 and use binary which can be stored in message pack

.dockerignore

@@ -0,0 +1 @@
+build

.travis.yml

@@ -0,0 +1,17 @@
+language: cpp
+dist: xenial
+
+compiler:
+  - gcc
+  - clang
+os:
+  - linux
+  - osx
+
+matrix:
+  exclude:
+    # GCC fails on recent Travis OSX images.
+    - compiler: gcc
+      os: osx
+
+script: python test/run.py

CMakeLists.txt

@@ -0,0 +1,115 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+#
+
+cmake_minimum_required(VERSION 3.4.1)
+project(ixwebsocket C CXX)
+
+set (CMAKE_CXX_STANDARD 14)
+set (CXX_STANDARD_REQUIRED ON)
+set (CMAKE_CXX_EXTENSIONS OFF)
+
+if (NOT WIN32)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic")
+endif()
+
+set( IXWEBSOCKET_SOURCES
+    ixwebsocket/IXEventFd.cpp
+    ixwebsocket/IXSocket.cpp
+    ixwebsocket/IXSocketServer.cpp
+    ixwebsocket/IXSocketConnect.cpp
+    ixwebsocket/IXDNSLookup.cpp
+    ixwebsocket/IXCancellationRequest.cpp
+    ixwebsocket/IXWebSocket.cpp
+    ixwebsocket/IXWebSocketServer.cpp
+    ixwebsocket/IXWebSocketTransport.cpp
+    ixwebsocket/IXWebSocketHandshake.cpp
+    ixwebsocket/IXWebSocketPerMessageDeflate.cpp
+    ixwebsocket/IXWebSocketPerMessageDeflateCodec.cpp
+    ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp
+)
+
+set( IXWEBSOCKET_HEADERS
+    ixwebsocket/IXEventFd.h
+    ixwebsocket/IXSocket.h
+    ixwebsocket/IXSocketServer.h
+    ixwebsocket/IXSocketConnect.h
+    ixwebsocket/IXSetThreadName.h
+    ixwebsocket/IXDNSLookup.h
+    ixwebsocket/IXCancellationRequest.h
+    ixwebsocket/IXProgressCallback.h
+    ixwebsocket/IXWebSocket.h
+    ixwebsocket/IXWebSocketServer.h
+    ixwebsocket/IXWebSocketTransport.h
+    ixwebsocket/IXWebSocketHandshake.h
+    ixwebsocket/IXWebSocketSendInfo.h
+    ixwebsocket/IXWebSocketErrorInfo.h
+    ixwebsocket/IXWebSocketPerMessageDeflate.h
+    ixwebsocket/IXWebSocketPerMessageDeflateCodec.h
+    ixwebsocket/IXWebSocketPerMessageDeflateOptions.h
+    ixwebsocket/IXWebSocketHttpHeaders.h
+    ixwebsocket/libwshandshake.hpp
+)
+
+# Platform specific code
+if (APPLE)
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/apple/IXSetThreadName_apple.cpp)
+elseif (WIN32)
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/windows/IXSetThreadName_windows.cpp)
+else()
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/linux/IXSetThreadName_linux.cpp)
+endif()
+
+if (USE_TLS)
+    add_definitions(-DIXWEBSOCKET_USE_TLS)
+
+    if (APPLE)
+        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketAppleSSL.h)
+        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketAppleSSL.cpp)
+    elseif (WIN32)
+        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketSChannel.h)
+        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketSChannel.cpp)
+    else()
+        list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSocketOpenSSL.h)
+        list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSocketOpenSSL.cpp)
+    endif()
+endif()
+
+add_library( ixwebsocket STATIC
+    ${IXWEBSOCKET_SOURCES}
+    ${IXWEBSOCKET_HEADERS}
+)
+
+# gcc/Linux needs -pthread
+find_package(Threads)
+
+if(UNIX AND NOT APPLE)
+  find_package(OpenSSL REQUIRED)
+  add_definitions(${OPENSSL_DEFINITIONS})
+  message(STATUS "OpenSSL: " ${OPENSSL_VERSION})
+  include_directories(${OPENSSL_INCLUDE_DIR})
+endif()
+
+if (WIN32)
+  get_filename_component(libz_path
+    ${PROJECT_SOURCE_DIR}/third_party/ZLIB-Windows/zlib-1.2.11_deploy_v140/release_dynamic/x64/lib/zlib.lib
+    ABSOLUTE)
+  add_library(libz STATIC IMPORTED)
+  set_target_properties(libz PROPERTIES IMPORTED_LOCATION
+    ${libz_path})
+
+  include_directories(${PROJECT_SOURCE_DIR}/third_party/ZLIB-Windows/zlib-1.2.11_deploy_v140/include)
+
+  target_link_libraries(ixwebsocket libz wsock32 ws2_32)
+  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+  
+else()
+  target_link_libraries(ixwebsocket 
+    z ${OPENSSL_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+endif()
+
+set( IXWEBSOCKET_INCLUDE_DIRS
+    .
+    ../../shared/OpenSSL/include)
+target_include_directories( ixwebsocket PUBLIC ${IXWEBSOCKET_INCLUDE_DIRS} )

Dockerfile

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

README.md

@@ -1,25 +1,42 @@
 # General
 
+![Alt text](https://travis-ci.org/machinezone/IXWebSocket.svg?branch=master)
+
 ## Introduction
 
 [*WebSocket*](https://en.wikipedia.org/wiki/WebSocket) is a computer communications protocol, providing full-duplex
-communication channels over a single TCP connection. This library provides a C++ library for Websocket communication. The code is derived from [easywsclient](https://github.com/dhbaird/easywsclient).
+communication channels over a single TCP connection. *IXWebSocket* is a C++ library for client and server Websocket communication. The code is derived from [easywsclient](https://github.com/dhbaird/easywsclient) and from the [Satori C SDK](https://github.com/satori-com/satori-rtm-sdk-c). It has been tested on the following platforms.
+
+* macOS
+* iOS
+* Linux
+* Android 
+* Windows (no TLS support yet)
 
 ## Examples
 
 The examples folder countains a simple chat program, using a node.js broadcast server.
 
-Here is what the API looks like.
+Here is what the client API looks like.
 
 ```
 ix::WebSocket webSocket;
 
 std::string url("ws://localhost:8080/");
-webSocket.configure(url);
+webSocket.setUrl(url);
+
+// Optional heart beat, sent every 45 seconds when there isn't any traffic
+// to make sure that load balancers do not kill an idle connection.
+webSocket.setHeartBeatPeriod(45);
 
 // Setup a callback to be fired when a message or an event (open, close, error) is received
 webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType, const std::string& str, ix::WebSocketErrorInfo error)
+    [](ix::WebSocketMessageType messageType,
+       const std::string& str,
+       size_t wireSize,
+       const ix::WebSocketErrorInfo& error,
+       const ix::WebSocketCloseInfo& closeInfo,
+       const ix::WebSocketHttpHeaders& headers)
     {
         if (messageType == ix::WebSocket_MessageType_Message)
         {
@@ -36,14 +53,78 @@ webSocket.send("hello world");
 // ... finally ...
 
 // Stop the connection
-webSocket:stop()
+webSocket.stop()
 ```
 
+Here is what the server API looks like. Note that server support is very recent and subject to changes.
+
+```
+// Run a server on localhost at a given port.
+// Bound host name, max connections and listen backlog can also be passed in as parameters.
+ix::WebSocketServer server(port);
+
+server.setOnConnectionCallback(
+    [&server](std::shared_ptr<ix::WebSocket> webSocket)
+    {
+        webSocket->setOnMessageCallback(
+            [webSocket, &server](ix::WebSocketMessageType messageType,
+               const std::string& str,
+               size_t wireSize,
+               const ix::WebSocketErrorInfo& error,
+               const ix::WebSocketOpenInfo& openInfo,
+               const ix::WebSocketCloseInfo& closeInfo)
+            {
+                if (messageType == ix::WebSocket_MessageType_Open)
+                {
+                    std::cerr << "New connection" << std::endl;
+                    std::cerr << "Uri: " << openInfo.uri << std::endl;
+                    std::cerr << "Headers:" << std::endl;
+                    for (auto it : openInfo.headers)
+                    {
+                        std::cerr << it.first << ": " << it.second << std::endl;
+                    }
+                }
+                else if (messageType == ix::WebSocket_MessageType_Message)
+                {
+                    // For an echo server, we just send back to the client whatever was received by the server
+                    // All connected clients are available in an std::set. See the broadcast cpp example.
+                    webSocket->send(str);
+                }
+            }
+        );
+    }
+);
+
+auto res = server.listen();
+if (!res.first)
+{
+    // Error handling
+    return 1;
+}
+
+// Run the server in the background. Server can be stoped by calling server.stop()
+server.start();
+
+// Block until server.stop() is called.
+server.wait();
+
+```
+
+## Build
+
+CMakefiles for the library and the examples are available. This library has few dependencies, so it is possible to just add the source files into your project.
+
+There is a Dockerfile for running some code on Linux, and a unittest which can be executed by typing `make test`.
+
 ## Implementation details
 
+### Per Message Deflate compression.
+
+The per message deflate compression option is supported. It can lead to very nice bandbwith savings (20x !) if your messages are similar, which is often the case for example for chat applications. All features of the spec should be supported.
+
 ### TLS/SSL
 
-Connections can be optionally secured and encrypted with TLS/SSL when using a wss:// endpoint, or using normal un-encrypted socket with ws:// endpoints. AppleSSL is used on iOS and OpenSSL is used on Android.
+Connections can be optionally secured and encrypted with TLS/SSL when using a wss:// endpoint, or using normal un-encrypted socket with ws:// endpoints. AppleSSL is used on iOS and macOS, and OpenSSL is used on Android and Linux.
 
 ### Polling and background thread work
 
@@ -53,11 +134,15 @@ No manual polling to fetch data is required. Data is sent and received instantly
 
 If the remote end (server) breaks the connection, the code will try to perpetually reconnect, by using an exponential backoff strategy, capped at one retry every 10 seconds.
 
+### Large messages
+
+Large frames are broken up into smaller chunks or messages to avoid filling up the os tcp buffers, which is permitted thanks to WebSocket [fragmentation](https://tools.ietf.org/html/rfc6455#section-5.4). Messages up to 500M were sent and received succesfully.
+
 ## Limitations
 
-* There is no per message compression support. That could be useful for retrieving large messages, but could also be implemented at the application level.
 * There is no text support for sending data, only the binary protocol is supported. Sending json or text over the binary protocol works well.
 * Automatic reconnection works at the TCP socket level, and will detect remote end disconnects. However, if the device/computer network become unreachable (by turning off wifi), it is quite hard to reliably and timely detect it at the socket level using `recv` and `send` error codes. [Here](https://stackoverflow.com/questions/14782143/linux-socket-how-to-detect-disconnected-network-in-a-client-program) is a good discussion on the subject. This behavior is consistent with other runtimes such as node.js. One way to detect a disconnected device with low level C code is to do a name resolution with DNS but this can be expensive. Mobile devices have good and reliable API to do that.
+* The server code is using select to detect incoming data, and creates one OS thread per connection. This isn't as scalable as strategies using epoll or kqueue.
 
 ## Examples
 
@@ -65,8 +150,8 @@ If the remote end (server) breaks the connection, the code will try to perpetual
 2. Compile the example C++ code. `sh build.sh`
 3. Install node.js from [here](https://nodejs.org/en/download/).
 4. Type `npm install` to install the node.js dependencies. Then `node broadcast-server.js` to run the server.
-5. Bring up a second terminal. `env USER=bob ./cmd_websocket_chat`
-6. Bring up a third terminal. `env USER=bill ./cmd_websocket_chat`
+5. Bring up a second terminal. `./cmd_websocket_chat bob`
+6. Bring up a third terminal. `./cmd_websocket_chat bill`
 7. Start typing things in any of those terminals. Hopefully you should see your message being received on the other end.
 
 ## C++ code organization
@@ -74,24 +159,41 @@ If the remote end (server) breaks the connection, the code will try to perpetual
 Here's a simplistic diagram which explains how the code is structured in term of class/modules.
 
 ```
-+-----------------------+
++-----------------------+ --- Public
 |                       | Start the receiving Background thread. Auto reconnection. Simple websocket Ping.
 |  IXWebSocket          | Interface used by C++ test clients. No IX dependencies.
 |                       | 
 +-----------------------+
 |                       |
+|  IXWebSocketServer    | Run a server and give each connections its own WebSocket object.
+|                       | Each connection is handled in a new OS thread.
+|                       |
++-----------------------+ --- Private 
+|                       |
 |  IXWebSocketTransport | Low level websocket code, framing, managing raw socket. Adapted from easywsclient.
 |                       |
 +-----------------------+
 |                       |
+|  IXWebSocketHandshake | Establish the connection between client and server.
+|                       |
++-----------------------+
+|                       |
 |  IXWebSocket          | ws://  Unencrypted Socket handler
 |  IXWebSocketAppleSSL  | wss:// TLS encrypted Socket AppleSSL handler. Used on iOS and macOS
 |  IXWebSocketOpenSSL   | wss:// TLS encrypted Socket OpenSSL handler.  Used on Android and Linux
 |                       |                                               Can be used on macOS too.
 +-----------------------+
+|                       |
+|  IXSocketConnect      | Connect to the remote host (client).
+|                       |
++-----------------------+
+|                       |
+|  IXDNSLookup          | Does DNS resolution asynchronously so that it can be interrupted.
+|                       |
++-----------------------+
 ```
 
-## Advanced usage
+## API
 
 ### Sending messages
 
@@ -114,15 +216,32 @@ The onMessage event will be fired when the connection is opened or closed. This
 
 ```
 webSocket.setOnMessageCallback(
-    [this](ix::WebSocketMessageType messageType, const std::string& str, ix::WebSocketErrorInfo error)
+    [](ix::WebSocketMessageType messageType,
+       const std::string& str,
+       size_t wireSize,
+       const ix::WebSocketErrorInfo& error,
+       const ix::WebSocketCloseInfo& closeInfo,
+       const ix::WebSocketHttpHeaders& headers)
     {
         if (messageType == ix::WebSocket_MessageType_Open)
         {
-            puts("send greetings");
+            std::cout << "send greetings" << std::endl;
+
+            // Headers can be inspected (pairs of string/string)
+            std::cout << "Handshake Headers:" << std::endl;
+            for (auto it : headers)
+            {
+                std::cout << it.first << ": " << it.second << std::endl;
+            }
         }
         else if (messageType == ix::WebSocket_MessageType_Close)
         {
-            puts("disconnected");
+            std::cout << "disconnected" << std::endl;
+
+            // The server can send an explicit code and reason for closing.
+            // This data can be accessed through the closeInfo object.
+            std::cout << closeInfo.code << std::endl;
+            std::cout << closeInfo.reason << std::endl;
         }
     }
 );
@@ -134,7 +253,12 @@ A message will be fired when there is an error with the connection. The message
 
 ```
 webSocket.setOnMessageCallback(
-    [this](ix::WebSocketMessageType messageType, const std::string& str, ix::WebSocketErrorInfo error)
+    [](ix::WebSocketMessageType messageType,
+       const std::string& str,
+       size_t wireSize,
+       const ix::WebSocketErrorInfo& error,
+       const ix::WebSocketCloseInfo& closeInfo,
+       const ix::WebSocketHttpHeaders& headers)
     {
         if (messageType == ix::WebSocket_MessageType_Error)
         {
@@ -162,3 +286,41 @@ The url can be set and queried after a websocket object has been created. You wi
 std::string url("wss://example.com");
 websocket.configure(url);
 ```
+
+### Ping/Pong support
+
+Ping/pong messages are used to implement keep-alive. 2 message types exists to identify ping and pong messages. Note that when a ping message is received, a pong is instantly send back as requested by the WebSocket spec.
+
+```
+webSocket.setOnMessageCallback(
+    [](ix::WebSocketMessageType messageType,
+       const std::string& str,
+       size_t wireSize,
+       const ix::WebSocketErrorInfo& error,
+       const ix::WebSocketCloseInfo& closeInfo,
+       const ix::WebSocketHttpHeaders& headers)
+    {
+        if (messageType == ix::WebSocket_MessageType_Ping ||
+            messageType == ix::WebSocket_MessageType_Pong)
+        {
+            std::cout << "pong data: " << str << std::endl;
+        }
+    }
+);
+```
+
+A ping message can be sent to the server, with an optional data string.
+
+```
+websocket.ping("ping data, optional (empty string is ok): limited to 125 bytes long");
+```
+
+### Heartbeat.
+
+You can configure an optional heart beat / keep-alive, sent every 45 seconds
+when there isn't any traffic to make sure that load balancers do not kill an
+idle connection.
+
+```
+webSocket.setHeartBeatPeriod(45);
+```

appveyor.yml

@@ -0,0 +1,10 @@
+image:
+- Visual Studio 2017
+- Ubuntu
+
+install:
+- ls -al
+- cmd: call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
+- python test/run.py
+
+build: off

docker/Dockerfile

@@ -0,0 +1,16 @@
+FROM debian:stretch
+
+# RUN yum install -y gcc-c++ make cmake openssl-devel gdb
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update 
+RUN apt-get -y install g++ 
+RUN apt-get -y install libssl-dev
+RUN apt-get -y install gdb
+RUN apt-get -y install screen
+RUN apt-get -y install procps
+RUN apt-get -y install lsof
+
+COPY . .
+
+WORKDIR examples/ws_connect
+RUN ["sh", "build_linux.sh"]

docker/Dockerfile.alpine

@@ -0,0 +1,11 @@
+FROM alpine:3.8
+
+RUN apk add --no-cache g++ musl-dev make cmake openssl-dev
+
+COPY . .
+
+WORKDIR examples/ws_connect
+RUN ["sh", "build_linux.sh"]
+
+EXPOSE 8765
+CMD ["ws_connect"]

docker/Dockerfile.centos

@@ -0,0 +1,11 @@
+FROM alpine:3.8
+
+RUN apk add --no-cache g++ musl-dev make cmake openssl-dev
+
+COPY . .
+
+WORKDIR examples/ws_connect
+RUN ["sh", "build_linux.sh"]
+
+EXPOSE 8765
+CMD ["ws_connect"]

docker/Dockerfile.debian

@@ -0,0 +1,22 @@
+FROM debian:stretch
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update 
+RUN apt-get -y install g++ 
+RUN apt-get -y install libssl-dev
+RUN apt-get -y install gdb
+RUN apt-get -y install screen
+RUN apt-get -y install procps
+RUN apt-get -y install lsof
+RUN apt-get -y install libz-dev
+RUN apt-get -y install vim
+RUN apt-get -y install make
+RUN apt-get -y install cmake
+
+COPY . .
+
+WORKDIR ws
+RUN ["sh", "docker_build.sh"]
+
+EXPOSE 8765
+CMD ["/ws/ws", "transfer", "8765"]

docker/Dockerfile.gcc

@@ -0,0 +1,8 @@
+FROM gcc:8
+
+# RUN yum install -y gcc-c++ make cmake openssl-devel gdb
+
+COPY . .
+
+WORKDIR examples/ws_connect
+RUN ["sh", "build_linux.sh"]

examples/broadcast_server/.gitignore

@@ -0,0 +1,9 @@
+CMakeCache.txt
+package-lock.json
+CMakeFiles		
+ixwebsocket_unittest	
+cmake_install.cmake	
+node_modules
+ixwebsocket
+Makefile
+build

examples/broadcast_server/CMakeLists.txt

@@ -0,0 +1,30 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+#
+
+cmake_minimum_required (VERSION 3.4.1)
+project (broadcast_server)
+
+# There's -Weverything too for clang
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wshorten-64-to-32")
+
+set (OPENSSL_PREFIX /usr/local/opt/openssl) # Homebrew openssl
+
+set (CMAKE_CXX_STANDARD 14)
+
+option(USE_TLS "Add TLS support" ON)
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
+
+include_directories(broadcast_server .)
+
+add_executable(broadcast_server 
+  broadcast_server.cpp)
+
+if (APPLE AND USE_TLS)
+    target_link_libraries(broadcast_server "-framework foundation" "-framework security")
+endif()
+
+target_link_libraries(broadcast_server ixwebsocket)
+install(TARGETS broadcast_server DESTINATION bin)

examples/broadcast_server/broadcast_server.cpp

@@ -0,0 +1,75 @@
+/*
+ *  broadcast_server.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <ixwebsocket/IXWebSocketServer.h>
+
+int main(int argc, char** argv)
+{
+    int port = 8080;
+    if (argc == 2)
+    {
+        std::stringstream ss;
+        ss << argv[1];
+        ss >> port;
+    }
+
+    ix::WebSocketServer server(port);
+
+    server.setOnConnectionCallback(
+        [&server](std::shared_ptr<ix::WebSocket> webSocket)
+        {
+            webSocket->setOnMessageCallback(
+                [webSocket, &server](ix::WebSocketMessageType messageType,
+                   const std::string& str,
+                   size_t wireSize,
+                   const ix::WebSocketErrorInfo& error,
+                   const ix::WebSocketOpenInfo& openInfo,
+                   const ix::WebSocketCloseInfo& closeInfo)
+                {
+                    if (messageType == ix::WebSocket_MessageType_Open)
+                    {
+                        std::cerr << "New connection" << std::endl;
+                        std::cerr << "Uri: " << openInfo.uri << std::endl;
+                        std::cerr << "Headers:" << std::endl;
+                        for (auto it : openInfo.headers)
+                        {
+                            std::cerr << it.first << ": " << it.second << std::endl;
+                        }
+                    }
+                    else if (messageType == ix::WebSocket_MessageType_Close)
+                    {
+                        std::cerr << "Closed connection" << std::endl;
+                    }
+                    else if (messageType == ix::WebSocket_MessageType_Message)
+                    {
+                        std::cerr << "Received " << wireSize << " bytes" << std::endl;
+                        for (auto&& client : server.getClients())
+                        {
+                            if (client != webSocket)
+                            {
+                                client->send(str);
+                            }
+                        }
+                    }
+                }
+            );
+        }
+    );
+
+    auto res = server.listen();
+    if (!res.first)
+    {
+        std::cerr << res.second << std::endl;
+        return 1;
+    }
+
+    server.start();
+    server.wait();
+
+    return 0;
+}

examples/chat/.gitignore

@@ -0,0 +1,3 @@
+build
+venv
+node_modules

examples/chat/CMakeLists.txt

@@ -0,0 +1,23 @@
+#
+# cmd_websocket_chat.cpp
+# Author: Benjamin Sergeant
+# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+#
+
+cmake_minimum_required (VERSION 3.4.1)
+project (cmd_websocket_chat)
+
+set (CMAKE_CXX_STANDARD 14)
+
+option(USE_TLS "Add TLS support" ON)
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
+
+add_executable(cmd_websocket_chat cmd_websocket_chat.cpp)
+
+if (APPLE AND USE_TLS)
+    target_link_libraries(cmd_websocket_chat "-framework foundation" "-framework security")
+endif()
+
+target_link_libraries(cmd_websocket_chat ixwebsocket)
+install(TARGETS cmd_websocket_chat DESTINATION bin)

examples/chat/README.md

@@ -0,0 +1,39 @@
+# Building
+
+1. cmake -G .
+2. make
+
+## Disable TLS
+
+chat$ cmake -DUSE_TLS=OFF .
+-- Configuring done
+-- Generating done
+-- Build files have been written to: /Users/bsergeant/src/foss/ixwebsocket/examples/chat
+chat$ make
+Scanning dependencies of target ixwebsocket
+[ 16%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXSocket.cpp.o
+[ 33%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXWebSocket.cpp.o
+[ 50%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXWebSocketTransport.cpp.o
+[ 66%] Linking CXX static library libixwebsocket.a
+[ 66%] Built target ixwebsocket
+[ 83%] Linking CXX executable cmd_websocket_chat
+[100%] Built target cmd_websocket_chat
+
+## Enable TLS (default)
+
+```
+chat$ cmake -DUSE_TLS=ON .
+-- Configuring done
+-- Generating done
+-- Build files have been written to: /Users/bsergeant/src/foss/ixwebsocket/examples/chat
+(venv) chat$ make
+Scanning dependencies of target ixwebsocket
+[ 14%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXSocket.cpp.o
+[ 28%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXWebSocket.cpp.o
+[ 42%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXWebSocketTransport.cpp.o
+[ 57%] Building CXX object ixwebsocket/CMakeFiles/ixwebsocket.dir/ixwebsocket/IXSocketAppleSSL.cpp.o
+[ 71%] Linking CXX static library libixwebsocket.a
+[ 71%] Built target ixwebsocket
+[ 85%] Linking CXX executable cmd_websocket_chat
+[100%] Built target cmd_websocket_chat
+```

examples/chat/broadcast-server.js

@@ -1,11 +1,11 @@
 /*
- *  cmd_websocket_chat.cpp
+ *  broadcast-server.js
  *  Author: Benjamin Sergeant
  *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
  */
 const WebSocket = require('ws');
 
-const wss = new WebSocket.Server({ port: 8080 });
+const wss = new WebSocket.Server({ port: 8080, perMessageDeflate: true });
 
 // Broadcast to all.
 wss.broadcast = function broadcast(data) {

examples/chat/broadcast-server.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+
+import os
+import asyncio
+import websockets
+
+connections = set()
+
+async def echo(websocket, path):
+
+    connections.add(websocket)
+
+    try:
+        async for message in websocket:
+            print(message)
+
+            for ws in connections:
+                if ws != websocket:
+                    await ws.send(message)
+    except:
+        raise
+    finally:
+        connections.remove(websocket)
+
+
+asyncio.get_event_loop().run_until_complete(
+    websockets.serve(echo, 'localhost', 8080))
+asyncio.get_event_loop().run_forever()

examples/chat/build_linux.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
+#
+
+# 'manual' way of building. You can also use cmake.
+
+g++ --std=c++11 \
+    ../../ixwebsocket/IXSocket.cpp	\
+    ../../ixwebsocket/IXWebSocketTransport.cpp \
+    ../../ixwebsocket/IXWebSocket.cpp \
+    -I ../.. \
+    cmd_websocket_chat.cpp \
+    -o cmd_websocket_chat

examples/chat/build_macos.sh

@@ -4,11 +4,13 @@
 # Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
 #
 
+# 'manual' way of building. You can also use cmake.
+
 clang++ --std=c++11 --stdlib=libc++ \
-    ../ixwebsocket/IXSocket.cpp	\
-    ../ixwebsocket/IXWebSocketTransport.cpp \
-    ../ixwebsocket/IXSocketAppleSSL.cpp	\
-    ../ixwebsocket/IXWebSocket.cpp \
+    ../../ixwebsocket/IXSocket.cpp	\
+    ../../ixwebsocket/IXWebSocketTransport.cpp \
+    ../../ixwebsocket/IXSocketAppleSSL.cpp	\
+    ../../ixwebsocket/IXWebSocket.cpp \
     cmd_websocket_chat.cpp \
     -o cmd_websocket_chat \
     -framework Security \

examples/chat/cmd_websocket_chat.cpp

@@ -12,7 +12,8 @@
 #include <iostream>
 #include <sstream>
 #include <queue>
-#include "../ixwebsocket/IXWebSocket.h"
+#include <ixwebsocket/IXWebSocket.h>
+#include <ixwebsocket/IXSocket.h>
 
 #include "nlohmann/json.hpp"
 
@@ -76,13 +77,18 @@ namespace
     void WebSocketChat::start()
     {
         std::string url("ws://localhost:8080/");
-        _webSocket.configure(url);
+        _webSocket.setUrl(url);
 
         std::stringstream ss;
         log(std::string("Connecting to url: ") + url);
 
         _webSocket.setOnMessageCallback(
-            [this](ix::WebSocketMessageType messageType, const std::string& str, ix::WebSocketErrorInfo error)
+            [this](ix::WebSocketMessageType messageType,
+               const std::string& str,
+               size_t wireSize,
+               const ix::WebSocketErrorInfo& error,
+               const ix::WebSocketOpenInfo& openInfo,
+               const ix::WebSocketCloseInfo& closeInfo)
             {
                 std::stringstream ss;
                 if (messageType == ix::WebSocket_MessageType_Open)
@@ -158,13 +164,10 @@ namespace
         _webSocket.send(encodeMessage(text));
     }
 
-    void interactiveMain()
+    void interactiveMain(const std::string& user)
     {
-        std::string user(getenv("USER"));
-
-        WebSocketChat webSocketChat(user);
-
         std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
+        WebSocketChat webSocketChat(user);
         webSocketChat.start();
 
         while (true)
@@ -186,8 +189,15 @@ namespace
     }
 }
 
-int main()
+int main(int argc, char** argv)
 {
-    interactiveMain();
+    std::string user("user");
+    if (argc == 2)
+    {
+        user = argv[1];
+    }
+
+    Socket::init();
+    interactiveMain(user);
     return 0;
 }

examples/chat/package-lock.json

@@ -0,0 +1,31 @@
+{
+  "requires": true,
+  "lockfileVersion": 1,
+  "dependencies": {
+    "async-limiter": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz",
+      "integrity": "sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg=="
+    },
+    "safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
+    },
+    "ultron": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz",
+      "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og=="
+    },
+    "ws": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz",
+      "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==",
+      "requires": {
+        "async-limiter": "1.0.0",
+        "safe-buffer": "5.1.2",
+        "ultron": "1.1.1"
+      }
+    }
+  }
+}

examples/chat/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
     "msgpack-js": "^0.3.0",
-    "ws": "^3.1.0"
+    "ws": "^3.3.3"
   }
 }

examples/cobra_publisher/.gitignore

@@ -0,0 +1,3 @@
+venv
+build
+node_modules

examples/cobra_publisher/CMakeLists.txt

@@ -0,0 +1,40 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+#
+
+cmake_minimum_required (VERSION 3.4.1)
+project (cobra_publisher)
+
+# There's -Weverything too for clang
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wshorten-64-to-32")
+
+set (OPENSSL_PREFIX /usr/local/opt/openssl) # Homebrew openssl
+
+set (CMAKE_CXX_STANDARD 14)
+
+option(USE_TLS "Add TLS support" ON)
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
+
+include_directories(cobra_publisher ${OPENSSL_PREFIX}/include)
+include_directories(cobra_publisher .)
+
+add_executable(cobra_publisher 
+  jsoncpp/jsoncpp.cpp
+  ixcrypto/IXHMac.cpp
+  ixcrypto/IXBase64.cpp
+  IXCobraConnection.cpp
+  cobra_publisher.cpp)
+
+if (APPLE AND USE_TLS)
+    target_link_libraries(cobra_publisher "-framework foundation" "-framework security")
+endif()
+
+get_filename_component(crypto_lib_path ${OPENSSL_PREFIX}/lib/libcrypto.a ABSOLUTE)
+add_library(lib_crypto STATIC IMPORTED)
+set_target_properties(lib_crypto PROPERTIES IMPORTED_LOCATION ${crypto_lib_path})
+
+link_directories(/usr/local/opt/openssl/lib)
+target_link_libraries(cobra_publisher ixwebsocket lib_crypto)
+install(TARGETS cobra_publisher DESTINATION bin)

examples/cobra_publisher/IXCobraConnection.cpp

@@ -0,0 +1,475 @@
+/*
+ *  IXCobraConnection.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2017-2018 Machine Zone. All rights reserved.
+ */
+
+#include "IXCobraConnection.h"
+#include <ixcrypto/IXHMac.h>
+
+#include <algorithm>
+#include <stdexcept>
+#include <cmath>
+#include <cassert>
+#include <cstring>
+
+
+namespace ix
+{
+    TrafficTrackerCallback CobraConnection::_trafficTrackerCallback = nullptr;
+    constexpr size_t CobraConnection::kQueueMaxSize;
+
+    CobraConnection::CobraConnection() :
+        _authenticated(false),
+        _eventCallback(nullptr),
+        _publishMode(CobraConnection_PublishMode_Immediate)
+    {
+        _pdu["action"] = "rtm/publish";
+
+        initWebSocketOnMessageCallback();
+    }
+
+    CobraConnection::~CobraConnection()
+    {
+        disconnect();
+    }
+
+    void CobraConnection::setTrafficTrackerCallback(const TrafficTrackerCallback& callback)
+    {
+        _trafficTrackerCallback = callback;
+    }
+
+    void CobraConnection::resetTrafficTrackerCallback()
+    {
+        setTrafficTrackerCallback(nullptr);
+    }
+
+    void CobraConnection::invokeTrafficTrackerCallback(size_t size, bool incoming)
+    {
+        if (_trafficTrackerCallback)
+        {
+            _trafficTrackerCallback(size, incoming);
+        }
+    }
+
+    void CobraConnection::setEventCallback(const EventCallback& eventCallback)
+    {
+        std::lock_guard<std::mutex> lock(_eventCallbackMutex);
+        _eventCallback = eventCallback;
+    }
+
+    void CobraConnection::invokeEventCallback(ix::CobraConnectionEventType eventType,
+                                              const std::string& errorMsg,
+                                              const WebSocketHttpHeaders& headers)
+    {
+        std::lock_guard<std::mutex> lock(_eventCallbackMutex);
+        if (_eventCallback)
+        {
+            _eventCallback(eventType, errorMsg, headers);
+        }
+    }
+
+    void CobraConnection::invokeErrorCallback(const std::string& errorMsg)
+    {
+        invokeEventCallback(ix::CobraConnection_EventType_Error, errorMsg);
+    }
+
+    void CobraConnection::disconnect()
+    {
+        _authenticated = false;
+        _webSocket.stop();
+    }
+
+    void CobraConnection::initWebSocketOnMessageCallback()
+    {
+        _webSocket.setOnMessageCallback(
+            [this](ix::WebSocketMessageType messageType,
+                   const std::string& str,
+                   size_t wireSize,
+                   const ix::WebSocketErrorInfo& error,
+                   const ix::WebSocketCloseInfo& closeInfo,
+                   const ix::WebSocketHttpHeaders& headers)
+            {
+                CobraConnection::invokeTrafficTrackerCallback(wireSize, true);
+
+                std::stringstream ss;
+                if (messageType == ix::WebSocket_MessageType_Open)
+                {
+                    invokeEventCallback(ix::CobraConnection_EventType_Open,
+                                        std::string(),
+                                        headers);
+                    sendHandshakeMessage();
+                }
+                else if (messageType == ix::WebSocket_MessageType_Close)
+                {
+                    _authenticated = false;
+
+                    std::stringstream ss;
+                    ss << "Close code " << closeInfo.code;
+                    ss << " reason " << closeInfo.reason;
+                    invokeEventCallback(ix::CobraConnection_EventType_Closed,
+                                        ss.str());
+                }
+                else if (messageType == ix::WebSocket_MessageType_Message)
+                {
+                    Json::Value data;
+                    Json::Reader reader;
+                    if (!reader.parse(str, data))
+                    {
+                        invokeErrorCallback(std::string("Invalid json: ") + str);
+                        return;
+                    }
+
+                    if (!data.isMember("action"))
+                    {
+                        invokeErrorCallback("Missing action");
+                        return;
+                    }
+
+                    auto action = data["action"].asString();
+
+                    if (action == "auth/handshake/ok")
+                    {
+                        if (!handleHandshakeResponse(data))
+                        {
+                            invokeErrorCallback("Error extracting nonce from handshake response");
+                        }
+                    }
+                    else if (action == "auth/handshake/error")
+                    {
+                        invokeErrorCallback("Handshake error."); // print full message ?
+                    }
+                    else if (action == "auth/authenticate/ok")
+                    {
+                        _authenticated = true;
+                        invokeEventCallback(ix::CobraConnection_EventType_Authenticated);
+                        flushQueue();
+                    }
+                    else if (action == "auth/authenticate/error")
+                    {
+                        invokeErrorCallback("Authentication error."); // print full message ?
+                    }
+                    else if (action == "rtm/subscription/data")
+                    {
+                        handleSubscriptionData(data);
+                    }
+                    else
+                    {
+                        invokeErrorCallback(std::string("Un-handled message type: ") + action);
+                    }
+                }
+                else if (messageType == ix::WebSocket_MessageType_Error)
+                {
+                    std::stringstream ss;
+                    ss << "Connection error: " << error.reason      << std::endl;
+                    ss << "#retries: "         << error.retries     << std::endl;
+                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
+                    ss << "HTTP Status: "      << error.http_status << std::endl;
+                    invokeErrorCallback(ss.str());
+                }
+        });
+    }
+
+    void CobraConnection::setPublishMode(CobraConnectionPublishMode publishMode)
+    {
+        _publishMode = publishMode;
+    }
+
+    void CobraConnection::configure(const std::string& appkey,
+                                    const std::string& endpoint,
+                                    const std::string& rolename,
+                                    const std::string& rolesecret,
+                                    WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions)
+    {
+        _appkey = appkey;
+        _endpoint = endpoint;
+        _role_name = rolename;
+        _role_secret = rolesecret;
+
+        std::stringstream ss;
+        ss << _endpoint;
+        ss << "/v2?appkey=";
+        ss << _appkey;
+
+        std::string url = ss.str();
+        _webSocket.setUrl(url);
+        _webSocket.setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
+    }
+
+    //
+    // Handshake message schema.
+    //
+    // handshake = {
+    //     "action": "auth/handshake",
+    //     "body": {
+    //         "data": {
+    //             "role": role
+    //         },
+    //         "method": "role_secret"
+    //     },
+    // }
+    //
+    //
+    bool CobraConnection::sendHandshakeMessage()
+    {
+        Json::Value data;
+        data["role"] = _role_name;
+
+        Json::Value body;
+        body["data"] = data;
+        body["method"] = "role_secret";
+
+        Json::Value pdu;
+        pdu["action"] = "auth/handshake";
+        pdu["body"] = body;
+
+        std::string serializedJson = serializeJson(pdu);
+        CobraConnection::invokeTrafficTrackerCallback(serializedJson.size(), false);
+
+        return _webSocket.send(serializedJson).success;
+    }
+
+    //
+    // Extract the nonce from the handshake response
+    // use it to compute a hash during authentication
+    //
+    // {
+    //     "action": "auth/handshake/ok",
+    //     "body": {
+    //         "data": {
+    //             "nonce": "MTI0Njg4NTAyMjYxMzgxMzgzMg==",
+    //             "version": "0.0.24"
+    //         }
+    //     }
+    // }
+    //
+    bool CobraConnection::handleHandshakeResponse(const Json::Value& pdu)
+    {
+        if (!pdu.isMember("body")) return false;
+        Json::Value body = pdu["body"];
+
+        if (!body.isMember("data")) return false;
+        Json::Value data = body["data"];
+
+        if (!data.isMember("nonce")) return false;
+        Json::Value nonce = data["nonce"];
+
+        if (!nonce.isString()) return false;
+
+        return sendAuthMessage(nonce.asString());
+    }
+
+    //
+    // Authenticate message schema.
+    //
+    // challenge = {
+    //     "action": "auth/authenticate",
+    //     "body": {
+    //         "method": "role_secret",
+    //         "credentials": {
+    //             "hash": computeHash(secret, nonce)
+    //         }
+    //     },
+    // }
+    //
+    bool CobraConnection::sendAuthMessage(const std::string& nonce)
+    {
+        Json::Value credentials;
+        credentials["hash"] = hmac(nonce, _role_secret);
+
+        Json::Value body;
+        body["credentials"] = credentials;
+        body["method"] = "role_secret";
+
+        Json::Value pdu;
+        pdu["action"] = "auth/authenticate";
+        pdu["body"] = body;
+
+        std::string serializedJson = serializeJson(pdu);
+        CobraConnection::invokeTrafficTrackerCallback(serializedJson.size(), false);
+
+        return _webSocket.send(serializedJson).success;
+    }
+
+
+    bool CobraConnection::handleSubscriptionData(const Json::Value& pdu)
+    {
+        if (!pdu.isMember("body")) return false;
+        Json::Value body = pdu["body"];
+
+        // Identify subscription_id, so that we can find
+        // which callback to execute
+        if (!body.isMember("subscription_id")) return false;
+        Json::Value subscriptionId = body["subscription_id"];
+
+        std::lock_guard<std::mutex> lock(_cbsMutex);
+        auto cb = _cbs.find(subscriptionId.asString());
+        if (cb == _cbs.end()) return false; // cannot find callback
+
+        // Extract messages now
+        if (!body.isMember("messages")) return false;
+        Json::Value messages = body["messages"];
+
+        for (auto&& msg : messages)
+        {
+            cb->second(msg);
+        }
+
+        return true;
+    }
+
+    bool CobraConnection::connect()
+    {
+        _webSocket.start();
+        return true;
+    }
+
+    bool CobraConnection::isConnected() const
+    {
+        return _webSocket.getReadyState() == ix::WebSocket_ReadyState_Open;
+    }
+
+    std::string CobraConnection::serializeJson(const Json::Value& value)
+    {
+        std::lock_guard<std::mutex> lock(_jsonWriterMutex);
+        return _jsonWriter.write(value);
+    }
+
+    //
+    // publish is not thread safe as we are trying to reuse some Json objects.
+    //
+    bool CobraConnection::publish(const Json::Value& channels,
+                                  const Json::Value& msg)
+    {
+        _body["channels"] = channels;
+        _body["message"] = msg;
+        _pdu["body"] = _body;
+
+        std::string serializedJson = serializeJson(_pdu);
+
+        if (_publishMode == CobraConnection_PublishMode_Batch)
+        {
+            enqueue(serializedJson);
+            return true;
+        }
+
+        //
+        // Fast path. We are authenticated and the publishing succeed
+        //            This should happen for 99% of the cases.
+        //
+        if (_authenticated && publishMessage(serializedJson))
+        {
+            return true;
+        }
+        else // Or else we enqueue
+             // Slow code path is when we haven't connected yet (startup),
+             // or when the connection drops for some reason.
+        {
+            enqueue(serializedJson);
+            return false;
+        }
+    }
+
+    void CobraConnection::subscribe(const std::string& channel,
+                                    SubscriptionCallback cb)
+    {
+        // Create and send a subscribe pdu
+        Json::Value body;
+        body["channel"] = channel;
+
+        Json::Value pdu;
+        pdu["action"] = "rtm/subscribe";
+        pdu["body"] = body;
+
+        _webSocket.send(pdu.toStyledString());
+
+        // Set the callback
+        std::lock_guard<std::mutex> lock(_cbsMutex);
+        _cbs[channel] = cb;
+    }
+
+    void CobraConnection::unsubscribe(const std::string& channel)
+    {
+        {
+            std::lock_guard<std::mutex> lock(_cbsMutex);
+            auto cb = _cbs.find(channel);
+            if (cb == _cbs.end()) return;
+
+            _cbs.erase(cb);
+        }
+
+        // Create and send an unsubscribe pdu
+        Json::Value body;
+        body["channel"] = channel;
+
+        Json::Value pdu;
+        pdu["action"] = "rtm/unsubscribe";
+        pdu["body"] = body;
+
+        _webSocket.send(pdu.toStyledString());
+    }
+
+    //
+    // Enqueue strategy drops old messages when we are at full capacity
+    //
+    // If we want to keep only 3 items max in the queue:
+    //
+    // enqueue(A) -> [A]
+    // enqueue(B) -> [B, A]
+    // enqueue(C) -> [C, B, A]
+    // enqueue(D) -> [D, C, B] -- now we drop A, the oldest message,
+    //                         -- and keep the 'fresh ones'
+    //
+    void CobraConnection::enqueue(const std::string& msg)
+    {
+        std::lock_guard<std::mutex> lock(_queueMutex);
+
+        if (_messageQueue.size() == CobraConnection::kQueueMaxSize)
+        {
+            _messageQueue.pop_back();
+        }
+        _messageQueue.push_front(msg);
+    }
+
+    //
+    // We process messages back (oldest) to front (newest) to respect ordering
+    // when sending them. If we fail to send something, we put it back in the queue
+    // at the end we picked it up originally (at the end).
+    //
+    bool CobraConnection::flushQueue()
+    {
+        std::lock_guard<std::mutex> lock(_queueMutex);
+
+        while (!_messageQueue.empty())
+        {
+            auto&& msg = _messageQueue.back();
+            if (!publishMessage(msg))
+            {
+                _messageQueue.push_back(msg);
+                return false;
+            }
+            _messageQueue.pop_back();
+        }
+
+        return true;
+    }
+
+    bool CobraConnection::publishMessage(const std::string& serializedJson)
+    {
+        auto webSocketSendInfo = _webSocket.send(serializedJson);
+        CobraConnection::invokeTrafficTrackerCallback(webSocketSendInfo.wireSize,
+                                                       false);
+        return webSocketSendInfo.success;
+    }
+
+    void CobraConnection::suspend()
+    {
+        disconnect();
+    }
+
+    void CobraConnection::resume()
+    {
+        connect();
+    }
+
+} // namespace ix

examples/cobra_publisher/IXCobraConnection.h

@@ -0,0 +1,163 @@
+/*
+ *  IXCobraConnection.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2017-2018 Machine Zone. All rights reserved.
+ */
+
+#pragma once
+
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+
+#include <jsoncpp/json/json.h>
+#include <ixwebsocket/IXWebSocket.h>
+#include <ixwebsocket/IXWebSocketPerMessageDeflateOptions.h>
+
+namespace ix
+{
+    enum CobraConnectionEventType
+    {
+        CobraConnection_EventType_Authenticated = 0,
+        CobraConnection_EventType_Error = 1,
+        CobraConnection_EventType_Open = 2,
+        CobraConnection_EventType_Closed = 3
+    };
+
+    enum CobraConnectionPublishMode
+    {
+        CobraConnection_PublishMode_Immediate = 0,
+        CobraConnection_PublishMode_Batch = 1
+    };
+
+    using SubscriptionCallback = std::function<void(const Json::Value&)>;
+    using EventCallback = std::function<void(CobraConnectionEventType,
+                                             const std::string&,
+                                             const WebSocketHttpHeaders&)>;
+    using TrafficTrackerCallback = std::function<void(size_t size, bool incoming)>;
+
+    class CobraConnection
+    {
+    public:
+        CobraConnection();
+        ~CobraConnection();
+
+        /// Configuration / set keys, etc...
+        /// All input data but the channel name is encrypted with rc4
+        void configure(const std::string& appkey,
+                       const std::string& endpoint,
+                       const std::string& rolename,
+                       const std::string& rolesecret,
+                       WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions);
+
+        static void setTrafficTrackerCallback(const TrafficTrackerCallback& callback);
+
+        /// Reset the traffic tracker callback to an no-op one.
+        static void resetTrafficTrackerCallback();
+
+        /// Set the closed callback
+        void setEventCallback(const EventCallback& eventCallback);
+
+        /// Start the worker thread, used for background publishing
+        void start();
+
+        /// Publish a message to a channel
+        ///
+        /// No-op if the connection is not established
+        bool publish(const Json::Value& channels,
+                     const Json::Value& msg);
+
+        // Subscribe to a channel, and execute a callback when an incoming
+        // message arrives.
+        void subscribe(const std::string& channel, SubscriptionCallback cb);
+
+        /// Unsubscribe from a channel
+        void unsubscribe(const std::string& channel);
+
+        /// Close the connection
+        void disconnect();
+
+        /// Connect to Cobra and authenticate the connection
+        bool connect();
+
+        /// Returns true only if we're connected
+        bool isConnected() const;
+
+        /// Flush the publish queue
+        bool flushQueue();
+
+        /// Set the publish mode
+        void setPublishMode(CobraConnectionPublishMode publishMode);
+
+        /// Lifecycle management. Free resources when backgrounding
+        void suspend();
+        void resume();
+
+    private:
+        bool sendHandshakeMessage();
+        bool handleHandshakeResponse(const Json::Value& data);
+        bool sendAuthMessage(const std::string& nonce);
+        bool handleSubscriptionData(const Json::Value& pdu);
+
+        void initWebSocketOnMessageCallback();
+
+        bool publishMessage(const std::string& serializedJson);
+        void enqueue(const std::string& msg);
+        std::string serializeJson(const Json::Value& pdu);
+
+        /// Invoke the traffic tracker callback
+        static void invokeTrafficTrackerCallback(size_t size, bool incoming);
+
+        /// Invoke event callbacks
+        void invokeEventCallback(CobraConnectionEventType eventType,
+                                 const std::string& errorMsg = std::string(),
+                                 const WebSocketHttpHeaders& headers = WebSocketHttpHeaders());
+        void invokeErrorCallback(const std::string& errorMsg);
+
+        ///
+        /// Member variables
+        ///
+        WebSocket _webSocket;
+
+        /// Configuration data
+        std::string _appkey;
+        std::string _endpoint;
+        std::string _role_name;
+        std::string _role_secret;
+        std::atomic<CobraConnectionPublishMode> _publishMode;
+
+        // Can be set on control+background thread, protecting with an atomic
+        std::atomic<bool> _authenticated;
+
+        // Keep some objects around
+        Json::Value _body;
+        Json::Value _pdu;
+        Json::FastWriter _jsonWriter;
+        mutable std::mutex _jsonWriterMutex;
+
+        /// Traffic tracker callback
+        static TrafficTrackerCallback _trafficTrackerCallback;
+
+        /// Cobra events callbacks
+        EventCallback _eventCallback;
+        mutable std::mutex _eventCallbackMutex;
+
+        /// Subscription callbacks, only one per channel
+        std::unordered_map<std::string, SubscriptionCallback> _cbs;
+        mutable std::mutex _cbsMutex;
+
+        // Message Queue can be touched on control+background thread,
+        // protecting with a mutex.
+        //
+        // Message queue is used when there are problems sending messages so
+        // that sending can be retried later.
+        std::deque<std::string> _messageQueue;
+        mutable std::mutex _queueMutex;
+
+        // Cap the queue size (100 elems so far -> ~100k)
+        static constexpr size_t kQueueMaxSize = 256;
+    };
+
+} // namespace ix

examples/cobra_publisher/README.md

@@ -0,0 +1,6 @@
+```
+mkdir build
+cd build
+cmake ..
+make && (cd .. ; sh cobra_publisher.sh)
+```

examples/cobra_publisher/cobra_publisher.cpp

@@ -0,0 +1,123 @@
+/*
+ *  cobra_publisher.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <atomic>
+#include <ixwebsocket/IXWebSocket.h>
+#include "IXCobraConnection.h"
+#include "jsoncpp/json/json.h"
+
+void msleep(int ms)
+{
+    std::chrono::duration<double, std::milli> duration(ms);
+    std::this_thread::sleep_for(duration);
+}
+
+int main(int argc, char* argv[])
+{
+    if (argc != 7)
+    {
+        std::cerr << "Usage error: need 6 arguments." << std::endl;
+    }
+
+    std::string endpoint = argv[1];
+    std::string appkey = argv[2];
+    std::string channel = argv[3];
+    std::string rolename = argv[4];
+    std::string rolesecret = argv[5];
+    std::string path = argv[6];
+
+    std::atomic<size_t> incomingBytes(0);
+    std::atomic<size_t> outgoingBytes(0);
+    ix::CobraConnection::setTrafficTrackerCallback(
+        [&incomingBytes, &outgoingBytes](size_t size, bool incoming)
+        {
+            if (incoming)
+            {
+                incomingBytes += size;
+            }
+            else
+            {
+                outgoingBytes += size;
+            }
+        }
+    );
+
+    bool done = false;
+    ix::CobraConnection cobraConnection;
+    ix::WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(
+        true, false, false, 15, 15);
+    cobraConnection.configure(appkey, endpoint, rolename, rolesecret,
+                               webSocketPerMessageDeflateOptions);
+    cobraConnection.connect();
+    cobraConnection.setEventCallback(
+        [&cobraConnection, channel, path, &done]
+        (ix::CobraConnectionEventType eventType,
+         const std::string& errMsg,
+         const ix::WebSocketHttpHeaders& headers)
+        {
+            if (eventType == ix::CobraConnection_EventType_Open)
+            {
+                std::cout << "Handshake Headers:" << std::endl;
+                for (auto it : headers)
+                {
+                    std::cout << it.first << ": " << it.second << std::endl;
+                }
+            }
+            else if (eventType == ix::CobraConnection_EventType_Authenticated)
+            {
+                std::cout << "Authenticated" << std::endl;
+
+                std::string line;
+                std::ifstream f(path);
+                if (!f.is_open())
+                {
+                    std::cerr << "Error while opening file: " << path << std::endl;
+                }
+
+                int n = 0;
+                while (getline(f, line))
+                {
+                    Json::Value value;
+                    Json::Reader reader;
+                    reader.parse(line, value);
+
+                    cobraConnection.publish(channel, value);
+                    n++;
+                }
+                std::cerr << "#published messages: " << n << std::endl;
+
+                if (f.bad())
+                {
+                    std::cerr << "Error while opening file: " << path << std::endl;
+                }
+
+                done = true;
+            }
+            else if (eventType == ix::CobraConnection_EventType_Error)
+            {
+                std::cerr << "Cobra Error received: " << errMsg << std::endl;
+                done = true;
+            }
+            else if (eventType == ix::CobraConnection_EventType_Closed)
+            {
+                std::cerr << "Cobra connection closed" << std::endl;
+            }
+        }
+    );
+
+    while (!done)
+    {
+        msleep(1);
+    }
+
+    std::cout << "Incoming bytes: " << incomingBytes << std::endl;
+    std::cout << "Outgoing bytes: " << outgoingBytes << std::endl;
+
+    return 0;
+}

examples/cobra_publisher/cobra_publisher.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+endpoint="ws://127.0.0.1:8765"
+endpoint="ws://127.0.0.1:5678"
+appkey="appkey"
+channel="foo"
+rolename="a_role"
+rolesecret="a_secret"
+filename=${FILENAME:=events.jsonl}
+
+build/cobra_publisher $endpoint $appkey $channel $rolename $rolesecret $filename

examples/cobra_publisher/devnull_server.js

@@ -0,0 +1,45 @@
+/*
+ *  devnull_server.js
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+const WebSocket = require('ws');
+
+let wss = new WebSocket.Server({ port: 5678, perMessageDeflate: true })
+
+wss.on('connection', (ws) => {
+
+  let handshake = false
+  let authenticated = false
+
+  ws.on('message', (data) => {
+
+    console.log(data.toString('utf-8'))
+
+    if (!handshake) {
+      let response = {
+          "action": "auth/handshake/ok",
+          "body": {
+              "data": {
+                  "nonce": "MTI0Njg4NTAyMjYxMzgxMzgzMg==",
+                  "version": "0.0.24"
+              }
+          },
+          "id": 1
+      }
+      ws.send(JSON.stringify(response))
+      handshake = true
+    } else if (!authenticated) {
+      let response = {
+        "action": "auth/authenticate/ok",
+        "body": {},
+        "id": 2
+      }
+      
+      ws.send(JSON.stringify(response))
+      authenticated = true
+    } else {
+      console.log(data)
+    }
+  });
+})

examples/cobra_publisher/devnull_server.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+import os
+import json
+import asyncio
+import websockets
+
+
+async def echo(websocket, path):
+    handshake = False
+    authenticated = False
+
+    async for message in websocket:
+        print(message)
+
+        if not handshake:
+            response = {
+                "action": "auth/handshake/ok",
+                "body": {
+                    "data": {
+                        "nonce": "MTI0Njg4NTAyMjYxMzgxMzgzMg==",
+                        "version": "0.0.24"
+                    }
+                },
+                "id": 1
+            }
+            await websocket.send(json.dumps(response))
+            handshake = True
+
+        elif not authenticated:
+            response = {
+                "action": "auth/authenticate/ok",
+                "body": {},
+                "id": 2
+            }
+          
+            await websocket.send(json.dumps(response))
+            authenticated = True
+
+
+asyncio.get_event_loop().run_until_complete(
+    websockets.serve(echo, 'localhost', 5678))
+asyncio.get_event_loop().run_forever()

examples/cobra_publisher/events.jsonl

@@ -0,0 +1,3 @@
+{"array":[1,2,3],"boolean":true,"color":"#82b92c","null":null,"number":123,"object":{"a":"b","c":"d","e":"f"},"string":"Foo"}
+{"array":[1,2,3],"boolean":true,"color":"#82b92c","null":null,"number":123,"object":{"a":"b","c":"d","e":"f"},"string":"Bar"}
+{"array":[1,2,3],"boolean":true,"color":"#82b92c","null":null,"number":123,"object":{"a":"b","c":"d","e":"f"},"string":"Baz"}

examples/cobra_publisher/jsoncpp/json/json-forwards.h

@@ -0,0 +1,333 @@
+/// Json-cpp amalgated 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_AMALGATED_H_INCLUDED
+# define JSON_FORWARD_AMALGATED_H_INCLUDED
+/// If defined, indicates that the source file is amalgated
+/// 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 <stddef.h>
+#include <string> //typedef String
+#include <stdint.h> //typedef int64_t, uint64_t
+
+/// If defined, indicates that json library is embedded in CppTL library.
+//# define JSON_IN_CPPTL 1
+
+/// If defined, indicates that json may leverage CppTL library
+//#  define JSON_USE_CPPTL 1
+/// If defined, indicates that cpptl vector based map should be used instead of
+/// std::map
+/// as Value container.
+//#  define JSON_USE_CPPTL_SMALLMAP 1
+
+// 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
+
+/// If defined, indicates that the source file is amalgated
+/// to prevent private header inclusion.
+/// Remarks: it is automatically defined in the generated amalgated header.
+// #define JSON_IS_AMALGAMATION
+
+#ifdef JSON_IN_CPPTL
+#include <cpptl/config.h>
+#ifndef JSON_USE_CPPTL
+#define JSON_USE_CPPTL 1
+#endif
+#endif
+
+#ifdef JSON_IN_CPPTL
+#define JSON_API CPPTL_API
+#elif defined(JSON_DLL_BUILD)
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define JSON_API __declspec(dllexport)
+#define JSONCPP_DISABLE_DLL_INTERFACE_WARNING
+#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_IN_CPPTL
+#if !defined(JSON_API)
+#define JSON_API
+#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
+
+#if defined(_MSC_VER) // MSVC
+#  if _MSC_VER <= 1200 // MSVC 6
+    // Microsoft Visual Studio 6 only support conversion from __int64 to double
+    // (no conversion from unsigned __int64).
+#    define JSON_USE_INT64_DOUBLE_CONVERSION 1
+    // Disable warning 4786 for VS6 caused by STL (identifier was truncated to '255'
+    // characters in the debug information)
+    // All projects I've ever seen with VS6 were using this globally (not bothering
+    // with pragma push/pop).
+#    pragma warning(disable : 4786)
+#  endif // MSVC 6
+
+#  if _MSC_VER >= 1500 // MSVC 2008
+    /// Indicates that the following function is deprecated.
+#    define JSONCPP_DEPRECATED(message) __declspec(deprecated(message))
+#  endif
+
+#endif // defined(_MSC_VER)
+
+// In c++11 the override keyword allows you to explicity define that a function
+// is intended to override the base-class version.  This makes the code more
+// managable and fixes a set of common hard-to-find bugs.
+#if __cplusplus >= 201103L
+# define JSONCPP_OVERRIDE override
+# define JSONCPP_NOEXCEPT noexcept
+#elif defined(_MSC_VER) && _MSC_VER > 1600 && _MSC_VER < 1900
+# define JSONCPP_OVERRIDE override
+# define JSONCPP_NOEXCEPT throw()
+#elif defined(_MSC_VER) && _MSC_VER >= 1900
+# define JSONCPP_OVERRIDE override
+# define JSONCPP_NOEXCEPT noexcept
+#else
+# define JSONCPP_OVERRIDE
+# define JSONCPP_NOEXCEPT throw()
+#endif
+
+#ifndef JSON_HAS_RVALUE_REFERENCES
+
+#if defined(_MSC_VER) && _MSC_VER >= 1600 // MSVC >= 2010
+#define JSON_HAS_RVALUE_REFERENCES 1
+#endif // MSVC >= 2010
+
+#ifdef __clang__
+#if __has_feature(cxx_rvalue_references)
+#define JSON_HAS_RVALUE_REFERENCES 1
+#endif  // has_feature
+
+#elif defined __GNUC__ // not clang (gcc comes later since clang emulates gcc)
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
+#define JSON_HAS_RVALUE_REFERENCES 1
+#endif  // GXX_EXPERIMENTAL
+
+#endif // __clang__ || __GNUC__
+
+#endif // not defined JSON_HAS_RVALUE_REFERENCES
+
+#ifndef JSON_HAS_RVALUE_REFERENCES
+#define JSON_HAS_RVALUE_REFERENCES 0
+#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
+#endif // __clang__ || __GNUC__
+
+#if !defined(JSONCPP_DEPRECATED)
+#define JSONCPP_DEPRECATED(message)
+#endif // if !defined(JSONCPP_DEPRECATED)
+
+#if __GNUC__ >= 6
+#  define JSON_USE_INT64_DOUBLE_CONVERSION 1
+#endif
+
+#if !defined(JSON_IS_AMALGAMATION)
+
+# include "version.h"
+
+# if JSONCPP_USING_SECURE_MEMORY
+#  include "allocator.h" //typedef Allocator
+# endif
+
+#endif // if !defined(JSON_IS_AMALGAMATION)
+
+namespace Json {
+typedef int Int;
+typedef unsigned int UInt;
+#if defined(JSON_NO_INT64)
+typedef int LargestInt;
+typedef unsigned int LargestUInt;
+#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
+typedef __int64 Int64;
+typedef unsigned __int64 UInt64;
+#else                 // if defined(_MSC_VER) // Other platforms, use long long
+typedef int64_t Int64;
+typedef uint64_t UInt64;
+#endif // if defined(_MSC_VER)
+typedef Int64 LargestInt;
+typedef UInt64 LargestUInt;
+#define JSON_HAS_INT64
+#endif // if defined(JSON_NO_INT64)
+#if JSONCPP_USING_SECURE_MEMORY
+#define JSONCPP_STRING        std::basic_string<char, std::char_traits<char>, Json::SecureAllocator<char> >
+#define JSONCPP_OSTRINGSTREAM std::basic_ostringstream<char, std::char_traits<char>, Json::SecureAllocator<char> >
+#define JSONCPP_OSTREAM       std::basic_ostream<char, std::char_traits<char>>
+#define JSONCPP_ISTRINGSTREAM std::basic_istringstream<char, std::char_traits<char>, Json::SecureAllocator<char> >
+#define JSONCPP_ISTREAM       std::istream
+#else
+#define JSONCPP_STRING        std::string
+#define JSONCPP_OSTRINGSTREAM std::ostringstream
+#define JSONCPP_OSTREAM       std::ostream
+#define JSONCPP_ISTRINGSTREAM std::istringstream
+#define JSONCPP_ISTREAM       std::istream
+#endif // if JSONCPP_USING_SECURE_MEMORY
+} // end namespace Json
+
+#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 FastWriter;
+class StyledWriter;
+
+// reader.h
+class Reader;
+
+// features.h
+class Features;
+
+// value.h
+typedef unsigned int ArrayIndex;
+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_AMALGATED_H_INCLUDED

examples/cobra_publisher/package-lock.json

@@ -0,0 +1,19 @@
+{
+  "requires": true,
+  "lockfileVersion": 1,
+  "dependencies": {
+    "async-limiter": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz",
+      "integrity": "sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg=="
+    },
+    "ws": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-6.1.0.tgz",
+      "integrity": "sha512-H3dGVdGvW2H8bnYpIDc3u3LH8Wue3Qh+Zto6aXXFzvESkTVT6rAfKR6tR/+coaUvxs8yHtmNV0uioBF62ZGSTg==",
+      "requires": {
+        "async-limiter": "1.0.0"
+      }
+    }
+  }
+}

examples/echo_server/CMakeLists.txt

@@ -0,0 +1,30 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+#
+
+cmake_minimum_required (VERSION 3.4.1)
+project (echo_server)
+
+# There's -Weverything too for clang
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wshorten-64-to-32")
+
+set (OPENSSL_PREFIX /usr/local/opt/openssl) # Homebrew openssl
+
+set (CMAKE_CXX_STANDARD 14)
+
+option(USE_TLS "Add TLS support" ON)
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
+
+include_directories(echo_server .)
+
+add_executable(echo_server 
+  echo_server.cpp)
+
+if (APPLE AND USE_TLS)
+    target_link_libraries(echo_server "-framework foundation" "-framework security")
+endif()
+
+target_link_libraries(echo_server ixwebsocket)
+install(TARGETS echo_server DESTINATION bin)

examples/echo_server/echo_server.cpp

@@ -0,0 +1,68 @@
+/*
+ *  echo_server.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <ixwebsocket/IXWebSocketServer.h>
+
+int main(int argc, char** argv)
+{
+    int port = 8080;
+    if (argc == 2)
+    {
+        std::stringstream ss;
+        ss << argv[1];
+        ss >> port;
+    }
+
+    ix::WebSocketServer server(port);
+
+    server.setOnConnectionCallback(
+        [&server](std::shared_ptr<ix::WebSocket> webSocket)
+        {
+            webSocket->setOnMessageCallback(
+                [webSocket, &server](ix::WebSocketMessageType messageType,
+                   const std::string& str,
+                   size_t wireSize,
+                   const ix::WebSocketErrorInfo& error,
+                   const ix::WebSocketOpenInfo& openInfo,
+                   const ix::WebSocketCloseInfo& closeInfo)
+                {
+                    if (messageType == ix::WebSocket_MessageType_Open)
+                    {
+                        std::cerr << "New connection" << std::endl;
+                        std::cerr << "Uri: " << openInfo.uri << std::endl;
+                        std::cerr << "Headers:" << std::endl;
+                        for (auto it : openInfo.headers)
+                        {
+                            std::cerr << it.first << ": " << it.second << std::endl;
+                        }
+                    }
+                    else if (messageType == ix::WebSocket_MessageType_Close)
+                    {
+                        std::cerr << "Closed connection" << std::endl;
+                    }
+                    else if (messageType == ix::WebSocket_MessageType_Message)
+                    {
+                        webSocket->send(str);
+                    }
+                }
+            );
+        }
+    );
+
+    auto res = server.listen();
+    if (!res.first)
+    {
+        std::cerr << res.second << std::endl;
+        return 1;
+    }
+
+    server.start();
+    server.wait();
+
+    return 0;
+}

examples/ping_pong/.gitignore

@@ -0,0 +1,2 @@
+venv
+build

examples/ping_pong/CMakeLists.txt

@@ -0,0 +1,27 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+#
+
+cmake_minimum_required (VERSION 3.4.1)
+project (ping_pong)
+
+set (CMAKE_CXX_STANDARD 14)
+
+option(USE_TLS "Add TLS support" ON)
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
+
+add_executable(ping_pong ping_pong.cpp)
+
+if (APPLE AND USE_TLS)
+    target_link_libraries(ping_pong "-framework foundation" "-framework security")
+endif()
+
+if (WIN32)
+    target_link_libraries(ping_pong wsock32 ws2_32)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+target_link_libraries(ping_pong ixwebsocket)
+install(TARGETS ping_pong DESTINATION bin)

examples/ping_pong/build_linux.sh

@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
+#
+
+# 'manual' way of building. You can also use cmake.
+
+g++ --std=c++11 \
+    ../../ixwebsocket/IXSocket.cpp	\
+    ../../ixwebsocket/IXWebSocketTransport.cpp \
+    ../../ixwebsocket/IXWebSocket.cpp \
+    -I ../.. \
+    cmd_websocket_chat.cpp \
+    -o cmd_websocket_chat

examples/ping_pong/client.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+import asyncio
+import websockets
+
+async def hello(uri):
+    async with websockets.connect(uri) as websocket:
+        await websocket.send("Hello world!")
+        response = await websocket.recv()
+        print(response)
+
+        pong_waiter = await websocket.ping('coucou')
+        ret = await pong_waiter   # only if you want to wait for the pong
+        print(ret)
+
+asyncio.get_event_loop().run_until_complete(
+    hello('ws://localhost:5678'))

examples/ping_pong/ping_pong.cpp

@@ -0,0 +1,171 @@
+/*
+ *  ping_pong.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <ixwebsocket/IXWebSocket.h>
+#include <ixwebsocket/IXSocket.h>
+
+using namespace ix;
+
+namespace
+{
+    void log(const std::string& msg)
+    {
+        std::cout << msg << std::endl;
+    }
+
+    class WebSocketPingPong
+    {
+        public:
+            WebSocketPingPong(const std::string& _url);
+
+            void subscribe(const std::string& channel);
+            void start();
+            void stop();
+
+            void ping(const std::string& text);
+            void send(const std::string& text);
+
+        private:
+            std::string _url;
+            ix::WebSocket _webSocket;
+    };
+
+    WebSocketPingPong::WebSocketPingPong(const std::string& url) :
+        _url(url)
+    {
+        ;
+    }
+
+    void WebSocketPingPong::stop()
+    {
+        _webSocket.stop();
+    }
+
+    void WebSocketPingPong::start()
+    {
+        _webSocket.setUrl(_url);
+
+        std::stringstream ss;
+        log(std::string("Connecting to url: ") + _url);
+
+        _webSocket.setOnMessageCallback(
+            [this](ix::WebSocketMessageType messageType,
+               const std::string& str,
+               size_t wireSize,
+               const ix::WebSocketErrorInfo& error,
+               const ix::WebSocketOpenInfo& openInfo,
+               const ix::WebSocketCloseInfo& closeInfo)
+            {
+                std::stringstream ss;
+                if (messageType == ix::WebSocket_MessageType_Open)
+                {
+                    log("ping_pong: connected");
+                }
+                else if (messageType == ix::WebSocket_MessageType_Close)
+                {
+                    ss << "ping_pong: disconnected:"
+                       << " code " << closeInfo.code
+                       << " reason " << closeInfo.reason
+                       << str;
+                    log(ss.str());
+                }
+                else if (messageType == ix::WebSocket_MessageType_Message)
+                {
+                    ss << "ping_pong: received message: "
+                       << str;
+                    log(ss.str());
+                }
+                else if (messageType == ix::WebSocket_MessageType_Ping)
+                {
+                    ss << "ping_pong: received ping message: "
+                       << str;
+                    log(ss.str());
+                }
+                else if (messageType == ix::WebSocket_MessageType_Pong)
+                {
+                    ss << "ping_pong: received pong message: "
+                       << str;
+                    log(ss.str());
+                }
+                else if (messageType == ix::WebSocket_MessageType_Error)
+                {
+                    ss << "Connection error: " << error.reason      << std::endl;
+                    ss << "#retries: "         << error.retries     << std::endl;
+                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
+                    ss << "HTTP Status: "      << error.http_status << std::endl;
+                    log(ss.str());
+                }
+                else
+                {
+                    ss << "Invalid ix::WebSocketMessageType";
+                    log(ss.str());
+                }
+            });
+
+        _webSocket.start();
+    }
+
+    void WebSocketPingPong::ping(const std::string& text)
+    {
+        if (!_webSocket.ping(text).success)
+        {
+            std::cerr << "Failed to send ping message. Message too long (> 125 bytes) or endpoint is disconnected"
+                      << std::endl;
+        }
+    }
+
+    void WebSocketPingPong::send(const std::string& text)
+    {
+        _webSocket.send(text);
+    }
+
+    void interactiveMain(const std::string& url)
+    {
+        std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
+        WebSocketPingPong webSocketPingPong(url);
+        webSocketPingPong.start();
+
+        while (true)
+        {
+            std::string text;
+            std::cout << "> " << std::flush;
+            std::getline(std::cin, text);
+
+            if (!std::cin)
+            {
+                break;
+            }
+
+            if (text == "/close")
+            {
+                webSocketPingPong.send(text);
+            }
+            else
+            {
+                webSocketPingPong.ping(text);
+            }
+        }
+
+        std::cout << std::endl;
+        webSocketPingPong.stop();
+    }
+}
+
+int main(int argc, char** argv)
+{
+    if (argc != 2)
+    {
+        std::cerr << "Usage: ping_pong <url>" << std::endl;
+        return 1;
+    }
+    std::string url = argv[1];
+
+    Socket::init();
+    interactiveMain(url);
+    return 0;
+}

examples/ping_pong/server.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python
+
+import os
+import asyncio
+import websockets
+
+async def echo(websocket, path):
+    async for message in websocket:
+        print(message)
+        await websocket.send(message)
+
+        if os.getenv('TEST_CLOSE'):
+            print('Closing')
+            # breakpoint()
+            await websocket.close(1001, 'close message')
+            # await websocket.close()
+            break
+
+asyncio.get_event_loop().run_until_complete(
+    websockets.serve(echo, 'localhost', 5678))
+asyncio.get_event_loop().run_forever()

examples/ping_pong/test.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+test -d build || {
+    mkdir -p build
+    cd build
+    cmake ..
+}
+(cd build ; make)
+./build/ping_pong ws://localhost:5678

examples/ws_connect/.gitignore

@@ -0,0 +1,3 @@
+build
+venv
+node_modules

examples/ws_connect/CMakeLists.txt

@@ -0,0 +1,22 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+#
+
+cmake_minimum_required (VERSION 3.4.1)
+project (ws_connect)
+
+set (CMAKE_CXX_STANDARD 14)
+
+option(USE_TLS "Add TLS support" ON)
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
+
+add_executable(ws_connect ws_connect.cpp)
+
+if (APPLE AND USE_TLS)
+    target_link_libraries(ws_connect "-framework foundation" "-framework security")
+endif()
+
+target_link_libraries(ws_connect ixwebsocket)
+install(TARGETS ws_connect DESTINATION bin)

examples/ws_connect/README.md

@@ -0,0 +1,11 @@
+# Building
+
+1. mkdir build
+2. cd build
+3. cmake ..
+4. make
+
+## Disable TLS
+
+* Enable: `cmake -DUSE_TLS=OFF ..`
+* Disable: `cmake -DUSE_TLS=ON ..`

examples/ws_connect/build_linux.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
+#
+
+# 'manual' way of building. You can also use cmake.
+
+g++ --std=c++11 \
+    -DIXWEBSOCKET_USE_TLS \
+    -g \
+    ../../ixwebsocket/IXEventFd.cpp	\
+    ../../ixwebsocket/IXSocket.cpp	\
+    ../../ixwebsocket/IXSetThreadName.cpp	\
+    ../../ixwebsocket/IXWebSocketTransport.cpp \
+    ../../ixwebsocket/IXWebSocket.cpp \
+    ../../ixwebsocket/IXDNSLookup.cpp \
+    ../../ixwebsocket/IXSocketConnect.cpp \
+    ../../ixwebsocket/IXSocketOpenSSL.cpp \
+    ../../ixwebsocket/IXWebSocketPerMessageDeflate.cpp \
+    ../../ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp \
+    -I ../.. \
+    ws_connect.cpp \
+    -o ws_connect \
+    -lcrypto -lssl -lz -lpthread

examples/ws_connect/ws_connect.cpp

@@ -0,0 +1,165 @@
+/*
+ *  ws_connect.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include <iostream>
+#include <sstream>
+#include <ixwebsocket/IXWebSocket.h>
+#include <ixwebsocket/IXSocket.h>
+
+using namespace ix;
+
+namespace
+{
+    void log(const std::string& msg)
+    {
+        std::cout << msg << std::endl;
+    }
+
+    class WebSocketConnect
+    {
+        public:
+            WebSocketConnect(const std::string& _url);
+
+            void subscribe(const std::string& channel);
+            void start();
+            void stop();
+
+            void sendMessage(const std::string& text);
+
+        private:
+            std::string _url;
+            ix::WebSocket _webSocket;
+    };
+
+    WebSocketConnect::WebSocketConnect(const std::string& url) :
+        _url(url)
+    {
+        ;
+    }
+
+    void WebSocketConnect::stop()
+    {
+        _webSocket.stop();
+    }
+
+    void WebSocketConnect::start()
+    {
+        _webSocket.setUrl(_url);
+
+        ix::WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(
+            true, false, false, 15, 15);
+        _webSocket.setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
+
+        std::stringstream ss;
+        log(std::string("Connecting to url: ") + _url);
+
+        _webSocket.setOnMessageCallback(
+            [this](ix::WebSocketMessageType messageType,
+               const std::string& str,
+               size_t wireSize,
+               const ix::WebSocketErrorInfo& error,
+               const ix::WebSocketOpenInfo& openInfo,
+               const ix::WebSocketCloseInfo& closeInfo)
+            {
+                std::stringstream ss;
+                if (messageType == ix::WebSocket_MessageType_Open)
+                {
+                    log("ws_connect: connected");
+                    std::cout << "Uri: " << openInfo.uri << std::endl;
+                    std::cout << "Handshake Headers:" << std::endl;
+                    for (auto it : openInfo.headers)
+                    {
+                        std::cout << it.first << ": " << it.second << std::endl;
+                    }
+                }
+                else if (messageType == ix::WebSocket_MessageType_Close)
+                {
+                    ss << "ws_connect: connection closed:";
+                    ss << " code " << closeInfo.code;
+                    ss << " reason " << closeInfo.reason << std::endl;
+                    log(ss.str());
+                }
+                else if (messageType == ix::WebSocket_MessageType_Message)
+                {
+                    ss << "ws_connect: received message: "
+                       << str;
+                    log(ss.str());
+                }
+                else if (messageType == ix::WebSocket_MessageType_Error)
+                {
+                    ss << "Connection error: " << error.reason      << std::endl;
+                    ss << "#retries: "         << error.retries     << std::endl;
+                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
+                    ss << "HTTP Status: "      << error.http_status << std::endl;
+                    log(ss.str());
+                }
+                else
+                {
+                    ss << "Invalid ix::WebSocketMessageType";
+                    log(ss.str());
+                }
+            });
+
+        _webSocket.start();
+    }
+
+    void WebSocketConnect::sendMessage(const std::string& text)
+    {
+        _webSocket.send(text);
+    }
+
+    void interactiveMain(const std::string& url)
+    {
+        std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
+        WebSocketConnect webSocketChat(url);
+        webSocketChat.start();
+
+        while (true)
+        {
+            std::string text;
+            std::cout << "> " << std::flush;
+            std::getline(std::cin, text);
+
+            if (text == "/stop")
+            {
+                std::cout << "Stopping connection..." << std::endl;
+                webSocketChat.stop();
+                continue;
+            }
+
+            if (text == "/start")
+            {
+                std::cout << "Starting connection..." << std::endl;
+                webSocketChat.start();
+                continue;
+            }
+
+            if (!std::cin)
+            {
+                break;
+            }
+
+            webSocketChat.sendMessage(text);
+        }
+
+        std::cout << std::endl;
+        webSocketChat.stop();
+    }
+}
+
+int main(int argc, char** argv)
+{
+    if (argc != 2)
+    {
+        std::cerr << "Usage: ws_connect <url>" << std::endl;
+        return 1;
+    }
+    std::string url = argv[1];
+
+    Socket::init();
+    interactiveMain(url);
+    return 0;
+}

ixwebsocket/IXCancellationRequest.cpp

@@ -0,0 +1,33 @@
+/*
+ *  IXCancellationRequest.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXCancellationRequest.h"
+
+#include <chrono>
+
+namespace ix
+{
+    CancellationRequest makeCancellationRequestWithTimeout(int secs,
+                                                           std::atomic<bool>& requestInitCancellation)
+    {
+        auto start = std::chrono::system_clock::now();
+        auto timeout = std::chrono::seconds(secs);
+
+        auto isCancellationRequested = [&requestInitCancellation, start, timeout]() -> bool
+        {
+            // Was an explicit cancellation requested ?
+            if (requestInitCancellation) return true;
+
+            auto now = std::chrono::system_clock::now();
+            if ((now - start) > timeout) return true;
+
+            // No cancellation request
+            return false;
+        };
+
+        return isCancellationRequested;
+    }
+}

ixwebsocket/IXCancellationRequest.h

@@ -0,0 +1,19 @@
+/*
+ *  IXCancellationRequest.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <functional>
+#include <atomic>
+
+namespace ix
+{
+    using CancellationRequest = std::function<bool()>;
+
+    CancellationRequest makeCancellationRequestWithTimeout(int seconds,
+                                                           std::atomic<bool>& requestInitCancellation);
+}
+

ixwebsocket/IXDNSLookup.cpp

@@ -0,0 +1,164 @@
+/*
+ *  IXDNSLookup.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXDNSLookup.h"
+#include "IXNetSystem.h"
+
+#include <string.h>
+#include <chrono>
+
+namespace ix
+{
+    const int64_t DNSLookup::kDefaultWait = 10; // ms
+
+    std::atomic<uint64_t> DNSLookup::_nextId(0);
+    std::set<uint64_t> DNSLookup::_activeJobs;
+    std::mutex DNSLookup::_activeJobsMutex;
+
+    DNSLookup::DNSLookup(const std::string& hostname, int port, int64_t wait) :
+        _hostname(hostname),
+        _port(port),
+        _wait(wait),
+        _res(nullptr),
+        _done(false),
+        _id(_nextId++)
+    {
+
+    }
+
+    DNSLookup::~DNSLookup()
+    {
+        // Remove this job from the active jobs list
+        std::unique_lock<std::mutex> lock(_activeJobsMutex);
+        _activeJobs.erase(_id);
+    }
+
+    struct addrinfo* DNSLookup::getAddrInfo(const std::string& hostname,
+                                            int port,
+                                            std::string& errMsg)
+    {
+        struct addrinfo hints;
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+
+        std::string sport = std::to_string(port);
+
+        struct addrinfo* res;
+        int getaddrinfo_result = getaddrinfo(hostname.c_str(), sport.c_str(),
+                                             &hints, &res);
+        if (getaddrinfo_result)
+        {
+            errMsg = gai_strerror(getaddrinfo_result);
+            res = nullptr;
+        }
+        return res;
+    }
+
+    struct addrinfo* DNSLookup::resolve(std::string& errMsg,
+                                        const CancellationRequest& isCancellationRequested,
+                                        bool blocking)
+    {
+        return blocking ? resolveBlocking(errMsg, isCancellationRequested)
+                        : resolveAsync(errMsg, isCancellationRequested);
+    }
+
+    struct addrinfo* DNSLookup::resolveBlocking(std::string& errMsg,
+                                                const CancellationRequest& isCancellationRequested)
+    {
+        errMsg = "no error";
+
+        // Maybe a cancellation request got in before the background thread terminated ?
+        if (isCancellationRequested())
+        {
+            errMsg = "cancellation requested";
+            return nullptr;
+        }
+
+        return getAddrInfo(_hostname, _port, errMsg);
+    }
+
+    struct addrinfo* DNSLookup::resolveAsync(std::string& errMsg,
+                                             const CancellationRequest& isCancellationRequested)
+    {
+        errMsg = "no error";
+
+        // Can only be called once, otherwise we would have to manage a pool
+        // of background thread which is overkill for our usage.
+        if (_done)
+        {
+            return nullptr; // programming error, create a second DNSLookup instance
+                            // if you need a second lookup.
+        }
+
+        // Record job in the active Job set
+        {
+            std::unique_lock<std::mutex> lock(_activeJobsMutex);
+            _activeJobs.insert(_id);
+        }
+
+        //
+        // Good resource on thread forced termination
+        // https://www.bo-yang.net/2017/11/19/cpp-kill-detached-thread
+        //
+        _thread = std::thread(&DNSLookup::run, this, _id, _hostname, _port);
+        _thread.detach();
+
+        std::unique_lock<std::mutex> lock(_conditionVariableMutex);
+
+        while (!_done)
+        {
+            // Wait for 10 milliseconds on the condition variable, to see
+            // if the bg thread has terminated.
+            if (_condition.wait_for(lock, std::chrono::milliseconds(_wait)) == std::cv_status::no_timeout)
+            {
+                // Background thread has terminated, so we can break of this loop
+                break;
+            }
+
+            // Were we cancelled ?
+            if (isCancellationRequested())
+            {
+                errMsg = "cancellation requested";
+                return nullptr;
+            }
+        }
+
+        // Maybe a cancellation request got in before the bg terminated ?
+        if (isCancellationRequested())
+        {
+            errMsg = "cancellation requested";
+            return nullptr;
+        }
+
+        return _res;
+    }
+
+    void DNSLookup::run(uint64_t id, const std::string& hostname, int port) // thread runner
+    {
+        // We don't want to read or write into members variables of an object that could be
+        // gone, so we use temporary variables (res) or we pass in by copy everything that
+        // getAddrInfo needs to work.
+        std::string errMsg;
+        struct addrinfo* res = getAddrInfo(hostname, port, errMsg);
+
+        // if this isn't an active job, and the control thread is gone
+        // there is not thing to do, and we don't want to touch the defunct
+        // object data structure such as _errMsg or _condition
+        std::unique_lock<std::mutex> lock(_activeJobsMutex);
+        if (_activeJobs.count(id) == 0)
+        {
+            return;
+        }
+
+        // Copy result into the member variables
+        _res = res;
+        _errMsg = errMsg;
+        _condition.notify_one();
+        _done = true;
+    }
+}

ixwebsocket/IXDNSLookup.h

@@ -0,0 +1,66 @@
+/*
+ *  IXDNSLookup.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ *
+ *  Resolve a hostname+port to a struct addrinfo obtained with getaddrinfo
+ *  Does this in a background thread so that it can be cancelled, since
+ *  getaddrinfo is a blocking call, and we don't want to block the main thread on Mobile.
+ */
+
+#pragma once
+
+#include "IXCancellationRequest.h"
+
+#include <string>
+#include <thread>
+#include <atomic>
+#include <condition_variable>
+#include <set>
+
+struct addrinfo;
+
+namespace ix
+{
+    class DNSLookup {
+    public:
+        DNSLookup(const std::string& hostname,
+                  int port,
+                  int64_t wait = DNSLookup::kDefaultWait);
+        ~DNSLookup();
+
+        struct addrinfo* resolve(std::string& errMsg,
+                                 const CancellationRequest& isCancellationRequested,
+                                 bool blocking = false);
+
+    private:
+        struct addrinfo* resolveAsync(std::string& errMsg,
+                                      const CancellationRequest& isCancellationRequested);
+        struct addrinfo* resolveBlocking(std::string& errMsg,
+                                         const CancellationRequest& isCancellationRequested);
+
+        static struct addrinfo* getAddrInfo(const std::string& hostname,
+                                            int port,
+                                            std::string& errMsg);
+
+        void run(uint64_t id, const std::string& hostname, int port); // thread runner
+
+        std::string _hostname;
+        int _port;
+        int64_t _wait;
+        std::string _errMsg;
+        struct addrinfo* _res;
+
+        std::atomic<bool> _done;
+        std::thread _thread;
+        std::condition_variable _condition;
+        std::mutex _conditionVariableMutex;
+
+        uint64_t _id;
+        static std::atomic<uint64_t> _nextId;
+        static std::set<uint64_t> _activeJobs;
+        static std::mutex _activeJobsMutex;
+
+        const static int64_t kDefaultWait;
+    };
+}

ixwebsocket/IXEventFd.cpp

@@ -0,0 +1,82 @@
+/*
+ *  IXEventFd.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+//
+// Linux/Android has a special type of virtual files. select(2) will react
+// when reading/writing to those files, unlike closing sockets.
+//
+// https://linux.die.net/man/2/eventfd
+// http://www.sourcexr.com/articles/2013/10/26/lightweight-inter-process-signaling-with-eventfd
+//
+// eventfd was added in Linux kernel 2.x, and our oldest Android (Kitkat 4.4)
+// is on Kernel 3.x
+//
+// cf Android/Kernel table here
+// https://android.stackexchange.com/questions/51651/which-android-runs-which-linux-kernel
+//
+
+#include "IXEventFd.h"
+
+#ifdef __linux__
+# include <sys/eventfd.h>
+#endif
+
+#ifndef _WIN32
+#include <unistd.h> // for write
+#endif
+
+namespace ix
+{
+    EventFd::EventFd() :
+        _eventfd(-1)
+    {
+#ifdef __linux__
+        _eventfd = eventfd(0, 0);
+#endif
+    }
+
+    EventFd::~EventFd()
+    {
+#ifdef __linux__
+        ::close(_eventfd);
+#endif
+    }
+
+    bool EventFd::notify()
+    {
+#if defined(__linux__)
+        if (_eventfd == -1) return false;
+
+        // select will wake up when a non-zero value is written to our eventfd
+        uint64_t value = 1;
+
+        // we should write 8 bytes for an uint64_t
+        return write(_eventfd, &value, sizeof(value)) == 8;
+#else
+        return true;
+#endif
+    }
+
+    bool EventFd::clear()
+    {
+#if defined(__linux__)
+        if (_eventfd == -1) return false;
+
+        // 0 is a special value ; select will not wake up
+        uint64_t value = 0;
+
+        // we should write 8 bytes for an uint64_t
+        return write(_eventfd, &value, sizeof(value)) == 8;
+#else
+        return true;
+#endif
+    }
+
+    int EventFd::getFd()
+    {
+        return _eventfd;
+    }
+}

ixwebsocket/IXEventFd.h

@@ -0,0 +1,23 @@
+/*
+ *  IXEventFd.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+namespace ix
+{
+    class EventFd {
+    public:
+        EventFd();
+        virtual ~EventFd();
+
+        bool notify();
+        bool clear();
+        int getFd();
+
+    private:
+        int _eventfd;
+    };
+}

ixwebsocket/IXNetSystem.h

@@ -0,0 +1,25 @@
+/*
+ *  IXNetSystem.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone. All rights reserved.
+ */
+
+#pragma once
+
+#ifdef _WIN32
+# include <WS2tcpip.h>
+# include <WinSock2.h>
+# include <basetsd.h>
+# include <io.h>
+# include <ws2def.h>
+#else
+# include <arpa/inet.h>
+# include <errno.h>
+# include <netdb.h>
+# include <netinet/tcp.h>
+# include <sys/select.h>
+# include <sys/socket.h>
+# include <sys/stat.h>
+# include <sys/time.h>
+# include <unistd.h>
+#endif

ixwebsocket/IXProgressCallback.h

@@ -0,0 +1,14 @@
+/*
+ *  IXProgressCallback.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <functional>
+
+namespace ix
+{
+    using OnProgressCallback = std::function<bool(int current, int total)>;
+}

ixwebsocket/IXSetThreadName.h

@@ -0,0 +1,13 @@
+/*
+ *  IXSetThreadName.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+#pragma once
+#include <string>
+
+namespace ix
+{
+    void setThreadName(const std::string& name);
+}
+

ixwebsocket/IXSocket.cpp

@@ -5,157 +5,41 @@
  */
 
 #include "IXSocket.h"
+#include "IXSocketConnect.h"
+#include "IXNetSystem.h"
 
-#include <netdb.h>
-#include <netinet/tcp.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <sys/select.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
 #include <assert.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/types.h>
 
-//
-// Linux/Android has a special type of virtual files. select(2) will react
-// when reading/writing to those files, unlike closing sockets.
-//
-// https://linux.die.net/man/2/eventfd
-//
-// eventfd was added in Linux kernel 2.x, and our oldest Android (Kitkat 4.4)
-// is on Kernel 3.x
-//
-// cf Android/Kernel table here 
-// https://android.stackexchange.com/questions/51651/which-android-runs-which-linux-kernel
-//
-#ifndef __APPLE__
-# include <sys/eventfd.h>
-#endif
-
-// Android needs extra headers for TCP_NODELAY and IPPROTO_TCP
-#ifdef ANDROID
-# include <linux/in.h>
-# include <linux/tcp.h>
-#endif
+#include <algorithm>
+#include <iostream>
 
 namespace ix
 {
-    Socket::Socket() : 
-        _sockfd(-1),
-        _eventfd(-1)
+    const int Socket::kDefaultPollNoTimeout = -1; // No poll timeout by default
+    const int Socket::kDefaultPollTimeout = kDefaultPollNoTimeout;
+
+    Socket::Socket(int fd) :
+        _sockfd(fd)
     {
-#ifndef __APPLE__
-        _eventfd = eventfd(0, 0);
-        assert(_eventfd != -1 && "Panic - eventfd not functioning on this platform");
-#endif
+
     }
 
     Socket::~Socket()
     {
         close();
-
-#ifndef __APPLE__
-        ::close(_eventfd);
-#endif
     }
 
-    bool connectToAddress(const struct addrinfo *address, 
-                          int& sockfd,
-                          std::string& errMsg)
-    {
-        sockfd = -1;
-
-        int fd = socket(address->ai_family,
-                        address->ai_socktype,
-                        address->ai_protocol);
-        if (fd < 0)
-        {
-            errMsg = "Cannot create a socket";
-            return false;
-        }
-
-        int maxRetries = 3;
-        for (int i = 0; i < maxRetries; ++i)
-        {
-            if (connect(fd, address->ai_addr, address->ai_addrlen) != -1)
-            {
-                sockfd = fd;
-                return true;
-            }
-
-            // EINTR means we've been interrupted, in which case we try again.
-            if (errno != EINTR) break;
-        }
-
-        ::close(fd);
-        sockfd = -1;
-        errMsg = strerror(errno);
-        return false;
-    }
-
-    int Socket::hostname_connect(const std::string& hostname,
-                                 int port,
-                                 std::string& errMsg)
-    {
-        struct addrinfo hints;
-        memset(&hints, 0, sizeof(hints));
-        hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
-        hints.ai_family = AF_UNSPEC;
-        hints.ai_socktype = SOCK_STREAM;
-
-        std::string sport = std::to_string(port);
-
-        struct addrinfo *res = nullptr;
-        int getaddrinfo_result = getaddrinfo(hostname.c_str(), sport.c_str(), 
-                                             &hints, &res);
-        if (getaddrinfo_result)
-        {
-            errMsg = gai_strerror(getaddrinfo_result);
-            return -1;
-        }
-
-        int sockfd = -1;
-
-        // iterate through the records to find a working peer
-        struct addrinfo *address;
-        bool success = false;
-        for (address = res; address != nullptr; address = address->ai_next)
-        {
-            success = connectToAddress(address, sockfd, errMsg);
-            if (success)
-            {
-                break;
-            }
-        }
-        freeaddrinfo(res);
-        return sockfd;
-    }
-
-    void Socket::configure()
-    {
-        int flag = 1;
-        setsockopt(_sockfd, IPPROTO_TCP, TCP_NODELAY, (char*) &flag, sizeof(flag)); // Disable Nagle's algorithm
-        fcntl(_sockfd, F_SETFL, O_NONBLOCK); // make socket non blocking
-
-#ifdef SO_NOSIGPIPE
-        int value = 1;
-        setsockopt(_sockfd, SOL_SOCKET, SO_NOSIGPIPE, 
-                   (void *)&value, sizeof(value));
-#endif
-    }
-
-    void Socket::poll(const OnPollCallback& onPollCallback)
+    void Socket::poll(const OnPollCallback& onPollCallback, int timeoutSecs)
     {
         if (_sockfd == -1)
         {
-            onPollCallback();
+            onPollCallback(PollResultType_Error);
             return;
         }
 
@@ -163,53 +47,48 @@ namespace ix
         FD_ZERO(&rfds);
         FD_SET(_sockfd, &rfds);
 
-#ifndef __APPLE__
-        FD_SET(_eventfd, &rfds);
+#ifdef __linux__
+        FD_SET(_eventfd.getFd(), &rfds);
 #endif
 
+        struct timeval timeout;
+        timeout.tv_sec = timeoutSecs;
+        timeout.tv_usec = 0;
+
         int sockfd = _sockfd;
-        int nfds = std::max(sockfd, _eventfd);
-        select(nfds + 1, &rfds, nullptr, nullptr, nullptr);
+        int nfds = (std::max)(sockfd, _eventfd.getFd());
+        int ret = select(nfds + 1, &rfds, nullptr, nullptr,
+                         (timeoutSecs < 0) ? nullptr : &timeout);
 
-        onPollCallback();
+        PollResultType pollResult = PollResultType_ReadyForRead;
+        if (ret < 0)
+        {
+            pollResult = PollResultType_Error;
+        }
+        else if (ret == 0)
+        {
+            pollResult = PollResultType_Timeout;
         }
 
-    void Socket::wakeUpFromPollApple()
-    {
-        close(); // All OS but Linux will wake up select
-                 // when closing the file descriptor watched by select
-    }
-
-    void Socket::wakeUpFromPollLinux()
-    {
-        std::string str("\n"); // this will wake up the thread blocked on select
-        const void* buf = reinterpret_cast<const void*>(str.c_str());
-        write(_eventfd, buf, str.size());
+        onPollCallback(pollResult);
     }
 
     void Socket::wakeUpFromPoll()
     {
-#ifdef __APPLE__
-        wakeUpFromPollApple();
-#else
-        wakeUpFromPollLinux();
-#endif
+        // this will wake up the thread blocked on select, only needed on Linux
+        _eventfd.notify();
     }
 
     bool Socket::connect(const std::string& host,
                          int port,
-                         std::string& errMsg)
+                         std::string& errMsg,
+                         const CancellationRequest& isCancellationRequested)
     {
         std::lock_guard<std::mutex> lock(_socketMutex);
 
-#ifndef __APPLE__
-        if (_eventfd == -1)
-        {
-            return false; // impossible to use this socket if eventfd is broken
-        }
-#endif
+        if (!_eventfd.clear()) return false;
 
-        _sockfd = Socket::hostname_connect(host, port, errMsg);
+        _sockfd = SocketConnect::connect(host, port, errMsg, isCancellationRequested);
         return _sockfd != -1;
     }
 
@@ -219,33 +98,165 @@ namespace ix
 
         if (_sockfd == -1) return;
 
-        ::close(_sockfd);
+        closeSocket(_sockfd);
         _sockfd = -1;
     }
 
-    int Socket::send(char* buffer, size_t length)
+    ssize_t Socket::send(char* buffer, size_t length)
     {
         int flags = 0;
 #ifdef MSG_NOSIGNAL
         flags = MSG_NOSIGNAL;
 #endif
 
-        return (int) ::send(_sockfd, buffer, length, flags);
+        return ::send(_sockfd, buffer, length, flags);
     }
 
-    int Socket::send(const std::string& buffer)
+    ssize_t Socket::send(const std::string& buffer)
     {
         return send((char*)&buffer[0], buffer.size());
     }
 
-    int Socket::recv(void* buffer, size_t length)
+    ssize_t Socket::recv(void* buffer, size_t length)
     {
         int flags = 0;
 #ifdef MSG_NOSIGNAL
         flags = MSG_NOSIGNAL;
 #endif
 
-        return (int) ::recv(_sockfd, buffer, length, flags);
+        return ::recv(_sockfd, (char*) buffer, length, flags);
     }
 
+    int Socket::getErrno()
+    {
+#ifdef _WIN32
+        return WSAGetLastError();
+#else
+        return errno;
+#endif
+    }
+
+    void Socket::closeSocket(int fd)
+    {
+#ifdef _WIN32
+        closesocket(fd);
+#else
+        ::close(fd);
+#endif
+    }
+
+    bool Socket::init()
+    {
+#ifdef _WIN32
+        INT rc;
+        WSADATA wsaData;
+
+        rc = WSAStartup(MAKEWORD(2, 2), &wsaData);
+        return rc != 0;
+#else
+        return true;
+#endif
+    }
+
+    void Socket::cleanup()
+    {
+#ifdef _WIN32
+        WSACleanup();
+#endif
+    }
+
+    bool Socket::readByte(void* buffer,
+                          const CancellationRequest& isCancellationRequested)
+    {
+        while (true)
+        {
+            if (isCancellationRequested()) return false;
+
+            ssize_t ret;
+            ret = recv(buffer, 1);
+
+            // We read one byte, as needed, all good.
+            if (ret == 1)
+            {
+                return true;
+            }
+            // There is possibly something to be read, try again
+            else if (ret < 0 && (getErrno() == EWOULDBLOCK ||
+                                 getErrno() == EAGAIN))
+            {
+                // Wait with a timeout until something is written.
+                // This way we are not busy looping
+                fd_set rfds;
+                struct timeval timeout;
+                timeout.tv_sec = 0;
+                timeout.tv_usec = 1 * 1000; // 1ms timeout
+
+                FD_ZERO(&rfds);
+                FD_SET(_sockfd, &rfds);
+
+                if (select(_sockfd + 1, &rfds, nullptr, nullptr, &timeout) < 0 &&
+                    (errno == EBADF || errno == EINVAL))
+                {
+                    return false;
+                }
+
+                continue;
+            }
+            // There was an error during the read, abort
+            else
+            {
+                return false;
+            }
+        }
+    }
+
+    bool Socket::writeBytes(const std::string& str,
+                            const CancellationRequest& isCancellationRequested)
+    {
+        while (true)
+        {
+            if (isCancellationRequested()) return false;
+
+            char* buffer = const_cast<char*>(str.c_str());
+            int len = (int) str.size();
+
+            ssize_t ret = send(buffer, len);
+
+            // We wrote some bytes, as needed, all good.
+            if (ret > 0)
+            {
+                return ret == len;
+            }
+            // There is possibly something to be write, try again
+            else if (ret < 0 && (getErrno() == EWOULDBLOCK ||
+                                 getErrno() == EAGAIN))
+            {
+                continue;
+            }
+            // There was an error during the write, abort
+            else
+            {
+                return false;
+            }
+        }
+    }
+
+    std::pair<bool, std::string> Socket::readLine(const CancellationRequest& isCancellationRequested)
+    {
+        char c;
+        std::string line;
+        line.reserve(64);
+
+        for (int i = 0; i < 2 || (line[i-2] != '\r' && line[i-1] != '\n'); ++i)
+        {
+            if (!readByte(&c, isCancellationRequested))
+            {
+                return std::make_pair(false, std::string());
+            }
+
+            line += c;
+        }
+
+        return std::make_pair(true, line);
+    }
 }

ixwebsocket/IXSocket.h

@@ -11,40 +11,68 @@
 #include <mutex>
 #include <atomic>
 
+#ifdef _WIN32
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+#include "IXEventFd.h"
+#include "IXCancellationRequest.h"
+
 namespace ix
 {
+    enum PollResultType
+    {
+        PollResultType_ReadyForRead = 0,
+        PollResultType_Timeout = 1,
+        PollResultType_Error = 2
+    };
+
     class Socket {
     public:
-        using OnPollCallback = std::function<void()>;
+        using OnPollCallback = std::function<void(PollResultType)>;
 
-        Socket();
+        Socket(int fd = -1);
         virtual ~Socket();
 
-        static int hostname_connect(const std::string& hostname,
-                                    int port,
-                                    std::string& errMsg);
         void configure();
 
-        virtual void poll(const OnPollCallback& onPollCallback);
+        virtual void poll(const OnPollCallback& onPollCallback,
+                          int timeoutSecs = kDefaultPollTimeout);
         virtual void wakeUpFromPoll();
 
         // Virtual methods
         virtual bool connect(const std::string& url,
                              int port,
-                             std::string& errMsg);
+                             std::string& errMsg,
+                             const CancellationRequest& isCancellationRequested);
         virtual void close();
 
-        virtual int send(char* buffer, size_t length);
-        virtual int send(const std::string& buffer);
-        virtual int recv(void* buffer, size_t length);
+        virtual ssize_t send(char* buffer, size_t length);
+        virtual ssize_t send(const std::string& buffer);
+        virtual ssize_t recv(void* buffer, size_t length);
+
+        // Blocking and cancellable versions, working with socket that can be set
+        // to non blocking mode. Used during HTTP upgrade.
+        bool readByte(void* buffer,
+                      const CancellationRequest& isCancellationRequested);
+        bool writeBytes(const std::string& str,
+                        const CancellationRequest& isCancellationRequested);
+        std::pair<bool, std::string> readLine(const CancellationRequest& isCancellationRequested);
+
+        static int getErrno();
+        static bool init(); // Required on Windows to initialize WinSocket
+        static void cleanup(); // Required on Windows to cleanup WinSocket
 
     protected:
-        void wakeUpFromPollApple();
-        void wakeUpFromPollLinux();
+        void closeSocket(int fd);
 
         std::atomic<int> _sockfd;
-        int _eventfd;
         std::mutex _socketMutex;
-    };
+        EventFd _eventfd;
 
+    private:
+        static const int kDefaultPollTimeout;
+        static const int kDefaultPollNoTimeout;
+    };
 }

ixwebsocket/IXSocketAppleSSL.cpp

@@ -6,6 +6,7 @@
  *  Adapted from Satori SDK Apple SSL code.
  */
 #include "IXSocketAppleSSL.h"
+#include "IXSocketConnect.h"
 
 #include <fcntl.h>
 #include <netdb.h>
@@ -142,7 +143,7 @@ std::string getSSLErrorDescription(OSStatus status)
 
 namespace ix
 {
-    SocketAppleSSL::SocketAppleSSL() : 
+    SocketAppleSSL::SocketAppleSSL(int fd) : Socket(fd),
         _sslContext(nullptr)
     {
         ;
@@ -156,13 +157,14 @@ namespace ix
     // No wait support
     bool SocketAppleSSL::connect(const std::string& host,
                                  int port,
-                                 std::string& errMsg)
+                                 std::string& errMsg,
+                                 const CancellationRequest& isCancellationRequested)
     {
         OSStatus status;
         {
             std::lock_guard<std::mutex> lock(_mutex);
 
-            _sockfd = Socket::hostname_connect(host, port, errMsg);
+            _sockfd = SocketConnect::connect(host, port, errMsg, isCancellationRequested);
             if (_sockfd == -1) return false;
 
             _sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType);
@@ -201,7 +203,7 @@ namespace ix
         Socket::close();
     }
 
-    int SocketAppleSSL::send(char* buf, size_t nbyte)
+    ssize_t SocketAppleSSL::send(char* buf, size_t nbyte)
     {
         ssize_t ret = 0;
         OSStatus status;
@@ -216,16 +218,16 @@ namespace ix
 
         if (ret == 0 && errSSLClosedAbort != status)
             ret = -1;
-        return (int) ret;
+        return ret;
     }
 
-    int SocketAppleSSL::send(const std::string& buffer)
+    ssize_t SocketAppleSSL::send(const std::string& buffer)
     {
         return send((char*)&buffer[0], buffer.size());
     }
 
     // No wait support
-    int SocketAppleSSL::recv(void* buf, size_t nbyte)
+    ssize_t SocketAppleSSL::recv(void* buf, size_t nbyte)
     {
         OSStatus status = errSSLWouldBlock;
         while (errSSLWouldBlock == status)
@@ -235,7 +237,7 @@ namespace ix
             status = SSLRead(_sslContext, buf, nbyte, &processed);
 
             if (processed > 0)
-                return (int) processed;
+                return (ssize_t) processed;
 
             // The connection was reset, inform the caller that this
             // Socket should close

ixwebsocket/IXSocketAppleSSL.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include "IXSocket.h"
+#include "IXCancellationRequest.h"
 
 #include <Security/Security.h>
 #include <Security/SecureTransport.h>
@@ -18,17 +19,18 @@ namespace ix
     class SocketAppleSSL : public Socket
     {
     public:
-        SocketAppleSSL();
+        SocketAppleSSL(int fd = -1);
         ~SocketAppleSSL();
 
         virtual bool connect(const std::string& host,
                              int port,
-                             std::string& errMsg) final;
+                             std::string& errMsg,
+                             const CancellationRequest& isCancellationRequested) final;
         virtual void close() final;
 
-        virtual int send(char* buffer, size_t length) final;
-        virtual int send(const std::string& buffer) final;
-        virtual int recv(void* buffer, size_t length) final;
+        virtual ssize_t send(char* buffer, size_t length) final;
+        virtual ssize_t send(const std::string& buffer) final;
+        virtual ssize_t recv(void* buffer, size_t length) final;
 
     private:
         SSLContextRef _sslContext;

ixwebsocket/IXSocketConnect.cpp

@@ -0,0 +1,186 @@
+/*
+ *  IXSocketConnect.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXSocketConnect.h"
+#include "IXDNSLookup.h"
+#include "IXNetSystem.h"
+
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+
+// Android needs extra headers for TCP_NODELAY and IPPROTO_TCP
+#ifdef ANDROID
+# include <linux/in.h>
+# include <linux/tcp.h>
+#endif
+
+namespace
+{
+    void closeSocket(int fd)
+    {
+#ifdef _WIN32
+        closesocket(fd);
+#else
+        ::close(fd);
+#endif
+    }
+}
+
+namespace ix
+{
+    //
+    // This function can be cancelled every 50 ms
+    // This is important so that we don't block the main UI thread when shutting down a connection which is
+    // already trying to reconnect, and can be blocked waiting for ::connect to respond.
+    //
+    int SocketConnect::connectToAddress(const struct addrinfo *address,
+                                        std::string& errMsg,
+                                        const CancellationRequest& isCancellationRequested)
+    {
+        errMsg = "no error";
+
+        int fd = socket(address->ai_family,
+                        address->ai_socktype,
+                        address->ai_protocol);
+        if (fd < 0)
+        {
+            errMsg = "Cannot create a socket";
+            return -1;
+        }
+
+        // Set the socket to non blocking mode, so that slow responses cannot
+        // block us for too long
+        SocketConnect::configure(fd);
+
+        if (::connect(fd, address->ai_addr, address->ai_addrlen) == -1
+            && errno != EINPROGRESS)
+        {
+            closeSocket(fd);
+            errMsg = strerror(errno);
+            return -1;
+        }
+
+        for (;;)
+        {
+            if (isCancellationRequested()) // Must handle timeout as well
+            {
+                closeSocket(fd);
+                errMsg = "Cancelled";
+                return -1;
+            }
+
+            // Use select to check the status of the new connection
+            struct timeval timeout;
+            timeout.tv_sec = 0;
+            timeout.tv_usec = 10 * 1000; // 10ms timeout
+            fd_set wfds;
+            fd_set efds;
+
+            FD_ZERO(&wfds);
+            FD_SET(fd, &wfds);
+            FD_ZERO(&efds);
+            FD_SET(fd, &efds);
+
+            if (select(fd + 1, nullptr, &wfds, &efds, &timeout) < 0 &&
+                (errno == EBADF || errno == EINVAL))
+            {
+                closeSocket(fd);
+                errMsg = std::string("Connect error, select error: ") + strerror(errno);
+                return -1;
+            }
+
+            // Nothing was written to the socket, wait again.
+            if (!FD_ISSET(fd, &wfds)) continue;
+
+            // Something was written to the socket. Check for errors.
+            int optval = -1;
+            socklen_t optlen = sizeof(optval);
+
+#ifdef _WIN32
+            // On connect error, in async mode, windows will write to the exceptions fds
+            if (FD_ISSET(fd, &efds))
+#else
+            // getsockopt() puts the errno value for connect into optval so 0
+            // means no-error.
+            if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &optval, &optlen) == -1 ||
+                optval != 0)
+#endif
+            {
+                closeSocket(fd);
+                errMsg = strerror(optval);
+                return -1;
+            }
+            else
+            {
+                // Success !
+                return fd;
+            }
+        }
+
+        closeSocket(fd);
+        errMsg = "connect timed out after 60 seconds";
+        return -1;
+    }
+
+    int SocketConnect::connect(const std::string& hostname,
+                               int port,
+                               std::string& errMsg,
+                               const CancellationRequest& isCancellationRequested)
+    {
+        //
+        // First do DNS resolution
+        //
+        DNSLookup dnsLookup(hostname, port);
+        struct addrinfo *res = dnsLookup.resolve(errMsg, isCancellationRequested);
+        if (res == nullptr)
+        {
+            return -1;
+        }
+
+        int sockfd = -1;
+
+        // iterate through the records to find a working peer
+        struct addrinfo *address;
+        for (address = res; address != nullptr; address = address->ai_next)
+        {
+            //
+            // Second try to connect to the remote host
+            //
+            sockfd = connectToAddress(address, errMsg, isCancellationRequested);
+            if (sockfd != -1)
+            {
+                break;
+            }
+        }
+
+        freeaddrinfo(res);
+        return sockfd;
+    }
+
+    // FIXME: configure is a terrible name
+    void SocketConnect::configure(int sockfd)
+    {
+        // 1. disable Nagle's algorithm
+        int flag = 1;
+        setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (char*) &flag, sizeof(flag));
+
+        // 2. make socket non blocking
+#ifdef _WIN32
+        unsigned long nonblocking = 1;
+        ioctlsocket(sockfd, FIONBIO, &nonblocking);
+#else
+        fcntl(sockfd, F_SETFL, O_NONBLOCK); // make socket non blocking
+#endif
+
+        // 3. (apple) prevent SIGPIPE from being emitted when the remote end disconnect
+#ifdef SO_NOSIGPIPE
+        int value = 1;
+        setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE,
+                   (void *)&value, sizeof(value));
+#endif
+    }
+}

ixwebsocket/IXSocketConnect.h

@@ -0,0 +1,32 @@
+/*
+ *  IXSocketConnect.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include "IXCancellationRequest.h"
+
+#include <string>
+
+struct addrinfo;
+
+namespace ix
+{
+    class SocketConnect {
+    public:
+        static int connect(const std::string& hostname,
+                           int port,
+                           std::string& errMsg,
+                           const CancellationRequest& isCancellationRequested);
+
+        static void configure(int sockfd);
+
+    private:
+        static int connectToAddress(const struct addrinfo *address,
+                                    std::string& errMsg,
+                                    const CancellationRequest& isCancellationRequested);
+    };
+}
+

ixwebsocket/IXSocketOpenSSL.cpp

@@ -7,38 +7,37 @@
  */
 
 #include "IXSocketOpenSSL.h"
+#include "IXSocketConnect.h"
+
 #include <cassert>
 #include <iostream>
 
 #include <openssl/x509v3.h>
 
+#include <fnmatch.h>
 #include <errno.h>
 #define socketerrno errno
 
-namespace {
-
-std::mutex initMutex;
-bool openSSLInitialized = false;
-bool openSSLInitializationSuccessful = false;
-
-bool openSSLInitialize(std::string& errMsg)
+namespace ix
 {
-    std::lock_guard<std::mutex> lock(initMutex);
+    std::atomic<bool> SocketOpenSSL::_openSSLInitializationSuccessful(false);
 
-    if (openSSLInitialized)
+    SocketOpenSSL::SocketOpenSSL(int fd) : Socket(fd),
+        _ssl_connection(nullptr),
+        _ssl_context(nullptr)
     {
-        return openSSLInitializationSuccessful;
+        std::call_once(_openSSLInitFlag, &SocketOpenSSL::openSSLInitialize, this);
     }
 
+    SocketOpenSSL::~SocketOpenSSL()
+    {
+        SocketOpenSSL::close();
+    }
+
+    void SocketOpenSSL::openSSLInitialize()
+    {
 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
-    if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, nullptr))
-    {
-        errMsg = "OPENSSL_init_ssl failure";
-
-        openSSLInitializationSuccessful = false;
-        openSSLInitialized = true;
-        return false;
-    }
+        if (!OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, nullptr)) return;
 #else
         (void) OPENSSL_config(nullptr);
 #endif
@@ -46,41 +45,7 @@ bool openSSLInitialize(std::string& errMsg)
         (void) OpenSSL_add_ssl_algorithms();
         (void) SSL_load_error_strings();
 
-    openSSLInitializationSuccessful = true;
-    return true;
-}
-
-int openssl_verify_callback(int preverify, X509_STORE_CTX *x509_ctx)
-{
-    return preverify;
-}
-
-/* create new SSL connection state object */
-SSL *openssl_create_connection(SSL_CTX *ctx, int socket)
-{
-    assert(ctx != nullptr);
-    assert(socket > 0);
-
-    SSL *ssl = SSL_new(ctx);
-    if (ssl)
-        SSL_set_fd(ssl, socket);
-    return ssl;
-}
-
-} // anonymous namespace
-
-namespace ix 
-{
-    SocketOpenSSL::SocketOpenSSL() :
-        _ssl_connection(nullptr), 
-        _ssl_context(nullptr)
-    {
-        ;
-    }
-
-    SocketOpenSSL::~SocketOpenSSL()
-    {
-        SocketOpenSSL::close();
+        _openSSLInitializationSuccessful = true;
     }
 
     std::string SocketOpenSSL::getSSLError(int ret)
@@ -149,7 +114,13 @@ namespace ix
         SSL_CTX* ctx = SSL_CTX_new(_ssl_method);
         if (ctx)
         {
-            SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, openssl_verify_callback);
+            // To skip verification, pass in SSL_VERIFY_NONE
+            SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER,
+                               [](int preverify, X509_STORE_CTX*) -> int
+                               {
+                                   return preverify;
+                               });
+
             SSL_CTX_set_verify_depth(ctx, 4);
             SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
         }
@@ -158,51 +129,10 @@ namespace ix
 
     /**
      * Check whether a hostname matches a pattern
-     *
-     * The pattern MUST contain at most a single, leading asterisk. This means that
-     * this function cannot serve as a generic validation function, as that would
-     * allow for partial wildcards, too. Also, this does not check whether the
-     * wildcard covers multiple levels of labels. For RTM, this suffices, as we
-     * are only interested in the main domain name.
-     *
-     * @param[in] hostname The hostname of the server
-     * @param[in] pattern The hostname pattern from a SSL certificate
-     * @return TRUE if the pattern matches, FALSE otherwise
      */
     bool SocketOpenSSL::checkHost(const std::string& host, const char *pattern)
     {
-        const char* hostname = host.c_str();
-
-        while (*pattern && *hostname)
-        {
-            if (*pattern == '*')
-            {
-                while (*hostname != '.' && *hostname) hostname++;
-                if (*(++pattern) != '.')
-                {
-                    return false;
-                }
-            }
-            else
-            {
-                char p = *pattern;
-                char h = *hostname;
-                if ((p & ~32) >= 'A' && (p & ~32) <= 'Z')
-                {
-                    p &= ~32;
-                    h &= ~32;
-                }
-                if (*pattern != *hostname)
-                {
-                    return false;
-                }
-            }
-            pattern++;
-            hostname++;
-        }
-
-        bool success = !(*hostname || *pattern);
-        return success;
+        return fnmatch(pattern, host.c_str(), 0) != FNM_NOMATCH;
     }
 
     bool SocketOpenSSL::openSSLCheckServerCert(SSL *ssl,
@@ -313,18 +243,20 @@ namespace ix
     // No wait support
     bool SocketOpenSSL::connect(const std::string& host,
                                 int port,
-                                std::string& errMsg)
+                                std::string& errMsg,
+                                const CancellationRequest& isCancellationRequested)
     {
         bool handshakeSuccessful = false;
         {
             std::lock_guard<std::mutex> lock(_mutex);
 
-            if (!openSSLInitialize(errMsg))
+            if (!_openSSLInitializationSuccessful)
             {
+                errMsg = "OPENSSL_init_ssl failure";
                 return false;
             }
 
-            _sockfd = Socket::hostname_connect(host, port, errMsg);
+            _sockfd = SocketConnect::connect(host, port, errMsg, isCancellationRequested);
             if (_sockfd == -1) return false;
 
             _ssl_context = openSSLCreateContext(errMsg);
@@ -342,18 +274,28 @@ namespace ix
                 errMsg += ERR_error_string(ssl_err, nullptr);
             }
 
-            _ssl_connection = openssl_create_connection(_ssl_context, _sockfd);
-            if (nullptr == _ssl_connection)
+            _ssl_connection = SSL_new(_ssl_context);
+            if (_ssl_connection == nullptr)
             {
                 errMsg = "OpenSSL failed to connect";
                 SSL_CTX_free(_ssl_context);
                 _ssl_context = nullptr;
                 return false;
             }
+            SSL_set_fd(_ssl_connection, _sockfd);
 
             // SNI support
             SSL_set_tlsext_host_name(_ssl_connection, host.c_str());
 
+#if OPENSSL_VERSION_NUMBER >= 0x10002000L
+            // Support for server name verification
+            // (The docs say that this should work from 1.0.2, and is the default from
+            // 1.1.0, but it does not. To be on the safe side, the manual test below is
+            // enabled for all versions prior to 1.1.0.)
+            X509_VERIFY_PARAM *param = SSL_get0_param(_ssl_connection);
+            X509_VERIFY_PARAM_set1_host(param, host.c_str(), 0);
+#endif
+
             handshakeSuccessful = openSSLHandshake(host, errMsg);
         }
 
@@ -384,7 +326,7 @@ namespace ix
         Socket::close();
     }
 
-    int SocketOpenSSL::send(char* buf, size_t nbyte)
+    ssize_t SocketOpenSSL::send(char* buf, size_t nbyte)
     {
         ssize_t sent = 0;
 
@@ -398,7 +340,7 @@ namespace ix
             }
 
             ERR_clear_error();
-            int write_result = SSL_write(_ssl_connection, buf + sent, (int) nbyte);
+            ssize_t write_result = SSL_write(_ssl_connection, buf + sent, (int) nbyte);
             int reason = SSL_get_error(_ssl_connection, write_result);
 
             if (reason == SSL_ERROR_NONE) {
@@ -411,16 +353,16 @@ namespace ix
                 return -1;
             }
         }
-        return (int) sent;
+        return sent;
     }
 
-    int SocketOpenSSL::send(const std::string& buffer)
+    ssize_t SocketOpenSSL::send(const std::string& buffer)
     {
         return send((char*)&buffer[0], buffer.size());
     }
 
     // No wait support
-    int SocketOpenSSL::recv(void* buf, size_t nbyte)
+    ssize_t SocketOpenSSL::recv(void* buf, size_t nbyte)
     {
         while (true)
         {
@@ -432,7 +374,7 @@ namespace ix
             }
 
             ERR_clear_error();
-            int read_result = SSL_read(_ssl_connection, buf, (int) nbyte);
+            ssize_t read_result = SSL_read(_ssl_connection, buf, (int) nbyte);
 
             if (read_result > 0)
             {
@@ -444,10 +386,8 @@ namespace ix
             if (reason == SSL_ERROR_WANT_READ || reason == SSL_ERROR_WANT_WRITE)
             {
                 errno = EWOULDBLOCK;
-                return -1;
-            } else {
-                return -1;
             }
+            return -1;
         }
     }
 

ixwebsocket/IXSocketOpenSSL.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include "IXSocket.h"
+#include "IXCancellationRequest.h"
 
 #include <openssl/bio.h>
 #include <openssl/hmac.h>
@@ -21,19 +22,21 @@ namespace ix
     class SocketOpenSSL : public Socket
     {
     public:
-        SocketOpenSSL();
+        SocketOpenSSL(int fd = -1);
         ~SocketOpenSSL();
 
         virtual bool connect(const std::string& host,
                              int port,
-                             std::string& errMsg) final;
+                             std::string& errMsg,
+                             const CancellationRequest& isCancellationRequested) final;
         virtual void close() final;
 
-        virtual int send(char* buffer, size_t length) final;
-        virtual int send(const std::string& buffer) final;
-        virtual int recv(void* buffer, size_t length) final;
+        virtual ssize_t send(char* buffer, size_t length) final;
+        virtual ssize_t send(const std::string& buffer) final;
+        virtual ssize_t recv(void* buffer, size_t length) final;
 
     private:
+        void openSSLInitialize();
         std::string getSSLError(int ret);
         SSL_CTX* openSSLCreateContext(std::string& errMsg);
         bool openSSLHandshake(const std::string& hostname, std::string& errMsg);
@@ -42,10 +45,13 @@ namespace ix
                                     std::string& errMsg);
         bool checkHost(const std::string& host, const char *pattern);
 
-        SSL_CTX* _ssl_context;
         SSL* _ssl_connection;
+        SSL_CTX* _ssl_context;
         const SSL_METHOD* _ssl_method;
         mutable std::mutex _mutex;  // OpenSSL routines are not thread-safe
+
+        std::once_flag _openSSLInitFlag;
+        static std::atomic<bool> _openSSLInitializationSuccessful;
     };
 
 }

ixwebsocket/IXSocketSChannel.cpp

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

ixwebsocket/IXSocketSChannel.h

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

ixwebsocket/IXSocketServer.cpp

@@ -0,0 +1,228 @@
+/*
+ *  IXSocketServer.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXSocketServer.h"
+#include "IXSocket.h"
+#include "IXSocketConnect.h"
+#include "IXNetSystem.h"
+
+#include <iostream>
+#include <sstream>
+#include <future>
+#include <string.h>
+
+namespace ix
+{
+    const int SocketServer::kDefaultPort(8080);
+    const std::string SocketServer::kDefaultHost("127.0.0.1");
+    const int SocketServer::kDefaultTcpBacklog(5);
+    const size_t SocketServer::kDefaultMaxConnections(32);
+
+    SocketServer::SocketServer(int port,
+                               const std::string& host,
+                               int backlog,
+                               size_t maxConnections) :
+        _port(port),
+        _host(host),
+        _backlog(backlog),
+        _maxConnections(maxConnections),
+        _stop(false)
+    {
+
+    }
+
+    SocketServer::~SocketServer()
+    {
+        stop();
+    }
+
+    void SocketServer::logError(const std::string& str)
+    {
+        std::lock_guard<std::mutex> lock(_logMutex);
+        std::cerr << str << std::endl;
+    }
+
+    void SocketServer::logInfo(const std::string& str)
+    {
+        std::lock_guard<std::mutex> lock(_logMutex);
+        std::cout << str << std::endl;
+    }
+
+    std::pair<bool, std::string> SocketServer::listen()
+    {
+        struct sockaddr_in server; // server address information
+
+        // Get a socket for accepting connections.
+        if ((_serverFd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
+        {
+            std::stringstream ss;
+            ss << "SocketServer::listen() error creating socket): "
+               << strerror(Socket::getErrno());
+
+            return std::make_pair(false, ss.str());
+        }
+
+        // Make that socket reusable. (allow restarting this server at will)
+        int enable = 1;
+        if (setsockopt(_serverFd, SOL_SOCKET, SO_REUSEADDR,
+                       (char*) &enable, sizeof(enable)) < 0)
+        {
+            std::stringstream ss;
+            ss << "SocketServer::listen() error calling setsockopt(SO_REUSEADDR) "
+               << "at address " << _host << ":" << _port
+               << " : " << strerror(Socket::getErrno());
+
+            ::close(_serverFd);
+            return std::make_pair(false, ss.str());
+        }
+
+        // Bind the socket to the server address.
+        server.sin_family = AF_INET;
+        server.sin_port   = htons(_port);
+
+        // Using INADDR_ANY trigger a pop-up box as binding to any address is detected
+        // by the osx firewall. We need to codesign the binary with a self-signed cert
+        // to allow that, but this is a bit of a pain. (this is what node or python would do).
+        //
+        // Using INADDR_LOOPBACK also does not work ... while it should.
+        // We default to 127.0.0.1 (localhost)
+        //
+        server.sin_addr.s_addr = inet_addr(_host.c_str());
+
+        if (bind(_serverFd, (struct sockaddr *)&server, sizeof(server)) < 0)
+        {
+            std::stringstream ss;
+            ss << "SocketServer::listen() error calling bind "
+               << "at address " << _host << ":" << _port
+               << " : " << strerror(Socket::getErrno());
+
+            ::close(_serverFd);
+            return std::make_pair(false, ss.str());
+        }
+
+        //
+        // Listen for connections. Specify the tcp backlog.
+        //
+        if (::listen(_serverFd, _backlog) < 0)
+        {
+            std::stringstream ss;
+            ss << "SocketServer::listen() error calling listen "
+               << "at address " << _host << ":" << _port
+               << " : " << strerror(Socket::getErrno());
+
+            ::close(_serverFd);
+            return std::make_pair(false, ss.str());
+        }
+
+        return std::make_pair(true, "");
+    }
+
+    void SocketServer::start()
+    {
+        if (_thread.joinable()) return; // we've already been started
+
+        _thread = std::thread(&SocketServer::run, this);
+    }
+
+    void SocketServer::wait()
+    {
+        std::unique_lock<std::mutex> lock(_conditionVariableMutex);
+        _conditionVariable.wait(lock);
+    }
+
+    void SocketServer::stop()
+    {
+        if (!_thread.joinable()) return; // nothing to do
+
+        _stop = true;
+        _thread.join();
+        _stop = false;
+
+        _conditionVariable.notify_one();
+        ::close(_serverFd);
+    }
+
+    void SocketServer::run()
+    {
+        // Set the socket to non blocking mode, so that accept calls are not blocking
+        SocketConnect::configure(_serverFd);
+
+        // Return value of std::async, ignored
+        std::future<void> f;
+
+        for (;;)
+        {
+            if (_stop) return;
+
+            // Use select to check whether a new connection is in progress
+            fd_set rfds;
+            struct timeval timeout;
+            timeout.tv_sec = 0;
+            timeout.tv_usec = 10 * 1000; // 10ms timeout
+
+            FD_ZERO(&rfds);
+            FD_SET(_serverFd, &rfds);
+
+            if (select(_serverFd + 1, &rfds, nullptr, nullptr, &timeout) < 0 &&
+                (errno == EBADF || errno == EINVAL))
+            {
+                std::stringstream ss;
+                ss << "SocketServer::run() error in select: "
+                   << strerror(Socket::getErrno());
+                logError(ss.str());
+                continue;
+            }
+
+            if (!FD_ISSET(_serverFd, &rfds))
+            {
+                // We reached the select timeout, and no new connections are pending
+                continue;
+            }
+
+            // Accept a connection.
+            struct sockaddr_in client; // client address information
+            int clientFd;              // socket connected to client
+            socklen_t addressLen = sizeof(socklen_t);
+            memset(&client, 0, sizeof(client));
+
+            if ((clientFd = accept(_serverFd, (struct sockaddr *)&client, &addressLen)) < 0)
+            {
+                if (Socket::getErrno() != EWOULDBLOCK)
+                {
+                    // FIXME: that error should be propagated
+                    std::stringstream ss;
+                    ss << "SocketServer::run() error accepting connection: "
+                       << strerror(Socket::getErrno());
+                    logError(ss.str());
+                }
+                continue;
+            }
+
+            if (getConnectedClientsCount() >= _maxConnections)
+            {
+                std::stringstream ss;
+                ss << "SocketServer::run() reached max connections = "
+                   << _maxConnections << ". "
+                   << "Not accepting connection";
+                logError(ss.str());
+
+                ::close(clientFd);
+
+                continue;
+            }
+
+            // Launch the handleConnection work asynchronously in its own thread.
+            //
+            // the destructor of a future returned by std::async blocks,
+            // so we need to declare it outside of this loop
+            f = std::async(std::launch::async,
+                           &SocketServer::handleConnection,
+                           this,
+                           clientFd);
+        }
+    }
+}
+

ixwebsocket/IXSocketServer.h

@@ -0,0 +1,68 @@
+/*
+ *  IXSocketServer.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <utility> // pair
+#include <string>
+#include <set>
+#include <thread>
+#include <mutex>
+#include <functional>
+#include <memory>
+#include <atomic>
+#include <condition_variable>
+
+namespace ix
+{
+    class SocketServer {
+    public:
+        SocketServer(int port = SocketServer::kDefaultPort,
+                     const std::string& host = SocketServer::kDefaultHost,
+                     int backlog = SocketServer::kDefaultTcpBacklog,
+                     size_t maxConnections = SocketServer::kDefaultMaxConnections);
+        virtual ~SocketServer();
+        virtual void stop();
+
+        const static int kDefaultPort;
+        const static std::string kDefaultHost;
+        const static int kDefaultTcpBacklog;
+        const static size_t kDefaultMaxConnections;
+
+        void start();
+        std::pair<bool, std::string> listen();
+        void wait();
+
+    protected:
+
+        // Logging
+        void logError(const std::string& str);
+        void logInfo(const std::string& str);
+
+    private:
+        // Member variables
+        int _port;
+        std::string _host;
+        int _backlog;
+        size_t _maxConnections;
+
+        // socket for accepting connections
+        int _serverFd;
+
+        std::mutex _logMutex;
+
+        std::atomic<bool> _stop;
+        std::thread _thread;
+
+        std::condition_variable _conditionVariable;
+        std::mutex _conditionVariableMutex;
+
+        // Methods
+        void run();
+        virtual void handleConnection(int fd) = 0;
+        virtual size_t getConnectedClientsCount() = 0;
+    };
+}

ixwebsocket/IXWebSocket.cpp

@@ -5,14 +5,15 @@
  */
 
 #include "IXWebSocket.h"
+#include "IXSetThreadName.h"
+#include "IXWebSocketHandshake.h"
 
 #include <iostream>
 #include <cmath>
 #include <cassert>
 
-namespace {
-
-    // FIXME: put this in a shared location, and use it in 
+namespace
+{
     uint64_t calculateRetryWaitMilliseconds(uint64_t retry_count)
     {
         // This will overflow quite fast for large value of retry_count
@@ -24,19 +25,29 @@ namespace {
         uint64_t tenSeconds = 10 * 1000;
         return (wait_time > tenSeconds || retry_count > 10) ? tenSeconds : wait_time;
     }
-
 }
 
-namespace ix {
-
+namespace ix
+{
     OnTrafficTrackerCallback WebSocket::_onTrafficTrackerCallback = nullptr;
+    const int WebSocket::kDefaultHandShakeTimeoutSecs(60);
+    const int WebSocket::kDefaultHeartBeatPeriod(-1);
 
     WebSocket::WebSocket() :
-        _verbose(false),
         _onMessageCallback(OnMessageCallback()),
         _stop(false),
-        _automaticReconnection(true)
+        _automaticReconnection(true),
+        _handshakeTimeoutSecs(kDefaultHandShakeTimeoutSecs),
+        _heartBeatPeriod(kDefaultHeartBeatPeriod)
     {
+        _ws.setOnCloseCallback(
+            [this](uint16_t code, const std::string& reason, size_t wireSize)
+            {
+                _onMessageCallback(WebSocket_MessageType_Close, "", wireSize,
+                                   WebSocketErrorInfo(), WebSocketOpenInfo(),
+                                   WebSocketCloseInfo(code, reason));
+            }
+        );
     }
 
     WebSocket::~WebSocket()
@@ -44,12 +55,42 @@ namespace ix {
         stop();
     }
 
-    void WebSocket::configure(const std::string& url)
+    void WebSocket::setUrl(const std::string& url)
     {
-        std::lock_guard<std::mutex> lock(_urlMutex);
+        std::lock_guard<std::mutex> lock(_configMutex);
         _url = url;
     }
 
+    const std::string& WebSocket::getUrl() const
+    {
+        std::lock_guard<std::mutex> lock(_configMutex);
+        return _url;
+    }
+
+    void WebSocket::setPerMessageDeflateOptions(const WebSocketPerMessageDeflateOptions& perMessageDeflateOptions)
+    {
+        std::lock_guard<std::mutex> lock(_configMutex);
+        _perMessageDeflateOptions = perMessageDeflateOptions;
+    }
+
+    const WebSocketPerMessageDeflateOptions& WebSocket::getPerMessageDeflateOptions() const
+    {
+        std::lock_guard<std::mutex> lock(_configMutex);
+        return _perMessageDeflateOptions;
+    }
+
+    void WebSocket::setHeartBeatPeriod(int hearBeatPeriod)
+    {
+        std::lock_guard<std::mutex> lock(_configMutex);
+        _heartBeatPeriod = hearBeatPeriod;
+    }
+
+    int WebSocket::getHeartBeatPeriod() const
+    {
+        std::lock_guard<std::mutex> lock(_configMutex);
+        return _heartBeatPeriod;
+    }
+
     void WebSocket::start()
     {
         if (_thread.joinable()) return; // we've already been started
@@ -59,13 +100,16 @@ namespace ix {
 
     void WebSocket::stop()
     {
+        bool automaticReconnection = _automaticReconnection;
+
+        // This value needs to be forced when shutting down, it is restored later
         _automaticReconnection = false;
 
         close();
 
         if (!_thread.joinable())
         {
-            _automaticReconnection = true;
+            _automaticReconnection = automaticReconnection;
             return;
         }
 
@@ -73,40 +117,47 @@ namespace ix {
         _thread.join();
         _stop = false;
 
-        _automaticReconnection = true;
+        _automaticReconnection = automaticReconnection;
     }
 
-    WebSocketInitResult WebSocket::connect()
+    WebSocketInitResult WebSocket::connect(int timeoutSecs)
     {
         {
-            std::lock_guard<std::mutex> lock(_urlMutex);
-            _ws.configure(_url);
+            std::lock_guard<std::mutex> lock(_configMutex);
+            _ws.configure(_perMessageDeflateOptions,
+                          _heartBeatPeriod);
         }
 
-        _ws.setOnStateChangeCallback(
-            [this](WebSocketTransport::ReadyStateValues readyStateValue)
-            {
-                if (readyStateValue == WebSocketTransport::CLOSED)
-                {
-                    _onMessageCallback(WebSocket_MessageType_Close, "", WebSocketErrorInfo());
-                }
-
-                if (_verbose)
-                {
-                    std::cout << "connection state changed -> " 
-                              << readyStateToString(getReadyState()) 
-                              << std::endl;
-                }
-            }
-        );
-
-        WebSocketInitResult status = _ws.init();
+        WebSocketInitResult status = _ws.connectToUrl(_url, timeoutSecs);
         if (!status.success)
         {
             return status;
         }
 
-        _onMessageCallback(WebSocket_MessageType_Open, "", WebSocketErrorInfo());
+        _onMessageCallback(WebSocket_MessageType_Open, "", 0,
+                           WebSocketErrorInfo(),
+                           WebSocketOpenInfo(status.uri, status.headers),
+                           WebSocketCloseInfo());
+        return status;
+    }
+
+    WebSocketInitResult WebSocket::connectToSocket(int fd, int timeoutSecs)
+    {
+        {
+            std::lock_guard<std::mutex> lock(_configMutex);
+            _ws.configure(_perMessageDeflateOptions, _heartBeatPeriod);
+        }
+
+        WebSocketInitResult status = _ws.connectToSocket(fd, timeoutSecs);
+        if (!status.success)
+        {
+            return status;
+        }
+
+        _onMessageCallback(WebSocket_MessageType_Open, "", 0,
+                           WebSocketErrorInfo(),
+                           WebSocketOpenInfo(status.uri, status.headers),
+                           WebSocketCloseInfo());
         return status;
     }
 
@@ -140,7 +191,7 @@ namespace ix {
                 break;
             }
 
-            status = connect();
+            status = connect(_handshakeTimeoutSecs);
 
             if (!status.success && !_stop)
             {
@@ -150,9 +201,9 @@ namespace ix {
                 connectErr.wait_time = duration.count();
                 connectErr.reason = status.errorStr;
                 connectErr.http_status = status.http_status;
-                _onMessageCallback(WebSocket_MessageType_Error, "", connectErr);
-
-                if (_verbose) std::cout << "Sleeping for " << duration.count() << "ms" << std::endl;
+                _onMessageCallback(WebSocket_MessageType_Error, "", 0,
+                                   connectErr, WebSocketOpenInfo(),
+                                   WebSocketCloseInfo());
 
                 std::this_thread::sleep_for(duration);
             }
@@ -161,6 +212,8 @@ namespace ix {
 
     void WebSocket::run()
     {
+        setThreadName(_url);
+
         while (true)
         {
             if (_stop) return;
@@ -177,12 +230,44 @@ namespace ix {
 
             // 3. Dispatch the incoming messages
             _ws.dispatch(
-                [this](const std::string& msg)
+                [this](const std::string& msg,
+                       size_t wireSize,
+                       bool decompressionError,
+                       WebSocketTransport::MessageKind messageKind)
                 {
-                    _onMessageCallback(WebSocket_MessageType_Message, msg, WebSocketErrorInfo());
+                    WebSocketMessageType webSocketMessageType;
+                    switch (messageKind)
+                    {
+                        case WebSocketTransport::MSG:
+                        {
+                            webSocketMessageType = WebSocket_MessageType_Message;
+                        } break;
+
+                        case WebSocketTransport::PING:
+                        {
+                            webSocketMessageType = WebSocket_MessageType_Ping;
+                        } break;
+
+                        case WebSocketTransport::PONG:
+                        {
+                            webSocketMessageType = WebSocket_MessageType_Pong;
+                        } break;
+                    }
+
+                    WebSocketErrorInfo webSocketErrorInfo;
+                    webSocketErrorInfo.decompressionError = decompressionError;
+
+                    _onMessageCallback(webSocketMessageType, msg, wireSize,
+                                       webSocketErrorInfo, WebSocketOpenInfo(),
+                                       WebSocketCloseInfo());
 
                     WebSocket::invokeTrafficTrackerCallback(msg.size(), true);
                 });
+
+            // 4. In blocking mode, getting out of this function is triggered by
+            //    an explicit disconnection from the callback, or by the remote end
+            //    closing the connection, ie isConnected() == false.
+            if (!_thread.joinable() && !isConnected() && !_automaticReconnection) return;
         }
     }
 
@@ -209,9 +294,26 @@ namespace ix {
         }
     }
 
-    bool WebSocket::send(const std::string& text)
+    WebSocketSendInfo WebSocket::send(const std::string& text,
+                                      const OnProgressCallback& onProgressCallback)
     {
-        if (!isConnected()) return false;
+        return sendMessage(text, false, onProgressCallback);
+    }
+
+    WebSocketSendInfo WebSocket::ping(const std::string& text)
+    {
+        // Standard limit ping message size
+        constexpr size_t pingMaxPayloadSize = 125;
+        if (text.size() > pingMaxPayloadSize) return WebSocketSendInfo(false);
+
+        return sendMessage(text, true);
+    }
+
+    WebSocketSendInfo WebSocket::sendMessage(const std::string& text,
+                                             bool ping,
+                                             const OnProgressCallback& onProgressCallback)
+    {
+        if (!isConnected()) return WebSocketSendInfo(false);
 
         //
         // It is OK to read and write on the same socket in 2 different threads.
@@ -223,11 +325,20 @@ namespace ix {
         // incoming messages are arriving / there's data to be received.
         //
         std::lock_guard<std::mutex> lock(_writeMutex);
-        _ws.sendBinary(text);
+        WebSocketSendInfo webSocketSendInfo;
 
-        WebSocket::invokeTrafficTrackerCallback(text.size(), false);
+        if (ping)
+        {
+            webSocketSendInfo = _ws.sendPing(text);
+        }
+        else
+        {
+            webSocketSendInfo = _ws.sendBinary(text, onProgressCallback);
+        }
 
-        return true;
+        WebSocket::invokeTrafficTrackerCallback(webSocketSendInfo.wireSize, false);
+
+        return webSocketSendInfo;
     }
 
     ReadyState WebSocket::getReadyState() const
@@ -238,6 +349,7 @@ namespace ix {
             case ix::WebSocketTransport::CONNECTING: return WebSocket_ReadyState_Connecting;
             case ix::WebSocketTransport::CLOSING: return WebSocket_ReadyState_Closing;
             case ix::WebSocketTransport::CLOSED: return WebSocket_ReadyState_Closed;
+            default: return WebSocket_ReadyState_Closed;
         }
     }
 
@@ -249,12 +361,17 @@ namespace ix {
             case WebSocket_ReadyState_Connecting: return "CONNECTING";
             case WebSocket_ReadyState_Closing: return "CLOSING";
             case WebSocket_ReadyState_Closed: return "CLOSED";
+            default: return "CLOSED";
         }
     }
 
-    const std::string& WebSocket::getUrl() const
+    void WebSocket::enableAutomaticReconnection()
     {
-        std::lock_guard<std::mutex> lock(_urlMutex);
-        return _url;
+        _automaticReconnection = true;
+    }
+
+    void WebSocket::disableAutomaticReconnection()
+    {
+        _automaticReconnection = false;
     }
 }

ixwebsocket/IXWebSocket.h

@@ -15,6 +15,11 @@
 #include <atomic>
 
 #include "IXWebSocketTransport.h"
+#include "IXWebSocketErrorInfo.h"
+#include "IXWebSocketSendInfo.h"
+#include "IXWebSocketPerMessageDeflateOptions.h"
+#include "IXWebSocketHttpHeaders.h"
+#include "IXProgressCallback.h"
 
 namespace ix
 {
@@ -32,18 +37,46 @@ namespace ix
         WebSocket_MessageType_Message = 0,
         WebSocket_MessageType_Open = 1,
         WebSocket_MessageType_Close = 2,
-        WebSocket_MessageType_Error = 3
+        WebSocket_MessageType_Error = 3,
+        WebSocket_MessageType_Ping = 4,
+        WebSocket_MessageType_Pong = 5
     };
 
-    struct WebSocketErrorInfo
+    struct WebSocketOpenInfo
     {
-        uint64_t retries;
-        double wait_time;
-        int http_status;
-        std::string reason;
+        std::string uri;
+        WebSocketHttpHeaders headers;
+
+        WebSocketOpenInfo(const std::string& u = std::string(),
+                          const WebSocketHttpHeaders& h = WebSocketHttpHeaders())
+            : uri(u)
+            , headers(h)
+        {
+            ;
+        }
     };
 
-    using OnMessageCallback = std::function<void(WebSocketMessageType, const std::string&, const WebSocketErrorInfo)>;
+    struct WebSocketCloseInfo
+    {
+        uint16_t code;
+        std::string reason;
+
+        WebSocketCloseInfo(uint16_t c = 0,
+                           const std::string& r = std::string())
+            : code(c)
+            , reason(r)
+        {
+            ;
+        }
+    };
+
+    using OnMessageCallback = std::function<void(WebSocketMessageType,
+                                                 const std::string&,
+                                                 size_t wireSize,
+                                                 const WebSocketErrorInfo&,
+                                                 const WebSocketOpenInfo&,
+                                                 const WebSocketCloseInfo&)>;
+
     using OnTrafficTrackerCallback = std::function<void(size_t size, bool incoming)>;
 
     class WebSocket
@@ -52,36 +85,57 @@ namespace ix
         WebSocket();
         ~WebSocket();
 
-        void configure(const std::string& url);
+        void setUrl(const std::string& url);
+        void setPerMessageDeflateOptions(const WebSocketPerMessageDeflateOptions& perMessageDeflateOptions);
+        void setHandshakeTimeout(int handshakeTimeoutSecs);
+        void setHeartBeatPeriod(int hearBeatPeriod);
+
+        // Run asynchronously, by calling start and stop.
         void start();
         void stop();
-        bool send(const std::string& text);
+
+        // Run in blocking mode, by connecting first manually, and then calling run.
+        WebSocketInitResult connect(int timeoutSecs);
+        void run();
+
+        WebSocketSendInfo send(const std::string& text,
+                               const OnProgressCallback& onProgressCallback = nullptr);
+        WebSocketSendInfo ping(const std::string& text);
         void close();
 
         void setOnMessageCallback(const OnMessageCallback& callback);
         static void setTrafficTrackerCallback(const OnTrafficTrackerCallback& callback);
         static void resetTrafficTrackerCallback();
 
-        void setVerbose(bool verbose) { _verbose = verbose; }
-
-        const std::string& getUrl() const;
         ReadyState getReadyState() const;
+        const std::string& getUrl() const;
+        const WebSocketPerMessageDeflateOptions& getPerMessageDeflateOptions() const;
+        int getHeartBeatPeriod() const;
+
+        void enableAutomaticReconnection();
+        void disableAutomaticReconnection();
 
     private:
-        void run();
 
-        WebSocketInitResult connect();
+        WebSocketSendInfo sendMessage(const std::string& text,
+                                      bool ping,
+                                      const OnProgressCallback& callback = nullptr);
+
         bool isConnected() const;
         bool isClosing() const;
         void reconnectPerpetuallyIfDisconnected();
         std::string readyStateToString(ReadyState readyState);
         static void invokeTrafficTrackerCallback(size_t size, bool incoming);
 
+        // Server
+        void setSocketFileDescriptor(int fd);
+        WebSocketInitResult connectToSocket(int fd, int timeoutSecs);
+
         WebSocketTransport _ws;
 
         std::string _url;
-        mutable std::mutex _urlMutex;
-        bool _verbose;
+        WebSocketPerMessageDeflateOptions _perMessageDeflateOptions;
+        mutable std::mutex _configMutex; // protect all config variables access
 
         OnMessageCallback _onMessageCallback;
         static OnTrafficTrackerCallback _onTrafficTrackerCallback;
@@ -91,6 +145,13 @@ namespace ix
         std::thread _thread;
         std::mutex _writeMutex;
 
-        static int kHeartBeatPeriod;
+        std::atomic<int> _handshakeTimeoutSecs;
+        static const int kDefaultHandShakeTimeoutSecs;
+
+        // Optional Heartbeat
+        int _heartBeatPeriod;
+        static const int kDefaultHeartBeatPeriod;
+
+        friend class WebSocketServer;
     };
 }

ixwebsocket/IXWebSocketErrorInfo.h

@@ -0,0 +1,21 @@
+/*
+ *  IXWebSocketErrorInfo.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ix
+{
+    struct WebSocketErrorInfo
+    {
+        uint64_t retries;
+        double wait_time;
+        int http_status;
+        std::string reason;
+        bool decompressionError;
+    };
+}

ixwebsocket/IXWebSocketHandshake.cpp

@@ -0,0 +1,525 @@
+/*
+ *  IXWebSocketHandshake.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXWebSocketHandshake.h"
+#include "IXSocketConnect.h"
+
+#include "libwshandshake.hpp"
+
+#include <iostream>
+#include <sstream>
+#include <regex>
+#include <random>
+#include <algorithm>
+
+
+namespace ix
+{
+    WebSocketHandshake::WebSocketHandshake(std::atomic<bool>& requestInitCancellation,
+                                           std::shared_ptr<Socket> socket,
+                                           WebSocketPerMessageDeflate& perMessageDeflate,
+                                           WebSocketPerMessageDeflateOptions& perMessageDeflateOptions,
+                                           std::atomic<bool>& enablePerMessageDeflate) :
+        _requestInitCancellation(requestInitCancellation),
+        _socket(socket),
+        _perMessageDeflate(perMessageDeflate),
+        _perMessageDeflateOptions(perMessageDeflateOptions),
+        _enablePerMessageDeflate(enablePerMessageDeflate)
+    {
+
+    }
+
+    bool WebSocketHandshake::parseUrl(const std::string& url,
+                                      std::string& protocol,
+                                      std::string& host,
+                                      std::string& path,
+                                      std::string& query,
+                                      int& port)
+    {
+        std::regex ex("(ws|wss)://([^/ :]+):?([^/ ]*)(/?[^ #?]*)\\x3f?([^ #]*)#?([^ ]*)");
+        std::cmatch what;
+        if (!regex_match(url.c_str(), what, ex))
+        {
+            return false;
+        }
+
+        std::string portStr;
+
+        protocol = std::string(what[1].first, what[1].second);
+        host     = std::string(what[2].first, what[2].second);
+        portStr  = std::string(what[3].first, what[3].second);
+        path     = std::string(what[4].first, what[4].second);
+        query    = std::string(what[5].first, what[5].second);
+
+        if (portStr.empty())
+        {
+            if (protocol == "ws")
+            {
+                port = 80;
+            }
+            else if (protocol == "wss")
+            {
+                port = 443;
+            }
+            else
+            {
+                // Invalid protocol. Should be caught by regex check
+                // but this missing branch trigger cpplint linter.
+                return false;
+            }
+        }
+        else
+        {
+            std::stringstream ss;
+            ss << portStr;
+            ss >> port;
+        }
+
+        if (path.empty())
+        {
+            path = "/";
+        }
+        else if (path[0] != '/')
+        {
+            path = '/' + path;
+        }
+
+        if (!query.empty())
+        {
+            path += "?";
+            path += query;
+        }
+
+        return true;
+    }
+
+    void WebSocketHandshake::printUrl(const std::string& url)
+    {
+        std::string protocol, host, path, query;
+        int port {0};
+
+        if (!WebSocketHandshake::parseUrl(url, protocol, host,
+                                          path, query, port))
+        {
+            return;
+        }
+
+        std::cout << "[" << url << "]" << std::endl;
+        std::cout << protocol << std::endl;
+        std::cout << host << std::endl;
+        std::cout << port << std::endl;
+        std::cout << path << std::endl;
+        std::cout << query << std::endl;
+        std::cout << "-------------------------------" << std::endl;
+    }
+
+    std::string WebSocketHandshake::trim(const std::string& str)
+    {
+        std::string out(str);
+        out.erase(std::remove(out.begin(), out.end(), ' '), out.end());
+        out.erase(std::remove(out.begin(), out.end(), '\r'), out.end());
+        out.erase(std::remove(out.begin(), out.end(), '\n'), out.end());
+        return out;
+    }
+
+    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);
+                          });
+    }
+
+    std::tuple<std::string, std::string, std::string> WebSocketHandshake::parseRequestLine(const std::string& line)
+    {
+        // Request-Line   = Method SP Request-URI SP HTTP-Version CRLF
+        std::string token;
+        std::stringstream tokenStream(line);
+        std::vector<std::string> tokens;
+
+        // Split by ' '
+        while (std::getline(tokenStream, token, ' '))
+        {
+            tokens.push_back(token);
+        }
+
+        std::string method;
+        if (tokens.size() >= 1)
+        {
+            method = trim(tokens[0]);
+        }
+
+        std::string requestUri;
+        if (tokens.size() >= 2)
+        {
+            requestUri = trim(tokens[1]);
+        }
+
+        std::string httpVersion;
+        if (tokens.size() >= 3)
+        {
+            httpVersion = trim(tokens[2]);
+        }
+
+        return std::make_tuple(method, requestUri, httpVersion);
+    }
+
+    std::string WebSocketHandshake::genRandomString(const int len)
+    {
+        std::string alphanum =
+            "0123456789"
+            "ABCDEFGH"
+            "abcdefgh";
+
+        std::random_device r;
+        std::default_random_engine e1(r());
+        std::uniform_int_distribution<int> dist(0, (int) alphanum.size() - 1);
+
+        std::string s;
+        s.resize(len);
+
+        for (int i = 0; i < len; ++i)
+        {
+            int x = dist(e1);
+            s[i] = alphanum[x];
+        }
+
+        return s;
+    }
+
+
+    std::pair<bool, WebSocketHttpHeaders> WebSocketHandshake::parseHttpHeaders(
+        const CancellationRequest& isCancellationRequested)
+    {
+        WebSocketHttpHeaders headers;
+
+        char line[256];
+        int i;
+
+        while (true)
+        {
+            int colon = 0;
+
+            for (i = 0;
+                 i < 2 || (i < 255 && line[i-2] != '\r' && line[i-1] != '\n');
+                 ++i)
+            {
+                if (!_socket->readByte(line+i, isCancellationRequested))
+                {
+                    return std::make_pair(false, headers);
+                }
+
+                if (line[i] == ':' && colon == 0)
+                {
+                    colon = i;
+                }
+            }
+            if (line[0] == '\r' && line[1] == '\n')
+            {
+                break;
+            }
+
+            // line is a single header entry. split by ':', and add it to our
+            // header map. ignore lines with no colon.
+            if (colon > 0)
+            {
+                line[i] = '\0';
+                std::string lineStr(line);
+                // colon is ':', colon+1 is ' ', colon+2 is the start of the value.
+                // i is end of string (\0), i-colon is length of string minus key;
+                // subtract 1 for '\0', 1 for '\n', 1 for '\r',
+                // 1 for the ' ' after the ':', and total is -4
+                std::string name(lineStr.substr(0, colon));
+                std::string value(lineStr.substr(colon + 2, i - colon - 4));
+
+                // Make the name lower case.
+                std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+
+                headers[name] = value;
+            }
+        }
+
+        return std::make_pair(true, headers);
+    }
+
+    WebSocketInitResult WebSocketHandshake::sendErrorResponse(int code, const std::string& reason)
+    {
+        std::stringstream ss;
+        ss << "HTTP/1.1 ";
+        ss << code;
+        ss << "\r\n";
+        ss << reason;
+        ss << "\r\n";
+
+        // Socket write can only be cancelled through a timeout here, not manually.
+        static std::atomic<bool> requestInitCancellation(false);
+        auto isCancellationRequested =
+            makeCancellationRequestWithTimeout(1, requestInitCancellation);
+
+        if (!_socket->writeBytes(ss.str(), isCancellationRequested))
+        {
+            return WebSocketInitResult(false, 500, "Timed out while sending error response");
+        }
+
+        return WebSocketInitResult(false, code, reason);
+    }
+
+    WebSocketInitResult WebSocketHandshake::clientHandshake(const std::string& url,
+                                                            const std::string& host,
+                                                            const std::string& path,
+                                                            int port,
+                                                            int timeoutSecs)
+    {
+        _requestInitCancellation = false;
+
+        auto isCancellationRequested =
+            makeCancellationRequestWithTimeout(timeoutSecs, _requestInitCancellation);
+
+        std::string errMsg;
+        bool success = _socket->connect(host, port, errMsg, isCancellationRequested);
+        if (!success)
+        {
+            std::stringstream ss;
+            ss << "Unable to connect to " << host
+               << " on port " << port
+               << ", error: " << errMsg;
+            return WebSocketInitResult(false, 0, ss.str());
+        }
+
+        //
+        // Generate a random 24 bytes string which looks like it is base64 encoded
+        // y3JJHMbDL1EzLkh9GBhXDw==
+        // 0cb3Vd9HkbpVVumoS3Noka==
+        //
+        // See https://stackoverflow.com/questions/18265128/what-is-sec-websocket-key-for
+        //
+        std::string secWebSocketKey = genRandomString(22);
+        secWebSocketKey += "==";
+
+        std::stringstream ss;
+        ss << "GET " << path << " HTTP/1.1\r\n";
+        ss << "Host: "<< host << ":" << port << "\r\n";
+        ss << "Upgrade: websocket\r\n";
+        ss << "Connection: Upgrade\r\n";
+        ss << "Sec-WebSocket-Version: 13\r\n";
+        ss << "Sec-WebSocket-Key: " << secWebSocketKey << "\r\n";
+
+        if (_enablePerMessageDeflate)
+        {
+            ss << _perMessageDeflateOptions.generateHeader();
+        }
+
+        ss << "\r\n";
+
+        if (!_socket->writeBytes(ss.str(), isCancellationRequested))
+        {
+            return WebSocketInitResult(false, 0, std::string("Failed sending GET request to ") + url);
+        }
+
+        // Read HTTP status line
+        auto lineResult = _socket->readLine(isCancellationRequested);
+        auto lineValid = lineResult.first;
+        auto line = lineResult.second;
+
+        if (!lineValid)
+        {
+            return WebSocketInitResult(false, 0,
+                                       std::string("Failed reading HTTP status line from ") + url);
+        }
+
+        // Validate status
+        int status;
+
+        // HTTP/1.0 is too old.
+        if (sscanf(line.c_str(), "HTTP/1.0 %d", &status) == 1)
+        {
+            std::stringstream ss;
+            ss << "Server version is HTTP/1.0. Rejecting connection to " << host
+               << ", status: " << status
+               << ", HTTP Status line: " << line;
+            return WebSocketInitResult(false, status, ss.str());
+        }
+
+        // We want an 101 HTTP status
+        if (sscanf(line.c_str(), "HTTP/1.1 %d", &status) != 1 || status != 101)
+        {
+            std::stringstream ss;
+            ss << "Got bad status connecting to " << host
+               << ", status: " << status
+               << ", HTTP Status line: " << line;
+            return WebSocketInitResult(false, status, ss.str());
+        }
+
+        auto result = parseHttpHeaders(isCancellationRequested);
+        auto headersValid = result.first;
+        auto headers = result.second;
+
+        if (!headersValid)
+        {
+            return WebSocketInitResult(false, status, "Error parsing HTTP headers");
+        }
+
+        // Check the presence of the connection field
+        if (headers.find("connection") == headers.end())
+        {
+            std::string errorMsg("Missing connection value");
+            return WebSocketInitResult(false, status, errorMsg);
+        }
+
+        // Check the value of the connection field
+        // Some websocket servers (Go/Gorilla?) send lowercase values for the
+        // connection header, so do a case insensitive comparison
+        if (!insensitiveStringCompare(headers["connection"], "Upgrade"))
+        {
+            std::stringstream ss;
+            ss << "Invalid connection value: " << headers["connection"];
+            return WebSocketInitResult(false, status, ss.str());
+        }
+
+        char output[29] = {};
+        WebSocketHandshakeKeyGen::generate(secWebSocketKey.c_str(), output);
+        if (std::string(output) != headers["sec-websocket-accept"])
+        {
+            std::string errorMsg("Invalid Sec-WebSocket-Accept value");
+            return WebSocketInitResult(false, status, errorMsg);
+        }
+
+        if (_enablePerMessageDeflate)
+        {
+            // Parse the server response. Does it support deflate ?
+            std::string header = headers["sec-websocket-extensions"];
+            WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(header);
+
+            // If the server does not support that extension, disable it.
+            if (!webSocketPerMessageDeflateOptions.enabled())
+            {
+                _enablePerMessageDeflate = false;
+            }
+            // Otherwise try to initialize the deflate engine (zlib)
+            else if (!_perMessageDeflate.init(webSocketPerMessageDeflateOptions))
+            {
+                return WebSocketInitResult(
+                    false, 0,"Failed to initialize per message deflate engine");
+            }
+        }
+
+        return WebSocketInitResult(true, status, "", headers, path);
+    }
+
+    WebSocketInitResult WebSocketHandshake::serverHandshake(int fd, int timeoutSecs)
+    {
+        _requestInitCancellation = false;
+
+        // Set the socket to non blocking mode + other tweaks
+        SocketConnect::configure(fd);
+
+        auto isCancellationRequested =
+            makeCancellationRequestWithTimeout(timeoutSecs, _requestInitCancellation);
+
+        std::string remote = std::string("remote fd ") + std::to_string(fd);
+
+        // Read first line
+        auto lineResult = _socket->readLine(isCancellationRequested);
+        auto lineValid = lineResult.first;
+        auto line = lineResult.second;
+
+        if (!lineValid)
+        {
+            return sendErrorResponse(400, "Error reading HTTP request line");
+        }
+
+        // Validate request line (GET /foo HTTP/1.1\r\n)
+        auto requestLine = parseRequestLine(line);
+        auto method      = std::get<0>(requestLine);
+        auto uri         = std::get<1>(requestLine);
+        auto httpVersion = std::get<2>(requestLine);
+
+        if (method != "GET")
+        {
+            return sendErrorResponse(400, "Invalid HTTP method, need GET, got " + method);
+        }
+
+        if (httpVersion != "HTTP/1.1")
+        {
+            return sendErrorResponse(400, "Invalid HTTP version, need HTTP/1.1, got: " + httpVersion);
+        }
+
+        // Retrieve and validate HTTP headers
+        auto result = parseHttpHeaders(isCancellationRequested);
+        auto headersValid = result.first;
+        auto headers = result.second;
+
+        if (!headersValid)
+        {
+            return sendErrorResponse(400, "Error parsing HTTP headers");
+        }
+
+        if (headers.find("sec-websocket-key") == headers.end())
+        {
+            return sendErrorResponse(400, "Missing Sec-WebSocket-Key value");
+        }
+
+        if (headers["upgrade"] != "websocket")
+        {
+            return sendErrorResponse(400, "Invalid or missing Upgrade header");
+        }
+
+        if (headers.find("sec-websocket-version") == headers.end())
+        {
+            return sendErrorResponse(400, "Missing Sec-WebSocket-Version value");
+        }
+
+        {
+            std::stringstream ss;
+            ss << headers["sec-websocket-version"];
+            int version;
+            ss >> version;
+
+            if (version != 13)
+            {
+                return sendErrorResponse(400, "Invalid Sec-WebSocket-Version, "
+                                              "need 13, got" + ss.str());
+            }
+        }
+
+        char output[29] = {};
+        WebSocketHandshakeKeyGen::generate(headers["sec-websocket-key"].c_str(), output);
+
+        std::stringstream ss;
+        ss << "HTTP/1.1 101\r\n";
+        ss << "Sec-WebSocket-Accept: " << std::string(output) << "\r\n";
+        ss << "Upgrade: websocket\r\n";
+        ss << "Connection: Upgrade\r\n";
+
+        // Parse the client headers. Does it support deflate ?
+        std::string header = headers["sec-websocket-extensions"];
+        WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(header);
+
+        // If the client has requested that extension, enable it.
+        if (webSocketPerMessageDeflateOptions.enabled())
+        {
+            _enablePerMessageDeflate = true;
+
+            if (!_perMessageDeflate.init(webSocketPerMessageDeflateOptions))
+            {
+                return WebSocketInitResult(
+                    false, 0,"Failed to initialize per message deflate engine");
+            }
+            ss << webSocketPerMessageDeflateOptions.generateHeader();
+        }
+
+        ss << "\r\n";
+
+        if (!_socket->writeBytes(ss.str(), isCancellationRequested))
+        {
+            return WebSocketInitResult(false, 0, std::string("Failed sending response to ") + remote);
+        }
+
+        return WebSocketInitResult(true, 200, "", headers, uri);
+    }
+}

ixwebsocket/IXWebSocketHandshake.h

@@ -0,0 +1,87 @@
+/*
+ *  IXWebSocketHandshake.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include "IXCancellationRequest.h"
+#include "IXWebSocketHttpHeaders.h"
+#include "IXWebSocketPerMessageDeflate.h"
+#include "IXWebSocketPerMessageDeflateOptions.h"
+#include "IXSocket.h"
+
+#include <string>
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <tuple>
+
+namespace ix
+{
+    struct WebSocketInitResult
+    {
+        bool success;
+        int http_status;
+        std::string errorStr;
+        WebSocketHttpHeaders headers;
+        std::string uri;
+
+        WebSocketInitResult(bool s = false,
+                            int status = 0,
+                            const std::string& e = std::string(),
+                            WebSocketHttpHeaders h = WebSocketHttpHeaders(),
+                            const std::string& u = std::string())
+        {
+            success = s;
+            http_status = status;
+            errorStr = e;
+            headers = h;
+            uri = u;
+        }
+    };
+
+    class WebSocketHandshake {
+    public:
+        WebSocketHandshake(std::atomic<bool>& requestInitCancellation,
+                           std::shared_ptr<Socket> _socket,
+                           WebSocketPerMessageDeflate& perMessageDeflate,
+                           WebSocketPerMessageDeflateOptions& perMessageDeflateOptions,
+                           std::atomic<bool>& enablePerMessageDeflate);
+
+        WebSocketInitResult clientHandshake(const std::string& url,
+                                            const std::string& host,
+                                            const std::string& path,
+                                            int port,
+                                            int timeoutSecs);
+
+        WebSocketInitResult serverHandshake(int fd,
+                                            int timeoutSecs);
+
+        static bool parseUrl(const std::string& url,
+                             std::string& protocol,
+                             std::string& host,
+                             std::string& path,
+                             std::string& query,
+                             int& port);
+
+    private:
+        static void printUrl(const std::string& url);
+        std::string genRandomString(const int len);
+
+        // Parse HTTP headers
+        std::pair<bool, WebSocketHttpHeaders> parseHttpHeaders(const CancellationRequest& isCancellationRequested);
+        WebSocketInitResult sendErrorResponse(int code, const std::string& reason);
+
+        std::tuple<std::string, std::string, std::string> parseRequestLine(const std::string& line);
+        std::string trim(const std::string& str);
+        bool insensitiveStringCompare(const std::string& a, const std::string& b);
+
+        std::atomic<bool>& _requestInitCancellation;
+        std::shared_ptr<Socket> _socket;
+        WebSocketPerMessageDeflate& _perMessageDeflate;
+        WebSocketPerMessageDeflateOptions& _perMessageDeflateOptions;
+        std::atomic<bool>& _enablePerMessageDeflate;
+    };
+}

ixwebsocket/IXWebSocketHttpHeaders.h

@@ -0,0 +1,15 @@
+/*
+ *  IXWebSocketHttpHeaders.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+namespace ix
+{
+    using WebSocketHttpHeaders = std::unordered_map<std::string, std::string>;
+}

ixwebsocket/IXWebSocketPerMessageDeflate.cpp

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2015, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ *
+ *  Adapted from websocketpp/extensions/permessage_deflate/enabled.hpp
+ *  (same license as MZ: https://opensource.org/licenses/BSD-3-Clause)
+ *
+ *  - Reused zlib compression + decompression bits.
+ *  - Refactored to have 2 class for compression and decompression, to allow multi-threading
+ *    and make sure that _compressBuffer is not shared between threads.
+ *  - Original code wasn't working for some reason, I had to add checks
+ *    for the presence of the kEmptyUncompressedBlock at the end of buffer so that servers
+ *    would start accepting receiving/decoding compressed messages. Original code was probably
+ *    modifying the passed in buffers before processing in enabled.hpp ?
+ *  - Added more documentation.
+ *
+ *  Per message Deflate RFC: https://tools.ietf.org/html/rfc7692
+ *  Chrome websocket -> https://github.com/chromium/chromium/tree/2ca8c5037021c9d2ecc00b787d58a31ed8fc8bcb/net/websockets
+ *
+ */
+
+#include "IXWebSocketPerMessageDeflate.h"
+#include "IXWebSocketPerMessageDeflateOptions.h"
+#include "IXWebSocketPerMessageDeflateCodec.h"
+
+namespace ix
+{
+    WebSocketPerMessageDeflate::WebSocketPerMessageDeflate() :
+        _compressor(std::make_unique<WebSocketPerMessageDeflateCompressor>()),
+        _decompressor(std::make_unique<WebSocketPerMessageDeflateDecompressor>())
+    {
+        ;
+    }
+
+    WebSocketPerMessageDeflate::~WebSocketPerMessageDeflate()
+    {
+        ;
+    }
+
+    bool WebSocketPerMessageDeflate::init(const WebSocketPerMessageDeflateOptions& perMessageDeflateOptions)
+    {
+        bool clientNoContextTakeover =
+            perMessageDeflateOptions.getClientNoContextTakeover();
+
+        uint8_t deflateBits = perMessageDeflateOptions.getClientMaxWindowBits();
+        uint8_t inflateBits = perMessageDeflateOptions.getServerMaxWindowBits();
+
+        return _compressor->init(deflateBits, clientNoContextTakeover) &&
+               _decompressor->init(inflateBits, clientNoContextTakeover);
+    }
+
+    bool WebSocketPerMessageDeflate::compress(const std::string& in,
+                                              std::string& out)
+    {
+        return _compressor->compress(in, out);
+    }
+
+    bool WebSocketPerMessageDeflate::decompress(const std::string& in,
+                                                std::string &out)
+    {
+        return _decompressor->decompress(in, out);
+    }
+
+}

ixwebsocket/IXWebSocketPerMessageDeflate.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2015, Peter Thorson. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the WebSocket++ Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ *
+ *  Adapted from websocketpp/extensions/permessage_deflate/enabled.hpp
+ *  (same license as MZ: https://opensource.org/licenses/BSD-3-Clause)
+ */
+
+#pragma once
+
+#include <string>
+#include <memory>
+
+namespace ix
+{
+    class WebSocketPerMessageDeflateOptions;
+    class WebSocketPerMessageDeflateCompressor;
+    class WebSocketPerMessageDeflateDecompressor;
+
+    class WebSocketPerMessageDeflate
+    {
+    public:
+        WebSocketPerMessageDeflate();
+        ~WebSocketPerMessageDeflate();
+
+        bool init(const WebSocketPerMessageDeflateOptions& perMessageDeflateOptions);
+        bool compress(const std::string& in, std::string& out);
+        bool decompress(const std::string& in, std::string& out);
+
+    private:
+        std::unique_ptr<WebSocketPerMessageDeflateCompressor> _compressor;
+        std::unique_ptr<WebSocketPerMessageDeflateDecompressor> _decompressor;
+    };
+}

ixwebsocket/IXWebSocketPerMessageDeflateCodec.cpp

@@ -0,0 +1,206 @@
+/*
+ *  IXWebSocketPerMessageDeflateCodec.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXWebSocketPerMessageDeflateCodec.h"
+#include "IXWebSocketPerMessageDeflateOptions.h"
+
+#include <iostream>
+#include <cassert>
+#include <string.h>
+
+namespace
+{
+    // The passed in size (4) is important, without it the string litteral
+    // is treated as a char* and the null termination (\x00) makes it
+    // look like an empty string.
+    const std::string kEmptyUncompressedBlock = std::string("\x00\x00\xff\xff", 4);
+
+    const int kBufferSize = 1 << 14;
+}
+
+namespace ix
+{
+    //
+    // Compressor
+    //
+    WebSocketPerMessageDeflateCompressor::WebSocketPerMessageDeflateCompressor()
+      : _compressBufferSize(kBufferSize)
+    {
+        memset(&_deflateState, 0, sizeof(_deflateState));
+
+        _deflateState.zalloc = Z_NULL;
+        _deflateState.zfree = Z_NULL;
+        _deflateState.opaque = Z_NULL;
+    }
+
+    WebSocketPerMessageDeflateCompressor::~WebSocketPerMessageDeflateCompressor()
+    {
+        deflateEnd(&_deflateState);
+    }
+
+    bool WebSocketPerMessageDeflateCompressor::init(uint8_t deflateBits,
+                                                    bool clientNoContextTakeOver)
+    {
+        int ret = deflateInit2(
+            &_deflateState,
+            Z_DEFAULT_COMPRESSION,
+            Z_DEFLATED,
+            -1*deflateBits,
+            4, // memory level 1-9
+            Z_DEFAULT_STRATEGY
+        );
+
+        if (ret != Z_OK) return false;
+
+        _compressBuffer = std::make_unique<unsigned char[]>(_compressBufferSize);
+
+        _flush = (clientNoContextTakeOver)
+                 ? Z_FULL_FLUSH
+                 : Z_SYNC_FLUSH;
+
+        return true;
+    }
+
+    bool WebSocketPerMessageDeflateCompressor::endsWith(const std::string& value,
+                                                        const std::string& ending)
+    {
+        if (ending.size() > value.size()) return false;
+        return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
+    }
+
+    bool WebSocketPerMessageDeflateCompressor::compress(const std::string& in,
+                                                        std::string& out)
+    {
+        //
+        // 7.2.1.  Compression
+        //
+        //    An endpoint uses the following algorithm to compress a message.
+        //
+        //    1.  Compress all the octets of the payload of the message using
+        //        DEFLATE.
+        //
+        //    2.  If the resulting data does not end with an empty DEFLATE block
+        //        with no compression (the "BTYPE" bits are set to 00), append an
+        //        empty DEFLATE block with no compression to the tail end.
+        //
+        //    3.  Remove 4 octets (that are 0x00 0x00 0xff 0xff) from the tail end.
+        //        After this step, the last octet of the compressed data contains
+        //        (possibly part of) the DEFLATE header bits with the "BTYPE" bits
+        //        set to 00.
+        //
+        size_t output;
+
+        if (in.empty())
+        {
+            uint8_t buf[6] = {0x02, 0x00, 0x00, 0x00, 0xff, 0xff};
+            out.append((char *)(buf), 6);
+            return true;
+        }
+
+        _deflateState.avail_in = (uInt) in.size();
+        _deflateState.next_in = (Bytef*) in.data();
+
+        do
+        {
+            // Output to local buffer
+            _deflateState.avail_out = (uInt) _compressBufferSize;
+            _deflateState.next_out = _compressBuffer.get();
+
+            deflate(&_deflateState, _flush);
+
+            output = _compressBufferSize - _deflateState.avail_out;
+
+            out.append((char *)(_compressBuffer.get()),output);
+        } while (_deflateState.avail_out == 0);
+
+        if (endsWith(out, kEmptyUncompressedBlock))
+        {
+            out.resize(out.size() - 4);
+        }
+
+        return true;
+    }
+
+    //
+    // Decompressor
+    //
+    WebSocketPerMessageDeflateDecompressor::WebSocketPerMessageDeflateDecompressor()
+      : _compressBufferSize(kBufferSize)
+    {
+        memset(&_inflateState, 0, sizeof(_inflateState));
+
+        _inflateState.zalloc = Z_NULL;
+        _inflateState.zfree = Z_NULL;
+        _inflateState.opaque = Z_NULL;
+        _inflateState.avail_in = 0;
+        _inflateState.next_in = Z_NULL;
+    }
+
+    WebSocketPerMessageDeflateDecompressor::~WebSocketPerMessageDeflateDecompressor()
+    {
+        inflateEnd(&_inflateState);
+    }
+
+    bool WebSocketPerMessageDeflateDecompressor::init(uint8_t inflateBits,
+                                                      bool clientNoContextTakeOver)
+    {
+        int ret = inflateInit2(
+            &_inflateState,
+            -1*inflateBits
+        );
+
+        if (ret != Z_OK) return false;
+
+        _compressBuffer = std::make_unique<unsigned char[]>(_compressBufferSize);
+
+        _flush = (clientNoContextTakeOver)
+                 ? Z_FULL_FLUSH
+                 : Z_SYNC_FLUSH;
+
+        return true;
+    }
+
+    bool WebSocketPerMessageDeflateDecompressor::decompress(const std::string& in,
+                                                            std::string& out)
+    {
+        //
+        // 7.2.2.  Decompression
+        //
+        //    An endpoint uses the following algorithm to decompress a message.
+        //
+        //    1.  Append 4 octets of 0x00 0x00 0xff 0xff to the tail end of the
+        //        payload of the message.
+        //
+        //    2.  Decompress the resulting data using DEFLATE.
+        //
+        std::string inFixed(in);
+        inFixed += kEmptyUncompressedBlock;
+
+        _inflateState.avail_in = (uInt) inFixed.size();
+        _inflateState.next_in = (unsigned char *)(const_cast<char *>(inFixed.data()));
+
+        do
+        {
+            _inflateState.avail_out = (uInt) _compressBufferSize;
+            _inflateState.next_out = _compressBuffer.get();
+
+            int ret = inflate(&_inflateState, Z_SYNC_FLUSH);
+
+            if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR)
+            {
+                return false; // zlib error
+            }
+
+            out.append(
+                reinterpret_cast<char *>(_compressBuffer.get()),
+                _compressBufferSize - _inflateState.avail_out
+            );
+        } while (_inflateState.avail_out == 0);
+
+        return true;
+    }
+}
+

ixwebsocket/IXWebSocketPerMessageDeflateCodec.h

@@ -0,0 +1,50 @@
+/*
+ *  IXWebSocketPerMessageDeflateCodec.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include "zlib.h"
+#include <string>
+#include <memory>
+
+namespace ix
+{
+    class WebSocketPerMessageDeflateCompressor
+    {
+    public:
+        WebSocketPerMessageDeflateCompressor();
+        ~WebSocketPerMessageDeflateCompressor();
+
+        bool init(uint8_t deflateBits, bool clientNoContextTakeOver);
+        bool compress(const std::string& in, std::string& out);
+
+    private:
+        static bool endsWith(const std::string& value, const std::string& ending);
+
+        int _flush;
+        size_t _compressBufferSize;
+        std::unique_ptr<unsigned char[]> _compressBuffer;
+        z_stream _deflateState;
+    };
+
+    class WebSocketPerMessageDeflateDecompressor
+    {
+    public:
+        WebSocketPerMessageDeflateDecompressor();
+        ~WebSocketPerMessageDeflateDecompressor();
+
+        bool init(uint8_t inflateBits, bool clientNoContextTakeOver);
+        bool decompress(const std::string& in, std::string& out);
+
+    private:
+        int _flush;
+        size_t _compressBufferSize;
+        std::unique_ptr<unsigned char[]> _compressBuffer;
+        z_stream _inflateState;
+    };
+
+}
+

ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp

@@ -0,0 +1,172 @@
+/*
+ *  IXWebSocketPerMessageDeflateOptions.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXWebSocketPerMessageDeflateOptions.h"
+
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+#include <cctype>
+
+namespace ix
+{
+    /// Default values as defined in the RFC
+    const uint8_t WebSocketPerMessageDeflateOptions::kDefaultServerMaxWindowBits = 15;
+    static const int minServerMaxWindowBits = 8;
+    static const int maxServerMaxWindowBits = 15;
+
+    const uint8_t WebSocketPerMessageDeflateOptions::kDefaultClientMaxWindowBits = 15;
+    static const int minClientMaxWindowBits = 8;
+    static const int maxClientMaxWindowBits = 15;
+
+    WebSocketPerMessageDeflateOptions::WebSocketPerMessageDeflateOptions(
+        bool enabled,
+        bool clientNoContextTakeover,
+        bool serverNoContextTakeover,
+        uint8_t clientMaxWindowBits,
+        uint8_t serverMaxWindowBits)
+    {
+        _enabled = enabled;
+        _clientNoContextTakeover = clientNoContextTakeover;
+        _serverNoContextTakeover = serverNoContextTakeover;
+        _clientMaxWindowBits = clientMaxWindowBits;
+        _serverMaxWindowBits = serverMaxWindowBits;
+    }
+
+    //
+    // Four extension parameters are defined for "permessage-deflate" to
+    // help endpoints manage per-connection resource usage.
+    //
+    // - "server_no_context_takeover"
+    // - "client_no_context_takeover"
+    // - "server_max_window_bits"
+    // - "client_max_window_bits"
+    //
+    // Server response could look like that:
+    //
+    // Sec-WebSocket-Extensions: permessage-deflate; client_no_context_takeover; server_no_context_takeover
+    //
+    WebSocketPerMessageDeflateOptions::WebSocketPerMessageDeflateOptions(std::string extension)
+    {
+        extension = removeSpaces(extension);
+
+        _enabled = false;
+        _clientNoContextTakeover = false;
+        _serverNoContextTakeover = false;
+        _clientMaxWindowBits = kDefaultClientMaxWindowBits;
+        _serverMaxWindowBits = kDefaultServerMaxWindowBits;
+
+        // Split by ;
+        std::string token;
+        std::stringstream tokenStream(extension);
+
+        while (std::getline(tokenStream, token, ';'))
+        {
+            if (token == "permessage-deflate")
+            {
+                _enabled = true;
+            }
+
+            if (token == "server_no_context_takeover")
+            {
+                _serverNoContextTakeover = true;
+            }
+
+            if (token == "client_no_context_takeover")
+            {
+                _clientNoContextTakeover = true;
+            }
+
+            if (startsWith(token, "server_max_window_bits="))
+            {
+                std::string val = token.substr(token.find_last_of("=") + 1);
+                std::stringstream ss;
+                ss << val;
+                int x;
+                ss >> x;
+
+                // Sanitize values to be in the proper range [8, 15] in
+                // case a server would give us bogus values
+                _serverMaxWindowBits =
+                    std::min(maxServerMaxWindowBits,
+                        std::max(x, minServerMaxWindowBits));
+            }
+
+            if (startsWith(token, "client_max_window_bits="))
+            {
+                std::string val = token.substr(token.find_last_of("=") + 1);
+                std::stringstream ss;
+                ss << val;
+                int x;
+                ss >> x;
+
+                // Sanitize values to be in the proper range [8, 15] in
+                // case a server would give us bogus values
+                _clientMaxWindowBits =
+                    std::min(maxClientMaxWindowBits,
+                        std::max(x, minClientMaxWindowBits));
+            }
+        }
+    }
+
+    std::string WebSocketPerMessageDeflateOptions::generateHeader()
+    {
+        std::stringstream ss;
+        ss << "Sec-WebSocket-Extensions: permessage-deflate";
+
+        if (_clientNoContextTakeover) ss << "; client_no_context_takeover";
+        if (_serverNoContextTakeover) ss << "; server_no_context_takeover";
+
+        ss << "; server_max_window_bits=" << _serverMaxWindowBits;
+        ss << "; client_max_window_bits=" << _clientMaxWindowBits;
+
+        ss << "\r\n";
+
+        return ss.str();
+    }
+
+    bool WebSocketPerMessageDeflateOptions::enabled() const
+    {
+        return _enabled;
+    }
+
+    bool WebSocketPerMessageDeflateOptions::getClientNoContextTakeover() const
+    {
+        return _clientNoContextTakeover;
+    }
+
+    bool WebSocketPerMessageDeflateOptions::getServerNoContextTakeover() const
+    {
+        return _serverNoContextTakeover;
+    }
+
+    uint8_t WebSocketPerMessageDeflateOptions::getClientMaxWindowBits() const
+    {
+        return _clientMaxWindowBits;
+    }
+
+    uint8_t WebSocketPerMessageDeflateOptions::getServerMaxWindowBits() const
+    {
+        return _serverMaxWindowBits;
+    }
+
+    bool WebSocketPerMessageDeflateOptions::startsWith(const std::string& str,
+                                                       const std::string& start)
+    {
+        return str.compare(0, start.length(), start) == 0;
+    }
+
+    std::string WebSocketPerMessageDeflateOptions::removeSpaces(const std::string& str)
+    {
+        std::string out(str);
+        out.erase(std::remove_if(out.begin(),
+                                 out.end(),
+                                 [](unsigned char x){ return std::isspace(x); }),
+                  out.end());
+
+        return out;
+    }
+}

ixwebsocket/IXWebSocketPerMessageDeflateOptions.h

@@ -0,0 +1,46 @@
+/*
+ *  IXWebSocketPerMessageDeflateOptions.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace ix
+{
+    class WebSocketPerMessageDeflateOptions
+    {
+    public:
+        WebSocketPerMessageDeflateOptions(
+            bool enabled = false,
+            bool clientNoContextTakeover = false,
+            bool serverNoContextTakeover = false,
+            uint8_t clientMaxWindowBits = kDefaultClientMaxWindowBits,
+            uint8_t serverMaxWindowBits = kDefaultServerMaxWindowBits);
+
+        WebSocketPerMessageDeflateOptions(std::string extension);
+
+        std::string generateHeader();
+        std::string parseHeader();
+        bool enabled() const;
+        bool getClientNoContextTakeover() const;
+        bool getServerNoContextTakeover() const;
+        uint8_t getServerMaxWindowBits() const;
+        uint8_t getClientMaxWindowBits() const;
+
+        static bool startsWith(const std::string& str, const std::string& start);
+        static std::string removeSpaces(const std::string& str);
+
+        static uint8_t const kDefaultClientMaxWindowBits;
+        static uint8_t const kDefaultServerMaxWindowBits;
+
+    private:
+        bool _enabled;
+        bool _clientNoContextTakeover;
+        bool _serverNoContextTakeover;
+        int _clientMaxWindowBits;
+        int _serverMaxWindowBits;
+    };
+}

ixwebsocket/IXWebSocketSendInfo.h

@@ -0,0 +1,31 @@
+/*
+ *  IXWebSocketSendInfo.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <string>
+#include <iostream>
+
+namespace ix
+{
+    struct WebSocketSendInfo
+    {
+        bool success;
+        bool compressionError;
+        size_t payloadSize;
+        size_t wireSize;
+
+        WebSocketSendInfo(bool s = false, bool c = false,
+                          size_t p = 0, size_t w = 0)
+            : success(s)
+            , compressionError(c)
+            , payloadSize(p)
+            , wireSize(w)
+        {
+            ;
+        }
+    };
+}

ixwebsocket/IXWebSocketServer.cpp

@@ -0,0 +1,105 @@
+/*
+ *  IXWebSocketServer.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXWebSocketServer.h"
+#include "IXWebSocketTransport.h"
+#include "IXWebSocket.h"
+#include "IXSocketConnect.h"
+#include "IXNetSystem.h"
+
+#include <sstream>
+#include <future>
+#include <string.h>
+
+namespace ix
+{
+    const int WebSocketServer::kDefaultHandShakeTimeoutSecs(3); // 3 seconds
+
+    WebSocketServer::WebSocketServer(int port,
+                                     const std::string& host,
+                                     int backlog,
+                                     size_t maxConnections,
+                                     int handshakeTimeoutSecs) : SocketServer(port, host, backlog, maxConnections),
+        _handshakeTimeoutSecs(handshakeTimeoutSecs)
+    {
+
+    }
+
+    WebSocketServer::~WebSocketServer()
+    {
+        stop();
+    }
+
+    void WebSocketServer::stop()
+    {
+        auto clients = getClients();
+        for (auto client : clients)
+        {
+            client->close();
+        }
+
+        SocketServer::stop();
+    }
+
+    void WebSocketServer::setOnConnectionCallback(const OnConnectionCallback& callback)
+    {
+        _onConnectionCallback = callback;
+    }
+
+    void WebSocketServer::handleConnection(int fd)
+    {
+        auto webSocket = std::make_shared<WebSocket>();
+        _onConnectionCallback(webSocket);
+
+        webSocket->disableAutomaticReconnection();
+
+        // Add this client to our client set
+        {
+            std::lock_guard<std::mutex> lock(_clientsMutex);
+            _clients.insert(webSocket);
+        }
+
+        auto status = webSocket->connectToSocket(fd, _handshakeTimeoutSecs);
+        if (status.success)
+        {
+            // Process incoming messages and execute callbacks
+            // until the connection is closed
+            webSocket->run();
+        }
+        else
+        {
+            std::stringstream ss;
+            ss << "WebSocketServer::handleConnection() error: "
+               << status.http_status
+               << " error: "
+               << status.errorStr;
+            logError(ss.str());
+        }
+
+        // Remove this client from our client set
+        {
+            std::lock_guard<std::mutex> lock(_clientsMutex);
+            if (_clients.erase(webSocket) != 1)
+            {
+                logError("Cannot delete client");
+            }
+        }
+
+        logInfo("WebSocketServer::handleConnection() done");
+    }
+
+    std::set<std::shared_ptr<WebSocket>> WebSocketServer::getClients()
+    {
+        std::lock_guard<std::mutex> lock(_clientsMutex);
+        return _clients;
+    }
+
+    size_t WebSocketServer::getConnectedClientsCount()
+    {
+        std::lock_guard<std::mutex> lock(_clientsMutex);
+        return _clients.size();
+    }
+}

ixwebsocket/IXWebSocketServer.h

@@ -0,0 +1,55 @@
+/*
+ *  IXWebSocketServer.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <utility> // pair
+#include <string>
+#include <set>
+#include <thread>
+#include <mutex>
+#include <functional>
+#include <memory>
+#include <condition_variable>
+
+#include "IXWebSocket.h"
+#include "IXSocketServer.h"
+
+namespace ix
+{
+    using OnConnectionCallback = std::function<void(std::shared_ptr<WebSocket>)>;
+
+    class WebSocketServer : public SocketServer {
+    public:
+        WebSocketServer(int port = SocketServer::kDefaultPort,
+                        const std::string& host = SocketServer::kDefaultHost,
+                        int backlog = SocketServer::kDefaultTcpBacklog,
+                        size_t maxConnections = SocketServer::kDefaultMaxConnections,
+                        int handshakeTimeoutSecs = WebSocketServer::kDefaultHandShakeTimeoutSecs);
+        virtual ~WebSocketServer();
+        virtual void stop() final;
+
+        void setOnConnectionCallback(const OnConnectionCallback& callback);
+
+        // Get all the connected clients
+        std::set<std::shared_ptr<WebSocket>> getClients();
+
+    private:
+        // Member variables
+        int _handshakeTimeoutSecs;
+
+        OnConnectionCallback _onConnectionCallback;
+
+        std::mutex _clientsMutex;
+        std::set<std::shared_ptr<WebSocket>> _clients;
+
+        const static int kDefaultHandShakeTimeoutSecs;
+
+        // Methods
+        virtual void handleConnection(int fd) final;
+        virtual size_t getConnectedClientsCount() final;
+    };
+}

ixwebsocket/IXWebSocketTransport.cpp

@@ -9,17 +9,19 @@
 //
 
 #include "IXWebSocketTransport.h"
+#include "IXWebSocketHandshake.h"
+#include "IXWebSocketHttpHeaders.h"
 
-#include "IXSocket.h"
+#ifdef IXWEBSOCKET_USE_TLS
 # ifdef __APPLE__
 #  include "IXSocketAppleSSL.h"
 # else
 #  include "IXSocketOpenSSL.h"
 # endif
+#endif
 
-#include <unistd.h>
-#include <errno.h>
 #include <string.h>
+#include <stdlib.h>
 
 #include <cstdlib>
 #include <vector>
@@ -27,15 +29,26 @@
 #include <cstdarg>
 #include <iostream>
 #include <sstream>
-#include <regex>
+#include <chrono>
+#include <thread>
 
 
-namespace ix {
+namespace ix
+{
+    const std::string WebSocketTransport::kHeartBeatPingMessage("ixwebsocket::hearbeat");
+    const int WebSocketTransport::kDefaultHeartBeatPeriod(-1);
+    constexpr size_t WebSocketTransport::kChunkSize;
 
     WebSocketTransport::WebSocketTransport() :
-        _readyState(CLOSED)
+        _readyState(CLOSED),
+        _closeCode(0),
+        _closeWireSize(0),
+        _enablePerMessageDeflate(false),
+        _requestInitCancellation(false),
+        _heartBeatPeriod(kDefaultHeartBeatPeriod),
+        _lastSendTimePoint(std::chrono::steady_clock::now())
     {
-        ;
+        _readbuf.resize(kChunkSize);
     }
 
     WebSocketTransport::~WebSocketTransport()
@@ -43,107 +56,39 @@ namespace ix {
         ;
     }
 
-    void WebSocketTransport::configure(const std::string& url)
+    void WebSocketTransport::configure(const WebSocketPerMessageDeflateOptions& perMessageDeflateOptions,
+                                       int hearBeatPeriod)
     {
-        _url = url;
+        _perMessageDeflateOptions = perMessageDeflateOptions;
+        _enablePerMessageDeflate = _perMessageDeflateOptions.enabled();
+        _heartBeatPeriod = hearBeatPeriod;
     }
 
-    bool WebSocketTransport::parseUrl(const std::string& url,
-                                      std::string& protocol,
-                                      std::string& host,
-                                      std::string& path,
-                                      std::string& query,
-                                      int& port)
-    {
-        std::regex ex("(ws|wss)://([^/ :]+):?([^/ ]*)(/?[^ #?]*)\\x3f?([^ #]*)#?([^ ]*)");
-        std::cmatch what;
-        if (!regex_match(url.c_str(), what, ex))
-        {
-            return false;
-        }
-
-        std::string portStr;
-
-        protocol = std::string(what[1].first, what[1].second);
-        host     = std::string(what[2].first, what[2].second);
-        portStr  = std::string(what[3].first, what[3].second);
-        path     = std::string(what[4].first, what[4].second);
-        query    = std::string(what[5].first, what[5].second);
-
-        if (portStr.empty())
-        {
-            if (protocol == "ws")
-            {
-                port = 80;
-            }
-            else if (protocol == "wss")
-            {
-                port = 443;
-            }
-        }
-        else
-        {
-            std::stringstream ss;
-            ss << portStr;
-            ss >> port;
-        }
-
-        if (path.empty())
-        {
-            path = "/";
-        }
-        else if (path[0] != '/')
-        {
-            path = '/' + path;
-        }
-
-        if (!query.empty())
-        {
-            path += "?";
-            path += query;
-        }
-
-        return true;
-    }
-
-    void WebSocketTransport::printUrl(const std::string& url)
-    {
-        std::string protocol, host, path, query;
-        int port {0};
-
-        if (!WebSocketTransport::parseUrl(url, protocol, host,
-                                          path, query, port))
-        {
-            return;
-        }
-
-        std::cout << "[" << url << "]" << std::endl;
-        std::cout << protocol << std::endl;
-        std::cout << host << std::endl;
-        std::cout << port << std::endl;
-        std::cout << path << std::endl;
-        std::cout << query << std::endl;
-        std::cout << "-------------------------------" << std::endl;
-    }
-
-    WebSocketInitResult WebSocketTransport::init()
+    // Client
+    WebSocketInitResult WebSocketTransport::connectToUrl(const std::string& url,
+                                                         int timeoutSecs)
     {
         std::string protocol, host, path, query;
         int port;
 
-        if (!WebSocketTransport::parseUrl(_url, protocol, host,
+        if (!WebSocketHandshake::parseUrl(url, protocol, host,
                                           path, query, port))
         {
-            return WebSocketInitResult(false, 0, "Could not parse URL");
+            return WebSocketInitResult(false, 0,
+                                       std::string("Could not parse URL ") + url);
         }
 
         if (protocol == "wss")
         {
             _socket.reset();
+#ifdef IXWEBSOCKET_USE_TLS
 # ifdef __APPLE__
              _socket = std::make_shared<SocketAppleSSL>();
 # else
              _socket = std::make_shared<SocketOpenSSL>();
+# endif
+#else
+            return WebSocketInitResult(false, 0, "TLS is not supported.");
 #endif
         }
         else
@@ -152,94 +97,39 @@ namespace ix {
             _socket = std::make_shared<Socket>();
         }
 
-        std::string errMsg;
-        bool success = _socket->connect(host, port, errMsg);
-        if (!success)
-        {
-            std::stringstream ss;
-            ss << "Unable to connect to " << host
-               << " on port " << port
-               << ", error: " << errMsg;
-            return WebSocketInitResult(false, 0, ss.str());
-        }
+        WebSocketHandshake webSocketHandshake(_requestInitCancellation,
+                                              _socket,
+                                              _perMessageDeflate,
+                                              _perMessageDeflateOptions,
+                                              _enablePerMessageDeflate);
 
-        char line[256];
-        int status;
-        int i;
-        snprintf(line, 256,
-            "GET %s HTTP/1.1\r\n"
-            "Host: %s:%d\r\n"
-            "Upgrade: websocket\r\n"
-            "Connection: Upgrade\r\n"
-            "Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==\r\n"
-            "Sec-WebSocket-Version: 13\r\n"
-            "\r\n",
-            path.c_str(), host.c_str(), port);
-
-        // XXX: this should be done non-blocking,
-
-        size_t lineSize = strlen(line);
-        if (_socket->send(line, lineSize) != lineSize)
+        auto result = webSocketHandshake.clientHandshake(url, host, path, port,
+                                                         timeoutSecs);
+        if (result.success)
         {
-            return WebSocketInitResult(false, 0, std::string("Failed sending GET request to ") + _url);
-
-        }
-
-        for (i = 0; i < 2 || (i < 255 && line[i-2] != '\r' && line[i-1] != '\n'); ++i)
-        {
-            if (_socket->recv(line+i, 1) == 0)
-            {
-                return WebSocketInitResult(false, 0, std::string("Failed reading HTTP status line from ") + _url);
-            } 
-        }
-        line[i] = 0;
-        if (i == 255)
-        {
-            return WebSocketInitResult(false, 0, std::string("Got bad status line connecting to ") + _url);
-        }
-
-        // HTTP/1.0 is too old.
-        if (sscanf(line, "HTTP/1.0 %d", &status) == 1)
-        {
-            std::stringstream ss;
-            ss << "Server version is HTTP/1.0. Rejecting connection to " << host
-               << ", status: " << status
-               << ", HTTP Status line: " << line;
-            return WebSocketInitResult(false, status, ss.str());
-        }
-
-        // We want an 101 HTTP status
-        if (sscanf(line, "HTTP/1.1 %d", &status) != 1 || status != 101)
-        {
-            std::stringstream ss;
-            ss << "Got bad status connecting to " << host
-               << ", status: " << status
-               << ", HTTP Status line: " << line;
-            return WebSocketInitResult(false, status, ss.str());
-        }
-
-        // TODO: verify response headers,
-        while (true) 
-        {
-            for (i = 0;
-                 i < 2 || (i < 255 && line[i-2] != '\r' && line[i-1] != '\n');
-                 ++i)
-            {
-                if (_socket->recv(line+i, 1) == 0)
-                {
-                    return WebSocketInitResult(false, status, std::string("Failed reading response header from ") + _url);
-                }
-            }
-            if (line[0] == '\r' && line[1] == '\n')
-            {
-                break;
-            }
-        }
-
-        _socket->configure();
             setReadyState(OPEN);
+        }
+        return result;
+    }
 
-        return WebSocketInitResult(true, status, "");
+    // Server
+    WebSocketInitResult WebSocketTransport::connectToSocket(int fd, int timeoutSecs)
+    {
+        _socket.reset();
+        _socket = std::make_shared<Socket>(fd);
+
+        WebSocketHandshake webSocketHandshake(_requestInitCancellation,
+                                              _socket,
+                                              _perMessageDeflate,
+                                              _perMessageDeflateOptions,
+                                              _enablePerMessageDeflate);
+
+        auto result = webSocketHandshake.serverHandshake(fd, timeoutSecs);
+        if (result.success)
+        {
+            setReadyState(OPEN);
+        }
+        return result;
     }
 
     WebSocketTransport::ReadyStateValues WebSocketTransport::getReadyState() const
@@ -249,44 +139,73 @@ namespace ix {
 
     void WebSocketTransport::setReadyState(ReadyStateValues readyStateValue)
     {
-        _readyState = readyStateValue;
-        _onStateChangeCallback(readyStateValue);
+        // No state change, return
+        if (_readyState == readyStateValue) return;
+
+        if (readyStateValue == CLOSED)
+        {
+            std::lock_guard<std::mutex> lock(_closeDataMutex);
+            _onCloseCallback(_closeCode, _closeReason, _closeWireSize);
+            _closeCode = 0;
+            _closeReason = std::string();
+            _closeWireSize = 0;
         }
 
-    void WebSocketTransport::setOnStateChangeCallback(const OnStateChangeCallback& onStateChangeCallback)
+        _readyState = readyStateValue;
+    }
+
+    void WebSocketTransport::setOnCloseCallback(const OnCloseCallback& onCloseCallback)
     {
-        _onStateChangeCallback = onStateChangeCallback; 
+        _onCloseCallback = onCloseCallback;
+    }
+
+    // Only consider send time points for that computation.
+    // The receive time points is taken into account in Socket::poll (second parameter).
+    bool WebSocketTransport::heartBeatPeriodExceeded()
+    {
+        std::lock_guard<std::mutex> lock(_lastSendTimePointMutex);
+        auto now = std::chrono::steady_clock::now();
+        return now - _lastSendTimePoint > std::chrono::seconds(_heartBeatPeriod);
     }
 
     void WebSocketTransport::poll()
     {
         _socket->poll(
-            [this]()
+            [this](PollResultType pollResult)
             {
+                // If (1) heartbeat is enabled, and (2) no data was received or
+                // send for a duration exceeding our heart-beat period, send a
+                // ping to the server.
+                if (pollResult == PollResultType_Timeout &&
+                    heartBeatPeriodExceeded())
+                {
+                    std::stringstream ss;
+                    ss << kHeartBeatPingMessage << "::" << _heartBeatPeriod << "s";
+                    sendPing(ss.str());
+                    return;
+                }
+
                 while (true)
                 {
-                    int N = (int) _rxbuf.size();
+                    ssize_t ret = _socket->recv((char*)&_readbuf[0], _readbuf.size());
 
-                    ssize_t ret;
-                    _rxbuf.resize(N + 1500);
-                    ret = _socket->recv((char*)&_rxbuf[0] + N, 1500);
-
-                    if (ret < 0 && (errno == EWOULDBLOCK || 
-                                    errno == EAGAIN)) {
-                        _rxbuf.resize(N);
+                    if (ret < 0 && (_socket->getErrno() == EWOULDBLOCK ||
+                                    _socket->getErrno() == EAGAIN))
+                    {
                         break;
                     }
                     else if (ret <= 0)
                     {
-                        _rxbuf.resize(N);
-
+                        _rxbuf.clear();
                         _socket->close();
                         setReadyState(CLOSED);
                         break;
                     }
                     else
                     {
-                        _rxbuf.resize(N + ret);
+                        _rxbuf.insert(_rxbuf.end(),
+                                      _readbuf.begin(),
+                                      _readbuf.begin() + ret);
                     }
                 }
 
@@ -295,7 +214,8 @@ namespace ix {
                     _socket->close();
                     setReadyState(CLOSED);
                 }
-            });
+            },
+            _heartBeatPeriod);
     }
 
     bool WebSocketTransport::isSendBufferEmpty() const
@@ -328,6 +248,17 @@ namespace ix {
         _txbuf.insert(_txbuf.end(), buffer.begin(), buffer.end());
     }
 
+    void WebSocketTransport::unmaskReceiveBuffer(const wsheader_type& ws)
+    {
+        if (ws.mask)
+        {
+            for (size_t j = 0; j != ws.N; ++j)
+            {
+                _rxbuf[j+ws.header_size] ^= ws.masking_key[j&0x3];
+            }
+        }
+    }
+
     //
     // http://tools.ietf.org/html/rfc6455#section-5.2  Base Framing Protocol
     //
@@ -352,12 +283,13 @@ namespace ix {
     //
     void WebSocketTransport::dispatch(const OnMessageCallback& onMessageCallback)
     {
-        // TODO: consider acquiring a lock on _rxbuf...
-        while (true) {
+        while (true)
+        {
             wsheader_type ws;
             if (_rxbuf.size() < 2) return; /* Need at least 2 */
             const uint8_t * data = (uint8_t *) &_rxbuf[0]; // peek, but don't consume
             ws.fin = (data[0] & 0x80) == 0x80;
+            ws.rsv1 = (data[0] & 0x40) == 0x40;
             ws.opcode = (wsheader_type::opcode_type) (data[0] & 0x0f);
             ws.mask = (data[1] & 0x80) == 0x80;
             ws.N0 = (data[1] & 0x7f);
@@ -428,51 +360,131 @@ namespace ix {
                 || ws.opcode == wsheader_type::BINARY_FRAME
                 || ws.opcode == wsheader_type::CONTINUATION
             ) {
-                if (ws.mask)
+                unmaskReceiveBuffer(ws);
+
+                //
+                // Usual case. Small unfragmented messages
+                //
+                if (ws.fin && _chunks.empty())
                 {
-                    for (size_t j = 0; j != ws.N; ++j)
+                    emitMessage(MSG,
+                                std::string(_rxbuf.begin()+ws.header_size,
+                                            _rxbuf.begin()+ws.header_size+(size_t) ws.N),
+                                ws,
+                                onMessageCallback);
+                }
+                else
                 {
-                        _rxbuf[j+ws.header_size] ^= ws.masking_key[j&0x3];
-                    }
-                }
-                _receivedData.insert(_receivedData.end(),
-                                     _rxbuf.begin()+ws.header_size,
-                                     _rxbuf.begin()+ws.header_size+(size_t)ws.N);// just feed
+                    //
+                    // Add intermediary message to our chunk list.
+                    // We use a chunk list instead of a big buffer because resizing
+                    // large buffer can be very costly when we need to re-allocate
+                    // the internal buffer which is slow and can let the internal OS
+                    // receive buffer fill out.
+                    //
+                    _chunks.emplace_back(
+                        std::vector<uint8_t>(_rxbuf.begin()+ws.header_size,
+                                             _rxbuf.begin()+ws.header_size+(size_t)ws.N));
                     if (ws.fin)
                     {
-                    // fire callback with a string message
-                    std::string stringMessage(_receivedData.begin(),
-                                              _receivedData.end());
-                    onMessageCallback(stringMessage);
-
-                    _receivedData.clear();
+                        emitMessage(MSG, getMergedChunks(), ws, onMessageCallback);
+                        _chunks.clear();
+                    }
                 }
             }
             else if (ws.opcode == wsheader_type::PING)
             {
-                if (ws.mask)
-                {
-                    for (size_t j = 0; j != ws.N; ++j)
-                    {
-                        _rxbuf[j+ws.header_size] ^= ws.masking_key[j&0x3];
-                    }
-                }
-
+                unmaskReceiveBuffer(ws);
                 std::string pingData(_rxbuf.begin()+ws.header_size,
                                      _rxbuf.begin()+ws.header_size + (size_t) ws.N);
 
-                sendData(wsheader_type::PONG, pingData.size(),
-                         pingData.begin(), pingData.end());
-            }
-            else if (ws.opcode == wsheader_type::PONG) { }
-            else if (ws.opcode == wsheader_type::CLOSE) { close(); }
-            else { close(); }
+                // Reply back right away
+                bool compress = false;
+                sendData(wsheader_type::PONG, pingData, compress);
 
+                emitMessage(PING, pingData, ws, onMessageCallback);
+            }
+            else if (ws.opcode == wsheader_type::PONG)
+            {
+                unmaskReceiveBuffer(ws);
+                std::string pongData(_rxbuf.begin()+ws.header_size,
+                                     _rxbuf.begin()+ws.header_size + (size_t) ws.N);
+
+                emitMessage(PONG, pongData, ws, onMessageCallback);
+            }
+            else if (ws.opcode == wsheader_type::CLOSE)
+            {
+                unmaskReceiveBuffer(ws);
+
+                // Extract the close code first, available as the first 2 bytes
+                uint16_t code = 0;
+                code |= ((uint64_t) _rxbuf[ws.header_size])   << 8;
+                code |= ((uint64_t) _rxbuf[ws.header_size+1]) << 0;
+
+                // Get the reason.
+                std::string reason(_rxbuf.begin()+ws.header_size + 2,
+                                   _rxbuf.begin()+ws.header_size + 2 + (size_t) ws.N);
+
+                {
+                    std::lock_guard<std::mutex> lock(_closeDataMutex);
+                    _closeCode = code;
+                    _closeReason = reason;
+                    _closeWireSize = _rxbuf.size();
+                }
+
+                close();
+            }
+            else
+            {
+                close();
+            }
+
+            // Erase the message that has been processed from the input/read buffer
             _rxbuf.erase(_rxbuf.begin(),
                          _rxbuf.begin() + ws.header_size + (size_t) ws.N);
         }
     }
 
+    std::string WebSocketTransport::getMergedChunks() const
+    {
+        size_t length = 0;
+        for (auto&& chunk : _chunks)
+        {
+            length += chunk.size();
+        }
+
+        std::string msg;
+        msg.reserve(length);
+
+        for (auto&& chunk : _chunks)
+        {
+            std::string str(chunk.begin(), chunk.end());
+            msg += str;
+        }
+
+        return msg;
+    }
+
+    void WebSocketTransport::emitMessage(MessageKind messageKind,
+                                         const std::string& message,
+                                         const wsheader_type& ws,
+                                         const OnMessageCallback& onMessageCallback)
+    {
+        size_t wireSize = message.size();
+
+        // When the RSV1 bit is 1 it means the message is compressed
+        if (_enablePerMessageDeflate && ws.rsv1)
+        {
+            std::string decompressedMessage;
+            bool success = _perMessageDeflate.decompress(message, decompressedMessage);
+            onMessageCallback(decompressedMessage, wireSize, !success, messageKind);
+        }
+        else
+        {
+            onMessageCallback(message, wireSize, false, messageKind);
+        }
+    }
+
     unsigned WebSocketTransport::getRandomUnsigned()
     {
         auto now = std::chrono::system_clock::now();
@@ -482,16 +494,103 @@ namespace ix {
         return static_cast<unsigned>(seconds);
     }
 
-    void WebSocketTransport::sendData(wsheader_type::opcode_type type, 
-                                      uint64_t message_size, 
-                                      std::string::const_iterator message_begin, 
-                                      std::string::const_iterator message_end) 
+    WebSocketSendInfo WebSocketTransport::sendData(
+        wsheader_type::opcode_type type,
+        const std::string& message,
+        bool compress,
+        const OnProgressCallback& onProgressCallback)
     {
         if (_readyState == CLOSING || _readyState == CLOSED)
         {
-            return;
+            return WebSocketSendInfo();
         }
 
+        size_t payloadSize = message.size();
+        size_t wireSize = message.size();
+        std::string compressedMessage;
+        bool compressionError = false;
+
+        std::string::const_iterator message_begin = message.begin();
+        std::string::const_iterator message_end = message.end();
+
+        if (compress)
+        {
+            if (!_perMessageDeflate.compress(message, compressedMessage))
+            {
+                bool success = false;
+                compressionError = true;
+                payloadSize = 0;
+                wireSize = 0;
+                return WebSocketSendInfo(success, compressionError, payloadSize, wireSize);
+            }
+            compressionError = false;
+            wireSize = compressedMessage.size();
+
+            message_begin = compressedMessage.begin();
+            message_end = compressedMessage.end();
+        }
+
+        // Common case for most message. No fragmentation required.
+        if (wireSize < kChunkSize)
+        {
+            sendFragment(type, true, message_begin, message_end, compress);
+        }
+        else
+        {
+            //
+            // Large messages need to be fragmented
+            //
+            // Rules:
+            // First message needs to specify a proper type (BINARY or TEXT)
+            // Intermediary and last messages need to be of type CONTINUATION
+            // Last message must set the fin byte.
+            //
+            auto steps = wireSize / kChunkSize;
+
+            std::string::const_iterator begin = message_begin;
+            std::string::const_iterator end = message_end;
+
+            for (uint64_t i = 0 ; i < steps; ++i)
+            {
+                bool firstStep = i == 0;
+                bool lastStep = (i+1) == steps;
+                bool fin = lastStep;
+
+                end = begin + kChunkSize;
+                if (lastStep)
+                {
+                    end = message_end;
+                }
+
+                auto opcodeType = type;
+                if (!firstStep)
+                {
+                    opcodeType = wsheader_type::CONTINUATION;
+                }
+
+                // Send message
+                sendFragment(opcodeType, fin, begin, end, compress);
+
+                if (onProgressCallback && !onProgressCallback(i, steps))
+                {
+                    break;
+                }
+
+                begin += kChunkSize;
+            }
+        }
+
+        return WebSocketSendInfo(true, compressionError, payloadSize, wireSize);
+    }
+
+    void WebSocketTransport::sendFragment(wsheader_type::opcode_type type,
+                                          bool fin,
+                                          std::string::const_iterator message_begin,
+                                          std::string::const_iterator message_end,
+                                          bool compress)
+    {
+        auto message_size = message_end - message_begin;
+
         unsigned x = getRandomUnsigned();
         uint8_t masking_key[4] = {};
         masking_key[0] = (x >> 24);
@@ -503,7 +602,20 @@ namespace ix {
         header.assign(2 +
                       (message_size >= 126 ? 2 : 0) +
                       (message_size >= 65536 ? 6 : 0) + 4, 0);
-        header[0] = 0x80 | type;
+        header[0] = type;
+
+        // The fin bit indicate that this is the last fragment. Fin is French for end.
+        if (fin)
+        {
+            header[0] |= 0x80;
+        }
+
+        // This bit indicate that the frame is compressed
+        if (compress)
+        {
+            header[0] |= 0x40;
+        }
+
         if (message_size < 126)
         {
             header[1] = (message_size & 0xff) | 0x80;
@@ -550,15 +662,19 @@ namespace ix {
         sendOnSocket();
     }
 
-    void WebSocketTransport::sendPing()
+    WebSocketSendInfo WebSocketTransport::sendPing(const std::string& message)
     {
-        std::string empty;
-        sendData(wsheader_type::PING, empty.size(), empty.begin(), empty.end());
+        bool compress = false;
+        return sendData(wsheader_type::PING, message, compress);
     }
 
-    void WebSocketTransport::sendBinary(const std::string& message) 
+    WebSocketSendInfo WebSocketTransport::sendBinary(
+        const std::string& message,
+        const OnProgressCallback& onProgressCallback)
+
     {
-        sendData(wsheader_type::BINARY_FRAME, message.size(), message.begin(), message.end());
+        return sendData(wsheader_type::BINARY_FRAME, message,
+                        _enablePerMessageDeflate, onProgressCallback);
     }
 
     void WebSocketTransport::sendOnSocket()
@@ -567,10 +683,10 @@ namespace ix {
 
         while (_txbuf.size())
         {
-            int ret = _socket->send((char*)&_txbuf[0], _txbuf.size());
+            ssize_t ret = _socket->send((char*)&_txbuf[0], _txbuf.size());
 
-            if (ret < 0 && (errno == EWOULDBLOCK || 
-                            errno == EAGAIN))
+            if (ret < 0 && (_socket->getErrno() == EWOULDBLOCK ||
+                            _socket->getErrno() == EAGAIN))
             {
                 break;
             }
@@ -586,20 +702,31 @@ namespace ix {
                 _txbuf.erase(_txbuf.begin(), _txbuf.begin() + ret);
             }
         }
+
+        std::lock_guard<std::mutex> lck(_lastSendTimePointMutex);
+        _lastSendTimePoint = std::chrono::steady_clock::now();
     }
 
     void WebSocketTransport::close()
     {
+        _requestInitCancellation = true;
+
         if (_readyState == CLOSING || _readyState == CLOSED) return;
 
+        // See list of close events here:
+        // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
+        // We use 1000: normal closure.
+        //
+        // >>> struct.pack('!H', 1000)
+        // b'\x03\xe8'
+        //
+        const std::string normalClosure = std::string("\x03\xe8");
+        bool compress = false;
+        sendData(wsheader_type::CLOSE, normalClosure, compress);
         setReadyState(CLOSING);
-        uint8_t closeFrame[6] = {0x88, 0x80, 0x00, 0x00, 0x00, 0x00}; // last 4 bytes are a masking key
-        std::vector<uint8_t> header(closeFrame, closeFrame+6);
-        appendToSendBuffer(header);
-
-        sendOnSocket();
 
         _socket->wakeUpFromPoll();
+        _socket->close();
     }
 
 } // namespace ix

ixwebsocket/IXWebSocketTransport.h

@@ -16,33 +16,20 @@
 #include <memory>
 #include <mutex>
 #include <atomic>
+#include <list>
+
+#include "IXWebSocketSendInfo.h"
+#include "IXWebSocketPerMessageDeflate.h"
+#include "IXWebSocketPerMessageDeflateOptions.h"
+#include "IXWebSocketHttpHeaders.h"
+#include "IXCancellationRequest.h"
+#include "IXWebSocketHandshake.h"
+#include "IXProgressCallback.h"
 
 namespace ix
 {
     class Socket;
 
-    struct WebSocketInitResult
-    {
-        bool success;
-        int http_status;
-        std::string errorStr;
-
-        WebSocketInitResult(bool s, int h, std::string e)
-        {
-            success = s;
-            http_status = h;
-            errorStr = e;
-        }
-
-        // need to define a default
-        WebSocketInitResult()
-        {
-            success = false;
-            http_status = 0;
-            errorStr = "";
-        }
-    };
-
     class WebSocketTransport
     {
     public:
@@ -54,41 +41,49 @@ namespace ix
             OPEN
         };
 
-        using OnMessageCallback = std::function<void(const std::string&)>;
-        using OnStateChangeCallback = std::function<void(ReadyStateValues)>;
+        enum MessageKind
+        {
+            MSG,
+            PING,
+            PONG
+        };
+
+        using OnMessageCallback = std::function<void(const std::string&,
+                                                     size_t,
+                                                     bool,
+                                                     MessageKind)>;
+        using OnCloseCallback = std::function<void(uint16_t,
+                                                   const std::string&,
+                                                   size_t)>;
 
         WebSocketTransport();
         ~WebSocketTransport();
 
-        void configure(const std::string& url);
-        WebSocketInitResult init();
+        void configure(const WebSocketPerMessageDeflateOptions& perMessageDeflateOptions,
+                       int hearBeatPeriod);
+
+        WebSocketInitResult connectToUrl(const std::string& url, // Client
+                                         int timeoutSecs);
+        WebSocketInitResult connectToSocket(int fd,              // Server
+                                            int timeoutSecs);
 
         void poll();
-        void send(const std::string& message);
-        void sendBinary(const std::string& message);
-        void sendBinary(const std::vector<uint8_t>& message);
-        void sendPing();
+        WebSocketSendInfo sendBinary(const std::string& message,
+                                     const OnProgressCallback& onProgressCallback);
+        WebSocketSendInfo sendPing(const std::string& message);
         void close();
         ReadyStateValues getReadyState() const;
         void setReadyState(ReadyStateValues readyStateValue);
-        void setOnStateChangeCallback(const OnStateChangeCallback& onStateChangeCallback);
+        void setOnCloseCallback(const OnCloseCallback& onCloseCallback);
         void dispatch(const OnMessageCallback& onMessageCallback);
 
-        static void printUrl(const std::string& url);
-        static bool parseUrl(const std::string& url,
-                             std::string& protocol,
-                             std::string& host,
-                             std::string& path,
-                             std::string& query,
-                             int& port);
-
     private:
         std::string _url;
-        std::string _origin;
 
         struct wsheader_type {
             unsigned header_size;
             bool fin;
+            bool rsv1;
             bool mask;
             enum opcode_type {
                 CONTINUATION = 0x0,
@@ -103,22 +98,73 @@ namespace ix
             uint8_t masking_key[4];
         };
 
+        // Buffer for reading from our socket. That buffer is never resized.
+        std::vector<uint8_t> _readbuf;
+
+        // Contains all messages that were fetched in the last socket read.
+        // This could be a mix of control messages (Close, Ping, etc...) and
+        // data messages. That buffer
         std::vector<uint8_t> _rxbuf;
+
+        // Contains all messages that are waiting to be sent
         std::vector<uint8_t> _txbuf;
         mutable std::mutex _txbufMutex;
-        std::vector<uint8_t> _receivedData;
 
+        // Hold fragments for multi-fragments messages in a list. We support receiving very large
+        // messages (tested messages up to 700M) and we cannot put them in a single
+        // buffer that is resized, as this operation can be slow when a buffer has its
+        // size increased 2 fold, while appending to a list has a fixed cost.
+        std::list<std::vector<uint8_t>> _chunks;
+
+        // Fragments are 32K long
+        static constexpr size_t kChunkSize = 1 << 15;
+
+        // Underlying TCP socket
         std::shared_ptr<Socket> _socket;
 
+        // Hold the state of the connection (OPEN, CLOSED, etc...)
         std::atomic<ReadyStateValues> _readyState;
 
-        OnStateChangeCallback _onStateChangeCallback;
+        OnCloseCallback _onCloseCallback;
+        uint16_t _closeCode;
+        std::string _closeReason;
+        size_t _closeWireSize;
+        mutable std::mutex _closeDataMutex;
+
+        // Data used for Per Message Deflate compression (with zlib)
+        WebSocketPerMessageDeflate _perMessageDeflate;
+        WebSocketPerMessageDeflateOptions _perMessageDeflateOptions;
+        std::atomic<bool> _enablePerMessageDeflate;
+
+        // Used to cancel dns lookup + socket connect + http upgrade
+        std::atomic<bool> _requestInitCancellation;
+
+        // Optional Heartbeat
+        int _heartBeatPeriod;
+        static const int kDefaultHeartBeatPeriod;
+        const static std::string kHeartBeatPingMessage;
+        mutable std::mutex _lastSendTimePointMutex;
+        std::chrono::time_point<std::chrono::steady_clock> _lastSendTimePoint;
+
+        // No data was send through the socket for longer that the hearbeat period
+        bool heartBeatPeriodExceeded();
 
         void sendOnSocket();
-        void sendData(wsheader_type::opcode_type type, 
-                      uint64_t message_size, 
-                      std::string::const_iterator message_begin, 
-                      std::string::const_iterator message_end);
+        WebSocketSendInfo sendData(wsheader_type::opcode_type type,
+                                   const std::string& message,
+                                   bool compress,
+                                   const OnProgressCallback& onProgressCallback = nullptr);
+
+        void sendFragment(wsheader_type::opcode_type type,
+                          bool fin,
+                          std::string::const_iterator begin,
+                          std::string::const_iterator end,
+                          bool compress);
+
+        void emitMessage(MessageKind messageKind,
+                         const std::string& message,
+                         const wsheader_type& ws,
+                         const OnMessageCallback& onMessageCallback);
 
         bool isSendBufferEmpty() const;
         void appendToSendBuffer(const std::vector<uint8_t>& header,
@@ -129,5 +175,8 @@ namespace ix
         void appendToSendBuffer(const std::vector<uint8_t>& buffer);
 
         unsigned getRandomUnsigned();
+        void unmaskReceiveBuffer(const wsheader_type& ws);
+
+        std::string getMergedChunks() const;
     };
 }

ixwebsocket/apple/IXSetThreadName_apple.cpp

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

ixwebsocket/libwshandshake.hpp

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

ixwebsocket/linux/IXSetThreadName_linux.cpp

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

ixwebsocket/windows/IXSetThreadName_windows.cpp

@@ -0,0 +1,16 @@
+/*
+ *  IXSetThreadName_windows.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+#include "../IXSetThreadName.h"
+#include <iostream>
+
+namespace ix
+{
+    void setThreadName(const std::string& name)
+    {
+        // FIXME
+        std::cerr << "setThreadName not implemented on Windows yet" << std::endl;
+    }
+}

makefile

@@ -0,0 +1,47 @@
+#
+# This makefile is just used to easily work with docker (linux build)
+#
+all: run
+
+brew:
+	mkdir -p ws/build && (cd ws/build ; cmake .. ; make)
+
+.PHONY: docker
+docker:
+	docker build -t broadcast_server:latest .
+
+run:
+	docker run --cap-add sys_ptrace -it broadcast_server:latest bash
+
+# this is helpful to remove trailing whitespaces
+trail:
+	sh third_party/remove_trailing_whitespaces.sh
+
+build:
+	(cd examples/satori_publisher ; mkdir -p build ; cd build ; cmake .. ; make)
+	(cd examples/chat ; mkdir -p build ; cd build ; cmake .. ; make)
+	(cd examples/ping_pong ; mkdir -p build ; cd build ; cmake .. ; make)
+	(cd examples/ws_connect ; mkdir -p build ; cd build ; cmake .. ; make)
+	(cd examples/echo_server ; mkdir -p build ; cd build ; cmake .. ; make)
+	(cd examples/broadcast_server ; mkdir -p build ; cd build ; cmake .. ; make)
+
+# That target is used to start a node server, but isn't required as we have 
+# a builtin C++ server started in the unittest now
+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
+test:
+	python test/run.py
+
+# For the fork that is configured with appveyor
+rebase_upstream:
+	git fetch upstream
+	git checkout master
+	git reset --hard upstream/master
+	git push origin master --force
+
+.PHONY: test
+.PHONY: build

test/.gitignore

@@ -0,0 +1,9 @@
+CMakeCache.txt
+package-lock.json
+CMakeFiles		
+ixwebsocket_unittest	
+cmake_install.cmake	
+node_modules
+ixwebsocket
+Makefile
+build

test/CMakeLists.txt

@@ -0,0 +1,52 @@
+#
+# Author: Benjamin Sergeant
+# Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+#
+cmake_minimum_required (VERSION 3.4.1)
+project (ixwebsocket_unittest)
+
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/../third_party/sanitizers-cmake/cmake" ${CMAKE_MODULE_PATH})
+find_package(Sanitizers)
+
+set (CMAKE_CXX_STANDARD 14)
+
+if (NOT WIN32)
+  option(USE_TLS "Add TLS support" ON)
+endif()
+
+add_subdirectory(${PROJECT_SOURCE_DIR}/.. ixwebsocket)
+
+include_directories(
+  ${PROJECT_SOURCE_DIR}/Catch2/single_include
+  ../third_party/msgpack11
+)
+
+# Shared sources
+set (SOURCES 
+  test_runner.cpp
+  IXTest.cpp
+  ../third_party/msgpack11/msgpack11.cpp
+
+  IXDNSLookupTest.cpp
+  IXSocketTest.cpp
+)
+
+# Some unittest don't work on windows yet
+if (NOT WIN32)
+  list(APPEND SOURCES 
+    IXWebSocketServerTest.cpp
+    IXWebSocketHeartBeatTest.cpp
+    cmd_websocket_chat.cpp
+    IXWebSocketTestConnectionDisconnection.cpp
+  )
+endif()
+
+add_executable(ixwebsocket_unittest ${SOURCES})
+add_sanitizers(ixwebsocket_unittest)
+
+if (APPLE AND USE_TLS)
+    target_link_libraries(ixwebsocket_unittest "-framework foundation" "-framework security")
+endif()
+
+target_link_libraries(ixwebsocket_unittest ixwebsocket)
+install(TARGETS ixwebsocket_unittest DESTINATION bin)