update appveyor windows build file

Yeah !

CMakeLists.txt

@@ -37,6 +37,7 @@ set( IXWEBSOCKET_SOURCES
     ixwebsocket/IXWebSocketHttpHeaders.cpp
     ixwebsocket/IXHttpClient.cpp
     ixwebsocket/IXUrlParser.cpp
+    ixwebsocket/LUrlParser.cpp
     ixwebsocket/IXSelectInterrupt.cpp
     ixwebsocket/IXSelectInterruptFactory.cpp
     ixwebsocket/IXConnectionState.cpp
@@ -65,6 +66,7 @@ set( IXWEBSOCKET_HEADERS
     ixwebsocket/libwshandshake.hpp
     ixwebsocket/IXHttpClient.h
     ixwebsocket/IXUrlParser.h
+    ixwebsocket/LUrlParser.h
     ixwebsocket/IXSelectInterrupt.h
     ixwebsocket/IXSelectInterruptFactory.h
     ixwebsocket/IXConnectionState.h

Dockerfile

@@ -1,42 +0,0 @@
-FROM fedora:30 as build
-
-RUN yum install -y gcc-g++
-RUN yum install -y cmake
-RUN yum install -y make
-RUN yum install -y openssl-devel
-
-RUN yum install -y wget
-RUN mkdir -p /tmp/cmake
-WORKDIR /tmp/cmake
-RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz 
-RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
-
-ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
-ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
-
-RUN yum install -y python
-RUN yum install -y libtsan
-
-COPY . .
-# RUN ["make", "test"]
-RUN ["make"]
-
-# Runtime
-FROM fedora:30 as runtime
-
-RUN yum install -y libtsan
-
-RUN groupadd app && useradd -g app app 
-COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
-RUN chmod +x /usr/local/bin/ws
-RUN ldd /usr/local/bin/ws
-
-# Now run in usermode
-USER app
-WORKDIR /home/app
-
-COPY --chown=app:app ws/snake/appsConfig.json .
-COPY --chown=app:app ws/cobraMetricsSample.json .
-
-ENTRYPOINT ["ws"]
-CMD ["--help"]

Dockerfile

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

README.md

@@ -10,8 +10,7 @@
 * iOS
 * Linux
 * Android
-
+* Windows (no TLS)
-The code was made to compile once on Windows but support is currently broken on this platform.
 
 ## Examples
 
@@ -199,6 +198,8 @@ make install # will install to /usr/local on Unix, on macOS it is a good idea to
 
 Headers and a static library will be installed to the target dir.
 
+A [conan](https://conan.io/) file is available at [conan-IXWebSocket](https://github.com/Zinnion/conan-IXWebSocket).
+
 There is a unittest which can be executed by typing `make test`.
 
 There is a Dockerfile for running some code on Linux. To use docker-compose you must make a docker container first.

appveyor.yml

@@ -1,10 +1,14 @@
 image:
 - Visual Studio 2017
-- Ubuntu
 
 install:
 - ls -al
 - cmd: call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
-- python test/run.py
+- cd test
+- mkdir build
+- cd build
+- cmake -G"NMake Makefiles" ..
+- nmake
+- ixwebsocket_unittest.exe
 
 build: off

docker/Dockerfile.debian

@@ -0,0 +1,52 @@
+# Build time
+FROM debian:buster as build
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update 
+RUN apt-get -y install wget 
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz 
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+RUN apt-get -y install g++ 
+RUN apt-get -y install libssl-dev
+RUN apt-get -y install libz-dev
+RUN apt-get -y install make
+
+COPY . .
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+RUN ["make"]
+
+# Runtime
+FROM debian:buster as runtime
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get update 
+# Runtime 
+RUN apt-get install -y libssl1.1 
+RUN apt-get install -y ca-certificates
+RUN ["update-ca-certificates"]
+
+# Debugging
+RUN apt-get install -y strace
+RUN apt-get install -y procps
+RUN apt-get install -y htop
+
+RUN adduser --disabled-password --gecos '' app
+COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
+RUN chmod +x /usr/local/bin/ws
+RUN ldd /usr/local/bin/ws
+
+# Now run in usermode
+USER app
+WORKDIR /home/app
+
+COPY --chown=app:app ws/snake/appsConfig.json .
+COPY --chown=app:app ws/cobraMetricsSample.json .
+
+ENTRYPOINT ["ws"]
+CMD ["--help"]

docker/Dockerfile.fedora

@@ -0,0 +1,42 @@
+FROM fedora:30 as build
+
+RUN yum install -y gcc-g++
+RUN yum install -y cmake
+RUN yum install -y make
+RUN yum install -y openssl-devel
+
+RUN yum install -y wget
+RUN mkdir -p /tmp/cmake
+WORKDIR /tmp/cmake
+RUN wget https://github.com/Kitware/CMake/releases/download/v3.14.0/cmake-3.14.0-Linux-x86_64.tar.gz 
+RUN tar zxf cmake-3.14.0-Linux-x86_64.tar.gz
+
+ARG CMAKE_BIN_PATH=/tmp/cmake/cmake-3.14.0-Linux-x86_64/bin
+ENV PATH="${CMAKE_BIN_PATH}:${PATH}"
+
+RUN yum install -y python
+RUN yum install -y libtsan
+
+COPY . .
+# RUN ["make", "test"]
+RUN ["make"]
+
+# Runtime
+FROM fedora:30 as runtime
+
+RUN yum install -y libtsan
+
+RUN groupadd app && useradd -g app app 
+COPY --chown=app:app --from=build /usr/local/bin/ws /usr/local/bin/ws
+RUN chmod +x /usr/local/bin/ws
+RUN ldd /usr/local/bin/ws
+
+# Now run in usermode
+USER app
+WORKDIR /home/app
+
+COPY --chown=app:app ws/snake/appsConfig.json .
+COPY --chown=app:app ws/cobraMetricsSample.json .
+
+ENTRYPOINT ["ws"]
+CMD ["--help"]

docker/Dockerfile.ubuntu_xenial

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

ixwebsocket/IXDNSLookup.cpp

@@ -17,28 +17,25 @@ namespace ix
     std::atomic<uint64_t> DNSLookup::_nextId(0);
     std::set<uint64_t> DNSLookup::_activeJobs;
     std::mutex DNSLookup::_activeJobsMutex;
-    std::mutex DNSLookup::_resMutex;
 
     DNSLookup::DNSLookup(const std::string& hostname, int port, int64_t wait) :
-        _hostname(hostname),
         _port(port),
         _wait(wait),
         _res(nullptr),
         _done(false),
         _id(_nextId++)
     {
-        ;
+        setHostname(hostname);
     }
 
     DNSLookup::~DNSLookup()
     {
         // Remove this job from the active jobs list
-        std::unique_lock<std::mutex> lock(_activeJobsMutex);
+        std::lock_guard<std::mutex> lock(_activeJobsMutex);
         _activeJobs.erase(_id);
     }
 
-    // we want hostname to be copied, not passed as a const reference
+    struct addrinfo* DNSLookup::getAddrInfo(const std::string& hostname,
-    struct addrinfo* DNSLookup::getAddrInfo(std::string hostname,
                                             int port,
                                             std::string& errMsg)
     {
@@ -81,7 +78,7 @@ namespace ix
             return nullptr;
         }
 
-        return getAddrInfo(_hostname, _port, errMsg);
+        return getAddrInfo(getHostname(), _port, errMsg);
     }
 
     struct addrinfo* DNSLookup::resolveAsync(std::string& errMsg,
@@ -99,7 +96,7 @@ namespace ix
 
         // Record job in the active Job set
         {
-            std::unique_lock<std::mutex> lock(_activeJobsMutex);
+            std::lock_guard<std::mutex> lock(_activeJobsMutex);
             _activeJobs.insert(_id);
         }
 
@@ -107,7 +104,7 @@ namespace ix
         // Good resource on thread forced termination
         // https://www.bo-yang.net/2017/11/19/cpp-kill-detached-thread
         //
-        _thread = std::thread(&DNSLookup::run, this, _id, _hostname, _port);
+        _thread = std::thread(&DNSLookup::run, this, _id, getHostname(), _port);
         _thread.detach();
 
         std::unique_lock<std::mutex> lock(_conditionVariableMutex);
@@ -137,13 +134,8 @@ namespace ix
             return nullptr;
         }
 
-        if (!_errMsg.empty())
+        errMsg = getErrMsg();
-        {
+        return getRes();
-            errMsg = _errMsg;
-        }
-
-        std::unique_lock<std::mutex> rlock(_resMutex);
-        return _res;
     }
 
     void DNSLookup::run(uint64_t id, const std::string& hostname, int port) // thread runner
@@ -155,21 +147,55 @@ namespace ix
         struct addrinfo* res = getAddrInfo(hostname, port, errMsg);
 
         // if this isn't an active job, and the control thread is gone
-        // there is not thing to do, and we don't want to touch the defunct
+        // there is nothing to do, and we don't want to touch the defunct
         // object data structure such as _errMsg or _condition
-        std::unique_lock<std::mutex> lock(_activeJobsMutex);
+        std::lock_guard<std::mutex> lock(_activeJobsMutex);
         if (_activeJobs.count(id) == 0)
         {
             return;
         }
 
         // Copy result into the member variables
-        {
+        setRes(res);
-            std::unique_lock<std::mutex> rlock(_resMutex);
+        setErrMsg(errMsg);
-            _res = res;
+
-        }
-        _errMsg = errMsg;
         _condition.notify_one();
         _done = true;
     }
+
+    void DNSLookup::setHostname(const std::string& hostname)
+    {
+        std::lock_guard<std::mutex> lock(_hostnameMutex);
+        _hostname = hostname;
+    }
+
+    const std::string& DNSLookup::getHostname()
+    {
+        std::lock_guard<std::mutex> lock(_hostnameMutex);
+        return _hostname;
+    }
+
+    void DNSLookup::setErrMsg(const std::string& errMsg)
+    {
+        std::lock_guard<std::mutex> lock(_errMsgMutex);
+        _errMsg = errMsg;
+    }
+
+    const std::string& DNSLookup::getErrMsg()
+    {
+        std::lock_guard<std::mutex> lock(_errMsgMutex);
+        return _errMsg;
+    }
+
+    void DNSLookup::setRes(struct addrinfo* addr)
+    {
+        std::lock_guard<std::mutex> lock(_resMutex);
+        _res = addr;
+    }
+
+    struct addrinfo* DNSLookup::getRes()
+    {
+        std::lock_guard<std::mutex> lock(_resMutex);
+        return _res;
+    }
 }

