fix bug with isReadyToWrite

workaround bug in Socket::isReadyToWrite
use milliseconds
2019-03-18 22:05:04 -07:00 · 2019-03-18 20:37:33 -07:00 · 2019-03-18 20:17:44 -07:00 · 2019-03-18 17:54:06 -07:00 · 2019-03-18 17:52:01 -07:00 · 2019-03-18 15:45:33 -07:00
74 changed files with 1356 additions and 9084 deletions
--- a/.gitmodules
+++ b/.gitmodules
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -16,7 +16,6 @@ if (NOT WIN32)
 endif()

 set( IXWEBSOCKET_SOURCES
-    ixwebsocket/IXEventFd.cpp
    ixwebsocket/IXSocket.cpp
    ixwebsocket/IXSocketServer.cpp
    ixwebsocket/IXSocketConnect.cpp
@ -33,10 +32,12 @@ set( IXWEBSOCKET_SOURCES
    ixwebsocket/IXWebSocketHttpHeaders.cpp
    ixwebsocket/IXHttpClient.cpp
    ixwebsocket/IXUrlParser.cpp
+    ixwebsocket/IXSelectInterrupt.cpp
+    ixwebsocket/IXSelectInterruptPipe.cpp
+    ixwebsocket/IXSelectInterruptFactory.cpp
 )

 set( IXWEBSOCKET_HEADERS
-    ixwebsocket/IXEventFd.h
    ixwebsocket/IXSocket.h
    ixwebsocket/IXSocketServer.h
    ixwebsocket/IXSocketConnect.h
@ -58,6 +59,9 @@ set( IXWEBSOCKET_HEADERS
    ixwebsocket/libwshandshake.hpp
    ixwebsocket/IXHttpClient.h
    ixwebsocket/IXUrlParser.h
+    ixwebsocket/IXSelectInterrupt.h
+    ixwebsocket/IXSelectInterruptPipe.h
+    ixwebsocket/IXSelectInterruptFactory.h
 )

 # Platform specific code
@ -67,6 +71,8 @@ elseif (WIN32)
    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/windows/IXSetThreadName_windows.cpp)
 else()
    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/linux/IXSetThreadName_linux.cpp)
+    list( APPEND IXWEBSOCKET_SOURCES ixwebsocket/IXSelectInterruptEventFd.cpp)
+    list( APPEND IXWEBSOCKET_HEADERS ixwebsocket/IXSelectInterruptEventFd.h)
 endif()

 if (USE_TLS)
--- a/1
+++ b/1
@ -1 +0,0 @@
-docker/Dockerfile.debian
--- a/31
+++ b/31
@ -0,0 +1,31 @@
+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
+RUN apt-get -y install curl
+RUN apt-get -y install python
+RUN apt-get -y install netcat
+
+# debian strech cmake is too old for building with Docker
+COPY makefile .
+RUN ["make", "install_cmake_for_linux"]
+
+COPY . .
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-rc4-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+# RUN ["make"]
+
+EXPOSE 8765
+CMD ["/ws/ws", "transfer", "--port", "8765", "--host", "0.0.0.0"]
--- a/README.md
+++ b/README.md
@ -11,7 +11,6 @@ communication channels over a single TCP connection. *IXWebSocket* is a C++ libr
 * iOS
 * Linux
 * Android 
-* Windows (no TLS support yet)

 ## Examples

