- travis CI uses g++ on Linux

- WebSocketMessage sets a new binary field, which tells whether the received incoming message is binary or text

.travis.yml

@@ -12,23 +12,23 @@ matrix:
         - python test/run.py
         - make ws
 
-    # # Linux
+    # Linux
-    # - os: linux
-    #   dist: xenial
-    #   script: 
-    #     - python test/run.py
-    #     - make ws
-    #   env:
-    #     - CC=gcc
-    #     - CXX=g++
-
-    # Clang + Linux disabled for now
     - os: linux
       dist: xenial
-      script: python test/run.py
+      script: 
+        - python test/run.py
+        - make ws
       env:
-        - CC=clang 
+        - CC=gcc
-        - CXX=clang++
+        - CXX=g++
+
+    # Clang + Linux disabled for now
+    # - os: linux
+    #   dist: xenial
+    #   script: python test/run.py
+    #   env:
+    #     - CC=clang 
+    #     - CXX=clang++
 
     # Windows
     - os: windows

CHANGELOG.md

@@ -1,11 +1,17 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
-## [Unreleased] - 2019-06-xx
+## [unreleased] - 2019-06-09
 ### Changed
+- travis CI uses g++ on Linux
+
+## [4.0.0] - 2019-06-09
+### Changed
+- WebSocket::send() sends message in TEXT mode by default
+- WebSocketMessage sets a new binary field, which tells whether the received incoming message is binary or text
 - WebSocket::send takes a third arg, binary which default to true (can be text too)
 - WebSocket callback only take one object, a const ix::WebSocketMessagePtr& msg
-- Add explicite WebSocket::sendBinary
+- Add explicit WebSocket::sendBinary method
 - New headers + WebSocketMessage class to hold message data, still not used across the board
 - Add test/compatibility folder with small servers and clients written in different languages and different libraries to test compatibility.
 - ws echo_server has a -g option to print a greeting message on connect

DOCKER_VERSION

@@ -1 +1 @@
-3.1.2
+4.0.0

README.md

@@ -33,27 +33,22 @@ webSocket.disablePerMessageDeflate();
 
 // Setup a callback to be fired when a message or an event (open, close, error) is received
 webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType,
+    [](const ix::WebSocketMessagePtr& msg)
-       const std::string& str,
-       size_t wireSize,
-       const ix::WebSocketErrorInfo& error,
-       const ix::WebSocketOpenInfo& openInfo,
-       const ix::WebSocketCloseInfo& closeInfo)
     {
-        if (messageType == ix::WebSocketMessageType::Message)
+        if (msg->type == ix::WebSocketMessageType::Message)
         {
-            std::cout << str << std::endl;
+            std::cout << msg->str << std::endl;
         }
 });
 
 // Now that our callback is setup, we can start our background thread and receive messages
 webSocket.start();
 
-// Send a message to the server (default to BINARY mode)
+// Send a message to the server (default to TEXT mode)
 webSocket.send("hello world");
 
-// The message can be sent in TEXT mode
+// The message can be sent in BINARY mode (useful if you send MsgPack data for example)
-webSocket.sendText("hello again");
+webSocket.sendBinary("some serialized binary data");
 
 // ... finally ...
 