ixwebsocket/IXDNSLookup.h

@@ -39,18 +39,32 @@ namespace ix
         struct addrinfo* resolveBlocking(std::string& errMsg,
                                          const CancellationRequest& isCancellationRequested);
 
-        static struct addrinfo* getAddrInfo(std::string hostname,
+        static struct addrinfo* getAddrInfo(const std::string& hostname,
                                             int port,
                                             std::string& errMsg);
 
         void run(uint64_t id, const std::string& hostname, int port); // thread runner
 
+        void setHostname(const std::string& hostname);
+        const std::string& getHostname();
+
+        void setErrMsg(const std::string& errMsg);
+        const std::string& getErrMsg();
+
+        void setRes(struct addrinfo* addr);
+        struct addrinfo* getRes();
+
         std::string _hostname;
+        std::mutex _hostnameMutex;
         int _port;
+
         int64_t _wait;
-        std::string _errMsg;
+
         struct addrinfo* _res;
-        static std::mutex _resMutex;
+        std::mutex _resMutex;
+
+        std::string _errMsg;
+        std::mutex _errMsgMutex;
 
         std::atomic<bool> _done;
         std::thread _thread;

ixwebsocket/IXHttpClient.cpp

@@ -47,9 +47,8 @@ namespace ix
 
         std::string protocol, host, path, query;
         int port;
-        bool websocket = false;
 
-        if (!UrlParser::parse(url, protocol, host, path, query, port, websocket))
+        if (!UrlParser::parse(url, protocol, host, path, query, port))
         {
             std::stringstream ss;
             ss << "Cannot parse url: " << url;

ixwebsocket/IXNetSystem.cpp

@@ -1,6 +1,6 @@
 /*
  *  IXNetSystem.cpp
- *  Author: Benjamin Sergeant
+ *  Author: Korchynskyi Dmytro
  *  Copyright (c) 2019 Machine Zone. All rights reserved.
  */
 

ixwebsocket/IXSocket.cpp

@@ -189,11 +189,27 @@ namespace ix
 
     int Socket::getErrno()
     {
+        int err;
+
 #ifdef _WIN32
-        return WSAGetLastError();
+        err = WSAGetLastError();
 #else
-        return errno;
+        err = errno;
 #endif
+
+        return err;
+    }
+
+    bool Socket::isWaitNeeded()
+    {
+        int err = getErrno();
+
+        if (err == EWOULDBLOCK || err == EAGAIN || err == EINPROGRESS)
+        {
+            return true;
+        }
+
+        return false;
     }
 
     void Socket::closeSocket(int fd)
@@ -228,8 +244,7 @@ namespace ix
                 return ret == len;
             }
             // There is possibly something to be writen, try again
-            else if (ret < 0 && (getErrno() == EWOULDBLOCK ||
+            else if (ret < 0 && Socket::isWaitNeeded())
-                                 getErrno() == EAGAIN))
             {
                 continue;
             }
@@ -257,8 +272,7 @@ namespace ix
                 return true;
             }
             // There is possibly something to be read, try again
-            else if (ret < 0 && (getErrno() == EWOULDBLOCK ||
+            else if (ret < 0 && Socket::isWaitNeeded())
-                                 getErrno() == EAGAIN))
             {
                 // Wait with a 1ms timeout until the socket is ready to read.
                 // This way we are not busy looping
@@ -317,13 +331,12 @@ namespace ix
             size_t size = std::min(kChunkSize, length - output.size());
             ssize_t ret = recv((char*)&_readBuffer[0], size);
 
-            if (ret <= 0 && (getErrno() != EWOULDBLOCK &&
+            if (ret <= 0 && !Socket::isWaitNeeded())
-                             getErrno() != EAGAIN))
             {
                 // Error
                 return std::make_pair(false, std::string());
             }
-            else if (ret > 0)
+            else
             {
                 output.insert(output.end(),
                               _readBuffer.begin(),

ixwebsocket/IXSocket.h

@@ -16,6 +16,20 @@
 #ifdef _WIN32
 #include <BaseTsd.h>
 typedef SSIZE_T ssize_t;
+
+#undef EWOULDBLOCK
+#undef EAGAIN
+#undef EINPROGRESS
+#undef EBADF
+#undef EINVAL
+
+// map to WSA error codes
+#define EWOULDBLOCK    WSAEWOULDBLOCK
+#define EAGAIN         WSATRY_AGAIN
+#define EINPROGRESS    WSAEINPROGRESS
+#define EBADF          WSAEBADF
+#define EINVAL         WSAEINVAL
+
 #endif
 
 #include "IXCancellationRequest.h"
@@ -41,8 +55,6 @@ namespace ix
         virtual ~Socket();
         bool init(std::string& errorMsg);
 
-        void configure();
-
         // Functions to check whether there is activity on the socket
         PollResultType poll(int timeoutSecs = kDefaultPollTimeout);
         bool wakeUpFromPoll(uint8_t wakeUpCode);
@@ -76,14 +88,14 @@ namespace ix
             const CancellationRequest& isCancellationRequested);
 
         static int getErrno();
+        static bool isWaitNeeded();
+        static void closeSocket(int fd);
 
         // 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;
 

ixwebsocket/IXSocketConnect.cpp

@@ -7,6 +7,7 @@
 #include "IXSocketConnect.h"
 #include "IXDNSLookup.h"
 #include "IXNetSystem.h"
+#include "IXSocket.h"
 
 #include <string.h>
 #include <fcntl.h>
@@ -18,18 +19,6 @@
 # include <linux/tcp.h>
 #endif
 
-namespace
-{
-    void closeSocket(int fd)
-    {
-#ifdef _WIN32
-        closesocket(fd);
-#else
-        ::close(fd);
-#endif
-    }
-}
-
 namespace ix
 {
     //
@@ -56,11 +45,12 @@ namespace ix
         // block us for too long
         SocketConnect::configure(fd);
 
-        if (::connect(fd, address->ai_addr, address->ai_addrlen) == -1
+        int res = ::connect(fd, address->ai_addr, address->ai_addrlen);
-            && errno != EINPROGRESS && errno != 0)
+
+        if (res == -1 && !Socket::isWaitNeeded())
         {
-            errMsg = strerror(errno);
+            errMsg = strerror(Socket::getErrno());
-            closeSocket(fd);
+            Socket::closeSocket(fd);
             return -1;
         }
 
@@ -68,15 +58,17 @@ namespace ix
         {
             if (isCancellationRequested && isCancellationRequested()) // Must handle timeout as well
             {
-                closeSocket(fd);
+                Socket::closeSocket(fd);
                 errMsg = "Cancelled";
                 return -1;
             }
 
-            // Use select to check the status of the new connection
+            // On Linux the timeout needs to be re-initialized everytime
+            // http://man7.org/linux/man-pages/man2/select.2.html
             struct timeval timeout;
             timeout.tv_sec = 0;
             timeout.tv_usec = 10 * 1000; // 10ms timeout
+
             fd_set wfds;
             fd_set efds;
 
@@ -85,11 +77,13 @@ namespace ix
             FD_ZERO(&efds);
             FD_SET(fd, &efds);
 
-            if (select(fd + 1, nullptr, &wfds, &efds, &timeout) < 0 &&
+            // Use select to check the status of the new connection
-                (errno == EBADF || errno == EINVAL))
+            res = select(fd + 1, nullptr, &wfds, &efds, &timeout);
+
+            if (res < 0 && (Socket::getErrno() == EBADF || Socket::getErrno() == EINVAL))
             {
-                closeSocket(fd);
+                Socket::closeSocket(fd);
-                errMsg = std::string("Connect error, select error: ") + strerror(errno);
+                errMsg = std::string("Connect error, select error: ") + strerror(Socket::getErrno());
                 return -1;
             }
 
@@ -110,7 +104,7 @@ namespace ix
                 optval != 0)
 #endif
             {
-                closeSocket(fd);
+                Socket::closeSocket(fd);
                 errMsg = strerror(optval);
                 return -1;
             }
@@ -121,7 +115,7 @@ namespace ix
             }
         }
 
-        closeSocket(fd);
+        Socket::closeSocket(fd);
         errMsg = "connect timed out after 60 seconds";
         return -1;
     }