@ -77,7 +76,10 @@ server.setOnConnectionCallback(
                if (messageType == ix::WebSocket_MessageType_Open)
                {
                    std::cerr << "New connection" << std::endl;
+
+                    // The uri the client did connect to.
                    std::cerr << "Uri: " << openInfo.uri << std::endl;
+
                    std::cerr << "Headers:" << std::endl;
                    for (auto it : openInfo.headers)
                    {
@ -122,7 +124,7 @@ HttpRequestArgs args;
 // Custom headers can be set
 WebSocketHttpHeaders headers;
 headers["Foo"] = "bar";
-args.extraHeaders = parseHeaders(headersData);
+args.extraHeaders = headers;

 // Timeout options
 args.connectTimeout = connectTimeout;
@ -178,6 +180,13 @@ CMakefiles for the library and the examples are available. This library has few

 There is a Dockerfile for running some code on Linux, and a unittest which can be executed by typing `make test`.

+You can build and install the ws command line tool with Homebrew.
+
+```
+brew tap bsergean/IXWebSocket
+brew install IXWebSocket
+```
+
 ## Implementation details

 ### Per Message Deflate compression.
@ -370,7 +379,7 @@ websocket.ping("ping data, optional (empty string is ok): limited to 125 bytes l
 ### Heartbeat.

 You can configure an optional heart beat / keep-alive, sent every 45 seconds
-when there is not any traffic to make sure that load balancers do not kill an
+when there is no any traffic to make sure that load balancers do not kill an
 idle connection.

 ```
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@ -1,16 +0,0 @@
-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"]
--- a/docker/Dockerfile.alpine
+++ b/docker/Dockerfile.alpine
@ -1,11 +0,0 @@
-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"]
--- a/docker/Dockerfile.centos
+++ b/docker/Dockerfile.centos
@ -1,11 +0,0 @@
-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"]
--- a/docker/Dockerfile.debian
+++ b/docker/Dockerfile.debian
@ -1,22 +0,0 @@
-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"]
--- a/docker/Dockerfile.gcc
+++ b/docker/Dockerfile.gcc
@ -1,8 +0,0 @@
-FROM gcc:8
-
-# RUN yum install -y gcc-c++ make cmake openssl-devel gdb
-
-COPY . .
-
-WORKDIR examples/ws_connect
-RUN ["sh", "build_linux.sh"]
--- a/examples/cobra_publisher/ixcrypto/IXHash.cpp
+++ b/examples/cobra_publisher/ixcrypto/IXHash.cpp
@ -1,22 +0,0 @@
-/*
- *  IXHash.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone. All rights reserved.
- */
-
-#include <string>
-
-namespace ix
-{
-    uint64_t djb2Hash(const std::string& data)
-    {
-        uint64_t hashAddress = 5381;
-
-        for (auto& c : data)
-        {
-            hashAddress = ((hashAddress << 5) + hashAddress) + c;
-        }
-
-        return hashAddress;
-    }
-}
--- a/examples/cobra_publisher/ixcrypto/IXHash.h
+++ b/examples/cobra_publisher/ixcrypto/IXHash.h
@ -1,15 +0,0 @@
-/*
- *  IXHash.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone. All rights reserved.
- */
-
-#pragma once
-
-#include <string>
-
-namespace ix
-{
-    uint64_t djb2Hash(const std::string& data);
-}
-
--- a/examples/cobra_publisher/ixcrypto/IXUuid.cpp
+++ b/examples/cobra_publisher/ixcrypto/IXUuid.cpp
@ -1,75 +0,0 @@
-/*
- *  IXUuid.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone. All rights reserved.
- */
-
-/**
- * Generate a random uuid similar to the uuid python module
- *
- * >>> import uuid
- * >>> uuid.uuid4().hex
- * 'bec08155b37d4050a1f3c3fa0276bf12'
- *
- * Code adapted from https://github.com/r-lyeh-archived/sole
- */
-
-#include "IXUuid.h"
-
-#include <sstream>
-#include <string>
-#include <iomanip>
-#include <random>
-
-
-namespace ix
-{
-    class Uuid
-    {
-        public:
-            Uuid();
-            std::string toString() const;
-
-        private:
-            uint64_t _ab;
-            uint64_t _cd;
-    };
-
-    Uuid::Uuid()
-    {
-        static std::random_device rd;
-        static std::uniform_int_distribution<uint64_t> dist(0, (uint64_t)(~0));
-
-        _ab = dist(rd);
-        _cd = dist(rd);
-
-        _ab = (_ab & 0xFFFFFFFFFFFF0FFFULL) | 0x0000000000004000ULL;
-        _cd = (_cd & 0x3FFFFFFFFFFFFFFFULL) | 0x8000000000000000ULL;
-    }
-
-    std::string Uuid::toString() const
-    {
-        std::stringstream ss;
-        ss << std::hex << std::nouppercase << std::setfill('0');
-
-        uint32_t a = (_ab >> 32);
-        uint32_t b = (_ab & 0xFFFFFFFF);
-        uint32_t c = (_cd >> 32);
-        uint32_t d = (_cd & 0xFFFFFFFF);
-
-        ss << std::setw(8) << (a);
-        ss << std::setw(4) << (b >> 16);
-        ss << std::setw(4) << (b & 0xFFFF);
-        ss << std::setw(4) << (c >> 16 );
-        ss << std::setw(4) << (c & 0xFFFF);
-        ss << std::setw(8) << d;
-
-        return ss.str();
-    }
-
-    std::string uuid4()
-    {
-        Uuid id;
-        return id.toString();
-    }
-}
--- a/examples/cobra_publisher/ixcrypto/IXUuid.h
+++ b/examples/cobra_publisher/ixcrypto/IXUuid.h
@ -1,17 +0,0 @@
-/*
- *  IXUuid.h
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2017 Machine Zone. All rights reserved.
- */
-#pragma once
-
-#include <string>
-
-namespace ix
-{
-   /**
-    * Generate a random uuid
-    */
-   std::string uuid4();
-
-}
--- a/examples/ws_receive/.gitignore
+++ b/examples/ws_receive/.gitignore
@ -1 +0,0 @@
-build
--- a/examples/ws_receive/CMakeLists.txt
+++ b/examples/ws_receive/CMakeLists.txt
@ -1,30 +0,0 @@
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (ws_receive)
-
-# There's -Weverything too for clang
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wshorten-64-to-32")
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
-
-include_directories(ws_receive .)
-
-add_executable(ws_receive 
-  jsoncpp/jsoncpp.cpp
-  ixcrypto/IXBase64.cpp
-  ixcrypto/IXHash.cpp
-  ws_receive.cpp)
-
-if (APPLE AND USE_TLS)
-    target_link_libraries(ws_receive "-framework foundation" "-framework security")
-endif()
-
-target_link_libraries(ws_receive ixwebsocket)
--- a/examples/ws_receive/README.md
+++ b/examples/ws_receive/README.md
@ -1 +0,0 @@
-ws_receive is a simple server upload program. It needs to be used in conjonction with ws_send.
--- a/examples/ws_receive/ixcrypto
+++ b/examples/ws_receive/ixcrypto
@ -1 +0,0 @@
-../cobra_publisher/ixcrypto
--- a/examples/ws_receive/jsoncpp/json/json-forwards.h
+++ b/examples/ws_receive/jsoncpp/json/json-forwards.h
@ -1,333 +0,0 @@
-/// 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
--- a/examples/ws_receive/jsoncpp/json/json.h
+++ b/examples/ws_receive/jsoncpp/json/json.h
--- a/examples/ws_receive/jsoncpp/jsoncpp.cpp
+++ b/examples/ws_receive/jsoncpp/jsoncpp.cpp
--- a/examples/ws_receive/package-lock.json
+++ b/examples/ws_receive/package-lock.json
@ -1,29 +0,0 @@
-{
-  "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=="
-    },
-    "base-64": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/base-64/-/base-64-0.1.0.tgz",
-      "integrity": "sha1-eAqZyE59YAJgNhURxId2E78k9rs="
-    },
-    "djb2": {
-      "version": "0.0.2",
-      "resolved": "https://registry.npmjs.org/djb2/-/djb2-0.0.2.tgz",
-      "integrity": "sha1-RAs4kao6uBQrVNRpsXe66p6W5O8="
-    },
-    "ws": {
-      "version": "6.1.4",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-6.1.4.tgz",
-      "integrity": "sha512-eqZfL+NE/YQc1/ZynhojeV8q+H050oR8AZ2uIev7RU10svA9ZnJUddHcOUZTJLinZ9yEfdA2kSATS2qZK5fhJA==",
-      "requires": {
-        "async-limiter": "1.0.0"
-      }
-    }
-  }
-}
--- a/examples/ws_receive/ws_receive.cpp
+++ b/examples/ws_receive/ws_receive.cpp
@ -1,153 +0,0 @@
-/*
- *  ws_receive.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
- */
-
-#include <iostream>
-#include <sstream>
-#include <fstream>
-#include <ixwebsocket/IXWebSocketServer.h>
-#include <jsoncpp/json/json.h>
-#include <ixcrypto/IXBase64.h>
-#include <ixcrypto/IXHash.h>
-
-
-namespace
-{
-    // We should cleanup the file name and full path further to remove .. as well
-    std::string extractFilename(const std::string& path)
-    {
-        std::string filename("filename.conf");
-        std::string::size_type idx;
-
-        idx = path.rfind('/');
-        if (idx != std::string::npos)
-        {
-            std::string filename = path.substr(idx+1);
-            return filename;
-        }
-        else
-        {
-            return std::string();
-        }
-    }
-}
-
-namespace ix
-{
-    void errorHandler(const std::string& errMsg,
-                      const std::string& id,
-                      std::shared_ptr<ix::WebSocket> webSocket)
-    {
-        Json::Value pdu;
-        pdu["kind"] = "error";
-        pdu["id"] = id;
-        pdu["message"] = errMsg;
-        webSocket->send(pdu.toStyledString());
-    }
-
-    void messageHandler(const std::string& str,
-                        std::shared_ptr<ix::WebSocket> webSocket)
-    {
-        std::cerr << "Received message: " << str.size() << std::endl;
-
-        Json::Value data;
-        Json::Reader reader;
-        if (!reader.parse(str, data))
-        {
-            errorHandler("Invalid JSON", std::string(), webSocket);
-            return;
-        }
-
-        std::cout << "id: " << data["id"].asString() << std::endl;
-
-        std::string content = ix::base64_decode(data["content"].asString());
-        std::cout << "Content size: " << content.size() << std::endl;
-
-        // Validate checksum
-        uint64_t cksum = ix::djb2Hash(data["content"].asString());
-        uint64_t cksumRef = data["djb2_hash"].asUInt64();
-
-        std::cout << "Computed hash: " << cksum << std::endl;
-        std::cout << "Reference hash: " << cksumRef << std::endl;
-
-        if (cksum != cksumRef)
-        {
-            errorHandler("Hash mismatch.", std::string(), webSocket);
-            return;
-        }
-
-        std::string filename = data["filename"].asString();
-        filename = extractFilename(filename);
-
-        std::ofstream out(filename);
-        out << content;
-        out.close();
-
-        Json::Value pdu;
-        pdu["ack"] = true;
-        pdu["id"] = data["id"];
-        pdu["filename"] = data["filename"];
-        webSocket->send(pdu.toStyledString());
-    }
-}
-
-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)
-                    {
-                        messageHandler(str, webSocket);
-                    }
-                }
-            );
-        }
-    );
-
-    auto res = server.listen();
-    if (!res.first)
-    {
-        std::cerr << res.second << std::endl;
-        return 1;
-    }
-
-    server.start();
-    server.wait();
-
-    return 0;
-}
--- a/examples/ws_receive/ws_receive.js
+++ b/examples/ws_receive/ws_receive.js
@ -1,43 +0,0 @@
-/*
- *  ws_receive.js
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
- */
-const WebSocket = require('ws')
-const djb2 = require('djb2')
-const fs = require('fs')
-
-const wss = new WebSocket.Server({ port: 8080,
-                                   perMessageDeflate: false,
-                                   maxPayload: 1024 * 1024 * 1024 * 1024});
-
-wss.on('connection', function connection(ws) {
-  ws.on('message', function incoming(data) {
-    console.log('Received message')
-
-    let str = data.toString()
-    let obj = JSON.parse(str)
-
-    console.log(obj.id)
-    console.log(obj.djb2_hash)
-    console.log(djb2(obj.content))
-
-    var content = Buffer.from(obj.content, 'base64')
-    // let bytes = base64.decode(obj.content)
-
-    let path = obj.filename
-    fs.writeFile(path, content, function(err) {
-      if (err) {
-        throw err
-      } else {
-        console.log('wrote data to disk')
-      }
-    });
-
-    let response = {
-      id: obj.id
-    }
-
-    ws.send(JSON.stringify(response))
-  });
-});
--- a/examples/ws_send/.gitignore
+++ b/examples/ws_send/.gitignore
@ -1 +0,0 @@
-build
--- a/examples/ws_send/CMakeLists.txt
+++ b/examples/ws_send/CMakeLists.txt
@ -1,31 +0,0 @@
-#
-# Author: Benjamin Sergeant
-# Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
-#
-
-cmake_minimum_required (VERSION 3.4.1)
-project (ws_send)
-
-# There's -Weverything too for clang
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wshorten-64-to-32")
-
-set (CMAKE_CXX_STANDARD 14)
-
-option(USE_TLS "Add TLS support" ON)
-
-add_subdirectory(${PROJECT_SOURCE_DIR}/../.. ixwebsocket)
-
-include_directories(ws_send .)
-
-add_executable(ws_send 
-  jsoncpp/jsoncpp.cpp
-  ixcrypto/IXBase64.cpp
-  ixcrypto/IXUuid.cpp
-  ixcrypto/IXHash.cpp
-  ws_send.cpp)
-
-if (APPLE AND USE_TLS)
-    target_link_libraries(ws_send "-framework foundation" "-framework security")
-endif()
-
-target_link_libraries(ws_send ixwebsocket)
--- a/examples/ws_send/README.md
+++ b/examples/ws_send/README.md
@ -1 +0,0 @@
-ws_send is a simple upload program. It needs to be used in conjonction with ws_receive.
--- a/examples/ws_send/ixcrypto
+++ b/examples/ws_send/ixcrypto
@ -1 +0,0 @@
-../cobra_publisher/ixcrypto
--- a/examples/ws_send/jsoncpp
+++ b/examples/ws_send/jsoncpp
@ -1 +0,0 @@
-../cobra_publisher/jsoncpp
--- a/examples/ws_send/ws_send.cpp
+++ b/examples/ws_send/ws_send.cpp
@ -1,306 +0,0 @@
-/*
- *  ws_send.cpp
- *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
- */
-
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <vector>
-#include <condition_variable>
-#include <mutex>
-#include <chrono>
-#include <ixwebsocket/IXWebSocket.h>
-#include <ixwebsocket/IXSocket.h>
-#include <ixcrypto/IXUuid.h>
-#include <ixcrypto/IXBase64.h>
-#include <ixcrypto/IXHash.h>
-#include <jsoncpp/json/json.h>
-
-using namespace ix;
-
-namespace
-{
-    void log(const std::string& msg)
-    {
-        std::cout << msg << std::endl;
-    }
-
-    class WebSocketSender
-    {
-        public:
-            WebSocketSender(const std::string& _url,
-                            bool enablePerMessageDeflate);
-
-            void subscribe(const std::string& channel);
-            void start();
-            void stop();
-
-            void waitForConnection();
-            void waitForAck();
-
-            void sendMessage(const std::string& filename, bool throttle);
-
-        private:
-            std::string _url;
-            std::string _id;
-            ix::WebSocket _webSocket;
-            bool _enablePerMessageDeflate;
-
-            std::mutex _conditionVariableMutex;
-            std::condition_variable _condition;
-    };
-
-    WebSocketSender::WebSocketSender(const std::string& url,
-                                     bool enablePerMessageDeflate) :
-        _url(url),
-        _enablePerMessageDeflate(enablePerMessageDeflate)
-    {
-        ;
-    }
-
-    void WebSocketSender::stop()
-    {
-        _webSocket.stop();
-    }
-
-    void WebSocketSender::waitForConnection()
-    {
-        std::cout << "Connecting..." << std::endl;
-
-        std::unique_lock<std::mutex> lock(_conditionVariableMutex);
-        _condition.wait(lock);
-    }
-
-    void WebSocketSender::waitForAck()
-    {
-        std::cout << "Waiting for ack..." << std::endl;
-
-        std::unique_lock<std::mutex> lock(_conditionVariableMutex);
-        _condition.wait(lock);
-    }
-
-    std::string load(const std::string& path)
-    {
-        // std::vector<uint8_t> memblock;
-        std::string str;
-
-        std::ifstream file(path);
-        if (!file.is_open()) return std::string();
-
-        file.seekg(0, file.end);
-        std::streamoff size = file.tellg();
-        file.seekg(0, file.beg);
-
-        str.resize(size);
-        file.read((char*)&str.front(), static_cast<std::streamsize>(size));
-
-        return str;
-    }
-
-    void WebSocketSender::start()
-    {
-        _webSocket.setUrl(_url);
-
-        ix::WebSocketPerMessageDeflateOptions webSocketPerMessageDeflateOptions(
-            _enablePerMessageDeflate, 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)
-                {
-                    _condition.notify_one();
-
-                    log("ws_send: 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_send: connection closed:";
-                    ss << " code " << closeInfo.code;
-                    ss << " reason " << closeInfo.reason << std::endl;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Message)
-                {
-                    _condition.notify_one();
-
-                    ss << "ws_send: received message: "
-                       << str;
-                    log(ss.str());
-
-                    Json::Value data;
-                    Json::Reader reader;
-                    if (!reader.parse(str, data))
-                    {
-                        std::cerr << "Invalid JSON response" << std::endl;
-                        return;
-                    }
-
-                    std::string id = data["id"].asString();
-                    if (_id != id)
-                    {
-                        std::cerr << "Invalid id" << std::endl;
-                    }
-                }
-                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();
-    }
-
-    class Bench
-    {
-        public:
-            Bench(const std::string& description) :
-                _description(description),
-                _start(std::chrono::system_clock::now()),
-                _reported(false)
-            {
-                ;
-            }
-
-            ~Bench()
-            {
-                if (!_reported)
-                {
-                    report();
-                }
-            }
-
-            void report()
-            {
-                auto now = std::chrono::system_clock::now();
-                auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(now - _start);
-
-                _ms = milliseconds.count();
-                std::cout << _description << " completed in "
-                          << _ms << "ms" << std::endl;
-
-                _reported = true;
-            }
-
-            uint64_t getDuration() const
-            {
-                return _ms;
-            }
-
-        private:
-            std::string _description;
-            std::chrono::time_point<std::chrono::system_clock> _start;
-            uint64_t _ms;
-            bool _reported;
-    };
-
-    void WebSocketSender::sendMessage(const std::string& filename,
-                                      bool throttle)
-    {
-        std::string content;
-        {
-            Bench bench("load file from disk");
-            content = load(filename);
-        }
-
-        _id = uuid4();
-
-        std::string b64Content;
-        {
-            Bench bench("base 64 encode file");
-            b64Content = base64_encode(content, content.size());
-        }
-
-        Json::Value pdu;
-        pdu["kind"] = "send";
-        pdu["id"] = _id;
-        pdu["content"] = b64Content;
-        pdu["djb2_hash"] = djb2Hash(b64Content);
-        pdu["filename"] = filename;
-
-        Bench bench("Sending file through websocket");
-        _webSocket.send(pdu.toStyledString(),
-                        [throttle](int current, int total) -> bool
-        {
-            std::cout << "Step " << current << " out of " << total << std::endl;
-
-            if (throttle)
-            {
-                std::chrono::duration<double, std::milli> duration(10);
-                std::this_thread::sleep_for(duration);
-            }
-
-            return true;
-        });
-
-        bench.report();
-        auto duration = bench.getDuration();
-        auto transferRate = 1000 * b64Content.size() / duration;
-        transferRate /= (1024 * 1024);
-        std::cout << "Send transfer rate: " << transferRate << "MB/s" << std::endl;
-    }
-
-    void wsSend(const std::string& url,
-                const std::string& path,
-                bool enablePerMessageDeflate,
-                bool throttle)
-    {
-        WebSocketSender webSocketSender(url, enablePerMessageDeflate);
-        webSocketSender.start();
-
-        webSocketSender.waitForConnection();
-
-        std::cout << "Sending..." << std::endl;
-        webSocketSender.sendMessage(path, throttle);
-
-        webSocketSender.waitForAck();
-
-        std::cout << "Done !" << std::endl;
-        webSocketSender.stop();
-    }
-}
-
-int main(int argc, char** argv)
-{
-    if (argc != 3)
-    {
-        std::cerr << "Usage: ws_send <url> <path>" << std::endl;
-        return 1;
-    }
-    std::string url = argv[1];
-    std::string path = argv[2];
-
-    bool throttle = false;
-    bool enablePerMessageDeflate = false;
-
-    Socket::init();
-    wsSend(url, path, enablePerMessageDeflate, throttle);
-    return 0;
-}
--- a/ixwebsocket/IXEventFd.cpp
+++ b/ixwebsocket/IXEventFd.cpp
@ -1,82 +0,0 @@
-/*
- *  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;
-    }
-}
--- a/ixwebsocket/IXEventFd.h
+++ b/ixwebsocket/IXEventFd.h
@ -1,23 +0,0 @@
-/*
- *  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;
-    };
-}
--- a/ixwebsocket/IXHttpClient.cpp
+++ b/ixwebsocket/IXHttpClient.cpp
@ -231,19 +231,17 @@ namespace ix

            payload.reserve(contentLength);

-            // FIXME: very inefficient way to read bytes, but it works...
-            for (int i = 0; i < contentLength; ++i)
+            auto chunkResult = _socket->readBytes(contentLength,
+                                                  args.onProgressCallback,
+                                                  isCancellationRequested);
+            if (!chunkResult.first)
            {
-                char c;
-                if (!_socket->readByte(&c, isCancellationRequested))
-                {
-                    return std::make_tuple(code, HttpErrorCode_ReadError,
-                                           headers, payload, "Cannot read byte",
-                                           uploadSize, downloadSize);
-                }
-
-                payload += c;
+                errorMsg = "Cannot read chunk";
+                return std::make_tuple(code, HttpErrorCode_ChunkReadError,
+                                       headers, payload, errorMsg,
+                                       uploadSize, downloadSize);
            }
+            payload += chunkResult.second;
        }
        else if (headers.find("Transfer-Encoding") != headers.end() &&
                 headers["Transfer-Encoding"] == "chunked")
@ -277,22 +275,20 @@ namespace ix

                payload.reserve(payload.size() + chunkSize);

-                // Read another line
-
-                for (uint64_t i = 0; i < chunkSize; ++i)
+                // Read a chunk
+                auto chunkResult = _socket->readBytes(chunkSize,
+                                                      args.onProgressCallback,
+                                                      isCancellationRequested);
+                if (!chunkResult.first)
                {
-                    char c;
-                    if (!_socket->readByte(&c, isCancellationRequested))
-                    {
-                        errorMsg = "Cannot read byte";
-                        return std::make_tuple(code, HttpErrorCode_ChunkReadError,
-                                               headers, payload, errorMsg,
-                                               uploadSize, downloadSize);
-                    }
-
-                    payload += c;
+                    errorMsg = "Cannot read chunk";
+                    return std::make_tuple(code, HttpErrorCode_ChunkReadError,
+                                           headers, payload, errorMsg,
+                                           uploadSize, downloadSize);
                }
+                payload += chunkResult.second;

+                // Read the line that terminates the chunk (\r\n)
                lineResult = _socket->readLine(isCancellationRequested);

                if (!lineResult.first)
--- a/ixwebsocket/IXHttpClient.h
+++ b/ixwebsocket/IXHttpClient.h
@ -61,6 +61,7 @@ namespace ix
        bool verbose;
        bool compress;
        Logger logger;
+        OnProgressCallback onProgressCallback;
    };

    class HttpClient {
--- a/ixwebsocket/IXSelectInterrupt.cpp
+++ b/ixwebsocket/IXSelectInterrupt.cpp
@ -0,0 +1,46 @@
+/*
+ *  IXSelectInterrupt.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXSelectInterrupt.h"
+
+namespace ix
+{
+    SelectInterrupt::SelectInterrupt()
+    {
+        ;
+    }
+
+    SelectInterrupt::~SelectInterrupt()
+    {
+        ;
+    }
+
+    bool SelectInterrupt::init(std::string& /*errorMsg*/)
+    {
+        return true;
+    }
+
+    bool SelectInterrupt::notify(uint64_t /*value*/)
+    {
+        return true;
+    }
+
+    uint64_t SelectInterrupt::read()
+    {
+        return 0;
+    }
+
+    bool SelectInterrupt::clear()
+    {
+        return true;
+    }
+
+    int SelectInterrupt::getFd() const
+    {
+        return -1;
+    }
+}
+
--- a/ixwebsocket/IXSelectInterrupt.h
+++ b/ixwebsocket/IXSelectInterrupt.h
@ -0,0 +1,28 @@
+/*
+ *  IXSelectInterrupt.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <string>
+
+namespace ix
+{
+    class SelectInterrupt {
+    public:
+        SelectInterrupt();
+        virtual ~SelectInterrupt();
+
+        virtual bool init(std::string& errorMsg);
+
+        virtual bool notify(uint64_t value);
+        virtual bool clear();
+        virtual uint64_t read();
+        virtual int getFd() const;
+    };
+}
+
+
--- a/ixwebsocket/IXSelectInterruptEventFd.cpp
+++ b/ixwebsocket/IXSelectInterruptEventFd.cpp
@ -0,0 +1,116 @@
+/*
+ *  IXSelectInterruptEventFd.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+//
+// On Linux we use eventd to wake up select.
+//
+
+//
+// Linux/Android has a special type of virtual files. select(2) will react
+// when reading/writing to those files, unlike closing sockets.
+//
+// https://linux.die.net/man/2/eventfd
+// http://www.sourcexr.com/articles/2013/10/26/lightweight-inter-process-signaling-with-eventfd
+//
+// eventfd was added in Linux kernel 2.x, and our oldest Android (Kitkat 4.4)
+// is on Kernel 3.x
+//
+// cf Android/Kernel table here
+// https://android.stackexchange.com/questions/51651/which-android-runs-which-linux-kernel
+//
+// On macOS we use UNIX pipes to wake up select.
+//
+
+#include "IXSelectInterruptEventFd.h"
+
+#include <sys/eventfd.h>
+
+#include <unistd.h> // for write
+#include <string.h> // for strerror
+#include <fcntl.h>
+#include <errno.h>
+#include <assert.h>
+#include <sstream>
+
+namespace ix
+{
+    SelectInterruptEventFd::SelectInterruptEventFd()
+    {
+        _eventfd = -1;
+    }
+
+    SelectInterruptEventFd::~SelectInterruptEventFd()
+    {
+        ::close(_eventfd);
+    }
+
+    bool SelectInterruptEventFd::init(std::string& errorMsg)
+    {
+        // calling init twice is a programming error
+        assert(_eventfd == -1);
+
+        _eventfd = eventfd(0, 0);
+        if (_eventfd < 0)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptEventFd::init() failed in eventfd()"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+
+            _eventfd = -1;
+            return false;
+        }
+
+        if (fcntl(_eventfd, F_SETFL, O_NONBLOCK) == -1)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptEventFd::init() failed in fcntl() call"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+
+            _eventfd = -1;
+            return false;
+        }
+
+        return true;
+    }
+
+    bool SelectInterruptEventFd::notify(uint64_t value)
+    {
+        int fd = _eventfd;
+
+        if (fd == -1) return false;
+
+        // we should write 8 bytes for an uint64_t
+        return write(fd, &value, sizeof(value)) == 8;
+    }
+
+    // TODO: return max uint64_t for errors ?
+    uint64_t SelectInterruptEventFd::read()
+    {
+        int fd = _eventfd;
+
+        uint64_t value = 0;
+        ::read(fd, &value, sizeof(value));
+        return value;
+    }
+
+    bool SelectInterruptEventFd::clear()
+    {
+        if (_eventfd == -1) return false;
+
+        // 0 is a special value ; select will not wake up
+        uint64_t value = 0;
+
+        // we should write 8 bytes for an uint64_t
+        return write(_eventfd, &value, sizeof(value)) == 8;
+    }
+
+    int SelectInterruptEventFd::getFd() const
+    {
+        return _eventfd;
+    }
+}
--- a/ixwebsocket/IXSelectInterruptEventFd.h
+++ b/ixwebsocket/IXSelectInterruptEventFd.h
@ -0,0 +1,32 @@
+/*
+ *  IXSelectInterruptEventFd.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include "IXSelectInterrupt.h"
+
+#include <stdint.h>
+#include <string>
+
+namespace ix
+{
+    class SelectInterruptEventFd : public SelectInterrupt {
+    public:
+        SelectInterruptEventFd();
+        virtual ~SelectInterruptEventFd();
+
+        bool init(std::string& errorMsg) final;
+
+        bool notify(uint64_t value) final;
+        bool clear() final;
+        uint64_t read() final;
+        int getFd() const final;
+
+    private:
+        int _eventfd;
+    };
+}
+
--- a/ixwebsocket/IXSelectInterruptFactory.cpp
+++ b/ixwebsocket/IXSelectInterruptFactory.cpp
@ -0,0 +1,25 @@
+/*
+ *  IXSelectInterruptFactory.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXSelectInterruptFactory.h"
+
+#if defined(__linux__) || defined(__APPLE__)
+# include <ixwebsocket/IXSelectInterruptPipe.h>
+#else
+# include <ixwebsocket/IXSelectInterrupt.h>
+#endif
+
+namespace ix
+{
+    std::shared_ptr<SelectInterrupt> createSelectInterrupt()
+    {
+#if defined(__linux__) || defined(__APPLE__)
+        return std::make_shared<SelectInterruptPipe>();
+#else
+        return std::make_shared<SelectInterrupt>();
+#endif
+    }
+}
--- a/ixwebsocket/IXSelectInterruptFactory.h
+++ b/ixwebsocket/IXSelectInterruptFactory.h
@ -0,0 +1,15 @@
+/*
+ *  IXSelectInterruptFactory.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include <memory>
+
+namespace ix
+{
+    class SelectInterrupt;
+    std::shared_ptr<SelectInterrupt> createSelectInterrupt();
+}
--- a/ixwebsocket/IXSelectInterruptPipe.cpp
+++ b/ixwebsocket/IXSelectInterruptPipe.cpp
@ -0,0 +1,138 @@
+/*
+ *  IXSelectInterruptPipe.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+//
+// On macOS we use UNIX pipes to wake up select.
+//
+
+#include "IXSelectInterruptPipe.h"
+
+#include <unistd.h> // for write
+#include <string.h> // for strerror
+#include <fcntl.h>
+#include <errno.h>
+#include <assert.h>
+#include <sstream>
+
+namespace ix
+{
+    // File descriptor at index 0 in _fildes is the read end of the pipe
+    // File descriptor at index 1 in _fildes is the write end of the pipe
+    const int SelectInterruptPipe::kPipeReadIndex = 0;
+    const int SelectInterruptPipe::kPipeWriteIndex = 1;
+
+    SelectInterruptPipe::SelectInterruptPipe()
+    {
+        _fildes[kPipeReadIndex] = -1;
+        _fildes[kPipeWriteIndex] = -1;
+    }
+
+    SelectInterruptPipe::~SelectInterruptPipe()
+    {
+        ::close(_fildes[kPipeReadIndex]);
+        ::close(_fildes[kPipeWriteIndex]);
+        _fildes[kPipeReadIndex] = -1;
+        _fildes[kPipeWriteIndex] = -1;
+    }
+
+    bool SelectInterruptPipe::init(std::string& errorMsg)
+    {
+        // calling init twice is a programming error
+        assert(_fildes[kPipeReadIndex] == -1);
+        assert(_fildes[kPipeWriteIndex] == -1);
+
+        if (pipe(_fildes) < 0)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptPipe::init() failed in pipe() call"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+            return false;
+        }
+
+        if (fcntl(_fildes[kPipeReadIndex], F_SETFL, O_NONBLOCK) == -1)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptPipe::init() failed in fcntl(..., O_NONBLOCK) call"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+
+            _fildes[kPipeReadIndex] = -1;
+            _fildes[kPipeWriteIndex] = -1;
+            return false;
+        }
+
+        if (fcntl(_fildes[kPipeWriteIndex], F_SETFL, O_NONBLOCK) == -1)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptPipe::init() failed in fcntl(..., O_NONBLOCK) call"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+
+            _fildes[kPipeReadIndex] = -1;
+            _fildes[kPipeWriteIndex] = -1;
+            return false;
+        }
+
+#ifdef F_SETNOSIGPIPE
+        if (fcntl(_fildes[kPipeWriteIndex], F_SETNOSIGPIPE, 1) == -1)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptPipe::init() failed in fcntl(.... F_SETNOSIGPIPE) call"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+
+            _fildes[kPipeReadIndex] = -1;
+            _fildes[kPipeWriteIndex] = -1;
+            return false;
+        }
+
+        if (fcntl(_fildes[kPipeWriteIndex], F_SETNOSIGPIPE, 1) == -1)
+        {
+            std::stringstream ss;
+            ss << "SelectInterruptPipe::init() failed in fcntl(..., F_SETNOSIGPIPE) call"
+               << " : " << strerror(errno);
+            errorMsg = ss.str();
+
+            _fildes[kPipeReadIndex] = -1;
+            _fildes[kPipeWriteIndex] = -1;
+            return false;
+        }
+#endif
+
+        return true;
+    }
+
+    bool SelectInterruptPipe::notify(uint64_t value)
+    {
+        int fd = _fildes[kPipeWriteIndex];
+        if (fd == -1) return false;
+
+        // we should write 8 bytes for an uint64_t
+        return write(fd, &value, sizeof(value)) == 8;
+    }
+
+    // TODO: return max uint64_t for errors ?
+    uint64_t SelectInterruptPipe::read()
+    {
+        int fd = _fildes[kPipeReadIndex];
+
+        uint64_t value = 0;
+        ::read(fd, &value, sizeof(value));
+
+        return value;
+    }
+
+    bool SelectInterruptPipe::clear()
+    {
+        return true;
+    }
+
+    int SelectInterruptPipe::getFd() const
+    {
+        return _fildes[kPipeReadIndex];
+    }
+}
--- a/ixwebsocket/IXSelectInterruptPipe.h
+++ b/ixwebsocket/IXSelectInterruptPipe.h
@ -0,0 +1,39 @@
+/*
+ *  IXSelectInterruptPipe.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
+ */
+
+#pragma once
+
+#include "IXSelectInterrupt.h"
+
+#include <stdint.h>
+#include <string>
+
+namespace ix
+{
+    class SelectInterruptPipe : public SelectInterrupt {
+    public:
+        SelectInterruptPipe();
+        virtual ~SelectInterruptPipe();
+
+        bool init(std::string& errorMsg) final;
+
+        bool notify(uint64_t value) final;
+        bool clear() final;
+        uint64_t read() final;
+        int getFd() const final;
+
+    private:
+        // Store file descriptors used by the communication pipe. Communication
+        // happens between a control thread and a background thread, which is
+        // blocked on select.
+        int _fildes[2];
+
+        // Used to identify the read/write idx
+        static const int kPipeReadIndex;
+        static const int kPipeWriteIndex;
+    };
+}
+
--- a/ixwebsocket/IXSocket.cpp
+++ b/ixwebsocket/IXSocket.cpp
@ -7,6 +7,8 @@
 #include "IXSocket.h"
 #include "IXSocketConnect.h"
 #include "IXNetSystem.h"
+#include "IXSelectInterrupt.h"
+#include "IXSelectInterruptFactory.h"

 #include <stdio.h>
 #include <stdlib.h>
@ -23,11 +25,15 @@ namespace ix
 {
    const int Socket::kDefaultPollNoTimeout = -1; // No poll timeout by default
    const int Socket::kDefaultPollTimeout = kDefaultPollNoTimeout;
+    const uint64_t Socket::kSendRequest = 1;
+    const uint64_t Socket::kCloseRequest = 2;
+    constexpr size_t Socket::kChunkSize;

    Socket::Socket(int fd) :
-        _sockfd(fd)
+        _sockfd(fd),
+        _selectInterrupt(createSelectInterrupt())
    {
-
+        ;
    }

    Socket::~Socket()
@ -39,26 +45,42 @@ namespace ix
    {
        if (_sockfd == -1)
        {
-            onPollCallback(PollResultType_Error);
+            if (onPollCallback) onPollCallback(PollResultType_Error);
            return;
        }

-        fd_set rfds;
-        FD_ZERO(&rfds);
-        FD_SET(_sockfd, &rfds);
+        PollResultType pollResult = isReadyToRead(1000 * timeoutSecs);

-#ifdef __linux__
-        FD_SET(_eventfd.getFd(), &rfds);
-#endif
+        if (onPollCallback) onPollCallback(pollResult);
+    }
+
+    PollResultType Socket::select(bool readyToRead, int timeoutMs)
+    {
+        fd_set rfds;
+        fd_set wfds;
+        FD_ZERO(&rfds);
+        FD_ZERO(&wfds);
+
+        fd_set* fds = (readyToRead) ? &rfds : & wfds;
+        FD_SET(_sockfd, fds);
+
+        // File descriptor used to interrupt select when needed
+        int interruptFd = _selectInterrupt->getFd();
+        if (interruptFd != -1)
+        {
+            FD_SET(interruptFd, fds);
+        }

        struct timeval timeout;
-        timeout.tv_sec = timeoutSecs;
-        timeout.tv_usec = 0;
+        timeout.tv_sec = timeoutMs / 1000;
+        timeout.tv_usec = (timeoutMs < 1000) ? 0 : 1000 * (timeoutMs % 1000);

+        // Compute the highest fd.
        int sockfd = _sockfd;
-        int nfds = (std::max)(sockfd, _eventfd.getFd());
-        int ret = select(nfds + 1, &rfds, nullptr, nullptr,
-                         (timeoutSecs < 0) ? nullptr : &timeout);
+        int nfds = (std::max)(sockfd, interruptFd);
+
+        int ret = ::select(nfds + 1, &rfds, &wfds, nullptr,
+                           (timeoutMs < 0) ? nullptr : &timeout);

        PollResultType pollResult = PollResultType_ReadyForRead;
        if (ret < 0)
@ -69,14 +91,47 @@ namespace ix
        {
            pollResult = PollResultType_Timeout;
        }
+        else if (interruptFd != -1 && FD_ISSET(interruptFd, &rfds))
+        {
+            uint64_t value = _selectInterrupt->read();

-        onPollCallback(pollResult);
+            if (value == kSendRequest)
+            {
+                pollResult = PollResultType_SendRequest;
+            }
+            else if (value == kCloseRequest)
+            {
+                pollResult = PollResultType_CloseRequest;
+            }
+        }
+        else if (sockfd != -1 && readyToRead && FD_ISSET(sockfd, &rfds))
+        {
+            pollResult = PollResultType_ReadyForRead;
+        }
+        else if (sockfd != -1 && !readyToRead && FD_ISSET(sockfd, &wfds))
+        {
+            pollResult = PollResultType_ReadyForWrite;
+        }
+
+        return pollResult;
    }

-    void Socket::wakeUpFromPoll()
+    PollResultType Socket::isReadyToRead(int timeoutMs)
    {
-        // this will wake up the thread blocked on select, only needed on Linux
-        _eventfd.notify();
+        bool readyToRead = true;
+        return select(readyToRead, timeoutMs);
+    }
+
+    PollResultType Socket::isReadyToWrite(int timeoutMs)
+    {
+        bool readyToRead = false;
+        return select(readyToRead, timeoutMs);
+    }
+
+    // Wake up from poll/select by writing to the pipe which is watched by select
+    bool Socket::wakeUpFromPoll(uint8_t wakeUpCode)
+    {
+        return _selectInterrupt->notify(wakeUpCode);
    }

    bool Socket::connect(const std::string& host,
@ -86,7 +141,7 @@ namespace ix
    {
        std::lock_guard<std::mutex> lock(_socketMutex);

-        if (!_eventfd.clear()) return false;
+        if (!_selectInterrupt->clear()) return false;

        _sockfd = SocketConnect::connect(host, port, errMsg, isCancellationRequested);
        return _sockfd != -1;
@ -145,69 +200,9 @@ namespace ix
 #endif
    }

-    bool Socket::init()
+    bool Socket::init(std::string& errorMsg)
    {
-#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;
-            }
-        }
+        return _selectInterrupt->init(errorMsg);
    }

    bool Socket::writeBytes(const std::string& str,
@ -241,7 +236,42 @@ namespace ix
        }
    }

-    std::pair<bool, std::string> Socket::readLine(const CancellationRequest& isCancellationRequested)
+    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 1ms timeout until the socket is ready to read.
+                // This way we are not busy looping
+                if (isReadyToRead(1) == PollResultType_Error)
+                {
+                    return false;
+                }
+            }
+            // There was an error during the read, abort
+            else
+            {
+                return false;
+            }
+        }
+    }
+
+    std::pair<bool, std::string> Socket::readLine(
+        const CancellationRequest& isCancellationRequested)
    {
        char c;
        std::string line;
@ -251,7 +281,8 @@ namespace ix
        {
            if (!readByte(&c, isCancellationRequested))
            {
-                return std::make_pair(false, std::string());
+                // Return what we were able to read
+                return std::make_pair(false, line);
            }

            line += c;
@ -259,4 +290,49 @@ namespace ix

        return std::make_pair(true, line);
    }
+
+    std::pair<bool, std::string> Socket::readBytes(
+        size_t length,
+        const OnProgressCallback& onProgressCallback,
+        const CancellationRequest& isCancellationRequested)
+    {
+        if (_readBuffer.empty())
+        {
+            _readBuffer.resize(kChunkSize);
+        }
+
+        std::vector<uint8_t> output;
+        while (output.size() != length)
+        {
+            if (isCancellationRequested()) return std::make_pair(false, std::string());
+
+            int size = std::min(kChunkSize, length - output.size());
+            ssize_t ret = recv((char*)&_readBuffer[0], size);
+
+            if (ret <= 0 && (getErrno() != EWOULDBLOCK &&
+                             getErrno() != EAGAIN))
+            {
+                // Error
+                return std::make_pair(false, std::string());
+            }
+            else if (ret > 0)
+            {
+                output.insert(output.end(),
+                              _readBuffer.begin(),
+                              _readBuffer.begin() + ret);
+            }
+
+            if (onProgressCallback) onProgressCallback((int) output.size(), (int) length);
+
+            // Wait with a 1ms timeout until the socket is ready to read.
+            // This way we are not busy looping
+            if (isReadyToRead(1) == PollResultType_Error)
+            {
+                return std::make_pair(false, std::string());
+            }
+        }
+
+        return std::make_pair(true, std::string(output.begin(),
+                                                output.end()));
+    }
 }
--- a/ixwebsocket/IXSocket.h
+++ b/ixwebsocket/IXSocket.h
@ -10,22 +10,29 @@
 #include <functional>
 #include <mutex>
 #include <atomic>
+#include <vector>
+#include <memory>

 #ifdef _WIN32
 #include <BaseTsd.h>
 typedef SSIZE_T ssize_t;
 #endif

-#include "IXEventFd.h"
 #include "IXCancellationRequest.h"
+#include "IXProgressCallback.h"

 namespace ix
 {
+    class SelectInterrupt;
+
    enum PollResultType
    {
        PollResultType_ReadyForRead = 0,
-        PollResultType_Timeout = 1,
-        PollResultType_Error = 2
+        PollResultType_ReadyForWrite = 1,
+        PollResultType_Timeout = 2,
+        PollResultType_Error = 3,
+        PollResultType_SendRequest = 4,
+        PollResultType_CloseRequest = 5
    };

    class Socket {
@ -34,12 +41,17 @@ namespace ix

        Socket(int fd = -1);
        virtual ~Socket();
+        bool init(std::string& errorMsg);

        void configure();

-        virtual void poll(const OnPollCallback& onPollCallback,
-                          int timeoutSecs = kDefaultPollTimeout);
-        virtual void wakeUpFromPoll();
+        // Functions to check whether there is activity on the socket
+        void poll(const OnPollCallback& onPollCallback,
+                  int timeoutSecs = kDefaultPollTimeout);
+        bool wakeUpFromPoll(uint8_t wakeUpCode);
+
+        PollResultType isReadyToWrite(int timeoutMs);
+        PollResultType isReadyToRead(int timeoutMs);

        // Virtual methods
        virtual bool connect(const std::string& url,
@ -58,21 +70,36 @@ namespace ix
                      const CancellationRequest& isCancellationRequested);
        bool writeBytes(const std::string& str,
                        const CancellationRequest& isCancellationRequested);
-        std::pair<bool, std::string> readLine(const CancellationRequest& isCancellationRequested);
+
+        std::pair<bool, std::string> readLine(
+            const CancellationRequest& isCancellationRequested);
+        std::pair<bool, std::string> readBytes(
+            size_t length,
+            const OnProgressCallback& onProgressCallback,
+            const CancellationRequest& isCancellationRequested);

        static int getErrno();
-        static bool init(); // Required on Windows to initialize WinSocket
-        static void cleanup(); // Required on Windows to cleanup WinSocket
+
+        // Used as special codes for pipe communication
+        static const uint64_t kSendRequest;
+        static const uint64_t kCloseRequest;

    protected:
        void closeSocket(int fd);

        std::atomic<int> _sockfd;
        std::mutex _socketMutex;
-        EventFd _eventfd;

    private:
+        PollResultType select(bool readyToRead, int timeoutMs);
+
        static const int kDefaultPollTimeout;
        static const int kDefaultPollNoTimeout;
+
+        // Buffer for reading from our socket. That buffer is never resized.
+        std::vector<uint8_t> _readBuffer;
+        static constexpr size_t kChunkSize = 1 << 15;
+
+        std::shared_ptr<SelectInterrupt> _selectInterrupt;
    };
 }
--- a/ixwebsocket/IXSocketFactory.cpp
+++ b/ixwebsocket/IXSocketFactory.cpp
@ -20,23 +20,45 @@ namespace ix
                                         std::string& errorMsg)
    {
        errorMsg.clear();
+        std::shared_ptr<Socket> socket;

        if (!tls)
        {
-            return std::make_shared<Socket>();
+            socket = std::make_shared<Socket>();
        }
        else
        {
 #ifdef IXWEBSOCKET_USE_TLS
 # ifdef __APPLE__
-            return std::make_shared<SocketAppleSSL>();
+            socket = std::make_shared<SocketAppleSSL>();
 # else
-            return std::make_shared<SocketOpenSSL>();
+            socket = std::make_shared<SocketOpenSSL>();
 # endif
 #else
            errorMsg = "TLS support is not enabled on this platform.";
            return nullptr;
 #endif
        }
+
+        if (!socket->init(errorMsg))
+        {
+            socket.reset();
+        }
+
+        return socket;
+    }
+
+    std::shared_ptr<Socket> createSocket(int fd,
+                                         std::string& errorMsg)
+    {
+        errorMsg.clear();
+
+        std::shared_ptr<Socket> socket = std::make_shared<Socket>(fd);
+        if (!socket->init(errorMsg))
+        {
+            socket.reset();
+        }
+
+        return socket;
    }
 }
--- a/ixwebsocket/IXSocketFactory.h
+++ b/ixwebsocket/IXSocketFactory.h
@ -14,4 +14,7 @@ namespace ix
    class Socket;
    std::shared_ptr<Socket> createSocket(bool tls,
                                         std::string& errorMsg);
+
+    std::shared_ptr<Socket> createSocket(int fd,
+                                         std::string& errorMsg);
 }
--- a/ixwebsocket/IXWebSocket.cpp
+++ b/ixwebsocket/IXWebSocket.cpp
@ -252,6 +252,11 @@ namespace ix
                        {
                            webSocketMessageType = WebSocket_MessageType_Pong;
                        } break;
+
+                        case WebSocketTransport::FRAGMENT:
+                        {
+                            webSocketMessageType = WebSocket_MessageType_Fragment;
+                        } break;
                    }

                    WebSocketErrorInfo webSocketErrorInfo;
@ -374,4 +379,9 @@ namespace ix
    {
        _automaticReconnection = false;
    }
+
+    size_t WebSocket::bufferedAmount() const
+    {
+        return _ws.bufferedAmount();
+    }
 }
--- a/ixwebsocket/IXWebSocket.h
+++ b/ixwebsocket/IXWebSocket.h
@ -39,7 +39,8 @@ namespace ix
        WebSocket_MessageType_Close = 2,
        WebSocket_MessageType_Error = 3,
        WebSocket_MessageType_Ping = 4,
-        WebSocket_MessageType_Pong = 5
+        WebSocket_MessageType_Pong = 5,
+        WebSocket_MessageType_Fragment = 6
    };

    struct WebSocketOpenInfo
@ -111,6 +112,7 @@ namespace ix
        const std::string& getUrl() const;
        const WebSocketPerMessageDeflateOptions& getPerMessageDeflateOptions() const;
        int getHeartBeatPeriod() const;
+        size_t bufferedAmount() const;

        void enableAutomaticReconnection();
        void disableAutomaticReconnection();
--- a/ixwebsocket/IXWebSocketTransport.cpp
+++ b/ixwebsocket/IXWebSocketTransport.cpp
@ -1,7 +1,31 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2012, 2013 <dhbaird@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
 /*
 *  IXWebSocketTransport.cpp
 *  Author: Benjamin Sergeant
- *  Copyright (c) 2017-2018 Machine Zone, Inc. All rights reserved.
+ *  Copyright (c) 2017-2019 Machine Zone, Inc. All rights reserved.
 */

 //
@ -14,14 +38,6 @@
 #include "IXUrlParser.h"
 #include "IXSocketFactory.h"

-#ifdef IXWEBSOCKET_USE_TLS
-# ifdef __APPLE__
-#  include "IXSocketAppleSSL.h"
-# else
-#  include "IXSocketOpenSSL.h"
-# endif
-#endif
-
 #include <string.h>
 #include <stdlib.h>

@ -80,16 +96,6 @@ namespace ix
                                       std::string("Could not parse URL ") + url);
        }

-        if (protocol != "ws" && protocol != "wss")
-        {
-            std::stringstream ss;
-            ss << "Invalid protocol: " << protocol
-               << " for url " << url
-               << " . Supported protocols are ws and wss";
-
-            return WebSocketInitResult(false, 0, ss.str());
-        }
-
        bool tls = protocol == "wss";
        std::string errorMsg;
        _socket = createSocket(tls, errorMsg);
@ -117,8 +123,13 @@ namespace ix
    // Server
    WebSocketInitResult WebSocketTransport::connectToSocket(int fd, int timeoutSecs)
    {
-        _socket.reset();
-        _socket = std::make_shared<Socket>(fd);
+        std::string errorMsg;
+        _socket = createSocket(fd, errorMsg);
+
+        if (!_socket)
+        {
+            return WebSocketInitResult(false, 0, errorMsg);
+        }

        WebSocketHandshake webSocketHandshake(_requestInitCancellation,
                                              _socket,
@ -184,37 +195,69 @@ namespace ix
                    std::stringstream ss;
                    ss << kHeartBeatPingMessage << "::" << _heartBeatPeriod << "s";
                    sendPing(ss.str());
-                    return;
                }
-
-                while (true)
+                // Make sure we send all the buffered data
+                // there can be a lot of it for large messages.
+                else if (pollResult == PollResultType_SendRequest)
                {
-                    ssize_t ret = _socket->recv((char*)&_readbuf[0], _readbuf.size());
+                    while (!isSendBufferEmpty() && !_requestInitCancellation)
+                    {
+                        // Wait with a 10ms timeout until the socket is ready to write.
+                        // This way we are not busy looping
+                        PollResultType result = _socket->isReadyToWrite(10);

-                    if (ret < 0 && (_socket->getErrno() == EWOULDBLOCK ||
-                                    _socket->getErrno() == EAGAIN))
-                    {
-                        break;
-                    }
-                    else if (ret <= 0)
-                    {
-                        _rxbuf.clear();
-                        _socket->close();
-                        setReadyState(CLOSED);
-                        break;
-                    }
-                    else
-                    {
-                        _rxbuf.insert(_rxbuf.end(),
-                                      _readbuf.begin(),
-                                      _readbuf.begin() + ret);
+                        if (result == PollResultType_Error)
+                        {
+                            _socket->close();
+                            setReadyState(CLOSED);
+                            break;
+                        }
+                        else if (result == PollResultType_ReadyForWrite)
+                        {
+                            sendOnSocket();
+                        }
                    }
                }
+                else if (pollResult == PollResultType_ReadyForRead)
+                {
+                    while (true)
+                    {
+                        ssize_t ret = _socket->recv((char*)&_readbuf[0], _readbuf.size());

-                if (isSendBufferEmpty() && _readyState == CLOSING)
+                        if (ret < 0 && (_socket->getErrno() == EWOULDBLOCK ||
+                                        _socket->getErrno() == EAGAIN))
+                        {
+                            break;
+                        }
+                        else if (ret <= 0)
+                        {
+                            _rxbuf.clear();
+                            _socket->close();
+                            setReadyState(CLOSED);
+                            break;
+                        }
+                        else
+                        {
+                            _rxbuf.insert(_rxbuf.end(),
+                                          _readbuf.begin(),
+                                          _readbuf.begin() + ret);
+                        }
+                    }
+                }
+                else if (pollResult == PollResultType_Error)
+                {
+                    _socket->close();
+                }
+                else if (pollResult == PollResultType_CloseRequest)
+                {
+                    _socket->close();
+                }
+
+                // Avoid a race condition where we get stuck in select
+                // while closing.
+                if (_readyState == CLOSING)
                {
                    _socket->close();
-                    setReadyState(CLOSED);
                }
            },
            _heartBeatPeriod);
@ -392,6 +435,10 @@ namespace ix
                        emitMessage(MSG, getMergedChunks(), ws, onMessageCallback);
                        _chunks.clear();
                    }
+                    else
+                    {
+                        emitMessage(FRAGMENT, std::string(), ws, onMessageCallback);
+                    }
                }
            }
            else if (ws.opcode == wsheader_type::PING)
@ -475,7 +522,7 @@ namespace ix
        size_t wireSize = message.size();

        // When the RSV1 bit is 1 it means the message is compressed
-        if (_enablePerMessageDeflate && ws.rsv1)
+        if (_enablePerMessageDeflate && ws.rsv1 && messageKind != FRAGMENT)
        {
            std::string decompressedMessage;
            bool success = _perMessageDeflate.decompress(message, decompressedMessage);
@ -573,7 +620,7 @@ namespace ix
                // Send message
                sendFragment(opcodeType, fin, begin, end, compress);

-                if (onProgressCallback && !onProgressCallback(i, steps))
+                if (onProgressCallback && !onProgressCallback((int)i, (int) steps))
                {
                    break;
                }
@ -582,6 +629,12 @@ namespace ix
            }
        }

+        // Request to flush the send buffer on the background thread if it isn't empty
+        if (!isSendBufferEmpty())
+        {
+            _socket->wakeUpFromPoll(Socket::kSendRequest);
+        }
+
        return WebSocketSendInfo(true, compressionError, payloadSize, wireSize);
    }

@ -727,8 +780,18 @@ namespace ix
        sendData(wsheader_type::CLOSE, normalClosure, compress);
        setReadyState(CLOSING);

-        _socket->wakeUpFromPoll();
+        _socket->wakeUpFromPoll(Socket::kCloseRequest);
        _socket->close();
+
+        _closeCode = 1000;
+        _closeReason = "Normal Closure";
+        setReadyState(CLOSED);
+    }
+
+    size_t WebSocketTransport::bufferedAmount() const
+    {
+        std::lock_guard<std::mutex> lock(_txbufMutex);
+        return _txbuf.size();
    }

 } // namespace ix
--- a/ixwebsocket/IXWebSocketTransport.h
+++ b/ixwebsocket/IXWebSocketTransport.h
@ -45,7 +45,8 @@ namespace ix
        {
            MSG,
            PING,
-            PONG
+            PONG,
+            FRAGMENT
        };

        using OnMessageCallback = std::function<void(const std::string&,
@ -76,6 +77,7 @@ namespace ix
        void setReadyState(ReadyStateValues readyStateValue);
        void setOnCloseCallback(const OnCloseCallback& onCloseCallback);
        void dispatch(const OnMessageCallback& onMessageCallback);
+        size_t bufferedAmount() const;

    private:
        std::string _url;
--- a/13
+++ b/13
@ -3,15 +3,17 @@
 #
 all: brew

+install: brew
+
 brew:
 	mkdir -p build && (cd build ; cmake .. ; make -j install)

 .PHONY: docker
 docker:
-	docker build -t broadcast_server:latest .
+	docker build -t ws:latest .

 run:
-	docker run --cap-add sys_ptrace -it broadcast_server:latest bash
+	docker run --cap-add sys_ptrace -it ws:latest

 # this is helpful to remove trailing whitespaces
 trail:
@ -36,6 +38,9 @@ test_server:
 test:
 	python test/run.py

+ws_test: all
+	(cd ws ; sh test_ws.sh)
+
 # For the fork that is configured with appveyor
 rebase_upstream:
 	git fetch upstream
@ -43,5 +48,9 @@ rebase_upstream:
 	git reset --hard upstream/master
 	git push origin master --force

+install_cmake_for_linux:
+	mkdir -p /tmp/cmake
+	(cd /tmp/cmake ; curl -L -O https://github.com/Kitware/CMake/releases/download/v3.14.0-rc4/cmake-3.14.0-rc4-Linux-x86_64.tar.gz ; tar zxf cmake-3.14.0-rc4-Linux-x86_64.tar.gz)
+
 .PHONY: test
 .PHONY: build
--- a/test/IXSocketTest.cpp
+++ b/test/IXSocketTest.cpp
@ -5,19 +5,13 @@
 */

 #include <iostream>
+#include <ixwebsocket/IXSocketFactory.h>
 #include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXCancellationRequest.h>

-#if defined(__APPLE__) or defined(__linux__)
-# ifdef __APPLE__
-#  include <ixwebsocket/IXSocketAppleSSL.h>
-# else
-#  include <ixwebsocket/IXSocketOpenSSL.h>
-# endif
-#endif
-
 #include "IXTest.h"
 #include "catch.hpp"
+#include <string.h>

 using namespace ix;

@ -39,16 +33,15 @@ namespace ix
        Logger() << "errMsg: " << errMsg;
        REQUIRE(success);

-        std::cout << "Sending request: " << request
-                  << "to " << host << ":" << port
-                  << std::endl;
+        Logger() << "Sending request: " << request
+                 << "to " << host << ":" << port;
        REQUIRE(socket->writeBytes(request, isCancellationRequested));

        auto lineResult = socket->readLine(isCancellationRequested);
        auto lineValid = lineResult.first;
        auto line = lineResult.second;

-        std::cout << "read error: " << strerror(Socket::getErrno()) << std::endl;
+        Logger() << "read error: " << strerror(Socket::getErrno());

        REQUIRE(lineValid);

@ -62,10 +55,18 @@ TEST_CASE("socket", "[socket]")
 {
    SECTION("Connect to google HTTP server. Send GET request without header. Should return 200")
    {
-        std::shared_ptr<Socket> socket(new Socket);
+        std::string errMsg;
+        bool tls = false;
+        std::shared_ptr<Socket> socket = createSocket(tls, errMsg);
        std::string host("www.google.com");
        int port = 80;
-        std::string request("GET / HTTP/1.1\r\n\r\n");
+
+        std::stringstream ss;
+        ss << "GET / HTTP/1.1\r\n";
+        ss << "Host: " << host << "\r\n";
+        ss << "\r\n";
+        std::string request(ss.str());
+
        int expectedStatus = 200;
        int timeoutSecs = 3;

@ -75,11 +76,9 @@ TEST_CASE("socket", "[socket]")
 #if defined(__APPLE__) or defined(__linux__)
    SECTION("Connect to google HTTPS server. Send GET request without header. Should return 200")
    {
-# ifdef __APPLE__
-        std::shared_ptr<Socket> socket = std::make_shared<SocketAppleSSL>();
-# else
-        std::shared_ptr<Socket> socket = std::make_shared<SocketOpenSSL>();
-# endif
+        std::string errMsg;
+        bool tls = true;
+        std::shared_ptr<Socket> socket = createSocket(tls, errMsg);
        std::string host("www.google.com");
        int port = 443;
        std::string request("GET / HTTP/1.1\r\n\r\n");
--- a/test/IXTest.cpp
+++ b/test/IXTest.cpp
@ -69,10 +69,15 @@ namespace ix
        Logger() << msg;
    }

+    int getAnyFreePortSimple()
+    {
+        static int defaultPort = 8090;
+        return defaultPort++;
+    }
+
    int getAnyFreePort()
    {
        int defaultPort = 8090;
-
        int sockfd;
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
        {
@ -122,8 +127,15 @@ namespace ix
    {
        while (true)
        {
+#if defined(__has_feature)
+# if __has_feature(address_sanitizer)
+            int port = getAnyFreePortSimple();
+# else
            int port = getAnyFreePort();
-
+# endif
+#else
+            int port = getAnyFreePort();
+#endif
            //
            // Only port above 1024 can be used by non root users, but for some
            // reason I got port 7 returned with macOS when binding on port 0...
--- a/test/IXWebSocketServerTest.cpp
+++ b/test/IXWebSocketServerTest.cpp
@ -8,6 +8,7 @@
 #include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <ixwebsocket/IXWebSocketServer.h>
+#include <ixwebsocket/IXSocketFactory.h>

 #include "IXTest.h"

@ -79,17 +80,18 @@ TEST_CASE("Websocket_server", "[websocket_server]")
        ix::WebSocketServer server(port);
        REQUIRE(startServer(server));

-        Socket socket;
-        std::string host("localhost");
        std::string errMsg;
+        bool tls = false;
+        std::shared_ptr<Socket> socket = createSocket(tls, errMsg);
+        std::string host("localhost");
        auto isCancellationRequested = []() -> bool
        {
            return false;
        };
-        bool success = socket.connect(host, port, errMsg, isCancellationRequested);
+        bool success = socket->connect(host, port, errMsg, isCancellationRequested);
        REQUIRE(success);

-        auto lineResult = socket.readLine(isCancellationRequested);
+        auto lineResult = socket->readLine(isCancellationRequested);
        auto lineValid = lineResult.first;
        auto line = lineResult.second;

@ -111,20 +113,21 @@ TEST_CASE("Websocket_server", "[websocket_server]")
        ix::WebSocketServer server(port);
        REQUIRE(startServer(server));

-        Socket socket;
-        std::string host("localhost");
        std::string errMsg;
+        bool tls = false;
+        std::shared_ptr<Socket> socket = createSocket(tls, errMsg);
+        std::string host("localhost");
        auto isCancellationRequested = []() -> bool
        {
            return false;
        };
-        bool success = socket.connect(host, port, errMsg, isCancellationRequested);
+        bool success = socket->connect(host, port, errMsg, isCancellationRequested);
        REQUIRE(success);

        Logger() << "writeBytes";
-        socket.writeBytes("GET /\r\n", isCancellationRequested);
+        socket->writeBytes("GET /\r\n", isCancellationRequested);

-        auto lineResult = socket.readLine(isCancellationRequested);
+        auto lineResult = socket->readLine(isCancellationRequested);
        auto lineValid = lineResult.first;
        auto line = lineResult.second;

@ -146,24 +149,25 @@ TEST_CASE("Websocket_server", "[websocket_server]")
        ix::WebSocketServer server(port);
        REQUIRE(startServer(server));

-        Socket socket;
-        std::string host("localhost");
        std::string errMsg;
+        bool tls = false;
+        std::shared_ptr<Socket> socket = createSocket(tls, errMsg);
+        std::string host("localhost");
        auto isCancellationRequested = []() -> bool
        {
            return false;
        };
-        bool success = socket.connect(host, port, errMsg, isCancellationRequested);
+        bool success = socket->connect(host, port, errMsg, isCancellationRequested);
        REQUIRE(success);

-        socket.writeBytes("GET / HTTP/1.1\r\n"
-                          "Upgrade: websocket\r\n"
-                          "Sec-WebSocket-Version: 13\r\n"
-                          "Sec-WebSocket-Key: foobar\r\n"
-                          "\r\n",
-                          isCancellationRequested);
+        socket->writeBytes("GET / HTTP/1.1\r\n"
+                           "Upgrade: websocket\r\n"
+                           "Sec-WebSocket-Version: 13\r\n"
+                           "Sec-WebSocket-Key: foobar\r\n"
+                           "\r\n",
+                           isCancellationRequested);

-        auto lineResult = socket.readLine(isCancellationRequested);
+        auto lineResult = socket->readLine(isCancellationRequested);
        auto lineValid = lineResult.first;
        auto line = lineResult.second;

--- a/test/cmd_websocket_chat.cpp
+++ b/test/cmd_websocket_chat.cpp
@ -164,10 +164,21 @@ namespace
                    ss << "cmd_websocket_chat: Error ! " << error.reason;
                    log(ss.str());
                }
+                else if (messageType == ix::WebSocket_MessageType_Ping)
+                {
+                    log("cmd_websocket_chat: received ping message");
+                }
+                else if (messageType == ix::WebSocket_MessageType_Pong)
+                {
+                    log("cmd_websocket_chat: received pong message");
+                }
+                else if (messageType == ix::WebSocket_MessageType_Fragment)
+                {
+                    log("cmd_websocket_chat: received message fragment");
+                }
                else
                {
-                    // FIXME: missing ping/pong messages
-                    ss << "Invalid ix::WebSocketMessageType";
+                    ss << "Unexpected ix::WebSocketMessageType";
                    log(ss.str());
                }
            });
--- a/test/run.py
+++ b/test/run.py
@ -2,14 +2,47 @@ import os
 import platform
 import shutil

+import subprocess
+import threading
+
+
+class Command(object):
+    """Run system commands with timeout
+    
+    From http://www.bo-yang.net/2016/12/01/python-run-command-with-timeout
+    Python3 might have a builtin way to do that.
+    """
+    def __init__(self, cmd):
+        self.cmd = cmd
+        self.process = None
+
+    def run_command(self, capture = False):
+        self.process = subprocess.Popen(self.cmd, shell=True)
+        self.process.communicate()
+
+    def run(self, timeout = 5 * 60):
+        '''5 minutes default timeout'''
+        thread = threading.Thread(target=self.run_command, args=())
+        thread.start()
+        thread.join(timeout)
+
+        if thread.is_alive():
+            print 'Command timeout, kill it: ' + self.cmd
+            self.process.terminate()
+            thread.join()
+            return False, 255
+        else:
+            return True, self.process.returncode
+
+
 osName = platform.system()
 print('os name = {}'.format(osName))

 root = os.path.dirname(os.path.realpath(__file__))
-buildDir = os.path.join(root, 'build')
+buildDir = os.path.join(root, 'build', osName)

 if not os.path.exists(buildDir):
-    os.mkdir(buildDir)
+    os.makedirs(buildDir)

 os.chdir(buildDir)

@ -38,7 +71,7 @@ sanitizerFlags = sanitizersFlags[sanitizer]
 #     os.environ['CC'] = 'clang-cl'
 #     os.environ['CXX'] = 'clang-cl'

-cmakeCmd = 'cmake -DCMAKE_BUILD_TYPE=Debug {} {} ..'.format(generator, sanitizerFlags)
+cmakeCmd = 'cmake -DCMAKE_BUILD_TYPE=Debug {} {} ../..'.format(generator, sanitizerFlags)
 print(cmakeCmd)
 ret = os.system(cmakeCmd)
 assert ret == 0, 'CMake failed, exiting'
@ -67,6 +100,7 @@ def findFiles(prefix):

 # We need to copy the zlib DLL in the current work directory
 shutil.copy(os.path.join(
+    '..',
    '..',
    '..',
    'third_party',
@ -77,6 +111,9 @@ shutil.copy(os.path.join(
    'bin',
    'zlib.dll'), '.')

-testCommand = '{} {}'.format(testBinary, os.getenv('TEST', ''))
-ret = os.system(testCommand)
+# lldb = "lldb --batch -o 'run' -k 'thread backtrace all' -k 'quit 1'"
+lldb = ""  # Disabled for now
+testCommand = '{} {} {}'.format(lldb, testBinary, os.getenv('TEST', ''))
+command = Command(testCommand)
+timedout, ret = command.run()
 assert ret == 0, 'Test command failed'
--- a/test/test_runner.cpp
+++ b/test/test_runner.cpp
@ -11,10 +11,6 @@

 int main(int argc, char* argv[])
 {
-    ix::Socket::init(); // for Windows
-
    int result = Catch::Session().run(argc, argv);
-
-    ix::Socket::cleanup(); // for Windows
    return result;
 }
--- a/third_party/homebrew_formula.rb
+++ b/third_party/homebrew_formula.rb
@ -0,0 +1,20 @@
+class Ixwebsocket < Formula
+  desc "WebSocket client and server, and HTTP client command-line tool"
+  homepage "https://github.com/machinezone/IXWebSocket"
+  url "https://github.com/machinezone/IXWebSocket/archive/v1.1.0.tar.gz"
+  sha256 "52592ce3d0a67ad0f90ac9e8a458f61724175d95a01a38d1bad3fcdc5c7b6666"
+  depends_on "cmake" => :build
+
+  def install
+    system "cmake", ".", *std_cmake_args
+    system "make", "install"
+  end
+
+  test do
+    system "#{bin}/ws", "--help"
+    system "#{bin}/ws", "send", "--help"
+    system "#{bin}/ws", "receive", "--help"
+    system "#{bin}/ws", "transfer", "--help"
+    system "#{bin}/ws", "curl", "--help"
+  end
+end
--- a/third_party/remote_trailing_whitespaces.sh
+++ b/third_party/remote_trailing_whitespaces.sh
--- a/ws/.gitignore
+++ b/ws/.gitignore
@ -1 +1,2 @@
 build
+node_modules
--- a/ws/README.md
+++ b/ws/README.md
@ -1,10 +1,62 @@
+# General
+
+ws is a command line tool that should exercise most of the IXWebSocket code, and provide example code.
+
+```
+$ ws --help
+ws is a websocket tool
+Usage: ws [OPTIONS] SUBCOMMAND
+
+Options:
+  -h,--help                   Print this help message and exit
+
+Subcommands:
+  send                        Send a file
+  receive                     Receive a file
+  transfer                    Broadcasting server
+  connect                     Connect to a remote server
+  chat                        Group chat
+  echo_server                 Echo server
+  broadcast_server            Broadcasting server
+  ping                        Ping pong
+  curl                        HTTP Client
+```
+
+## file transfer
+
 ```
 # Start transfer server, which is just a broadcast server at this point
-./ws transfer # running on port 8080.
+ws transfer # running on port 8080.

 # Start receiver first
-./ws receive ws://localhost:8080 
+ws receive ws://localhost:8080 

 # Then send a file. File will be received and written to disk by the receiver process
-./ws send ws://localhost:8080 /file/to/path
+ws send ws://localhost:8080 /file/to/path
+```
+
+## curl
+
+```
+$ ws curl --help
+HTTP Client
+Usage: ws curl [OPTIONS] url
+
+Positionals:
+  url TEXT REQUIRED           Connection url
+
+Options:
+  -h,--help                   Print this help message and exit
+  -d TEXT                     Form data
+  -F TEXT                     Form data
+  -H TEXT                     Header
+  --output TEXT               Output file
+  -I                          Send a HEAD request
+  -L                          Follow redirects
+  --max-redirects INT         Max Redirects
+  -v                          Verbose
+  -O                          Save output to disk
+  --compress                  Enable gzip compression
+  --connect-timeout INT       Connection timeout
+  --transfer-timeout INT      Transfer timeout
 ```
--- a/ws/docker_build.sh
+++ b/ws/docker_build.sh
@ -13,6 +13,7 @@ g++ --std=c++14 \
    ../ixwebsocket/IXSocket.cpp \
    ../ixwebsocket/IXSocketServer.cpp \
    ../ixwebsocket/IXSocketConnect.cpp \
+    ../ixwebsocket/IXSocketFactory.cpp \
    ../ixwebsocket/IXDNSLookup.cpp \
    ../ixwebsocket/IXCancellationRequest.cpp \
    ../ixwebsocket/IXWebSocket.cpp \
@ -22,12 +23,16 @@ g++ --std=c++14 \
    ../ixwebsocket/IXWebSocketPerMessageDeflate.cpp \
    ../ixwebsocket/IXWebSocketPerMessageDeflateCodec.cpp \
    ../ixwebsocket/IXWebSocketPerMessageDeflateOptions.cpp \
+    ../ixwebsocket/IXWebSocketHttpHeaders.cpp \
+    ../ixwebsocket/IXHttpClient.cpp \
+    ../ixwebsocket/IXUrlParser.cpp \
    ../ixwebsocket/IXSocketOpenSSL.cpp \
    ../ixwebsocket/linux/IXSetThreadName_linux.cpp \
-    ../third_party/jsoncpp/jsoncpp.cpp \
+    ../third_party/msgpack11/msgpack11.cpp \
    ixcrypto/IXBase64.cpp \
    ixcrypto/IXHash.cpp \
    ixcrypto/IXUuid.cpp \
+    ws_http_client.cpp \
    ws_ping_pong.cpp \
    ws_broadcast_server.cpp \
    ws_echo_server.cpp \
--- a/ws/package-lock.json
+++ b/ws/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.2.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-6.2.0.tgz",
+      "integrity": "sha512-deZYUNlt2O4buFCa3t5bKLf8A7FPP/TVjwOeVNpw818Ma5nk4MLXls2eoEGS39o8119QIYxTrTDoPQ5B/gTD6w==",
+      "requires": {
+        "async-limiter": "1.0.0"
+      }
+    }
+  }
+}
--- a/ws/test_ws.sh
+++ b/ws/test_ws.sh
@ -0,0 +1,64 @@
+#!/bin/sh
+
+# Handle Ctrl-C by killing all sub-processing AND exiting
+trap cleanup INT
+
+function cleanup {
+    kill `cat /tmp/ws_test/pidfile.transfer`
+    kill `cat /tmp/ws_test/pidfile.receive`
+    kill `cat /tmp/ws_test/pidfile.send`
+    exit 1
+}
+
+rm -rf /tmp/ws_test
+mkdir -p /tmp/ws_test
+
+# Start a transport server
+cd /tmp/ws_test
+ws transfer --port 8090 --pidfile /tmp/ws_test/pidfile.transfer &
+
+# Wait until the transfer server is up 
+while true
+do
+    nc -zv 127.0.0.1 8090 && {
+        echo "Transfer server up and running"
+        break
+    }
+    echo "sleep ... wait for transfer server"
+    sleep 0.1
+done
+
+# Start a receiver
+mkdir -p /tmp/ws_test/receive
+cd /tmp/ws_test/receive
+ws receive --delay 10 ws://127.0.0.1:8090 --pidfile /tmp/ws_test/pidfile.receive &
+
+mkdir /tmp/ws_test/send
+cd /tmp/ws_test/send
+dd if=/dev/urandom of=20M_file count=20000 bs=1024
+
+# Start the sender job
+ws send --pidfile /tmp/ws_test/pidfile.send ws://127.0.0.1:8090 20M_file
+
+# Wait until the file has been written to disk
+while true
+do
+    if test -f /tmp/ws_test/receive/20M_file ; then
+        echo "Received file does exists, exiting loop"
+        break
+    fi
+    echo "sleep ... wait for output file"
+    sleep 0.1
+done
+
+cksum /tmp/ws_test/send/20M_file
+cksum /tmp/ws_test/receive/20M_file
+
+# Give some time to ws receive to terminate
+sleep 2
+
+# Cleanup
+kill `cat /tmp/ws_test/pidfile.transfer`
+kill `cat /tmp/ws_test/pidfile.receive`
+kill `cat /tmp/ws_test/pidfile.send`
+
--- a/ws/ws.cpp
+++ b/ws/ws.cpp
@ -16,6 +16,8 @@
 #include <string>
 #include <sstream>
 #include <iostream>
+#include <fstream>
+#include <unistd.h>

 #include <cli11/CLI11.hpp>
 #include <ixwebsocket/IXSocket.h>
@ -31,6 +33,8 @@ int main(int argc, char** argv)
    std::string data;
    std::string headers;
    std::string output;
+    std::string hostname("127.0.0.1");
+    std::string pidfile;
    bool headersOnly = false;
    bool followRedirects = false;
    bool verbose = false;
@ -40,16 +44,24 @@ int main(int argc, char** argv)
    int connectTimeOut = 60;
    int transferTimeout = 1800;
    int maxRedirects = 5;
+    int delayMs = -1;

    CLI::App* sendApp = app.add_subcommand("send", "Send a file");
    sendApp->add_option("url", url, "Connection url")->required();
    sendApp->add_option("path", path, "Path to the file to send")
        ->required()->check(CLI::ExistingPath);
+    sendApp->add_option("--pidfile", pidfile, "Pid file");
+
    CLI::App* receiveApp = app.add_subcommand("receive", "Receive a file");
    receiveApp->add_option("url", url, "Connection url")->required();
+    receiveApp->add_option("--delay", delayMs, "Delay (ms) to wait after receiving a fragment"
+                                               " to artificially slow down the receiver");
+    receiveApp->add_option("--pidfile", pidfile, "Pid file");

    CLI::App* transferApp = app.add_subcommand("transfer", "Broadcasting server");
    transferApp->add_option("--port", port, "Connection url");
+    transferApp->add_option("--host", hostname, "Hostname");
+    transferApp->add_option("--pidfile", pidfile, "Pid file");

    CLI::App* connectApp = app.add_subcommand("connect", "Connect to a remote server");
    connectApp->add_option("url", url, "Connection url")->required();
@ -59,10 +71,12 @@ int main(int argc, char** argv)
    chatApp->add_option("user", user, "User name")->required();

    CLI::App* echoServerApp = app.add_subcommand("echo_server", "Echo server");
-    echoServerApp->add_option("--port", port, "Connection url");
+    echoServerApp->add_option("--port", port, "Port");
+    echoServerApp->add_option("--host", hostname, "Hostname");

    CLI::App* broadcastServerApp = app.add_subcommand("broadcast_server", "Broadcasting server");
-    broadcastServerApp->add_option("--port", port, "Connection url");
+    broadcastServerApp->add_option("--port", port, "Port");
+    broadcastServerApp->add_option("--host", hostname, "Hostname");

    CLI::App* pingPongApp = app.add_subcommand("ping", "Ping pong");
    pingPongApp->add_option("url", url, "Connection url")->required();
@ -84,11 +98,20 @@ int main(int argc, char** argv)

    CLI11_PARSE(app, argc, argv);

-    ix::Socket::init();
+    // pid file handling
+    if (!pidfile.empty())
+    {
+        unlink(pidfile.c_str());
+
+        std::ofstream f;
+        f.open(pidfile);
+        f << getpid();
+        f.close();
+    }

    if (app.got_subcommand("transfer"))
    {
-        return ix::ws_transfer_main(port);
+        return ix::ws_transfer_main(port, hostname);
    }
    else if (app.got_subcommand("send"))
    {
@ -97,7 +120,7 @@ int main(int argc, char** argv)
    else if (app.got_subcommand("receive"))
    {
        bool enablePerMessageDeflate = false;
-        return ix::ws_receive_main(url, enablePerMessageDeflate);
+        return ix::ws_receive_main(url, enablePerMessageDeflate, delayMs);
    }
    else if (app.got_subcommand("connect"))
    {
@ -109,11 +132,11 @@ int main(int argc, char** argv)
    }
    else if (app.got_subcommand("echo_server"))
    {
-        return ix::ws_echo_server_main(port);
+        return ix::ws_echo_server_main(port, hostname);
    }
    else if (app.got_subcommand("broadcast_server"))
    {
-        return ix::ws_broadcast_server_main(port);
+        return ix::ws_broadcast_server_main(port, hostname);
    }
    else if (app.got_subcommand("ping"))
    {
--- a/ws/ws.h
+++ b/ws/ws.h
@ -24,9 +24,9 @@ namespace ix

    int ws_ping_pong_main(const std::string& url);

-    int ws_echo_server_main(int port);
-
-    int ws_broadcast_server_main(int port);
+    int ws_echo_server_main(int port, const std::string& hostname);
+    int ws_broadcast_server_main(int port, const std::string& hostname);
+    int ws_transfer_main(int port, const std::string& hostname);

    int ws_chat_main(const std::string& url,
                     const std::string& user);
@ -34,9 +34,8 @@ namespace ix
    int ws_connect_main(const std::string& url);

    int ws_receive_main(const std::string& url,
-                        bool enablePerMessageDeflate);
-
-    int ws_transfer_main(int port);
+                        bool enablePerMessageDeflate,
+                        int delayMs);

    int ws_send_main(const std::string& url,
                     const std::string& path);
--- a/ws/ws_broadcast_server.cpp
+++ b/ws/ws_broadcast_server.cpp
@ -10,11 +10,11 @@

 namespace ix
 {
-    int ws_broadcast_server_main(int port)
+    int ws_broadcast_server_main(int port, const std::string& hostname)
    {
-        std::cout << "Listening on port " << port << std::endl;
+        std::cout << "Listening on " << hostname << ":" << port << std::endl;

-        ix::WebSocketServer server(port);
+        ix::WebSocketServer server(port, hostname);

        server.setOnConnectionCallback(
            [&server](std::shared_ptr<ix::WebSocket> webSocket)
@ -39,16 +39,47 @@ namespace ix
                        }
                        else if (messageType == ix::WebSocket_MessageType_Close)
                        {
-                            std::cerr << "Closed connection" << std::endl;
+                            std::cerr << "Closed connection"
+                                      << " code " << closeInfo.code
+                                      << " reason " << closeInfo.reason << std::endl;
+                        }
+                        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;
+                            std::cerr << ss.str();
+                        }
+                        else if (messageType == ix::WebSocket_MessageType_Fragment)
+                        {
+                            std::cerr << "Received message fragment" << 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);
+                                    client->send(str,
+                                                 [](int current, int total) -> bool
+                                    {
+                                        std::cerr << "Step " << current
+                                                  << " out of " << total << std::endl;
+                                        return true;
+                                    });
+
+                                    do
+                                    {
+                                        size_t bufferedAmount = client->bufferedAmount();
+                                        std::cerr << bufferedAmount << " bytes left to be sent" << std::endl;
+
+                                        std::chrono::duration<double, std::milli> duration(10);
+                                        std::this_thread::sleep_for(duration);
+                                    } while (client->bufferedAmount() != 0);
                                }
                            }
                        }
--- a/ws/ws_chat.cpp
+++ b/ws/ws_chat.cpp
@ -94,16 +94,26 @@ namespace ix
                std::stringstream ss;
                if (messageType == ix::WebSocket_MessageType_Open)
                {
-                    ss << "cmd_websocket_chat: user "
+                    log("ws chat: 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;
+                    }
+
+                    ss << "ws chat: user "
                       << _user
                       << " Connected !";
                       log(ss.str());
                }
                else if (messageType == ix::WebSocket_MessageType_Close)
                {
-                    ss << "cmd_websocket_chat: user "
+                    ss << "ws chat: user "
                       << _user
-                       << " disconnected !";
+                       << " disconnected !"
+                       << " code " << closeInfo.code
+                       << " reason " << closeInfo.reason;
                       log(ss.str());
                }
                else if (messageType == ix::WebSocket_MessageType_Message)
@ -117,7 +127,7 @@ namespace ix
                    _receivedQueue.push(result.second);

                    ss << std::endl
-                       << result.first << " > " << result.second
+                       << result.first << "(" << wireSize << " bytes)" << " > " << result.second
                       << std::endl
                       << _user << " > ";
                    log(ss.str());
@ -188,5 +198,7 @@ namespace ix

        std::cout << std::endl;
        webSocketChat.stop();
+
+        return 0;
    }
 }
--- a/ws/ws_connect.cpp
+++ b/ws/ws_connect.cpp
@ -84,6 +84,8 @@ namespace ix
                }
                else if (messageType == ix::WebSocket_MessageType_Message)
                {
+                    std::cerr << "Received " << wireSize << " bytes" << std::endl;
+
                    ss << "ws_connect: received message: "
                       << str;
                    log(ss.str());
@ -151,7 +153,6 @@ namespace ix

    int ws_connect_main(const std::string& url)
    {
-        Socket::init();
        interactiveMain(url);
        return 0;
    }
--- a/ws/ws_echo_server.cpp
+++ b/ws/ws_echo_server.cpp
@ -10,17 +10,17 @@

 namespace ix
 {
-    int ws_echo_server_main(int port)
+    int ws_echo_server_main(int port, const std::string& hostname)
    {
-        std::cout << "Listening on port " << port << std::endl;
+        std::cout << "Listening on " << hostname << ":" << port << std::endl;

-        ix::WebSocketServer server(port);
+        ix::WebSocketServer server(port, hostname);

        server.setOnConnectionCallback(
-            [&server](std::shared_ptr<ix::WebSocket> webSocket)
+            [](std::shared_ptr<ix::WebSocket> webSocket)
            {
                webSocket->setOnMessageCallback(
-                    [webSocket, &server](ix::WebSocketMessageType messageType,
+                    [webSocket](ix::WebSocketMessageType messageType,
                       const std::string& str,
                       size_t wireSize,
                       const ix::WebSocketErrorInfo& error,
@ -39,7 +39,18 @@ namespace ix
                        }
                        else if (messageType == ix::WebSocket_MessageType_Close)
                        {
-                            std::cerr << "Closed connection" << std::endl;
+                            std::cerr << "Closed connection"
+                                      << " code " << closeInfo.code
+                                      << " reason " << closeInfo.reason << std::endl;
+                        }
+                        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;
+                            std::cerr << ss.str();
                        }
                        else if (messageType == ix::WebSocket_MessageType_Message)
                        {
--- a/ws/ws_http_client.cpp
+++ b/ws/ws_http_client.cpp
@ -107,6 +107,12 @@ namespace ix
        {
            std::cout << msg;
        };
+        args.onProgressCallback = [](int current, int total) -> bool
+        {
+            std::cerr << "\r" << "Downloaded "
+                      << current << " bytes out of " << total;
+            return true;
+        };

        HttpParameters httpParameters = parsePostParameters(data);

@ -125,6 +131,8 @@ namespace ix
            out = httpClient.post(url, httpParameters, args);
        }

+        std::cerr << std::endl;
+
        auto statusCode = std::get<0>(out);
        auto errorCode = std::get<1>(out);
        auto responseHeaders = std::get<2>(out);
--- a/ws/ws_ping_pong.cpp
+++ b/ws/ws_ping_pong.cpp
@ -61,10 +61,19 @@ namespace ix
               const ix::WebSocketOpenInfo& openInfo,
               const ix::WebSocketCloseInfo& closeInfo)
            {
+                std::cerr << "Received " << wireSize << " bytes" << std::endl;
+
                std::stringstream ss;
                if (messageType == ix::WebSocket_MessageType_Open)
                {
                    log("ping_pong: 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)
                {
@ -153,5 +162,7 @@ namespace ix

        std::cout << std::endl;
        webSocketPingPong.stop();
+
+        return 0;
    }
 }
--- a/ws/ws_receive.cpp
+++ b/ws/ws_receive.cpp
@ -26,7 +26,8 @@ namespace ix
    {
        public:
            WebSocketReceiver(const std::string& _url,
-                              bool enablePerMessageDeflate);
+                              bool enablePerMessageDeflate,
+                              int delayMs);

            void subscribe(const std::string& channel);
            void start();
@ -41,6 +42,8 @@ namespace ix
            std::string _id;
            ix::WebSocket _webSocket;
            bool _enablePerMessageDeflate;
+            int _delayMs;
+            int _receivedFragmentCounter;

            std::mutex _conditionVariableMutex;
            std::condition_variable _condition;
@ -51,9 +54,12 @@ namespace ix
    };

    WebSocketReceiver::WebSocketReceiver(const std::string& url,
-                                         bool enablePerMessageDeflate) :
+                                         bool enablePerMessageDeflate,
+                                         int delayMs) :
        _url(url),
-        _enablePerMessageDeflate(enablePerMessageDeflate)
+        _enablePerMessageDeflate(enablePerMessageDeflate),
+        _delayMs(delayMs),
+        _receivedFragmentCounter(0)
    {
        ;
    }
@ -146,11 +152,16 @@ namespace ix
        std::string filename = data["filename"].string_value();
        filename = extractFilename(filename);

-        std::cout << "Writing to disk: " << filename << std::endl;
-        std::ofstream out(filename);
+        std::string filenameTmp = filename + ".tmp";
+
+        std::cout << "Writing to disk: " << filenameTmp << std::endl;
+        std::ofstream out(filenameTmp);
        out.write((char*)&content.front(), content.size());
        out.close();

+        std::cout << "Renaming " << filenameTmp << " to " << filename << std::endl;
+        rename(filenameTmp.c_str(), filename.c_str());
+
        std::map<MsgPack, MsgPack> pdu;
        pdu["ack"] = true;
        pdu["id"] = data["id"];
@ -206,8 +217,21 @@ namespace ix
                    handleMessage(str);
                    _condition.notify_one();
                }
+                else if (messageType == ix::WebSocket_MessageType_Fragment)
+                {
+                    ss << "ws_receive: received fragment " << _receivedFragmentCounter++;
+                    log(ss.str());
+
+                    if (_delayMs > 0)
+                    {
+                        // Introduce an arbitrary delay, to simulate a slow connection
+                        std::chrono::duration<double, std::milli> duration(_delayMs);
+                        std::this_thread::sleep_for(duration);
+                    }
+                }
                else if (messageType == ix::WebSocket_MessageType_Error)
                {
+                    ss << "ws_receive ";
                    ss << "Connection error: " << error.reason      << std::endl;
                    ss << "#retries: "         << error.retries     << std::endl;
                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
@ -225,9 +249,10 @@ namespace ix
    }

    void wsReceive(const std::string& url,
-                   bool enablePerMessageDeflate)
+                   bool enablePerMessageDeflate,
+                   int delayMs)
    {
-        WebSocketReceiver webSocketReceiver(url, enablePerMessageDeflate);
+        WebSocketReceiver webSocketReceiver(url, enablePerMessageDeflate, delayMs);
        webSocketReceiver.start();

        webSocketReceiver.waitForConnection();
@ -242,10 +267,10 @@ namespace ix
    }

    int ws_receive_main(const std::string& url,
-                        bool enablePerMessageDeflate)
+                        bool enablePerMessageDeflate,
+                        int delayMs)
    {
-        Socket::init();
-        wsReceive(url, enablePerMessageDeflate);
+        wsReceive(url, enablePerMessageDeflate, delayMs);
        return 0;
    }
 }
--- a/ws/ws_send.cpp
+++ b/ws/ws_send.cpp
@ -162,6 +162,7 @@ namespace ix
                }
                else if (messageType == ix::WebSocket_MessageType_Error)
                {
+                    ss << "ws_send ";
                    ss << "Connection error: " << error.reason      << std::endl;
                    ss << "#retries: "         << error.retries     << std::endl;
                    ss << "Wait time(ms): "    << error.wait_time   << std::endl;
@ -246,7 +247,7 @@ namespace ix
        _webSocket.send(msg.dump(),
                        [throttle](int current, int total) -> bool
        {
-            std::cout << "Step " << current << " out of " << total << std::endl;
+            std::cout << "ws_send: Step " << current << " out of " << total << std::endl;

            if (throttle)
            {
@ -257,6 +258,16 @@ namespace ix
            return true;
        });

+        do
+        {
+            size_t bufferedAmount = _webSocket.bufferedAmount();
+            std::cout << "ws_send: " << bufferedAmount
+                      << " bytes left to be sent" << std::endl;
+
+            std::chrono::duration<double, std::milli> duration(10);
+            std::this_thread::sleep_for(duration);
+        } while (_webSocket.bufferedAmount() != 0);
+
        bench.report();
        auto duration = bench.getDuration();
        auto transferRate = 1000 * content.size() / duration;
@ -289,7 +300,6 @@ namespace ix
        bool throttle = false;
        bool enablePerMessageDeflate = false;

-        Socket::init();
        wsSend(url, path, enablePerMessageDeflate, throttle);
        return 0;
    }
--- a/ws/ws_transfer.cpp
+++ b/ws/ws_transfer.cpp
@ -10,11 +10,11 @@

 namespace ix
 {
-    int ws_transfer_main(int port)
+    int ws_transfer_main(int port, const std::string& hostname)
    {
-        std::cout << "Listening on port " << port << std::endl;
+        std::cout << "Listening on " << hostname << ":" << port << std::endl;

-        ix::WebSocketServer server(port);
+        ix::WebSocketServer server(port, hostname);

        server.setOnConnectionCallback(
            [&server](std::shared_ptr<ix::WebSocket> webSocket)
@ -39,7 +39,23 @@ namespace ix
                        }
                        else if (messageType == ix::WebSocket_MessageType_Close)
                        {
-                            std::cerr << "Closed connection" << std::endl;
+                            std::cerr << "Closed connection"
+                                      << " code " << closeInfo.code
+                                      << " reason " << closeInfo.reason << std::endl;
+                        }
+                        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;
+                            std::cerr << ss.str();
+                        }
+                        else if (messageType == ix::WebSocket_MessageType_Fragment)
+                        {
+                            std::cerr << "Received message fragment "
+                                      << std::endl;
                        }
                        else if (messageType == ix::WebSocket_MessageType_Message)
                        {
@ -48,7 +64,23 @@ namespace ix
                            {
                                if (client != webSocket)
                                {
-                                    client->send(str);
+                                    client->send(str,
+                                                 [](int current, int total) -> bool
+                                    {
+                                        std::cerr << "ws_transfer: Step " << current
+                                                  << " out of " << total << std::endl;
+                                        return true;
+                                    });
+
+                                    do
+                                    {
+                                        size_t bufferedAmount = client->bufferedAmount();
+                                        std::cerr << "ws_transfer: " << bufferedAmount
+                                                  << " bytes left to be sent" << std::endl;
+
+                                        std::chrono::duration<double, std::milli> duration(10);
+                                        std::this_thread::sleep_for(duration);
+                                    } while (client->bufferedAmount() != 0);
                                }
                            }
                        }
Author	SHA1	Message	Date
Benjamin Sergeant	ceba8ae620	fix bug with isReadyToWrite	2019-03-18 22:05:04 -07:00
Benjamin Sergeant	fead661ab7	workaround bug in Socket::isReadyToWrite	2019-03-18 20:37:33 -07:00
Benjamin Sergeant	9c8c17f577	use milliseconds	2019-03-18 20:17:44 -07:00
Benjamin Sergeant	a04f83930f	ws / log subcommand name	2019-03-18 17:54:06 -07:00
Benjamin Sergeant	c421d19800	disable sigpipe on osx when writing/reading into a dead pipe	2019-03-18 17:52:01 -07:00
Benjamin Sergeant	521f02c90e	edit homebrew install steps	2019-03-18 15:45:33 -07:00
Benjamin Sergeant	c86b6074f2	add an install target	2019-03-18 15:11:08 -07:00
Benjamin Sergeant	d5d1a2c5f4	no default parameters for isReadyToWrite and isReadyToRead	2019-03-18 14:31:21 -07:00
Benjamin Sergeant	2a90e3f478	when trying to flush the send buffer, use select to wait until it is possible instead of using sleep to retry at a given frequency	2019-03-18 14:25:27 -07:00
Dimon4eg	1d49ba41ea	Fix typo (#19 )	2019-03-17 16:08:28 -07:00
Benjamin Sergeant	e1de1f6682	remove unused gitmodule file	2019-03-17 10:38:48 -07:00
Benjamin Sergeant	47ed5e4d4d	remove unused folder	2019-03-17 10:38:19 -07:00
Benjamin Sergeant	d77f6f5659	linux hangs when closing	2019-03-16 11:38:23 -07:00
Benjamin Sergeant	05f0045d5d	edit README	2019-03-16 11:32:46 -07:00
Benjamin Sergeant	c4afb84f6e	use pipe to abort select on Linux as well as macOS	2019-03-15 17:46:40 -07:00
Benjamin Sergeant	b0b2f9b6d2	missing assert include on Linux	2019-03-15 11:43:27 -07:00
Benjamin Sergeant	ee37feb489	cleanup	2019-03-15 11:41:57 -07:00
Benjamin Sergeant	6b8337596f	unittest fix	2019-03-14 18:58:16 -07:00
Benjamin Sergeant	250665b92e	linux compile fix	2019-03-14 18:55:33 -07:00
Benjamin Sergeant	86b83c889e	linux fixes	2019-03-14 18:54:47 -07:00
Benjamin Sergeant	c9c657c07b	build fix	2019-03-14 18:53:21 -07:00
Benjamin Sergeant	4f2babaf54	select interrupt cleanup	2019-03-14 18:37:38 -07:00
Benjamin Sergeant	1b03bf4555	linux build fix	2019-03-14 15:17:17 -07:00
Benjamin Sergeant	977b995af9	replace uint8_t with uint64_t for the send/close requests types / use named variable to index into the _fildes array	2019-03-14 15:03:57 -07:00
Benjamin Sergeant	310ab990bd	set a default close reason string	2019-03-14 14:52:51 -07:00
Benjamin Sergeant	d6b49b54d4	do not busy loop while sending	2019-03-14 14:48:08 -07:00
Benjamin Sergeant	f00cf39462	remove docker folder	2019-03-14 14:48:02 -07:00
Benjamin Sergeant	18550cf1cb	send optimization + ws file transfer test	2019-03-14 14:47:53 -07:00
Benjamin Sergeant	168918f807	Update README.md Stop lying about Windows support ...	2019-03-13 23:10:40 -07:00
Benjamin Sergeant	2750df8aa7	send can fail silently when sending would block (EWOULDBLOCK return for send) (#18 ) * try to use a pipe for communication * flush send buffer on the background thread * cleanup * linux fix / linux still use event fd for now * cleanup	2019-03-13 23:09:45 -07:00
Benjamin Sergeant	d6597d9f52	websocket send: make sure all data in the kernel buffer is sent	2019-03-11 22:16:55 -07:00
Benjamin Sergeant	892ea375e3	add new message type when receiving message fragments	2019-03-11 11:12:43 -07:00
Benjamin Sergeant	03abe77b5f	ws broacast_server / can set serving hostname	2019-03-10 16:36:44 -07:00
Benjamin Sergeant	e46eb8aa49	debian 9 unittest build fix	2019-03-10 16:07:48 -07:00
Benjamin Sergeant	2c4862e0f1	asan test suite fix	2019-03-09 10:45:40 -08:00
Benjamin Sergeant	fd69efa45c	unittest + warning fix	2019-03-09 10:37:14 -08:00
Benjamin Sergeant	e8aa15917f	add ability to run with asan on macOS	2019-03-05 17:07:28 -08:00
Benjamin Sergeant	b3d77f8902	fix compiler warnings in ws command line tool	2019-03-04 13:56:30 -08:00
Benjamin Sergeant	9c3b0b08ec	Socket code refactoring, plus stop polling with a 1s timeout in readBytes while we only want to poll with a 1ms timeout	2019-03-04 13:40:15 -08:00
Benjamin Sergeant	fe7d94194c	readBytes does not read bytes one by one but in chunks	2019-03-02 21:11:16 -08:00
Benjamin Sergeant	d6c26d6aa8	create a blocking + cancellable Socket::readBytes method	2019-03-02 15:16:46 -08:00
Benjamin Sergeant	8a74ddcd13	create a blocking + cancellable Socket::readBytes method	2019-03-02 11:01:51 -08:00
Benjamin Sergeant	18e7189a07	more ws doc	2019-02-28 22:07:45 -08:00
Benjamin Sergeant	785dd42c84	more ws doc	2019-02-28 22:03:48 -08:00
Benjamin Sergeant	0cff5065d9	Feature/http (#16 ) * add skeleton and broken http client code. GET returns "Resource temporarily unavailable" errors... * linux compile fix * can GET some pages * Update formatting in README.md * unittest for sending large messages * document bug * Feature/send large message (#14) * introduce send fragment * can pass a fin frame * can send messages which are a perfect multiple of the chunk size * set fin only for last fragment * cleanup * last fragment should be of type CONTINUATION * Add simple send and receive programs * speedups receiving + better way to wait for thing * receive speedup by using linked list of chunks instead of large array * document bug * use chunks to receive data * trailing spaces * Update README.md Add note about message fragmentation. * Feature/ws cli (#15) * 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 * add target for building with homebrew * all CMakeLists are referenced by the top level one * add ws_chat and ws_connect sub commands to ws * cleanup * add echo and broadcast server as ws sub-commands * add gitignore * comments * ping pong added to ws * mv cobra_publisher under ws folder * Update README.md * linux build fix * linux build fix * move http_client to a ws sub-command * simple HTTP post support (urlencode parameters) * can specify extra headers * chunk encoding / simple redirect support / -I option * follow redirects is optional * make README vim markdown plugin friendly * cleanup argument parsing + add socket creation factory * add missing file * http gzip compression * cleanup * doc * Feature/send large message (#14) * introduce send fragment * can pass a fin frame * can send messages which are a perfect multiple of the chunk size * set fin only for last fragment * cleanup * last fragment should be of type CONTINUATION * Add simple send and receive programs * speedups receiving + better way to wait for thing * receive speedup by using linked list of chunks instead of large array * document bug * use chunks to receive data * trailing spaces	2019-02-28 21:54:03 -08:00
				`@ -1 +0,0 @@`
				`ws_receive is a simple server upload program. It needs to be used in conjonction with ws_send.`
				`@ -1 +0,0 @@`
				`ws_send is a simple upload program. It needs to be used in conjonction with ws_receive.`