@@ -73,14 +68,9 @@ server.setOnConnectionCallback(
               std::shared_ptr<ConnectionState> connectionState)
     {
         webSocket->setOnMessageCallback(
-            [webSocket, connectionState, &server](ix::WebSocketMessageType messageType,
+            [webSocket, connectionState, &server](const ix::WebSocketMessagePtr msg)
-               const std::string& str,
-               size_t wireSize,
-               const ix::WebSocketErrorInfo& error,
-               const ix::WebSocketOpenInfo& openInfo,
-               const ix::WebSocketCloseInfo& closeInfo)
             {
-                if (messageType == ix::WebSocketMessageType::Open)
+                if (msg->type == ix::WebSocketMessageType::Open)
                 {
                     std::cerr << "New connection" << std::endl;
 
@@ -91,19 +81,21 @@ server.setOnConnectionCallback(
                     std::cerr << "id: " << connectionState->getId() << std::endl;
 
                     // The uri the client did connect to.
-                    std::cerr << "Uri: " << openInfo.uri << std::endl;
+                    std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
 
                     std::cerr << "Headers:" << std::endl;
-                    for (auto it : openInfo.headers)
+                    for (auto it : msg->openInfo.headers)
                     {
                         std::cerr << it.first << ": " << it.second << std::endl;
                     }
                 }
-                else if (messageType == ix::WebSocketMessageType::Message)
+                else if (msg->type == ix::WebSocketMessageType::Message)
                 {
                     // For an echo server, we just send back to the client whatever was received by the server
                     // All connected clients are available in an std::set. See the broadcast cpp example.
-                    webSocket->send(str);
+                    // Second parameter tells whether we are sending the message in binary or text mode.
+                    // Here we send it in the same mode as it was received.
+                    webSocket->send(msg->str, msg->binary);
                 }
             }
         );
@@ -334,32 +326,27 @@ The onMessage event will be fired when the connection is opened or closed. This
 
 ```
 webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType,
+    [](const ix::WebSocketMessagePtr& msg)
-       const std::string& str,
-       size_t wireSize,
-       const ix::WebSocketErrorInfo& error,
-       const ix::WebSocketOpenInfo& openInfo,
-       const ix::WebSocketCloseInfo& closeInfo)
     {
-        if (messageType == ix::WebSocketMessageType::Open)
+        if (msg->type == ix::WebSocketMessageType::Open)
         {
             std::cout << "send greetings" << std::endl;
 
             // Headers can be inspected (pairs of string/string)
             std::cout << "Handshake Headers:" << std::endl;
-            for (auto it : headers)
+            for (auto it : msg->headers)
             {
                 std::cout << it.first << ": " << it.second << std::endl;
             }
         }
-        else if (messageType == ix::WebSocketMessageType::Close)
+        else if (msg->type == ix::WebSocketMessageType::Close)
         {
             std::cout << "disconnected" << std::endl;
 
             // The server can send an explicit code and reason for closing.
             // This data can be accessed through the closeInfo object.
-            std::cout << closeInfo.code << std::endl;
+            std::cout << msg->closeInfo.code << std::endl;
-            std::cout << closeInfo.reason << std::endl;
+            std::cout << msg->closeInfo.reason << std::endl;
         }
     }
 );
@@ -371,20 +358,15 @@ A message will be fired when there is an error with the connection. The message
 
 ```
 webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType,
+    [](const ix::WebSocketMessagePtr& msg)
-       const std::string& str,
-       size_t wireSize,
-       const ix::WebSocketErrorInfo& error,
-       const ix::WebSocketOpenInfo& openInfo,
-       const ix::WebSocketCloseInfo& closeInfo)
     {
-        if (messageType == ix::WebSocketMessageType::Error)
+        if (msg->type == ix::WebSocketMessageType::Error)
         {
             std::stringstream ss;
-            ss << "Error: "         << error.reason      << std::endl;
+            ss << "Error: "         << msg->errorInfo.reason      << std::endl;
-            ss << "#retries: "      << event.retries     << std::endl;
+            ss << "#retries: "      << msg->eventInfo.retries     << std::endl;
-            ss << "Wait time(ms): " << event.wait_time   << std::endl;
+            ss << "Wait time(ms): " << msg->eventInfo.wait_time   << std::endl;
-            ss << "HTTP Status: "   << event.http_status << std::endl;
+            ss << "HTTP Status: "   << msg->eventInfo.http_status << std::endl;
             std::cout << ss.str() << std::endl;
         }
     }
@@ -411,17 +393,12 @@ Ping/pong messages are used to implement keep-alive. 2 message types exists to i
 
 ```
 webSocket.setOnMessageCallback(
-    [](ix::WebSocketMessageType messageType,
+    [](const ix::WebSocketMessagePtr& msg)
-       const std::string& str,
-       size_t wireSize,
-       const ix::WebSocketErrorInfo& error,
-       const ix::WebSocketOpenInfo& openInfo,
-       const ix::WebSocketCloseInfo& closeInfo)
     {
-        if (messageType == ix::WebSocketMessageType::Ping ||
+        if (msg->type == ix::WebSocketMessageType::Ping ||
-            messageType == ix::WebSocketMessageType::Pong)
+            msg->type == ix::WebSocketMessageType::Pong)
         {
-            std::cout << "pong data: " << str << std::endl;
+            std::cout << "pong data: " << msg->str << std::endl;
         }
     }
 );

ixwebsocket/IXWebSocket.cpp

@@ -325,8 +325,8 @@ namespace ix
                     WebSocketMessageType webSocketMessageType;
                     switch (messageKind)
                     {
-                        default:
+                        case WebSocketTransport::MessageKind::MSG_TEXT:
-                        case WebSocketTransport::MessageKind::MSG:
+                        case WebSocketTransport::MessageKind::MSG_BINARY:
                         {
                             webSocketMessageType = WebSocketMessageType::Message;
                         } break;
@@ -350,11 +350,13 @@ namespace ix
                     WebSocketErrorInfo webSocketErrorInfo;
                     webSocketErrorInfo.decompressionError = decompressionError;
 
+                    bool binary = messageKind == WebSocketTransport::MessageKind::MSG_BINARY;
+
                     _onMessageCallback(
                          std::make_shared<WebSocketMessage>(
                             webSocketMessageType, msg, wireSize,
                             webSocketErrorInfo, WebSocketOpenInfo(),
-                            WebSocketCloseInfo()));
+                            WebSocketCloseInfo(), binary));
 
                     WebSocket::invokeTrafficTrackerCallback(msg.size(), true);
                 });
@@ -385,8 +387,8 @@ namespace ix
     }
 
     WebSocketSendInfo WebSocket::send(const std::string& data,
-                                      const OnProgressCallback& onProgressCallback,
+                                      bool binary,
-                                      bool binary)
+                                      const OnProgressCallback& onProgressCallback)
     {
         return sendMessage(data,
                            (binary) ? SendMessageKind::Binary: SendMessageKind::Text,

ixwebsocket/IXWebSocket.h

@@ -66,8 +66,8 @@ namespace ix
 
         // send is in binary mode by default
         WebSocketSendInfo send(const std::string& data,
-                               const OnProgressCallback& onProgressCallback = nullptr,
+                               bool binary = false,
-                               bool binary = true);
+                               const OnProgressCallback& onProgressCallback = nullptr);
         WebSocketSendInfo sendBinary(const std::string& text,
                                      const OnProgressCallback& onProgressCallback = nullptr);
         WebSocketSendInfo sendText(const std::string& text,

ixwebsocket/IXWebSocketMessage.h

@@ -31,13 +31,15 @@ namespace ix
                          size_t w,
                          WebSocketErrorInfo e,
                          WebSocketOpenInfo o,
-                         WebSocketCloseInfo c)
+                         WebSocketCloseInfo c,
+                         bool b = false)
             : type(t)
             , str(std::move(s))
             , wireSize(w)
             , errorInfo(e)
             , openInfo(o)
             , closeInfo(c)
+            , binary(b)
         {
             ;
         }

ixwebsocket/IXWebSocketTransport.cpp

@@ -542,12 +542,17 @@ namespace ix
             ) {
                 unmaskReceiveBuffer(ws);
 
+                MessageKind messageKind = 
+                    (ws.opcode == wsheader_type::TEXT_FRAME)
+                    ? MessageKind::MSG_TEXT
+                    : MessageKind::MSG_BINARY;
+
                 //
                 // Usual case. Small unfragmented messages
                 //
                 if (ws.fin && _chunks.empty())
                 {
-                    emitMessage(MessageKind::MSG,
+                    emitMessage(messageKind,
                                 std::string(_rxbuf.begin()+ws.header_size,
                                             _rxbuf.begin()+ws.header_size+(size_t) ws.N),
                                 ws,
@@ -567,7 +572,7 @@ namespace ix
                                              _rxbuf.begin()+ws.header_size+(size_t)ws.N));
                     if (ws.fin)
                     {
-                        emitMessage(MessageKind::MSG, getMergedChunks(), ws, onMessageCallback);
+                        emitMessage(messageKind, getMergedChunks(), ws, onMessageCallback);
                         _chunks.clear();
                     }
                     else

ixwebsocket/IXWebSocketTransport.h

@@ -50,7 +50,8 @@ namespace ix
 
         enum class MessageKind
         {
-            MSG,
+            MSG_TEXT,
+            MSG_BINARY,
             PING,
             PONG,
             FRAGMENT

test/IXTest.cpp

@@ -200,7 +200,7 @@ namespace ix
                             {
                                 if (client != webSocket)
                                 {
-                                    client->send(msg->str);
+                                    client->send(msg->str, msg->binary);
                                 }
                             }
                         }

test/IXWebSocketMessageQTest.cpp

@@ -30,7 +30,7 @@ namespace
                     Logger() << "New connection";
                     connectionState->computeId();
                     Logger() << "id: " << connectionState->getId();
-                    Logger() << "Uri: " << openInfo.uri;
+                    Logger() << "Uri: " << msg->openInfo.uri;
                     Logger() << "Headers:";
                     for (auto&& it : msg->openInfo.headers)
                     {
@@ -43,11 +43,11 @@ namespace
                 }
                 else if (msg->type == ix::WebSocketMessageType::Message)
                 {
-                    Logger() << "Message received: " << str;
+                    Logger() << "Message received: " << msg->str;
 
                     for (auto&& client : server.getClients())
                     {
-                        client->send(str);
+                        client->send(msg->str);
                     }
                 }
             }
@@ -89,25 +89,25 @@ namespace
                 }
                 else if (msg->type == WebSocketMessageType::Error)
                 {
-                    ss << "Error ! " << error.reason;
+                    ss << "Error ! " << msg->errorInfo.reason;
                     log(ss.str());
                     testDone = true;
                 }
                 else if (msg->type == WebSocketMessageType::Pong)
                 {
-                    ss << "Received pong message " << str;
+                    ss << "Received pong message " << msg->str;
                     log(ss.str());
                 }
                 else if (msg->type == WebSocketMessageType::Ping)
                 {
-                    ss << "Received ping message " << str;
+                    ss << "Received ping message " << msg->str;
                     log(ss.str());
                 }
                 else if (msg->type == WebSocketMessageType::Message)
                 {
-                    REQUIRE(str.compare("Hey dude!") == 0);
+                    REQUIRE(msg->str.compare("Hey dude!") == 0);
                     ++receivedCount;
-                    ss << "Received message " << str;
+                    ss << "Received message " << msg->str;
                     log(ss.str());
                     sendNextMessage();
                 }

ws/ws_broadcast_server.cpp

@@ -62,6 +62,7 @@ namespace ix
                                 if (client != webSocket)
                                 {
                                     client->send(msg->str,
+                                                 msg->binary,
                                                  [](int current, int total) -> bool
                                     {
                                         std::cerr << "Step " << current

ws/ws_echo_server.cpp

@@ -59,7 +59,7 @@ namespace ix
                             std::cerr << "Received "
                                       << msg->wireSize << " bytes"
                                       << std::endl;
-                            webSocket->send(msg->str);
+                            webSocket->send(msg->str, msg->binary);
                         }
                     }
                 );

ws/ws_transfer.cpp

@@ -62,6 +62,7 @@ namespace ix
                                 if (client != webSocket)
                                 {
                                     client->send(msg->str,
+                                                 msg->binary,
                                                  [](int current, int total) -> bool
                                     {
                                         std::cerr << "ws_transfer: Step " << current