ixwebsocket/IXSocketServer.cpp

@@ -77,7 +77,7 @@ namespace ix
                << "at address " << _host << ":" << _port
                << " : " << strerror(Socket::getErrno());
 
-            ::close(_serverFd);
+            Socket::closeSocket(_serverFd);
             return std::make_pair(false, ss.str());
         }
 
@@ -101,7 +101,7 @@ namespace ix
                << "at address " << _host << ":" << _port
                << " : " << strerror(Socket::getErrno());
 
-            ::close(_serverFd);
+            Socket::closeSocket(_serverFd);
             return std::make_pair(false, ss.str());
         }
 
@@ -115,7 +115,7 @@ namespace ix
                << "at address " << _host << ":" << _port
                << " : " << strerror(Socket::getErrno());
 
-            ::close(_serverFd);
+            Socket::closeSocket(_serverFd);
             return std::make_pair(false, ss.str());
         }
 
@@ -159,7 +159,7 @@ namespace ix
         _stop = false;
 
         _conditionVariable.notify_one();
-        ::close(_serverFd);
+        Socket::closeSocket(_serverFd);
     }
 
     void SocketServer::setConnectionStateFactory(
@@ -242,17 +242,18 @@ namespace ix
             // Accept a connection.
             struct sockaddr_in client; // client address information
             int clientFd;              // socket connected to client
-            socklen_t addressLen = sizeof(socklen_t);
+            socklen_t addressLen = sizeof(client);
             memset(&client, 0, sizeof(client));
 
             if ((clientFd = accept(_serverFd, (struct sockaddr *)&client, &addressLen)) < 0)
             {
-                if (Socket::getErrno() != EWOULDBLOCK)
+                if (!Socket::isWaitNeeded())
                 {
                     // FIXME: that error should be propagated
+                    int err = Socket::getErrno();
                     std::stringstream ss;
                     ss << "SocketServer::run() error accepting connection: "
-                       << strerror(Socket::getErrno());
+                       << err << ", " << strerror(err);
                     logError(ss.str());
                 }
                 continue;
@@ -266,7 +267,7 @@ namespace ix
                    << "Not accepting connection";
                 logError(ss.str());
 
-                ::close(clientFd);
+                Socket::closeSocket(clientFd);
 
                 continue;
             }
@@ -280,7 +281,7 @@ namespace ix
             if (_stop) return;
 
             // Launch the handleConnection work asynchronously in its own thread.
-            std::lock_guard<std::mutex> lock(_conditionVariableMutex);
+            std::lock_guard<std::mutex> lock(_connectionsThreadsMutex);
             _connectionsThreads.push_back(std::make_pair(
                     connectionState,
                     std::thread(&SocketServer::handleConnection,

ixwebsocket/IXUrlParser.cpp

@@ -5,43 +5,32 @@
  */
 
 #include "IXUrlParser.h"
+#include "LUrlParser.h"
 
 #include <iostream>
-#include <sstream>
-
 
 namespace ix
 {
-    //
-    // The only difference between those 2 regex is the protocol
-    //
-    std::regex UrlParser::_httpRegex("(http|https)://([^/ :]+):?([^/ ]*)(/?[^ #?]*)\\x3f?([^ #]*)#?([^ ]*)");
-    std::regex UrlParser::_webSocketRegex("(ws|wss)://([^/ :]+):?([^/ ]*)(/?[^ #?]*)\\x3f?([^ #]*)#?([^ ]*)");
-
     bool UrlParser::parse(const std::string& url,
                           std::string& protocol,
                           std::string& host,
                           std::string& path,
                           std::string& query,
-                          int& port,
+                          int& port)
-                          bool websocket)
     {
-        std::cmatch what;
+        LUrlParser::clParseURL res = LUrlParser::clParseURL::ParseURL(url);
-        if (!regex_match(url.c_str(), what,
+
-                         websocket ? _webSocketRegex : _httpRegex))
+        if (!res.IsValid())
         {
             return false;
         }
 
-        std::string portStr;
+        protocol = res.m_Scheme;
+        host     = res.m_Host;
+        path     = res.m_Path;
+        query    = res.m_Query;
 
-        protocol = std::string(what[1].first, what[1].second);
+        if (!res.GetPort(&port))
-        host     = std::string(what[2].first, what[2].second);
-        portStr  = std::string(what[3].first, what[3].second);
-        path     = std::string(what[4].first, what[4].second);
-        query    = std::string(what[5].first, what[5].second);
-
-        if (portStr.empty())
         {
             if (protocol == "ws" || protocol == "http")
             {
@@ -58,12 +47,6 @@ namespace ix
                 return false;
             }
         }
-        else
-        {
-            std::stringstream ss;
-            ss << portStr;
-            ss >> port;
-        }
 
         if (path.empty())
         {
@@ -83,12 +66,12 @@ namespace ix
         return true;
     }
 
-    void UrlParser::printUrl(const std::string& url, bool websocket)
+    void UrlParser::printUrl(const std::string& url)
     {
         std::string protocol, host, path, query;
         int port {0};
 
-        if (!parse(url, protocol, host, path, query, port, websocket))
+        if (!parse(url, protocol, host, path, query, port))
         {
             return;
         }

ixwebsocket/IXUrlParser.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include <string>
-#include <regex>
 
 namespace ix
 {
@@ -19,13 +18,8 @@ namespace ix
                           std::string& host,
                           std::string& path,
                           std::string& query,
-                          int& port,
+                          int& port);
-                          bool websocket);
 
-        static void printUrl(const std::string& url, bool websocket);
+        static void printUrl(const std::string& url);
-
-    private:
-        static std::regex _httpRegex;
-        static std::regex _webSocketRegex;
     };
 }

ixwebsocket/IXWebSocket.cpp

@@ -216,14 +216,9 @@ namespace ix
         return getReadyState() == WebSocket_ReadyState_Closing;
     }
 
-    bool WebSocket::isConnectedOrClosing() const
+    void WebSocket::close()
     {
-        return isConnected() || isClosing();
+        _ws.close();
-    }
-
-    void WebSocket::close(uint16_t code, const std::string& reason)
-    {
-        _ws.close(code, reason);
     }
 
     void WebSocket::reconnectPerpetuallyIfDisconnected()
@@ -234,6 +229,27 @@ namespace ix
         using millis = std::chrono::duration<double, std::milli>;
         millis duration;
 
+        // Try to connect only once when we don't have automaticReconnection setup
+        if (!isConnected() && !isClosing() && !_stop && !_automaticReconnection)
+        {
+            status = connect(_handshakeTimeoutSecs);
+
+            if (!status.success)
+            {
+                duration = millis(calculateRetryWaitMilliseconds(retries++));
+
+                connectErr.retries = retries;
+                connectErr.wait_time = duration.count();
+                connectErr.reason = status.errorStr;
+                connectErr.http_status = status.http_status;
+                _onMessageCallback(WebSocket_MessageType_Error, "", 0,
+                                   connectErr, WebSocketOpenInfo(),
+                                   WebSocketCloseInfo());
+            }
+        }
+        else
+        {
+            // Otherwise try to reconnect perpertually
             while (true)
             {
                 if (isConnected() || isClosing() || _stop || !_automaticReconnection)
@@ -243,7 +259,7 @@ namespace ix
 
                 status = connect(_handshakeTimeoutSecs);
 
-            if (!status.success && !_stop)
+                if (!status.success)
                 {
                     duration = millis(calculateRetryWaitMilliseconds(retries++));
 
@@ -255,10 +271,15 @@ namespace ix
                                        connectErr, WebSocketOpenInfo(),
                                        WebSocketCloseInfo());
 
+                    // Only sleep if we aren't in the middle of stopping
+                    if (!_stop)
+                    {
                         std::this_thread::sleep_for(duration);
                     }
                 }
             }
+        }
+    }
 
     void WebSocket::run()
     {
@@ -266,17 +287,20 @@ namespace ix
 
         while (true)
         {
-            if (_stop && !isClosing()) return;
+            if (_stop) return;
 
             // 1. Make sure we are always connected
             reconnectPerpetuallyIfDisconnected();
 
+            if (_stop) return;
+
             // 2. Poll to see if there's any new data available
-            WebSocketTransport::PollPostTreatment pollPostTreatment = _ws.poll();
+            _ws.poll();
+
+            if (_stop) return;
 
             // 3. Dispatch the incoming messages
             _ws.dispatch(
-                pollPostTreatment,
                 [this](const std::string& msg,
                        size_t wireSize,
                        bool decompressionError,
@@ -316,10 +340,8 @@ namespace ix
                     WebSocket::invokeTrafficTrackerCallback(msg.size(), true);
                 });
 
-            // 4. In blocking mode, getting out of this function is triggered by
+            // If we aren't trying to reconnect automatically, exit if we aren't connected
-            //    an explicit disconnection from the callback, or by the remote end
+            if (!isConnected() && !_automaticReconnection) return;
-            //    closing the connection, ie isConnectedOrClosing() == false.
-            if (!_thread.joinable() && !isConnectedOrClosing() && !_automaticReconnection) return;
         }
     }
 

ixwebsocket/IXWebSocket.h

@@ -111,8 +111,7 @@ namespace ix
         WebSocketSendInfo sendText(const std::string& text,
                                    const OnProgressCallback& onProgressCallback = nullptr);
         WebSocketSendInfo ping(const std::string& text);
-        void close(uint16_t code = 1000,
+        void close();
-                   const std::string& reason = "Normal closure");
 
         void setOnMessageCallback(const OnMessageCallback& callback);
         static void setTrafficTrackerCallback(const OnTrafficTrackerCallback& callback);
@@ -137,7 +136,6 @@ namespace ix
 
         bool isConnected() const;
         bool isClosing() const;
-        bool isConnectedOrClosing() const;
         void reconnectPerpetuallyIfDisconnected();
         std::string readyStateToString(ReadyState readyState);
         static void invokeTrafficTrackerCallback(size_t size, bool incoming);

ixwebsocket/IXWebSocketHandshake.cpp

@@ -12,7 +12,6 @@
 
 #include <iostream>
 #include <sstream>
-#include <regex>
 #include <random>
 #include <algorithm>
 

ixwebsocket/IXWebSocketTransport.cpp

@@ -72,9 +72,7 @@ namespace ix
     const int WebSocketTransport::kDefaultPingIntervalSecs(-1);
     const int WebSocketTransport::kDefaultPingTimeoutSecs(-1);
     const bool WebSocketTransport::kDefaultEnablePong(true);
-    const int WebSocketTransport::kClosingMaximumWaitingDelayInMs(200);
     constexpr size_t WebSocketTransport::kChunkSize;
-
     const uint16_t WebSocketTransport::kInternalErrorCode(1011);
     const uint16_t WebSocketTransport::kAbnormalCloseCode(1006);
     const uint16_t WebSocketTransport::kProtocolErrorCode(1002);
@@ -92,7 +90,6 @@ namespace ix
         _closeRemote(false),
         _enablePerMessageDeflate(false),
         _requestInitCancellation(false),
-        _closingTimePoint(std::chrono::steady_clock::now()),
         _enablePong(kDefaultEnablePong),
         _pingIntervalSecs(kDefaultPingIntervalSecs),
         _pingTimeoutSecs(kDefaultPingTimeoutSecs),
@@ -140,9 +137,8 @@ namespace ix
     {
         std::string protocol, host, path, query;
         int port;
-        bool websocket = true;
 
-        if (!UrlParser::parse(url, protocol, host, path, query, port, websocket))
+        if (!UrlParser::parse(url, protocol, host, path, query, port))
         {
             return WebSocketInitResult(false, 0,
                                        std::string("Could not parse URL ") + url);
@@ -249,19 +245,9 @@ namespace ix
         return now - _lastReceivePongTimePoint > std::chrono::seconds(_pingTimeoutSecs);
     }
 
-    bool WebSocketTransport::closingDelayExceeded()
+    void WebSocketTransport::poll()
     {
-        std::lock_guard<std::mutex> lock(_closingTimePointMutex);
+        PollResultType pollResult = _socket->poll(_pingIntervalOrTimeoutGCDSecs);
-        auto now = std::chrono::steady_clock::now();
-        return now - _closingTimePoint > std::chrono::milliseconds(kClosingMaximumWaitingDelayInMs);
-    }
-
-    WebSocketTransport::PollPostTreatment WebSocketTransport::poll()
-    {
-        // we need to have no timeout if state is CLOSING
-        int timeoutDelaySecs = (_readyState == CLOSING) ? 0 : _pingIntervalOrTimeoutGCDSecs;
-
-        PollResultType pollResult = _socket->poll(timeoutDelaySecs);
 
         if (_readyState == OPEN)
         {
@@ -309,19 +295,23 @@ namespace ix
             {
                 ssize_t ret = _socket->recv((char*)&_readbuf[0], _readbuf.size());
 
-                if (ret < 0 && _readyState != CLOSING && (_socket->getErrno() == EWOULDBLOCK ||
+                if (ret < 0 && Socket::isWaitNeeded())
-                                                          _socket->getErrno() == EAGAIN))
                 {
                     break;
                 }
                 else if (ret <= 0)
                 {
-                    // if there are received data pending to be processed, then delay the abnormal closure
+                    _rxbuf.clear();
-                    // to after dispatch (other close code/reason could be read from the buffer)
-                    
                     _socket->close();
-
+                    {
-                    return CHECK_OR_RAISE_ABNORMAL_CLOSE_AFTER_DISPATCH;
+                        std::lock_guard<std::mutex> lock(_closeDataMutex);
+                        _closeCode = kAbnormalCloseCode;
+                        _closeReason = kAbnormalCloseMessage;
+                        _closeWireSize = 0;
+                        _closeRemote = true;
+                    }
+                    setReadyState(CLOSED);
+                    break;
                 }
                 else
                 {
@@ -340,15 +330,12 @@ namespace ix
             _socket->close();
         }
 
-        if (_readyState == CLOSING && closingDelayExceeded())
+        // Avoid a race condition where we get stuck in select
+        // while closing.
+        if (_readyState == CLOSING)
         {
-            _rxbuf.clear();
-            // close code and reason were set when calling close()
             _socket->close();
-            setReadyState(CLOSED);
         }
-
-        return NONE;
     }
 
     bool WebSocketTransport::isSendBufferEmpty() const
@@ -410,13 +397,12 @@ namespace ix
     // |                     Payload Data continued ...                |
     // +---------------------------------------------------------------+
     //
-    void WebSocketTransport::dispatch(WebSocketTransport::PollPostTreatment pollPostTreatment,
+    void WebSocketTransport::dispatch(const OnMessageCallback& onMessageCallback)
-                                      const OnMessageCallback& onMessageCallback)
     {
         while (true)
         {
             wsheader_type ws;
-            if (_rxbuf.size() < 2) break; /* Need at least 2 */
+            if (_rxbuf.size() < 2) return; /* Need at least 2 */
             const uint8_t * data = (uint8_t *) &_rxbuf[0]; // peek, but don't consume
             ws.fin = (data[0] & 0x80) == 0x80;
             ws.rsv1 = (data[0] & 0x40) == 0x40;
@@ -424,7 +410,7 @@ namespace ix
             ws.mask = (data[1] & 0x80) == 0x80;
             ws.N0 = (data[1] & 0x7f);
             ws.header_size = 2 + (ws.N0 == 126? 2 : 0) + (ws.N0 == 127? 8 : 0) + (ws.mask? 4 : 0);
-            if (_rxbuf.size() < ws.header_size) break; /* Need: ws.header_size - _rxbuf.size() */
+            if (_rxbuf.size() < ws.header_size) return; /* Need: ws.header_size - _rxbuf.size() */
 
             //
             // Calculate payload length:
@@ -566,25 +552,9 @@ namespace ix
                 std::string reason(_rxbuf.begin()+ws.header_size + 2,
                                    _rxbuf.begin()+ws.header_size + (size_t) ws.N);
 
-                
-                // We receive a CLOSE frame from remote and are NOT the ones who triggered the close
-                if (_readyState != CLOSING)
-                {
-                    // send back the CLOSE frame
-                    sendCloseFrame(code, reason);
-
-                    _socket->wakeUpFromPoll(Socket::kCloseRequest);
-                    
                 bool remote = true;
-                    closeSocketAndSwitchToClosedState(code, reason, _rxbuf.size(), remote);
+
-                }
+                close(code, reason, _rxbuf.size(), remote);
-                // we got the CLOSE frame answer from our close, so we can close the connection if
-                // the code/reason are the same
-                else if (_closeCode == code && _closeReason == reason)
-                {
-                    bool remote = false;
-                    closeSocketAndSwitchToClosedState(code, reason, _rxbuf.size(), remote);
-                }
             }
             else
             {
@@ -597,25 +567,6 @@ namespace ix
             _rxbuf.erase(_rxbuf.begin(),
                          _rxbuf.begin() + ws.header_size + (size_t) ws.N);
         }
-
-        // if an abnormal closure was raised in poll, and nothing else triggered a CLOSED state in
-        // the received and processed data then close the connection
-        if (pollPostTreatment == CHECK_OR_RAISE_ABNORMAL_CLOSE_AFTER_DISPATCH)
-        {
-            _rxbuf.clear();
-
-            // if we previously closed the connection (CLOSING state), then set state to CLOSED (code/reason were set before)
-            if (_readyState == CLOSING)
-            {
-                _socket->close();
-                setReadyState(CLOSED);
-            }
-            // if we weren't closing, then close using abnormal close code and message 
-            else if (_readyState != CLOSED)
-            {
-                closeSocketAndSwitchToClosedState(kAbnormalCloseCode, kAbnormalCloseMessage, 0, false);
-            }
-        }
     }
 
     std::string WebSocketTransport::getMergedChunks() const
@@ -891,8 +842,7 @@ namespace ix
         {
             ssize_t ret = _socket->send((char*)&_txbuf[0], _txbuf.size());
 
-            if (ret < 0 && (_socket->getErrno() == EWOULDBLOCK ||
+            if (ret < 0 && Socket::isWaitNeeded())
-                            _socket->getErrno() == EAGAIN))
             {
                 break;
             }
@@ -910,9 +860,12 @@ namespace ix
         }
     }
 
-
+    void WebSocketTransport::close(uint16_t code, const std::string& reason, size_t closeWireSize, bool remote)
-    void WebSocketTransport::sendCloseFrame(uint16_t code, const std::string& reason)
     {
+        _requestInitCancellation = true;
+
+        if (_readyState == CLOSING || _readyState == CLOSED) return;
+
         // See list of close events here:
         // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
 
@@ -925,43 +878,20 @@ namespace ix
 
         bool compress = false;
         sendData(wsheader_type::CLOSE, closure, compress);
-    }
-
-    void WebSocketTransport::closeSocketAndSwitchToClosedState(uint16_t code, const std::string& reason, size_t closeWireSize, bool remote)
-    {
-        _socket->close();
-        {
-            std::lock_guard<std::mutex> lock(_closeDataMutex);
-            _closeCode = code;
-            _closeReason = reason;
-            _closeWireSize = closeWireSize;
-            _closeRemote = remote;
-        }
-        setReadyState(CLOSED);
-    }
-
-    void WebSocketTransport::close(uint16_t code, const std::string& reason, size_t closeWireSize, bool remote)
-    {
-        _requestInitCancellation = true;
-
-        if (_readyState == CLOSING || _readyState == CLOSED) return;
-
-        sendCloseFrame(code, reason);
-        {
-            std::lock_guard<std::mutex> lock(_closeDataMutex);
-            _closeCode = code;
-            _closeReason = reason;
-            _closeWireSize = closeWireSize;
-            _closeRemote = remote;
-        }
-        {
-            std::lock_guard<std::mutex> lock(_closingTimePointMutex);
-            _closingTimePoint = std::chrono::steady_clock::now();
-        }
         setReadyState(CLOSING);
 
-        // wake up the poll, but do not close yet
+        _socket->wakeUpFromPoll(Socket::kCloseRequest);
-        _socket->wakeUpFromPoll(Socket::kSendRequest);
+        _socket->close();
+
+        {
+            std::lock_guard<std::mutex> lock(_closeDataMutex);
+            _closeCode = code;
+            _closeReason = reason;
+            _closeWireSize = closeWireSize;
+            _closeRemote = remote;
+        }
+
+        setReadyState(CLOSED);
     }
 
     size_t WebSocketTransport::bufferedAmount() const

ixwebsocket/IXWebSocketTransport.h

@@ -56,12 +56,6 @@ namespace ix
             FRAGMENT
         };
 
-        enum PollPostTreatment
-        {
-            NONE,
-            CHECK_OR_RAISE_ABNORMAL_CLOSE_AFTER_DISPATCH
-        };
-
         using OnMessageCallback = std::function<void(const std::string&,
                                                      size_t,
                                                      bool,
@@ -84,7 +78,7 @@ namespace ix
         WebSocketInitResult connectToSocket(int fd,              // Server
                                             int timeoutSecs);
 
-        PollPostTreatment poll();
+        void poll();
         WebSocketSendInfo sendBinary(const std::string& message,
                                      const OnProgressCallback& onProgressCallback);
         WebSocketSendInfo sendText(const std::string& message,
@@ -99,8 +93,7 @@ namespace ix
         ReadyStateValues getReadyState() const;
         void setReadyState(ReadyStateValues readyStateValue);
         void setOnCloseCallback(const OnCloseCallback& onCloseCallback);
-        void dispatch(PollPostTreatment pollPostTreatment,
+        void dispatch(const OnMessageCallback& onMessageCallback);
-                      const OnMessageCallback& onMessageCallback);
         size_t bufferedAmount() const;
 
     private:
@@ -126,7 +119,7 @@ namespace ix
 
         // Tells whether we should mask the data we send.
         // client should mask but server should not
-        bool _useMask;
+        std::atomic<bool> _useMask;
 
         // Buffer for reading from our socket. That buffer is never resized.
         std::vector<uint8_t> _readbuf;
@@ -170,10 +163,6 @@ namespace ix
         // Used to cancel dns lookup + socket connect + http upgrade
         std::atomic<bool> _requestInitCancellation;
 
-        mutable std::mutex _closingTimePointMutex;
-        std::chrono::time_point<std::chrono::steady_clock>_closingTimePoint;
-        static const int kClosingMaximumWaitingDelayInMs;
-
         // Constants for dealing with closing conneections
         static const uint16_t kInternalErrorCode;
         static const uint16_t kAbnormalCloseCode;
@@ -212,16 +201,6 @@ namespace ix
         // No PONG data was received through the socket for longer than ping timeout delay
         bool pingTimeoutExceeded();
 
-        // after calling close(), if no CLOSE frame answer is received back from the remote, we should close the connexion
-        bool closingDelayExceeded();
-
-        void sendCloseFrame(uint16_t code, const std::string& reason);
-
-        void closeSocketAndSwitchToClosedState(uint16_t code,
-                                               const std::string& reason,
-                                               size_t closeWireSize,
-                                               bool remote);
-
         void sendOnSocket();
         WebSocketSendInfo sendData(wsheader_type::opcode_type type,
                                    const std::string& message,

ixwebsocket/LUrlParser.cpp

@@ -0,0 +1,265 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ * 
+ * The MIT License (MIT)
+ * 
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "LUrlParser.h"
+
+#include <algorithm>
+#include <cstring>
+#include <stdlib.h>
+
+// check if the scheme name is valid
+static bool IsSchemeValid( const std::string& SchemeName )
+{
+	for ( auto c : SchemeName  )
+	{
+		if ( !isalpha( c ) && c != '+' && c != '-' && c != '.' ) return false;
+	}
+
+	return true;
+}
+
+bool LUrlParser::clParseURL::GetPort( int* OutPort ) const
+{
+	if ( !IsValid() ) { return false; }
+
+	int Port = atoi( m_Port.c_str() );
+
+	if ( Port <= 0 || Port > 65535 ) { return false; }
+
+	if ( OutPort ) { *OutPort = Port; }
+
+	return true;
+}
+
+// based on RFC 1738 and RFC 3986
+LUrlParser::clParseURL LUrlParser::clParseURL::ParseURL( const std::string& URL )
+{
+	LUrlParser::clParseURL Result;
+
+	const char* CurrentString = URL.c_str();
+
+	/*
+	 *	<scheme>:<scheme-specific-part>
+	 *	<scheme> := [a-z\+\-\.]+
+	 *	For resiliency, programs interpreting URLs should treat upper case letters as equivalent to lower case in scheme names
+	 */
+
+	// try to read scheme
+	{
+		const char* LocalString = strchr( CurrentString, ':' );
+
+		if ( !LocalString )
+		{
+			return clParseURL( LUrlParserError_NoUrlCharacter );
+		}
+
+		// save the scheme name
+		Result.m_Scheme = std::string( CurrentString, LocalString - CurrentString );
+
+		if ( !IsSchemeValid( Result.m_Scheme ) )
+		{
+			return clParseURL( LUrlParserError_InvalidSchemeName );
+		}
+
+		// scheme should be lowercase
+		std::transform( Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower );
+
+		// skip ':'
+		CurrentString = LocalString+1;
+	}
+
+	/*
+	 *	//<user>:<password>@<host>:<port>/<url-path>
+	 *	any ":", "@" and "/" must be normalized
+	 */
+
+	// skip "//"
+	if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+	if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+
+	// check if the user name and password are specified
+	bool bHasUserName = false;
+
+	const char* LocalString = CurrentString;
+
+	while ( *LocalString )
+	{
+		if ( *LocalString == '@' )
+		{
+			// user name and password are specified
+			bHasUserName = true;
+			break;
+		}
+		else if ( *LocalString == '/' )
+		{
+			// end of <host>:<port> specification
+			bHasUserName = false;
+			break;
+		}
+
+		LocalString++;
+	}
+
+	// user name and password
+	LocalString = CurrentString;
+
+	if ( bHasUserName )
+	{
+		// read user name
+		while ( *LocalString && *LocalString != ':' && *LocalString != '@' ) LocalString++;
+
+		Result.m_UserName = std::string( CurrentString, LocalString - CurrentString );
+
+		// proceed with the current pointer
+		CurrentString = LocalString;
+
+		if ( *CurrentString == ':' )
+		{
+			// skip ':'
+			CurrentString++;
+
+			// read password
+			LocalString = CurrentString;
+
+			while ( *LocalString && *LocalString != '@' ) LocalString++;
+
+			Result.m_Password = std::string( CurrentString, LocalString - CurrentString );
+
+			CurrentString = LocalString;
+		}
+
+		// skip '@'
+		if ( *CurrentString != '@' )
+		{
+			return clParseURL( LUrlParserError_NoAtSign );
+		}
+
+		CurrentString++;
+	}
+
+	bool bHasBracket = ( *CurrentString == '[' );
+
+	// go ahead, read the host name
+	LocalString = CurrentString;
+
+	while ( *LocalString )
+	{
+		if ( bHasBracket && *LocalString == ']' )
+		{
+			// end of IPv6 address
+			LocalString++;
+			break;
+		}
+		else if ( !bHasBracket && ( *LocalString == ':' || *LocalString == '/' ) )
+		{
+			// port number is specified
+			break;
+		}
+
+		LocalString++;
+	}
+
+	Result.m_Host = std::string( CurrentString, LocalString - CurrentString );
+
+	CurrentString = LocalString;
+
+	// is port number specified?
+	if ( *CurrentString == ':' )
+	{
+		CurrentString++;
+
+		// read port number
+		LocalString = CurrentString;
+
+		while ( *LocalString && *LocalString != '/' ) LocalString++;
+
+		Result.m_Port = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	// end of string
+	if ( !*CurrentString )
+	{
+		Result.m_ErrorCode = LUrlParserError_Ok;
+
+		return Result;
+	}
+
+	// skip '/'
+	if ( *CurrentString != '/' )
+	{
+		return clParseURL( LUrlParserError_NoSlash );
+	}
+
+	CurrentString++;
+
+	// parse the path
+	LocalString = CurrentString;
+
+	while ( *LocalString && *LocalString != '#' && *LocalString != '?' ) LocalString++;
+
+	Result.m_Path = std::string( CurrentString, LocalString - CurrentString );
+
+	CurrentString = LocalString;
+
+	// check for query
+	if ( *CurrentString == '?' )
+	{
+		// skip '?'
+		CurrentString++;
+
+		// read query
+		LocalString = CurrentString;
+
+		while ( *LocalString && *LocalString != '#' ) LocalString++;
+
+		Result.m_Query = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	// check for fragment
+	if ( *CurrentString == '#' )
+	{
+		// skip '#'
+		CurrentString++;
+
+		// read fragment
+		LocalString = CurrentString;
+
+		while ( *LocalString ) LocalString++;
+
+		Result.m_Fragment = std::string( CurrentString, LocalString - CurrentString );
+
+		CurrentString = LocalString;
+	}
+
+	Result.m_ErrorCode = LUrlParserError_Ok;
+
+	return Result;
+}

ixwebsocket/LUrlParser.h

@@ -0,0 +1,78 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ * 
+ * The MIT License (MIT)
+ * 
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace LUrlParser
+{
+	enum LUrlParserError
+	{
+		LUrlParserError_Ok = 0,
+		LUrlParserError_Uninitialized = 1,
+		LUrlParserError_NoUrlCharacter = 2,
+		LUrlParserError_InvalidSchemeName = 3,
+		LUrlParserError_NoDoubleSlash = 4,
+		LUrlParserError_NoAtSign = 5,
+		LUrlParserError_UnexpectedEndOfLine = 6,
+		LUrlParserError_NoSlash = 7,
+	};
+
+	class clParseURL
+	{
+	public:
+		LUrlParserError m_ErrorCode;
+		std::string m_Scheme;
+		std::string m_Host;
+		std::string m_Port;
+		std::string m_Path;
+		std::string m_Query;
+		std::string m_Fragment;
+		std::string m_UserName;
+		std::string m_Password;
+
+		clParseURL()
+			: m_ErrorCode( LUrlParserError_Uninitialized )
+		{}
+
+		/// return 'true' if the parsing was successful
+		bool IsValid() const { return m_ErrorCode == LUrlParserError_Ok; }
+
+		/// helper to convert the port number to int, return 'true' if the port is valid (within the 0..65535 range)
+		bool GetPort( int* OutPort ) const;
+
+		/// parse the URL
+		static clParseURL ParseURL( const std::string& URL );
+
+	private:
+		explicit clParseURL( LUrlParserError ErrorCode )
+			: m_ErrorCode( ErrorCode )
+		{}
+	};
+
+} // namespace LUrlParser

test/CMakeLists.txt

@@ -8,12 +8,11 @@ project (ixwebsocket_unittest)
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/../third_party/sanitizers-cmake/cmake" ${CMAKE_MODULE_PATH})
 find_package(Sanitizers)
 
-# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
-# set(CMAKE_LD_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
-
 set (CMAKE_CXX_STANDARD 14)
 
 if (NOT WIN32)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
+  set(CMAKE_LD_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=thread")
   option(USE_TLS "Add TLS support" ON)
 endif()
 
@@ -33,17 +32,17 @@ set (SOURCES
   IXDNSLookupTest.cpp
   IXSocketTest.cpp
   IXSocketConnectTest.cpp
+  IXWebSocketServerTest.cpp
+  IXWebSocketPingTest.cpp
+  IXWebSocketTestConnectionDisconnection.cpp
+  IXUrlParserTest.cpp
 )
 
 # Some unittest don't work on windows yet
 if (NOT WIN32)
   list(APPEND SOURCES
-    IXWebSocketCloseTest.cpp
-    IXWebSocketServerTest.cpp
-    IXWebSocketPingTest.cpp
     IXWebSocketPingTimeoutTest.cpp
     cmd_websocket_chat.cpp
-    IXWebSocketTestConnectionDisconnection.cpp
   )
 endif()
 

test/IXTest.cpp

@@ -108,7 +108,7 @@ namespace ix
         {
             log("Cannot compute a free port. bind error.");
 
-            ::close(sockfd);
+            Socket::closeSocket(sockfd);
             return getAnyFreePortRandom();
         }
 
@@ -118,12 +118,12 @@ namespace ix
         {
             log("Cannot compute a free port. getsockname error.");
 
-            ::close(sockfd);
+            Socket::closeSocket(sockfd);
             return getAnyFreePortRandom();
         }
 
         int port = ntohs(sa.sin_port);
-        ::close(sockfd);
+        Socket::closeSocket(sockfd);
 
         return port;
     }

test/IXUrlParserTest.cpp

@@ -0,0 +1,108 @@
+/*
+ *  IXSocketTest.cpp
+ *  Author: Korchynskyi Dmytro
+ *  Copyright (c) 2019 Machine Zone. All rights reserved.
+ */
+
+#include <iostream>
+#include <ixwebsocket/IXUrlParser.h>
+
+#include "IXTest.h"
+#include "catch.hpp"
+#include <string.h>
+
+using namespace ix;
+
+namespace ix
+{
+
+TEST_CASE("urlParser", "[urlParser]")
+{
+    SECTION("http://google.com")
+    {
+        std::string url = "http://google.com";
+        std::string protocol, host, path, query;
+        int port;
+        bool res;
+
+        res = UrlParser::parse(url, protocol, host, path, query, port);
+
+        REQUIRE(res);
+        REQUIRE(protocol == "http");
+        REQUIRE(host == "google.com");
+        REQUIRE(path == "/");
+        REQUIRE(query == "");
+        REQUIRE(port == 80); // default port for http
+    }
+
+    SECTION("https://google.com")
+    {
+        std::string url = "https://google.com";
+        std::string protocol, host, path, query;
+        int port;
+        bool res;
+
+        res = UrlParser::parse(url, protocol, host, path, query, port);
+
+        REQUIRE(res);
+        REQUIRE(protocol == "https");
+        REQUIRE(host == "google.com");
+        REQUIRE(path == "/");
+        REQUIRE(query == "");
+        REQUIRE(port == 443); // default port for https
+    }
+
+    SECTION("ws://google.com")
+    {
+        std::string url = "ws://google.com";
+        std::string protocol, host, path, query;
+        int port;
+        bool res;
+
+        res = UrlParser::parse(url, protocol, host, path, query, port);
+
+        REQUIRE(res);
+        REQUIRE(protocol == "ws");
+        REQUIRE(host == "google.com");
+        REQUIRE(path == "/");
+        REQUIRE(query == "");
+        REQUIRE(port == 80); // default port for ws
+    }
+
+    SECTION("wss://google.com/ws?arg=value")
+    {
+        std::string url = "wss://google.com/ws?arg=value&arg2=value2";
+        std::string protocol, host, path, query;
+        int port;
+        bool res;
+
+        res = UrlParser::parse(url, protocol, host, path, query, port);
+
+        REQUIRE(res);
+        REQUIRE(protocol == "wss");
+        REQUIRE(host == "google.com");
+        REQUIRE(path == "/ws?arg=value&arg2=value2");
+        REQUIRE(query == "arg=value&arg2=value2");
+        REQUIRE(port == 443); // default port for wss
+    }
+
+    SECTION("real test")
+    {
+        std::string url = "ws://127.0.0.1:7350/ws?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NTcxNzAwNzIsInVpZCI6ImMwZmZjOGE1LTk4OTktNDAwYi1hNGU5LTJjNWM3NjFmNWQxZiIsInVzbiI6InN2YmhOdlNJSmEifQ.5L8BUbpTA4XAHlSrdwhIVlrlIpRtjExepim7Yh5eEO4&status=true&format=protobuf";
+        std::string protocol, host, path, query;
+        int port;
+        bool res;
+
+        res = UrlParser::parse(url, protocol, host, path, query, port);
+
+        REQUIRE(res);
+        REQUIRE(protocol == "ws");
+        REQUIRE(host == "127.0.0.1");
+        REQUIRE(path == "/ws?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NTcxNzAwNzIsInVpZCI6ImMwZmZjOGE1LTk4OTktNDAwYi1hNGU5LTJjNWM3NjFmNWQxZiIsInVzbiI6InN2YmhOdlNJSmEifQ.5L8BUbpTA4XAHlSrdwhIVlrlIpRtjExepim7Yh5eEO4&status=true&format=protobuf");
+        REQUIRE(query == "token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NTcxNzAwNzIsInVpZCI6ImMwZmZjOGE1LTk4OTktNDAwYi1hNGU5LTJjNWM3NjFmNWQxZiIsInVzbiI6InN2YmhOdlNJSmEifQ.5L8BUbpTA4XAHlSrdwhIVlrlIpRtjExepim7Yh5eEO4&status=true&format=protobuf");
+        REQUIRE(port == 7350);
+    }
+
+}
+
+}

test/IXWebSocketCloseTest.cpp

@@ -1,407 +0,0 @@
-/*
- *  IXWebSocketCloseTest.cpp
- *  Author: Alexandre Konieczny
- *  Copyright (c) 2019 Machine Zone. All rights reserved.
- */
-
-#include <iostream>
-#include <sstream>
-#include <queue>
-#include <ixwebsocket/IXWebSocket.h>
-#include <ixwebsocket/IXWebSocketServer.h>
-
-#include "IXTest.h"
-
-#include "catch.hpp"
-
-using namespace ix;
-
-namespace
-{
-    class WebSocketClient
-    {
-        public:
-            WebSocketClient(int port);
-
-            void subscribe(const std::string& channel);
-            void start();
-            void stop();
-            void stop(uint16_t code, const std::string& reason);
-            bool isReady() const;
-            void sendMessage(const std::string& text);
-
-            uint16_t getCloseCode();
-            const std::string& getCloseReason();
-            bool getCloseRemote();
-
-        private:
-            ix::WebSocket _webSocket;
-            int _port;
-
-            mutable std::mutex _mutexCloseData;
-            uint16_t _closeCode;
-            std::string _closeReason;
-            bool _closeRemote;
-    };
-
-    WebSocketClient::WebSocketClient(int port)
-        : _port(port)
-        , _closeCode(0)
-        , _closeReason(std::string(""))
-        , _closeRemote(false)
-    {
-        ;
-    }
-
-    bool WebSocketClient::isReady() const
-    {
-        return _webSocket.getReadyState() == ix::WebSocket_ReadyState_Open;
-    }
-
-    uint16_t WebSocketClient::getCloseCode()
-    {
-        std::lock_guard<std::mutex> lck(_mutexCloseData);
-        
-        return _closeCode;
-    }
-
-    const std::string& WebSocketClient::getCloseReason()
-    {
-        std::lock_guard<std::mutex> lck(_mutexCloseData);
-
-        return _closeReason;
-    }
-
-    bool WebSocketClient::getCloseRemote()
-    {
-        std::lock_guard<std::mutex> lck(_mutexCloseData);
-        
-        return _closeRemote;
-    }
-
-    void WebSocketClient::stop()
-    {
-        _webSocket.stop();
-    }
-
-    void WebSocketClient::stop(uint16_t code, const std::string& reason)
-    {
-        _webSocket.close(code, reason);
-        _webSocket.stop();
-    }
-
-    void WebSocketClient::start()
-    {
-        std::string url;
-        {
-            std::stringstream ss;
-            ss << "ws://localhost:"
-               << _port
-               << "/";
-
-            url = ss.str();
-        }
-
-        _webSocket.setUrl(url);
-
-        std::stringstream ss;
-        log(std::string("Connecting to url: ") + url);
-
-        _webSocket.setOnMessageCallback(
-            [this](ix::WebSocketMessageType messageType,
-               const std::string& str,
-               size_t wireSize,
-               const ix::WebSocketErrorInfo& error,
-               const ix::WebSocketOpenInfo& openInfo,
-                   const ix::WebSocketCloseInfo& closeInfo)
-            {
-                std::stringstream ss;
-                if (messageType == ix::WebSocket_MessageType_Open)
-                {
-                    log("client connected");
-
-                    _webSocket.disableAutomaticReconnection();
-                }
-                else if (messageType == ix::WebSocket_MessageType_Close)
-                {
-                    log("client disconnected");
-
-                    std::lock_guard<std::mutex> lck(_mutexCloseData);
-                    
-                    _closeCode = closeInfo.code;
-                    _closeReason = std::string(closeInfo.reason);
-                    _closeRemote = closeInfo.remote;
-                    
-                    _webSocket.disableAutomaticReconnection();
-                }
-                else if (messageType == ix::WebSocket_MessageType_Error)
-                {
-                    ss << "Error ! " << error.reason;
-                    log(ss.str());
-
-                    _webSocket.disableAutomaticReconnection();
-                }
-                else if (messageType == ix::WebSocket_MessageType_Pong)
-                {
-                    ss << "Received pong message " << str;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Ping)
-                {
-                    ss << "Received ping message " << str;
-                    log(ss.str());
-                }
-                else if (messageType == ix::WebSocket_MessageType_Message)
-                {
-                    ss << "Received message " << str;
-                    log(ss.str());
-                }
-                else
-                {
-                    ss << "Invalid ix::WebSocketMessageType";
-                    log(ss.str());
-                }
-            });
-
-        _webSocket.start();
-    }
-
-    void WebSocketClient::sendMessage(const std::string& text)
-    {
-        _webSocket.send(text);
-    }
-
-    bool startServer(ix::WebSocketServer& server,
-                     uint16_t& receivedCloseCode,
-                     std::string& receivedCloseReason,
-                     bool& receivedCloseRemote,
-                     std::mutex& mutexWrite)
-    {
-        // A dev/null server
-        server.setOnConnectionCallback(
-            [&server, &receivedCloseCode, &receivedCloseReason, &receivedCloseRemote, &mutexWrite](std::shared_ptr<ix::WebSocket> webSocket,
-                                             std::shared_ptr<ConnectionState> connectionState)
-            {
-                webSocket->setOnMessageCallback(
-                    [webSocket, connectionState, &server, &receivedCloseCode, &receivedCloseReason, &receivedCloseRemote, &mutexWrite](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)
-                        {
-                            Logger() << "New server connection";
-                            Logger() << "id: " << connectionState->getId();
-                            Logger() << "Uri: " << openInfo.uri;
-                            Logger() << "Headers:";
-                            for (auto it : openInfo.headers)
-                            {
-                                Logger() << it.first << ": " << it.second;
-                            }
-                        }
-                        else if (messageType == ix::WebSocket_MessageType_Close)
-                        {
-                            log("Server closed connection");
-
-                            //Logger() << closeInfo.code;
-                            //Logger() << closeInfo.reason;
-                            //Logger() << closeInfo.remote;
-
-                            std::lock_guard<std::mutex> lck(mutexWrite);
-                            
-                            receivedCloseCode = closeInfo.code;
-                            receivedCloseReason = std::string(closeInfo.reason);
-                            receivedCloseRemote = closeInfo.remote;
-                        }
-                    }
-                );
-            }
-        );
-
-        auto res = server.listen();
-        if (!res.first)
-        {
-            log(res.second);
-            return false;
-        }
-
-        server.start();
-        return true;
-    }
-}
-
-TEST_CASE("Websocket_client_close_default", "[close]")
-{
-    SECTION("Make sure that close code and reason was used and sent to server.")
-    {
-        ix::setupWebSocketTrafficTrackerCallback();
-
-        int port = getFreePort();
-        ix::WebSocketServer server(port);
-        
-        uint16_t serverReceivedCloseCode(0);
-        bool serverReceivedCloseRemote(false);
-        std::string serverReceivedCloseReason("");
-        std::mutex mutexWrite;
-
-        REQUIRE(startServer(server, serverReceivedCloseCode, serverReceivedCloseReason, serverReceivedCloseRemote, mutexWrite));
-
-        std::string session = ix::generateSessionId();
-        WebSocketClient webSocketClient(port);
-
-        webSocketClient.start();
-
-        // Wait for all chat instance to be ready
-        while (true)
-        {
-            if (webSocketClient.isReady()) break;
-            ix::msleep(10);
-        }
-
-        REQUIRE(server.getClients().size() == 1);
-
-        ix::msleep(100);
-
-        webSocketClient.stop();
-
-        ix::msleep(200);
-
-        // ensure client close is the same as values given
-        REQUIRE(webSocketClient.getCloseCode() == 1000);
-        REQUIRE(webSocketClient.getCloseReason() == "Normal closure");
-        REQUIRE(webSocketClient.getCloseRemote() == false);
-
-        {
-            std::lock_guard<std::mutex> lck(mutexWrite);
-            
-            // Here we read the code/reason received by the server, and ensure that remote is true
-            REQUIRE(serverReceivedCloseCode == 1000);
-            REQUIRE(serverReceivedCloseReason == "Normal closure");
-            REQUIRE(serverReceivedCloseRemote == true);
-        }
-
-        // Give us 1000ms for the server to notice that clients went away
-        ix::msleep(1000);
-        REQUIRE(server.getClients().size() == 0);
-
-        ix::reportWebSocketTraffic();
-    }
-}
-
-TEST_CASE("Websocket_client_close_params_given", "[close]")
-{
-    SECTION("Make sure that close code and reason was used and sent to server.")
-    {
-        ix::setupWebSocketTrafficTrackerCallback();
-
-        int port = getFreePort();
-        ix::WebSocketServer server(port);
-        
-        uint16_t serverReceivedCloseCode(0);
-        bool serverReceivedCloseRemote(false);
-        std::string serverReceivedCloseReason("");
-        std::mutex mutexWrite;
-
-        REQUIRE(startServer(server, serverReceivedCloseCode, serverReceivedCloseReason, serverReceivedCloseRemote, mutexWrite));
-
-        std::string session = ix::generateSessionId();
-        WebSocketClient webSocketClient(port);
-
-        webSocketClient.start();
-
-        // Wait for all chat instance to be ready
-        while (true)
-        {
-            if (webSocketClient.isReady()) break;
-            ix::msleep(10);
-        }
-
-        REQUIRE(server.getClients().size() == 1);
-
-        ix::msleep(100);
-
-        webSocketClient.stop(4000, "My reason");
-
-        ix::msleep(500);
-
-        // ensure client close is the same as values given
-        REQUIRE(webSocketClient.getCloseCode() == 4000);
-        REQUIRE(webSocketClient.getCloseReason() == "My reason");
-        REQUIRE(webSocketClient.getCloseRemote() == false);
-
-        {
-            std::lock_guard<std::mutex> lck(mutexWrite);
-            
-            // Here we read the code/reason received by the server, and ensure that remote is true
-            REQUIRE(serverReceivedCloseCode == 4000);
-            REQUIRE(serverReceivedCloseReason == "My reason");
-            REQUIRE(serverReceivedCloseRemote == true);
-        }
-
-        // Give us 1000ms for the server to notice that clients went away
-        ix::msleep(1000);
-        REQUIRE(server.getClients().size() == 0);
-
-        ix::reportWebSocketTraffic();
-    }
-}
-
-TEST_CASE("Websocket_server_close", "[close]")
-{
-    SECTION("Make sure that close code and reason was read from server.")
-    {
-        ix::setupWebSocketTrafficTrackerCallback();
-
-        int port = getFreePort();
-        ix::WebSocketServer server(port);
-        
-        uint16_t serverReceivedCloseCode(0);
-        bool serverReceivedCloseRemote(false);
-        std::string serverReceivedCloseReason("");
-        std::mutex mutexWrite;
-
-        REQUIRE(startServer(server, serverReceivedCloseCode, serverReceivedCloseReason, serverReceivedCloseRemote, mutexWrite));
-
-        std::string session = ix::generateSessionId();
-        WebSocketClient webSocketClient(port);
-
-        webSocketClient.start();
-
-        // Wait for all chat instance to be ready
-        while (true)
-        {
-            if (webSocketClient.isReady()) break;
-            ix::msleep(10);
-        }
-
-        REQUIRE(server.getClients().size() == 1);
-
-        ix::msleep(200);
-
-        server.stop();
-
-        ix::msleep(500);
-
-        // ensure client close is the same as values given
-        REQUIRE(webSocketClient.getCloseCode() == 1000);
-        REQUIRE(webSocketClient.getCloseReason() == "Normal closure");
-        REQUIRE(webSocketClient.getCloseRemote() == true);
-
-        {
-            std::lock_guard<std::mutex> lck(mutexWrite);
-            
-            // Here we read the code/reason received by the server, and ensure that remote is true
-            REQUIRE(serverReceivedCloseCode == 1000);
-            REQUIRE(serverReceivedCloseReason == "Normal closure");
-            REQUIRE(serverReceivedCloseRemote == false);
-        }
-
-        // Give us 1000ms for the server to notice that clients went away
-        ix::msleep(1000);
-        REQUIRE(server.getClients().size() == 0);
-
-        ix::reportWebSocketTraffic();
-    }
-}

test/IXWebSocketPingTest.cpp

@@ -23,7 +23,6 @@ namespace
         public:
             WebSocketClient(int port, bool useHeartBeatMethod);
 
-            void subscribe(const std::string& channel);
             void start();
             void stop();
             bool isReady() const;
@@ -57,7 +56,7 @@ namespace
         std::string url;
         {
             std::stringstream ss;
-            ss << "ws://localhost:"
+            ss << "ws://127.0.0.1:"
                << _port
                << "/";
 
@@ -347,6 +346,9 @@ TEST_CASE("Websocket_ping_data_sent_setPingInterval", "[setPingInterval]")
 
         webSocketClient.stop();
 
+        // without this sleep test fails on Windows
+        ix::msleep(100);
+
         // Here we test ping interval
         // client has sent data, but ping should have been sent no matter what
         // -> expected ping messages == 3 as 900+900+1300 = 3100 seconds, 1 ping sent every second

test/IXWebSocketPingTimeoutTest.cpp

@@ -23,7 +23,6 @@ namespace
         public:
             WebSocketClient(int port, int pingInterval, int pingTimeout);
 
-            void subscribe(const std::string& channel);
             void start();
             void stop();
             bool isReady() const;
@@ -71,7 +70,7 @@ namespace
         std::string url;
         {
             std::stringstream ss;
-            ss << "ws://localhost:"
+            ss << "ws://127.0.0.1:"
                << _port
                << "/";
 

test/IXWebSocketServerTest.cpp

@@ -107,7 +107,7 @@ TEST_CASE("Websocket_server", "[websocket_server]")
         std::string errMsg;
         bool tls = false;
         std::shared_ptr<Socket> socket = createSocket(tls, errMsg);
-        std::string host("localhost");
+        std::string host("127.0.0.1");
         auto isCancellationRequested = []() -> bool
         {
             return false;
@@ -141,7 +141,7 @@ TEST_CASE("Websocket_server", "[websocket_server]")
         std::string errMsg;
         bool tls = false;
         std::shared_ptr<Socket> socket = createSocket(tls, errMsg);
-        std::string host("localhost");
+        std::string host("127.0.0.1");
         auto isCancellationRequested = []() -> bool
         {
             return false;
@@ -178,7 +178,7 @@ TEST_CASE("Websocket_server", "[websocket_server]")
         std::string errMsg;
         bool tls = false;
         std::shared_ptr<Socket> socket = createSocket(tls, errMsg);
-        std::string host("localhost");
+        std::string host("127.0.0.1");
         auto isCancellationRequested = []() -> bool
         {
             return false;

test/cmd_websocket_chat.cpp

@@ -100,7 +100,7 @@ namespace
         std::string url;
         {
             std::stringstream ss;
-            ss << "ws://localhost:"
+            ss << "ws://127.0.0.1:"
                << _port
                << "/"
                << _user;

test/run.py

@@ -251,8 +251,8 @@ def executeJob(job):
     sys.stderr.write('.')
     # print('Executing ' + job['cmd'] + '...')
 
-    # 10 minutes of timeout for a single test, cf PR #42
+    # 2 minutes of timeout for a single test
-    timeout = 10 * 60
+    timeout = 2 * 60
     command = Command(job['cmd'])
     timedout, ret = command.run(timeout)
 

ws/ws.cpp

@@ -58,6 +58,7 @@ int main(int argc, char** argv)
     bool compress = false;
     bool strict = false;
     bool stress = false;
+    bool disableAutomaticReconnection = false;
     int port = 8080;
     int redisPort = 6379;
     int statsdPort = 8125;
@@ -87,6 +88,7 @@ int main(int argc, char** argv)
 
     CLI::App* connectApp = app.add_subcommand("connect", "Connect to a remote server");
     connectApp->add_option("url", url, "Connection url")->required();
+    connectApp->add_flag("-d", disableAutomaticReconnection, "Disable Automatic Reconnection");
 
     CLI::App* chatApp = app.add_subcommand("chat", "Group chat");
     chatApp->add_option("url", url, "Connection url")->required();
@@ -218,7 +220,7 @@ int main(int argc, char** argv)
     }
     else if (app.got_subcommand("connect"))
     {
-        ret = ix::ws_connect_main(url);
+        ret = ix::ws_connect_main(url, disableAutomaticReconnection);
     }
     else if (app.got_subcommand("chat"))
     {

ws/ws.h

@@ -31,7 +31,7 @@ namespace ix
     int ws_chat_main(const std::string& url,
                      const std::string& user);
 
-    int ws_connect_main(const std::string& url);
+    int ws_connect_main(const std::string& url, bool disableAutomaticReconnection);
 
     int ws_receive_main(const std::string& url,
                         bool enablePerMessageDeflate,

ws/ws_connect.cpp

@@ -14,7 +14,8 @@ namespace ix
     class WebSocketConnect
     {
         public:
-            WebSocketConnect(const std::string& _url);
+            WebSocketConnect(const std::string& _url,
+                             bool disableAutomaticReconnection);
 
             void subscribe(const std::string& channel);
             void start();
@@ -29,10 +30,17 @@ namespace ix
             void log(const std::string& msg);
     };
 
-    WebSocketConnect::WebSocketConnect(const std::string& url) :
+    WebSocketConnect::WebSocketConnect(const std::string& url,
+                                       bool disableAutomaticReconnection) :
         _url(url)
     {
-        ;
+        if (disableAutomaticReconnection)
+        {
+            std::cout << "Disabling automatic reconnection with "
+                         "_webSocket.disableAutomaticReconnection()"
+                         " not supported yet" << std::endl;
+            _webSocket.disableAutomaticReconnection();
+        }
     }
 
     void WebSocketConnect::log(const std::string& msg)
@@ -113,10 +121,10 @@ namespace ix
         _webSocket.send(text);
     }
 
-    void interactiveMain(const std::string& url)
+    int ws_connect_main(const std::string& url, bool disableAutomaticReconnection)
     {
         std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
-        WebSocketConnect webSocketChat(url);
+        WebSocketConnect webSocketChat(url, disableAutomaticReconnection);
         webSocketChat.start();
 
         while (true)
@@ -149,11 +157,7 @@ namespace ix
 
         std::cout << std::endl;
         webSocketChat.stop();
-    }
 
-    int ws_connect_main(const std::string& url)
-    {
-        interactiveMain(url);
         return 0;
     }
 }