(ssl) wip code to handle certs on apple

docs/CHANGELOG.md

@@ -1,20 +1,13 @@
 # Changelog
 All changes to this project will be documented in this file.
 
-## [7.7.0] - 2019-12-24
-
-(ws client) all commands use spdlog instead of std::cerr or std::cout for logging
-
-## [7.6.5] - 2019-12-24
-
-(cobra client) send a websocket ping every 30s to keep the connection opened
-
 ## [7.6.4] - 2019-12-22
 
 (client) error handling, quote url in error case when failing to parse one
 (ws) ws_cobra_publish: register callbacks before connecting
 (doc) mention mbedtls in supported ssl server backend
 
+
 ## [7.6.3] - 2019-12-20
 
 (tls) add a simple description of the TLS configuration routine for debugging

ixcobra/ixcobra/IXCobraConnection.cpp

@@ -24,7 +24,6 @@ namespace ix
     PublishTrackerCallback CobraConnection::_publishTrackerCallback = nullptr;
     constexpr size_t CobraConnection::kQueueMaxSize;
     constexpr CobraConnection::MsgId CobraConnection::kInvalidMsgId;
-    constexpr int CobraConnection::kPingIntervalSecs;
 
     CobraConnection::CobraConnection() :
         _webSocket(new WebSocket()),
@@ -229,10 +228,6 @@ namespace ix
                     ss << "HTTP Status: "      << msg->errorInfo.http_status << std::endl;
                     invokeErrorCallback(ss.str(), std::string());
                 }
-                else if (msg->type == ix::WebSocketMessageType::Pong)
-                {
-                    invokeEventCallback(ix::CobraConnection_EventType_Pong);
-                }
         });
     }
 
@@ -265,7 +260,6 @@ namespace ix
         _webSocket->setUrl(url);
         _webSocket->setPerMessageDeflateOptions(webSocketPerMessageDeflateOptions);
         _webSocket->setTLSOptions(socketTLSOptions);
-        _webSocket->setPingInterval(kPingIntervalSecs);
     }
 
     //

ixcobra/ixcobra/IXCobraConnection.h

@@ -30,8 +30,7 @@ namespace ix
         CobraConnection_EventType_Closed = 3,
         CobraConnection_EventType_Subscribed = 4,
         CobraConnection_EventType_UnSubscribed = 5,
-        CobraConnection_EventType_Published = 6,
-        CobraConnection_EventType_Pong = 7
+        CobraConnection_EventType_Published = 6
     };
 
     enum CobraConnectionPublishMode
@@ -216,9 +215,6 @@ namespace ix
 
         // Each pdu sent should have an incremental unique id
         std::atomic<uint64_t> _id;
-
-        // Frequency at which we send a websocket ping to the backing cobra connection
-        static constexpr int kPingIntervalSecs = 30;
     };
 
 } // namespace ix

ixcobra/ixcobra/IXCobraMetricsThreadedPublisher.cpp

@@ -65,10 +65,6 @@ namespace ix
                 {
                     ss << "Published message " << msgId << " acked";
                 }
-                else if (eventType == ix::CobraConnection_EventType_Pong)
-                {
-                    ss << "Received websocket pong";
-                }
 
                 ix::IXCoreLogger::Log(ss.str().c_str());
         });

ixwebsocket/IXHttpServer.cpp

@@ -10,6 +10,7 @@
 #include "IXSocketConnect.h"
 #include "IXUserAgent.h"
 #include <fstream>
+#include <iostream>
 #include <sstream>
 #include <vector>
 

ixwebsocket/IXSocketAppleSSL.cpp

@@ -24,47 +24,9 @@
 
 #include <Security/SecureTransport.h>
 
-namespace ix
+namespace
 {
-    SocketAppleSSL::SocketAppleSSL(const SocketTLSOptions& tlsOptions, int fd)
-        : Socket(fd)
-        , _sslContext(nullptr)
-        , _tlsOptions(tlsOptions)
-    {
-        ;
-    }
-
-    SocketAppleSSL::~SocketAppleSSL()
-    {
-        SocketAppleSSL::close();
-    }
-
-    std::string SocketAppleSSL::getSSLErrorDescription(OSStatus status)
-    {
-        std::string errMsg("Unknown SSL error.");
-
-        CFErrorRef error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainOSStatus, status, NULL);
-        if (error)
-        {
-            CFStringRef message = CFErrorCopyDescription(error);
-            if (message)
-            {
-                char localBuffer[128];
-                Boolean success;
-                success = CFStringGetCString(message, localBuffer, 128, kCFStringEncodingUTF8);
-                if (success)
-                {
-                    errMsg = localBuffer;
-                }
-                CFRelease(message);
-            }
-            CFRelease(error);
-        }
-
-        return errMsg;
-    }
-
-    OSStatus SocketAppleSSL::readFromSocket(SSLConnectionRef connection, void* data, size_t* len)
+    OSStatus read_from_socket(SSLConnectionRef connection, void* data, size_t* len)
     {
         int fd = (int) (long) connection;
         if (fd < 0) return errSSLInternal;
@@ -105,7 +67,7 @@ namespace ix
         }
     }
 
-    OSStatus SocketAppleSSL::writeToSocket(SSLConnectionRef connection, const void* data, size_t* len)
+    OSStatus write_to_socket(SSLConnectionRef connection, const void* data, size_t* len)
     {
         int fd = (int) (long) connection;
         if (fd < 0) return errSSLInternal;
@@ -143,6 +105,145 @@ namespace ix
         }
     }
 
+    std::string getSSLErrorDescription(OSStatus status)
+    {
+        std::string errMsg("Unknown SSL error.");
+
+        CFErrorRef error = CFErrorCreate(kCFAllocatorDefault, kCFErrorDomainOSStatus, status, NULL);
+        if (error)
+        {
+            CFStringRef message = CFErrorCopyDescription(error);
+            if (message)
+            {
+                char localBuffer[128];
+                Boolean success;
+                success = CFStringGetCString(message, localBuffer, 128, kCFStringEncodingUTF8);
+                if (success)
+                {
+                    errMsg = localBuffer;
+                }
+                CFRelease(message);
+            }
+            CFRelease(error);
+        }
+
+        return errMsg;
+    }
+
+#undef CURL_BUILD_IOS
+    OSStatus CopyIdentityFromPKCS12File(
+        const char *cPath,
+        const char *cPassword,
+        SecIdentityRef *out_cert_and_key)
+    {
+        OSStatus status = errSecItemNotFound;
+        CFURLRef pkcs_url = CFURLCreateFromFileSystemRepresentation(
+            NULL, (const UInt8 *)cPath, strlen(cPath), false);
+        CFStringRef password = cPassword ? CFStringCreateWithCString(NULL,
+            cPassword, kCFStringEncodingUTF8) : NULL;
+        CFDataRef pkcs_data = NULL;
+
+        /* We can import P12 files on iOS or OS X 10.7 or later: */
+        /* These constants are documented as having first appeared in 10.6 but they
+           raise linker errors when used on that cat for some reason. */
+        if (CFURLCreateDataAndPropertiesFromResource(
+            NULL, pkcs_url, &pkcs_data, NULL, NULL, &status)) {
+            CFArrayRef items = NULL;
+
+            /* On iOS SecPKCS12Import will never add the client certificate to the
+             * Keychain.
+             *
+             * It gives us back a SecIdentityRef that we can use directly. */
+#if CURL_BUILD_IOS
+            const void *cKeys[] = {kSecImportExportPassphrase};
+            const void *cValues[] = {password};
+            CFDictionaryRef options = CFDictionaryCreate(NULL, cKeys, cValues,
+                    password ? 1L : 0L, NULL, NULL);
+
+            if (options != NULL) {
+                status = SecPKCS12Import(pkcs_data, options, &items);
+                CFRelease(options);
+            }
+
+            /* On macOS SecPKCS12Import will always add the client certificate to
+             * the Keychain.
+             *
+             * As this doesn't match iOS, and apps may not want to see their client
+             * certificate saved in the the user's keychain, we use SecItemImport
+             * with a NULL keychain to avoid importing it.
+             *
+             * This returns a SecCertificateRef from which we can construct a
+             * SecIdentityRef.
+             */
+#else
+            SecItemImportExportKeyParameters keyParams;
+            SecExternalFormat inputFormat = kSecFormatPKCS12;
+            SecExternalItemType inputType = kSecItemTypeCertificate;
+
+            memset(&keyParams, 0x00, sizeof(keyParams));
+            keyParams.version    = SEC_KEY_IMPORT_EXPORT_PARAMS_VERSION;
+            keyParams.passphrase = password;
+
+            status = SecItemImport(pkcs_data, NULL, &inputFormat, &inputType,
+                                   0, &keyParams, NULL, &items);
+#endif
+
+            /* Extract the SecIdentityRef */
+            if (status == errSecSuccess && items && CFArrayGetCount(items))
+            {
+                CFIndex i, count;
+                count = CFArrayGetCount(items);
+
+                for (i = 0; i < count; i++)
+                {
+                    CFTypeRef item = (CFTypeRef) CFArrayGetValueAtIndex(items, i);
+                    CFTypeID  itemID = CFGetTypeID(item);
+
+                    if (itemID == CFDictionaryGetTypeID())
+                    {
+                        CFTypeRef identity = (CFTypeRef) CFDictionaryGetValue(
+                                (CFDictionaryRef) item,
+                                kSecImportItemIdentity);
+                        CFRetain(identity);
+                        *out_cert_and_key = (SecIdentityRef) identity;
+                        break;
+                    }
+                    else if (itemID == SecCertificateGetTypeID())
+                    {
+                        status = SecIdentityCreateWithCertificate(NULL,
+                                (SecCertificateRef) item,
+                                out_cert_and_key);
+                        break;
+                    }
+                }
+            }
+
+            if (items) CFRelease(items);
+            CFRelease(pkcs_data);
+        }
+
+        if (password) CFRelease(password);
+        CFRelease(pkcs_url);
+        return status;
+    }
+
+
+} // anonymous namespace
+
+namespace ix
+{
+    SocketAppleSSL::SocketAppleSSL(const SocketTLSOptions& tlsOptions, int fd)
+        : Socket(fd)
+        , _sslContext(nullptr)
+        , _tlsOptions(tlsOptions)
+    {
+        ;
+    }
+
+    SocketAppleSSL::~SocketAppleSSL()
+    {
+        SocketAppleSSL::close();
+    }
 
     bool SocketAppleSSL::accept(std::string& errMsg)
     {
@@ -150,6 +251,63 @@ namespace ix
         return false;
     }
 
+    bool SocketAppleSSL::handleTLSOptions(std::string& errMsg)
+    {
+        SecIdentityRef cert_and_key = NULL;
+
+        const char* ssl_cert = _tlsOptions.certFile.c_str();
+
+        OSStatus err = CopyIdentityFromPKCS12File(ssl_cert, "foobar", &cert_and_key);
+
+        if (err == noErr && cert_and_key)
+        {
+            SecCertificateRef cert = NULL;
+            CFTypeRef certs_c[1];
+            CFArrayRef certs;
+
+            err = SecIdentityCopyCertificate(cert_and_key, &cert);
+
+            certs_c[0] = cert_and_key;
+            certs = CFArrayCreate(NULL, (const void **)certs_c, 1L,
+                    &kCFTypeArrayCallBacks);
+            err = SSLSetCertificate(_sslContext, certs);
+            if (err != noErr)
+            {
+                errMsg = "SSLSetCertificate failed";
+                return false;
+            }
+        }
+        else
+        {
+            switch(err) {
+                case errSecAuthFailed: case -25264: /* errSecPkcs12VerifyFailure */
+                    errMsg = "SSL: Incorrect password for the certificate \"%s\" "
+                            "and its private key."; // , ssl_cert);
+                    break;
+                case -26275: /* errSecDecode */ case -25257: /* errSecUnknownFormat */
+                    errMsg = "SSL: Couldn't make sense of the data in the "
+                            "certificate \"%s\" and its private key.";
+                            ; // ssl_cert);
+                    break;
+                case -25260: /* errSecPassphraseRequired */
+                    errMsg = "SSL The certificate \"%s\" requires a password.";
+                            // ssl_cert);
+                    break;
+                case errSecItemNotFound:
+                    errMsg = "SSL: Can't find the certificate \"%s\" and its private "
+                            "key in the Keychain."; // , ssl_cert);
+                    break;
+                default:
+                    errMsg = "SSL: Can't load the certificate \"%s\" and its private "
+                            "key: OSStatus %d" ; // , ssl_cert, err);
+                    break;
+            }
+            return false;
+        }
+
+        return true;
+    }
+
     // No wait support
     bool SocketAppleSSL::connect(const std::string& host,
                                  int port,
@@ -165,11 +323,13 @@ namespace ix
 
             _sslContext = SSLCreateContext(kCFAllocatorDefault, kSSLClientSide, kSSLStreamType);
 
-            SSLSetIOFuncs(_sslContext, SocketAppleSSL::readFromSocket, SocketAppleSSL::writeToSocket);
+            SSLSetIOFuncs(_sslContext, read_from_socket, write_to_socket);
             SSLSetConnection(_sslContext, (SSLConnectionRef)(long) _sockfd);
             SSLSetProtocolVersionMin(_sslContext, kTLSProtocol12);
             SSLSetPeerDomainName(_sslContext, host.c_str(), host.size());
 
+            if (!handleTLSOptions(errMsg)) return false; // FIXME not calling close()
+
             if (_tlsOptions.isPeerVerifyDisabled())
             {
                 Boolean option(1);

ixwebsocket/IXSocketAppleSSL.h

@@ -34,9 +34,7 @@ namespace ix
         virtual ssize_t recv(void* buffer, size_t length) final;
 
     private:
-        static std::string getSSLErrorDescription(OSStatus status);
-        static OSStatus writeToSocket(SSLConnectionRef connection, const void* data, size_t* len);
-        static OSStatus readFromSocket(SSLConnectionRef connection, void* data, size_t* len);
+        bool handleTLSOptions(std::string& errMsg);
 
         SSLContextRef _sslContext;
         mutable std::mutex _mutex; // AppleSSL routines are not thread-safe

ixwebsocket/IXSocketServer.cpp

@@ -11,7 +11,7 @@
 #include "IXSocketConnect.h"
 #include "IXSocketFactory.h"
 #include <assert.h>
-#include <stdio.h>
+#include <iostream>
 #include <sstream>
 #include <string.h>
 
@@ -45,13 +45,13 @@ namespace ix
     void SocketServer::logError(const std::string& str)
     {
         std::lock_guard<std::mutex> lock(_logMutex);
-        fprintf(stderr, "%s\n", str.c_str());
+        std::cerr << str << std::endl;
     }
 
     void SocketServer::logInfo(const std::string& str)
     {
         std::lock_guard<std::mutex> lock(_logMutex);
-        fprintf(stdout, "%s\n", str.c_str());
+        std::cout << str << std::endl;
     }
 
     std::pair<bool, std::string> SocketServer::listen()

ixwebsocket/IXWebSocketVersion.h

@@ -6,4 +6,4 @@
 
 #pragma once
 
-#define IX_WEBSOCKET_VERSION "7.8.0"
+#define IX_WEBSOCKET_VERSION "7.6.4"

ws/ws.cpp

@@ -11,6 +11,7 @@
 
 #include <cli11/CLI11.hpp>
 #include <fstream>
+#include <iostream>
 #include <ixcore/utils/IXCoreLogger.h>
 #include <ixwebsocket/IXNetSystem.h>
 #include <ixwebsocket/IXSocket.h>
@@ -38,13 +39,12 @@ int main(int argc, char** argv)
     // Display command.
     if (getenv("DEBUG"))
     {
-        std::stringstream ss;
-        ss << "Command: ";
+        std::cout << "Command: ";
         for (int i = 0; i < argc; ++i)
         {
-            ss << argv[i] << " ";
+            std::cout << argv[i] << " ";
         }
-        spdlog::info(ss.str());
+        std::cout << std::endl;
     }
 
     CLI::App app {"ws is a websocket tool"};
@@ -496,11 +496,11 @@ int main(int argc, char** argv)
     }
     else if (version)
     {
-        spdlog::info("ws {}", ix::userAgent());
+        std::cout << "ws " << ix::userAgent() << std::endl;
     }
     else
     {
-        spdlog::error("A subcommand or --version is required");
+        std::cerr << "A subcommand or --version is required" << std::endl;
     }
 
     ix::uninitNetSystem();

ws/ws_autobahn.cpp

@@ -32,6 +32,7 @@
 
 #include <atomic>
 #include <condition_variable>
+#include <iostream>
 #include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <mutex>
@@ -90,7 +91,7 @@ namespace ix
     {
         if (!_quiet)
         {
-            spdlog::info(msg);
+            std::cerr << msg;
         }
     }
 
@@ -182,7 +183,7 @@ namespace ix
         webSocket.setOnMessageCallback([&condition, &success](const ix::WebSocketMessagePtr& msg) {
             if (msg->type == ix::WebSocketMessageType::Close)
             {
-                spdlog::info("Report generated");
+                std::cerr << "Report generated" << std::endl;
                 condition.notify_one();
             }
             else if (msg->type == ix::WebSocketMessageType::Error)
@@ -192,7 +193,7 @@ namespace ix
                 ss << "#retries: " << msg->errorInfo.retries << std::endl;
                 ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
                 ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
-                spdlog::info(ss.str());
+                std::cerr << ss.str() << std::endl;
 
                 success = false;
             }
@@ -235,7 +236,7 @@ namespace ix
                 ss << "#retries: " << msg->errorInfo.retries << std::endl;
                 ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
                 ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
-                spdlog::info(ss.str());
+                std::cerr << ss.str() << std::endl;
 
                 condition.notify_one();
             }
@@ -268,7 +269,7 @@ namespace ix
     int ws_autobahn_main(const std::string& url, bool quiet)
     {
         int testCasesCount = getTestCaseCount(url);
-        spdlog::info("Test cases count: {}", testCasesCount);
+        std::cerr << "Test cases count: " << testCasesCount << std::endl;
 
         if (testCasesCount == -1)
         {

ws/ws_broadcast_server.cpp

@@ -4,10 +4,9 @@
  *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
  */
 
+#include <iostream>
 #include <ixwebsocket/IXWebSocketServer.h>
 #include <sstream>
-#include <spdlog/spdlog.h>
-
 
 namespace ix
 {
@@ -15,7 +14,7 @@ namespace ix
                                  const std::string& hostname,
                                  const ix::SocketTLSOptions& tlsOptions)
     {
-        spdlog::info("Listening on {}:{}", hostname, port);
+        std::cout << "Listening on " << hostname << ":" << port << std::endl;
 
         ix::WebSocketServer server(port, hostname);
         server.setTLSOptions(tlsOptions);
@@ -26,19 +25,20 @@ namespace ix
                                                 const WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
-                    spdlog::info("New connection");
-                    spdlog::info("id: {}", connectionState->getId());
-                    spdlog::info("Uri: {}", msg->openInfo.uri);
-                    spdlog::info("Headers:");
+                    std::cerr << "New connection" << std::endl;
+                    std::cerr << "id: " << connectionState->getId() << std::endl;
+                    std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
+                    std::cerr << "Headers:" << std::endl;
                     for (auto it : msg->openInfo.headers)
                     {
-                        spdlog::info("{}: {}", it.first, it.second);
+                        std::cerr << it.first << ": " << it.second << std::endl;
                     }
                 }
                 else if (msg->type == ix::WebSocketMessageType::Close)
                 {
-                    spdlog::info("Closed connection: code {} reason {}",
-                                 msg->closeInfo.code, msg->closeInfo.reason);
+                    std::cerr << "Closed connection"
+                              << " code " << msg->closeInfo.code << " reason "
+                              << msg->closeInfo.reason << std::endl;
                 }
                 else if (msg->type == ix::WebSocketMessageType::Error)
                 {
@@ -47,29 +47,30 @@ namespace ix
                     ss << "#retries: " << msg->errorInfo.retries << std::endl;
                     ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
                     ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
-                    spdlog::info(ss.str());
+                    std::cerr << ss.str();
                 }
                 else if (msg->type == ix::WebSocketMessageType::Fragment)
                 {
-                    spdlog::info("Received message fragment");
+                    std::cerr << "Received message fragment" << std::endl;
                 }
                 else if (msg->type == ix::WebSocketMessageType::Message)
                 {
-                    spdlog::info("Received {} bytes", msg->wireSize);
+                    std::cerr << "Received " << msg->wireSize << " bytes" << std::endl;
 
                     for (auto&& client : server.getClients())
                     {
                         if (client != webSocket)
                         {
                             client->send(msg->str, msg->binary, [](int current, int total) -> bool {
-                                spdlog::info("Step {} out of {}", current, total);
+                                std::cerr << "Step " << current << " out of " << total << std::endl;
                                 return true;
                             });
 
                             do
                             {
                                 size_t bufferedAmount = client->bufferedAmount();
-                                spdlog::info("{} bytes left to be sent", bufferedAmount);
+                                std::cerr << bufferedAmount << " bytes left to be sent"
+                                          << std::endl;
 
                                 std::chrono::duration<double, std::milli> duration(10);
                                 std::this_thread::sleep_for(duration);
@@ -83,7 +84,7 @@ namespace ix
         auto res = server.listen();
         if (!res.first)
         {
-            spdlog::info(res.second);
+            std::cerr << res.second << std::endl;
             return 1;
         }
 

ws/ws_chat.cpp

@@ -9,13 +9,12 @@
 // Broadcast server can be ran with `ws broadcast_server`
 //
 
-#include "linenoise.hpp"
 #include "nlohmann/json.hpp"
+#include <iostream>
 #include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <queue>
 #include <sstream>
-#include <spdlog/spdlog.h>
 
 // for convenience
 using json = nlohmann::json;
@@ -56,7 +55,7 @@ namespace ix
 
     void WebSocketChat::log(const std::string& msg)
     {
-        spdlog::info(msg);
+        std::cout << msg << std::endl;
     }
 
     size_t WebSocketChat::getReceivedMessagesCount() const
@@ -86,21 +85,20 @@ namespace ix
             if (msg->type == ix::WebSocketMessageType::Open)
             {
                 log("ws chat: connected");
-                spdlog::info("Uri: {}", msg->openInfo.uri);
-                spdlog::info("Headers:");
+                std::cout << "Uri: " << msg->openInfo.uri << std::endl;
+                std::cout << "Handshake Headers:" << std::endl;
                 for (auto it : msg->openInfo.headers)
                 {
-                    spdlog::info("{}: {}", it.first, it.second);
+                    std::cout << it.first << ": " << it.second << std::endl;
                 }
 
-                spdlog::info("ws chat: user {} connected !", _user);
+                ss << "ws chat: user " << _user << " Connected !";
                 log(ss.str());
             }
             else if (msg->type == ix::WebSocketMessageType::Close)
             {
-                ss << "ws chat user disconnected: " << _user;
-                ss << " code " << msg->closeInfo.code;
-                ss << " reason " << msg->closeInfo.reason << std::endl;
+                ss << "ws chat: user " << _user << " disconnected !"
+                   << " code " << msg->closeInfo.code << " reason " << msg->closeInfo.reason;
                 log(ss.str());
             }
             else if (msg->type == ix::WebSocketMessageType::Message)
@@ -164,25 +162,25 @@ namespace ix
 
     int ws_chat_main(const std::string& url, const std::string& user)
     {
-        spdlog::info("Type Ctrl-D to exit prompt...");
+        std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
         WebSocketChat webSocketChat(url, user);
         webSocketChat.start();
 
         while (true)
         {
-            // Read line
-            std::string line;
-            auto quit = linenoise::Readline("> ", line);
+            std::string text;
+            std::cout << user << " > " << std::flush;
+            std::getline(std::cin, text);
 
-            if (quit)
+            if (!std::cin)
             {
                 break;
             }
 
-            webSocketChat.sendMessage(line);
+            webSocketChat.sendMessage(text);
         }
 
-        spdlog::info("");
+        std::cout << std::endl;
         webSocketChat.stop();
 
         return 0;

ws/ws_cobra_metrics_publish.cpp

@@ -7,6 +7,7 @@
 #include <atomic>
 #include <chrono>
 #include <fstream>
+#include <iostream>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <jsoncpp/json/json.h>
 #include <spdlog/spdlog.h>

ws/ws_cobra_metrics_to_redis.cpp

@@ -7,6 +7,7 @@
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
+#include <iostream>
 #include <ixcobra/IXCobraConnection.h>
 #include <ixsnake/IXRedisClient.h>
 #include <mutex>
@@ -43,7 +44,8 @@ namespace ix
         auto timer = [&msgPerSeconds, &msgCount] {
             while (true)
             {
-                spdlog::info("#messages {} msg/s {}", msgCount, msgPerSeconds);
+                std::cout << "#messages " << msgCount << " "
+                          << "msg/s " << msgPerSeconds << std::endl;
 
                 msgPerSeconds = 0;
                 auto duration = std::chrono::seconds(1);

ws/ws_cobra_publish.cpp

@@ -7,6 +7,7 @@
 #include <atomic>
 #include <chrono>
 #include <fstream>
+#include <iostream>
 #include <ixcobra/IXCobraMetricsPublisher.h>
 #include <jsoncpp/json/json.h>
 #include <mutex>
@@ -90,10 +91,6 @@ namespace ix
                 spdlog::info("Published message id {} acked", msgId);
                 messageAcked = true;
             }
-            else if (eventType == ix::CobraConnection_EventType_Pong)
-            {
-                spdlog::info("Received websocket pong");
-            }
         });
 
         conn.connect();

ws/ws_cobra_subscribe.cpp

@@ -6,6 +6,7 @@
 
 #include <atomic>
 #include <chrono>
+#include <iostream>
 #include <ixcobra/IXCobraConnection.h>
 #include <spdlog/spdlog.h>
 #include <sstream>
@@ -40,7 +41,8 @@ namespace ix
         auto timer = [&msgPerSeconds, &msgCount] {
             while (true)
             {
-                spdlog::info("#messages {} msg/s {}", msgCount, msgPerSeconds);
+                std::cout << "#messages " << msgCount << " "
+                          << "msg/s " << msgPerSeconds << std::endl;
 
                 msgPerSeconds = 0;
                 auto duration = std::chrono::seconds(1);
@@ -75,7 +77,7 @@ namespace ix
                         [&jsonWriter, &quiet, &msgPerSeconds, &msgCount](const Json::Value& msg) {
                             if (!quiet)
                             {
-                                spdlog::info(jsonWriter.write(msg));
+                                std::cerr << jsonWriter.write(msg) << std::endl;
                             }
 
                             msgPerSeconds++;
@@ -98,10 +100,6 @@ namespace ix
                 {
                     spdlog::error("Published message hacked: {}", msgId);
                 }
-                else if (eventType == ix::CobraConnection_EventType_Pong)
-                {
-                    spdlog::info("Received websocket pong");
-                }
             });
 
         while (true)

ws/ws_cobra_to_sentry.cpp

@@ -7,6 +7,7 @@
 #include <atomic>
 #include <chrono>
 #include <condition_variable>
+#include <iostream>
 #include <ixcobra/IXCobraConnection.h>
 #include <ixsentry/IXSentryClient.h>
 #include <mutex>
@@ -160,7 +161,7 @@ namespace ix
         };
 
         // Create a thread pool
-        spdlog::info("Starting {} sentry sender jobs", jobs);
+        std::cerr << "Starting " << jobs << " sentry sender jobs" << std::endl;
         std::vector<std::thread> pool;
         for (int i = 0; i < jobs; i++)
         {
@@ -196,7 +197,7 @@ namespace ix
             }
             else if (eventType == ix::CobraConnection_EventType_Authenticated)
             {
-                spdlog::info("Subscriber authenticated");
+                std::cerr << "Subscriber authenticated" << std::endl;
                 conn.subscribe(channel,
                                filter,
                                [&jsonWriter,
@@ -244,10 +245,6 @@ namespace ix
             {
                 spdlog::error("Published message hacked: {}", msgId);
             }
-            else if (eventType == ix::CobraConnection_EventType_Pong)
-            {
-                spdlog::info("Received websocket pong");
-            }
         });
 
         while (true)

ws/ws_cobra_to_statsd.cpp

@@ -6,6 +6,7 @@
 
 #include <atomic>
 #include <chrono>
+#include <iostream>
 #include <ixcobra/IXCobraConnection.h>
 #include <spdlog/spdlog.h>
 #include <sstream>
@@ -159,10 +160,6 @@ namespace ix
             {
                 spdlog::error("Published message hacked: {}", msgId);
             }
-            else if (eventType == ix::CobraConnection_EventType_Pong)
-            {
-                spdlog::info("Received websocket pong");
-            }
         });
 
         while (true)

ws/ws_connect.cpp

@@ -5,10 +5,10 @@
  */
 
 #include "linenoise.hpp"
+#include <iostream>
 #include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocket.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
 
 
@@ -93,7 +93,7 @@ namespace ix
             auto key = token.substr(0, pos);
             auto val = token.substr(pos + 1);
 
-            spdlog::info("{}: {}", key, val);
+            std::cerr << key << ": " << val << std::endl;
             headers[key] = val;
         }
 
@@ -129,11 +129,11 @@ namespace ix
             if (msg->type == ix::WebSocketMessageType::Open)
             {
                 log("ws_connect: connected");
-                spdlog::info("Uri: {}", msg->openInfo.uri);
-                spdlog::info("Headers:");
+                std::cout << "Uri: " << msg->openInfo.uri << std::endl;
+                std::cout << "Handshake Headers:" << std::endl;
                 for (auto it : msg->openInfo.headers)
                 {
-                    spdlog::info("{}: {}", it.first, it.second);
+                    std::cout << it.first << ": " << it.second << std::endl;
                 }
             }
             else if (msg->type == ix::WebSocketMessageType::Close)
@@ -145,7 +145,7 @@ namespace ix
             }
             else if (msg->type == ix::WebSocketMessageType::Message)
             {
-                spdlog::info("Received {} bytes", msg->wireSize);
+                std::cerr << "Received " << msg->wireSize << " bytes" << std::endl;
 
                 ss << "ws_connect: received message: " << msg->str;
                 log(ss.str());
@@ -160,15 +160,15 @@ namespace ix
             }
             else if (msg->type == ix::WebSocketMessageType::Fragment)
             {
-                spdlog::info("Received message fragment");
+                std::cerr << "Received message fragment" << std::endl;
             }
             else if (msg->type == ix::WebSocketMessageType::Ping)
             {
-                spdlog::info("Received ping");
+                std::cerr << "Received ping" << std::endl;
             }
             else if (msg->type == ix::WebSocketMessageType::Pong)
             {
-                spdlog::info("Received pong");
+                std::cerr << "Received pong" << std::endl;
             }
             else
             {
@@ -225,14 +225,14 @@ namespace ix
 
             if (line == "/stop")
             {
-                spdlog::info("Stopping connection...");
+                std::cout << "Stopping connection..." << std::endl;
                 webSocketChat.stop();
                 continue;
             }
 
             if (line == "/start")
             {
-                spdlog::info("Starting connection...");
+                std::cout << "Starting connection..." << std::endl;
                 webSocketChat.start();
                 continue;
             }
@@ -243,7 +243,7 @@ namespace ix
             linenoise::AddHistory(line.c_str());
         }
 
-        spdlog::info("");
+        std::cout << std::endl;
         webSocketChat.stop();
 
         return 0;

ws/ws_echo_server.cpp

@@ -4,8 +4,8 @@
  *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
  */
 
+#include <iostream>
 #include <ixwebsocket/IXWebSocketServer.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
 
 namespace ix
@@ -15,7 +15,7 @@ namespace ix
                             const std::string& hostname,
                             const ix::SocketTLSOptions& tlsOptions)
     {
-        spdlog::info("Listening on {}:{}", hostname, port);
+        std::cout << "Listening on " << hostname << ":" << port << std::endl;
 
         ix::WebSocketServer server(port, hostname);
         server.setTLSOptions(tlsOptions);
@@ -27,13 +27,13 @@ namespace ix
                     [webSocket, connectionState, greetings](const WebSocketMessagePtr& msg) {
                         if (msg->type == ix::WebSocketMessageType::Open)
                         {
-                            spdlog::info("New connection");
-                            spdlog::info("id: {}", connectionState->getId());
-                            spdlog::info("Uri: {}", msg->openInfo.uri);
-                            spdlog::info("Headers:");
+                            std::cerr << "New connection" << std::endl;
+                            std::cerr << "id: " << connectionState->getId() << std::endl;
+                            std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
+                            std::cerr << "Headers:" << std::endl;
                             for (auto it : msg->openInfo.headers)
                             {
-                                spdlog::info("{}: {}", it.first, it.second);
+                                std::cerr << it.first << ": " << it.second << std::endl;
                             }
 
                             if (greetings)
@@ -43,21 +43,22 @@ namespace ix
                         }
                         else if (msg->type == ix::WebSocketMessageType::Close)
                         {
-                            spdlog::info("Closed connection: client id {} code {} reason {}",
-                                         connectionState->getId(),
-                                         msg->closeInfo.code,
-                                         msg->closeInfo.reason);
+                            std::cerr << "Closed connection"
+                                      << " code " << msg->closeInfo.code << " reason "
+                                      << msg->closeInfo.reason << std::endl;
                         }
                         else if (msg->type == ix::WebSocketMessageType::Error)
                         {
-                            spdlog::error("Connection error: {}", msg->errorInfo.reason);
-                            spdlog::error("#retries: {}", msg->errorInfo.retries);
-                            spdlog::error("Wait time(ms): {}", msg->errorInfo.wait_time);
-                            spdlog::error("HTTP Status: {}", msg->errorInfo.http_status);
+                            std::stringstream ss;
+                            ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                            ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                            ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                            ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                            std::cerr << ss.str();
                         }
                         else if (msg->type == ix::WebSocketMessageType::Message)
                         {
-                            spdlog::info("Received {} bytes", msg->wireSize);
+                            std::cerr << "Received " << msg->wireSize << " bytes" << std::endl;
                             webSocket->send(msg->str, msg->binary);
                         }
                     });
@@ -66,7 +67,7 @@ namespace ix
         auto res = server.listen();
         if (!res.first)
         {
-            spdlog::error(res.second);
+            std::cerr << res.second << std::endl;
             return 1;
         }
 

ws/ws_http_client.cpp

@@ -5,10 +5,10 @@
  */
 
 #include <fstream>
+#include <iostream>
 #include <ixwebsocket/IXHttpClient.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocketHttpHeaders.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
 
 namespace ix
@@ -47,7 +47,7 @@ namespace ix
             auto key = token.substr(0, pos);
             auto val = token.substr(pos + 1);
 
-            spdlog::info("{}: {}", key, val);
+            std::cerr << key << ": " << val << std::endl;
             headers[key] = val;
         }
 
@@ -76,7 +76,7 @@ namespace ix
             auto key = token.substr(0, pos);
             auto val = token.substr(pos + 1);
 
-            spdlog::info("{}: {}", key, val);
+            std::cerr << key << ": " << val << std::endl;
             httpParameters[key] = val;
         }
 
@@ -108,9 +108,10 @@ namespace ix
         args->maxRedirects = maxRedirects;
         args->verbose = verbose;
         args->compress = compress;
-        args->logger = [](const std::string& msg) { spdlog::info(msg); };
+        args->logger = [](const std::string& msg) { std::cout << msg; };
         args->onProgressCallback = [](int current, int total) -> bool {
-            spdlog::info("Downloaded {} bytes out of {}", current, total);
+            std::cerr << "\r"
+                      << "Downloaded " << current << " bytes out of " << total;
             return true;
         };
 
@@ -130,20 +131,20 @@ namespace ix
             response = httpClient.post(url, httpParameters, args);
         }
 
-        spdlog::info("");
+        std::cerr << std::endl;
 
         for (auto it : response->headers)
         {
-            spdlog::info("{}: {}", it.first, it.second);
+            std::cerr << it.first << ": " << it.second << std::endl;
         }
 
-        spdlog::info("Upload size: {}", response->uploadSize);
-        spdlog::info("Download size: {}", response->downloadSize);
+        std::cerr << "Upload size: " << response->uploadSize << std::endl;
+        std::cerr << "Download size: " << response->downloadSize << std::endl;
 
-        spdlog::info("Status: {}", response->statusCode);
+        std::cerr << "Status: " << response->statusCode << std::endl;
         if (response->errorCode != HttpErrorCode::Ok)
         {
-            spdlog::info("error message: ", response->errorMsg);
+            std::cerr << "error message: " << response->errorMsg << std::endl;
         }
 
         if (!headersOnly && response->errorCode == HttpErrorCode::Ok)
@@ -157,7 +158,7 @@ namespace ix
                     filename = output;
                 }
 
-                spdlog::info("Writing to disk: {}", filename);
+                std::cout << "Writing to disk: " << filename << std::endl;
                 std::ofstream out(filename);
                 out.write((char*) &response->payload.front(), response->payload.size());
                 out.close();
@@ -166,13 +167,14 @@ namespace ix
             {
                 if (response->headers["Content-Type"] != "application/octet-stream")
                 {
-                    spdlog::info("payload: {}", response->payload);
+                    std::cout << "payload: " << response->payload << std::endl;
                 }
                 else
                 {
-                    spdlog::info("Binary output can mess up your terminal.");
-                    spdlog::info("Use the -O flag to save the file to disk.");
-                    spdlog::info("You can also use the --output option to specify a filename.");
+                    std::cerr << "Binary output can mess up your terminal." << std::endl;
+                    std::cerr << "Use the -O flag to save the file to disk." << std::endl;
+                    std::cerr << "You can also use the --output option to specify a filename."
+                              << std::endl;
                 }
             }
         }

ws/ws_httpd.cpp

@@ -5,6 +5,7 @@
  */
 
 #include <fstream>
+#include <iostream>
 #include <ixwebsocket/IXHttpServer.h>
 #include <spdlog/spdlog.h>
 #include <sstream>
@@ -31,7 +32,7 @@ namespace ix
         auto res = server.listen();
         if (!res.first)
         {
-            spdlog::error(res.second);
+            std::cerr << res.second << std::endl;
             return 1;
         }
 

ws/ws_ping_pong.cpp

@@ -4,12 +4,11 @@
  *  Copyright (c) 2018-2019 Machine Zone, Inc. All rights reserved.
  */
 
+#include <iostream>
 #include <ixwebsocket/IXSocket.h>
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocket.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
-#include <iostream>
 
 namespace ix
 {
@@ -41,7 +40,7 @@ namespace ix
 
     void WebSocketPingPong::log(const std::string& msg)
     {
-        spdlog::info(msg);
+        std::cout << msg << std::endl;
     }
 
     void WebSocketPingPong::stop()
@@ -57,18 +56,18 @@ namespace ix
         log(std::string("Connecting to url: ") + _url);
 
         _webSocket.setOnMessageCallback([this](const ix::WebSocketMessagePtr& msg) {
-            spdlog::info("Received {} bytes", msg->wireSize);
+            std::cerr << "Received " << msg->wireSize << " bytes" << std::endl;
 
             std::stringstream ss;
             if (msg->type == ix::WebSocketMessageType::Open)
             {
                 log("ping_pong: connected");
 
-                spdlog::info("Uri: {}", msg->openInfo.uri);
-                spdlog::info("Headers:");
+                std::cout << "Uri: " << msg->openInfo.uri << std::endl;
+                std::cout << "Handshake Headers:" << std::endl;
                 for (auto it : msg->openInfo.headers)
                 {
-                    spdlog::info("{}: {}", it.first, it.second);
+                    std::cout << it.first << ": " << it.second << std::endl;
                 }
             }
             else if (msg->type == ix::WebSocketMessageType::Close)
@@ -128,7 +127,7 @@ namespace ix
 
     int ws_ping_pong_main(const std::string& url, const ix::SocketTLSOptions& tlsOptions)
     {
-        spdlog::info("Type Ctrl-D to exit prompt...");
+        std::cout << "Type Ctrl-D to exit prompt..." << std::endl;
         WebSocketPingPong webSocketPingPong(url, tlsOptions);
         webSocketPingPong.start();
 

ws/ws_proxy_server.cpp

@@ -4,8 +4,8 @@
  *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
  */
 
+#include <iostream>
 #include <ixwebsocket/IXWebSocketServer.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
 
 namespace ix
@@ -44,7 +44,7 @@ namespace ix
                              const std::string& remoteUrl,
                              bool verbose)
     {
-        spdlog::info("Listening on {}:{}", hostname, port);
+        std::cout << "Listening on " << hostname << ":" << port << std::endl;
 
         ix::WebSocketServer server(port, hostname);
         server.setTLSOptions(tlsOptions);
@@ -64,36 +64,38 @@ namespace ix
                                                      const WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
-                    spdlog::info("New connection to remote server");
-                    spdlog::info("id: {}", state->getId());
-                    spdlog::info("Uri: {}", msg->openInfo.uri);
-                    spdlog::info("Headers:");
+                    std::cerr << "New connection" << std::endl;
+                    std::cerr << "server id: " << state->getId() << std::endl;
+                    std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
+                    std::cerr << "Headers:" << std::endl;
                     for (auto it : msg->openInfo.headers)
                     {
-                        spdlog::info("{}: {}", it.first, it.second);
+                        std::cerr << it.first << ": " << it.second << std::endl;
                     }
                 }
                 else if (msg->type == ix::WebSocketMessageType::Close)
                 {
-                    spdlog::info("Closed remote server connection: client id {} code {} reason {}",
-                                 state->getId(),
-                                 msg->closeInfo.code,
-                                 msg->closeInfo.reason);
+                    std::cerr << "Closed connection"
+                              << " code " << msg->closeInfo.code << " reason "
+                              << msg->closeInfo.reason << std::endl;
+                    webSocket->close(msg->closeInfo.code, msg->closeInfo.reason);
                     state->setTerminated();
                 }
                 else if (msg->type == ix::WebSocketMessageType::Error)
                 {
-                    spdlog::error("Connection error: {}", msg->errorInfo.reason);
-                    spdlog::error("#retries: {}", msg->errorInfo.retries);
-                    spdlog::error("Wait time(ms): {}", msg->errorInfo.wait_time);
-                    spdlog::error("HTTP Status: {}", msg->errorInfo.http_status);
+                    std::stringstream ss;
+                    ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                    ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                    ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                    ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                    std::cerr << ss.str();
                 }
                 else if (msg->type == ix::WebSocketMessageType::Message)
                 {
-                    spdlog::info("Received {} bytes from server", msg->wireSize);
+                    std::cerr << "Received " << msg->wireSize << " bytes from server" << std::endl;
                     if (verbose)
                     {
-                        spdlog::info("payload {}", msg->str);
+                        std::cerr << "payload " << msg->str << std::endl;
                     }
 
                     webSocket->send(msg->str, msg->binary);
@@ -105,13 +107,13 @@ namespace ix
                                                 const WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
-                    spdlog::info("New connection from client");
-                    spdlog::info("id: {}", state->getId());
-                    spdlog::info("Uri: {}", msg->openInfo.uri);
-                    spdlog::info("Headers:");
+                    std::cerr << "New connection" << std::endl;
+                    std::cerr << "client id: " << state->getId() << std::endl;
+                    std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
+                    std::cerr << "Headers:" << std::endl;
                     for (auto it : msg->openInfo.headers)
                     {
-                        spdlog::info("{}: {}", it.first, it.second);
+                        std::cerr << it.first << ": " << it.second << std::endl;
                     }
 
                     // Connect to the 'real' server
@@ -125,34 +127,34 @@ namespace ix
                     // connection with the remote server
                     while (state->webSocket().getReadyState() != ReadyState::Open)
                     {
-                        spdlog::info("waiting for server connection establishment");
+                        std::cerr << "waiting for server connection establishment" << std::endl;
                         std::this_thread::sleep_for(std::chrono::milliseconds(10));
                     }
-                    spdlog::info("server connection established");
+                    std::cerr << "server connection established" << std::endl;
                 }
                 else if (msg->type == ix::WebSocketMessageType::Close)
                 {
-                    spdlog::info("Closed client connection: client id {} code {} reason {}",
-                                 state->getId(),
-                                 msg->closeInfo.code,
-                                 msg->closeInfo.reason);
+                    std::cerr << "Closed connection"
+                              << " code " << msg->closeInfo.code << " reason "
+                              << msg->closeInfo.reason << std::endl;
                     state->webSocket().close(msg->closeInfo.code, msg->closeInfo.reason);
                 }
                 else if (msg->type == ix::WebSocketMessageType::Error)
                 {
-                    spdlog::error("Connection error: {}", msg->errorInfo.reason);
-                    spdlog::error("#retries: {}", msg->errorInfo.retries);
-                    spdlog::error("Wait time(ms): {}", msg->errorInfo.wait_time);
-                    spdlog::error("HTTP Status: {}", msg->errorInfo.http_status);
+                    std::stringstream ss;
+                    ss << "Connection error: " << msg->errorInfo.reason << std::endl;
+                    ss << "#retries: " << msg->errorInfo.retries << std::endl;
+                    ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
+                    ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
+                    std::cerr << ss.str();
                 }
                 else if (msg->type == ix::WebSocketMessageType::Message)
                 {
-                    spdlog::info("Received {} bytes from client", msg->wireSize);
+                    std::cerr << "Received " << msg->wireSize << " bytes from client" << std::endl;
                     if (verbose)
                     {
-                        spdlog::info("payload {}", msg->str);
+                        std::cerr << "payload " << msg->str << std::endl;
                     }
-
                     state->webSocket().send(msg->str, msg->binary);
                 }
             });
@@ -161,7 +163,7 @@ namespace ix
         auto res = server.listen();
         if (!res.first)
         {
-            spdlog::info(res.second);
+            std::cerr << res.second << std::endl;
             return 1;
         }
 

ws/ws_receive.cpp

@@ -7,6 +7,7 @@
 #include <chrono>
 #include <condition_variable>
 #include <fstream>
+#include <iostream>
 #include <ixcrypto/IXBase64.h>
 #include <ixcrypto/IXHash.h>
 #include <ixcrypto/IXUuid.h>
@@ -14,7 +15,6 @@
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <msgpack11/msgpack11.hpp>
-#include <spdlog/spdlog.h>
 #include <mutex>
 #include <sstream>
 #include <vector>
@@ -75,12 +75,12 @@ namespace ix
 
     void WebSocketReceiver::log(const std::string& msg)
     {
-        spdlog::info(msg);
+        std::cout << msg << std::endl;
     }
 
     void WebSocketReceiver::waitForConnection()
     {
-        spdlog::info("{}: Connecting...", "ws_receive");
+        std::cout << "ws_receive: Connecting..." << std::endl;
 
         std::unique_lock<std::mutex> lock(_conditionVariableMutex);
         _condition.wait(lock);
@@ -88,7 +88,7 @@ namespace ix
 
     void WebSocketReceiver::waitForMessage()
     {
-        spdlog::info("{}: Waiting for message...", "ws_receive");
+        std::cout << "ws_receive: Waiting for message..." << std::endl;
 
         std::unique_lock<std::mutex> lock(_conditionVariableMutex);
         _condition.wait(lock);
@@ -124,7 +124,7 @@ namespace ix
 
     void WebSocketReceiver::handleMessage(const std::string& str)
     {
-        spdlog::info("ws_receive: Received message: {}", str.size());
+        std::cerr << "ws_receive: Received message: " << str.size() << std::endl;
 
         std::string errMsg;
         MsgPack data = MsgPack::parse(str, errMsg);
@@ -134,17 +134,17 @@ namespace ix
             return;
         }
 
-        spdlog::info("id: {}", data["id"].string_value());
+        std::cout << "id: " << data["id"].string_value() << std::endl;
 
         std::vector<uint8_t> content = data["content"].binary_items();
-        spdlog::info("ws_receive: Content size: {}", content.size());
+        std::cout << "ws_receive: Content size: " << content.size() << std::endl;
 
         // Validate checksum
         uint64_t cksum = ix::djb2Hash(content);
         auto cksumRef = data["djb2_hash"].string_value();
 
-        spdlog::info("ws_receive: Computed hash: {}", cksum);
-        spdlog::info("ws_receive: Reference hash: {}", cksumRef);
+        std::cout << "ws_receive: Computed hash: " << cksum << std::endl;
+        std::cout << "ws_receive: Reference hash: " << cksumRef << std::endl;
 
         if (std::to_string(cksum) != cksumRef)
         {
@@ -157,12 +157,12 @@ namespace ix
 
         std::string filenameTmp = filename + ".tmp";
 
-        spdlog::info("ws_receive: Writing to disk: {}", filenameTmp);
+        std::cout << "ws_receive: Writing to disk: " << filenameTmp << std::endl;
         std::ofstream out(filenameTmp);
         out.write((char*) &content.front(), content.size());
         out.close();
 
-        spdlog::info("ws_receive: Renaming {} to {}", filenameTmp, filename);
+        std::cout << "ws_receive: Renaming " << filenameTmp << " to " << filename << std::endl;
         rename(filenameTmp.c_str(), filename.c_str());
 
         std::map<MsgPack, MsgPack> pdu;
@@ -170,7 +170,7 @@ namespace ix
         pdu["id"] = data["id"];
         pdu["filename"] = data["filename"];
 
-        spdlog::info("Sending ack to sender");
+        std::cout << "Sending ack to sender" << std::endl;
         MsgPack msg(pdu);
         _webSocket.sendBinary(msg.dump());
     }
@@ -192,11 +192,11 @@ namespace ix
                 _condition.notify_one();
 
                 log("ws_receive: connected");
-                spdlog::info("Uri: {}", msg->openInfo.uri);
-                spdlog::info("Headers:");
+                std::cout << "Uri: " << msg->openInfo.uri << std::endl;
+                std::cout << "Handshake Headers:" << std::endl;
                 for (auto it : msg->openInfo.headers)
                 {
-                    spdlog::info("{}: {}", it.first, it.second);
+                    std::cout << it.first << ": " << it.second << std::endl;
                 }
             }
             else if (msg->type == ix::WebSocketMessageType::Close)
@@ -259,7 +259,7 @@ namespace ix
         std::chrono::duration<double, std::milli> duration(1000);
         std::this_thread::sleep_for(duration);
 
-        spdlog::info("ws_receive: Done !");
+        std::cout << "ws_receive: Done !" << std::endl;
         webSocketReceiver.stop();
     }
 

ws/ws_redis_publish.cpp

@@ -4,8 +4,8 @@
  *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
  */
 
+#include <iostream>
 #include <ixsnake/IXRedisClient.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
 
 namespace ix
@@ -20,7 +20,7 @@ namespace ix
         RedisClient redisClient;
         if (!redisClient.connect(hostname, port))
         {
-            spdlog::info("Cannot connect to redis host");
+            std::cerr << "Cannot connect to redis host" << std::endl;
             return 1;
         }
 
@@ -30,10 +30,10 @@ namespace ix
             if (!redisClient.auth(password, authResponse))
             {
                 std::stringstream ss;
-                spdlog::info("Cannot authenticated to redis");
+                std::cerr << "Cannot authenticated to redis" << std::endl;
                 return 1;
             }
-            spdlog::info("Auth response: {}", authResponse);
+            std::cout << "Auth response: " << authResponse << ":" << port << std::endl;
         }
 
         std::string errMsg;
@@ -41,7 +41,8 @@ namespace ix
         {
             if (!redisClient.publish(channel, message, errMsg))
             {
-                spdlog::error("Error publishing to channel {} error {}", channel, errMsg);
+                std::cerr << "Error publishing to channel " << channel << "error: " << errMsg
+                          << std::endl;
                 return 1;
             }
         }

ws/ws_redis_server.cpp

@@ -4,6 +4,7 @@
  *  Copyright (c) 2019 Machine Zone, Inc. All rights reserved.
  */
 
+#include <iostream>
 #include <ixsnake/IXRedisServer.h>
 #include <spdlog/spdlog.h>
 #include <sstream>
@@ -19,7 +20,7 @@ namespace ix
         auto res = server.listen();
         if (!res.first)
         {
-            spdlog::info(res.second);
+            std::cerr << res.second << std::endl;
             return 1;
         }
 

ws/ws_redis_subscribe.cpp

@@ -6,8 +6,8 @@
 
 #include <atomic>
 #include <chrono>
+#include <iostream>
 #include <ixsnake/IXRedisClient.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
 #include <thread>
 
@@ -22,7 +22,7 @@ namespace ix
         RedisClient redisClient;
         if (!redisClient.connect(hostname, port))
         {
-            spdlog::info("Cannot connect to redis host");
+            std::cerr << "Cannot connect to redis host" << std::endl;
             return 1;
         }
 
@@ -32,10 +32,10 @@ namespace ix
             if (!redisClient.auth(password, authResponse))
             {
                 std::stringstream ss;
-                spdlog::info("Cannot authenticated to redis");
+                std::cerr << "Cannot authenticated to redis" << std::endl;
                 return 1;
             }
-            spdlog::info("Auth response: {}", authResponse);
+            std::cout << "Auth response: " << authResponse << ":" << port << std::endl;
         }
 
         std::atomic<int> msgPerSeconds(0);
@@ -44,7 +44,7 @@ namespace ix
         auto callback = [&msgPerSeconds, &msgCount, verbose](const std::string& message) {
             if (verbose)
             {
-                spdlog::info("recived: {}", message);
+                std::cout << "received: " << message << std::endl;
             }
 
             msgPerSeconds++;
@@ -52,13 +52,14 @@ namespace ix
         };
 
         auto responseCallback = [](const std::string& redisResponse) {
-            spdlog::info("Redis subscribe response: {}", redisResponse);
+            std::cout << "Redis subscribe response: " << redisResponse << std::endl;
         };
 
         auto timer = [&msgPerSeconds, &msgCount] {
             while (true)
             {
-                spdlog::info("#messages {} msg/s {}", msgCount, msgPerSeconds);
+                std::cout << "#messages " << msgCount << " "
+                          << "msg/s " << msgPerSeconds << std::endl;
 
                 msgPerSeconds = 0;
                 auto duration = std::chrono::seconds(1);
@@ -68,10 +69,10 @@ namespace ix
 
         std::thread t(timer);
 
-        spdlog::info("Subscribing to {} ...", channel);
+        std::cerr << "Subscribing to " << channel << "..." << std::endl;
         if (!redisClient.subscribe(channel, responseCallback, callback))
         {
-            spdlog::info("Error subscribing to channel {}", channel);
+            std::cerr << "Error subscribing to channel " << channel << std::endl;
             return 1;
         }
 

ws/ws_send.cpp

@@ -7,6 +7,7 @@
 #include <chrono>
 #include <condition_variable>
 #include <fstream>
+#include <iostream>
 #include <ixcrypto/IXBase64.h>
 #include <ixcrypto/IXHash.h>
 #include <ixcrypto/IXUuid.h>
@@ -14,7 +15,6 @@
 #include <ixwebsocket/IXSocketTLSOptions.h>
 #include <ixwebsocket/IXWebSocket.h>
 #include <msgpack11/msgpack11.hpp>
-#include <spdlog/spdlog.h>
 #include <mutex>
 #include <sstream>
 #include <vector>
@@ -68,12 +68,12 @@ namespace ix
 
     void WebSocketSender::log(const std::string& msg)
     {
-        spdlog::info(msg);
+        std::cout << msg << std::endl;
     }
 
     void WebSocketSender::waitForConnection()
     {
-        spdlog::info("{}: Connecting...", "ws_send");
+        std::cout << "ws_send: Connecting..." << std::endl;
 
         std::unique_lock<std::mutex> lock(_conditionVariableMutex);
         _condition.wait(lock);
@@ -81,7 +81,7 @@ namespace ix
 
     void WebSocketSender::waitForAck()
     {
-        spdlog::info("{}: Waiting for ack...", "ws_send");
+        std::cout << "ws_send: Waiting for ack..." << std::endl;
 
         std::unique_lock<std::mutex> lock(_conditionVariableMutex);
         _condition.wait(lock);
@@ -122,11 +122,11 @@ namespace ix
                 _condition.notify_one();
 
                 log("ws_send: connected");
-                spdlog::info("Uri: {}", msg->openInfo.uri);
-                spdlog::info("Headers:");
+                std::cout << "Uri: " << msg->openInfo.uri << std::endl;
+                std::cout << "Handshake Headers:" << std::endl;
                 for (auto it : msg->openInfo.headers)
                 {
-                    spdlog::info("{}: {}", it.first, it.second);
+                    std::cout << it.first << ": " << it.second << std::endl;
                 }
             }
             else if (msg->type == ix::WebSocketMessageType::Close)
@@ -147,14 +147,14 @@ namespace ix
                 MsgPack data = MsgPack::parse(msg->str, errMsg);
                 if (!errMsg.empty())
                 {
-                    spdlog::info("Invalid MsgPack response");
+                    std::cerr << "Invalid MsgPack response" << std::endl;
                     return;
                 }
 
                 std::string id = data["id"].string_value();
                 if (_id != id)
                 {
-                    spdlog::info("Invalid id");
+                    std::cerr << "Invalid id" << std::endl;
                 }
             }
             else if (msg->type == ix::WebSocketMessageType::Error)
@@ -201,7 +201,7 @@ namespace ix
             auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(now - _start);
 
             _ms = milliseconds.count();
-            spdlog::info("{} completed in {}", _description, _ms);
+            std::cout << _description << " completed in " << _ms << "ms" << std::endl;
 
             _reported = true;
         }
@@ -240,7 +240,7 @@ namespace ix
 
         Bench bench("Sending file through websocket");
         _webSocket.sendBinary(msg.dump(), [throttle](int current, int total) -> bool {
-            spdlog::info("ws_send: Step {} out of {}", current, total);
+            std::cout << "ws_send: Step " << current << " out of " << total << std::endl;
 
             if (throttle)
             {
@@ -254,7 +254,7 @@ namespace ix
         do
         {
             size_t bufferedAmount = _webSocket.bufferedAmount();
-            spdlog::info("ws_send: {} bytes left to be sent", bufferedAmount);
+            std::cout << "ws_send: " << bufferedAmount << " bytes left to be sent" << std::endl;
 
             std::chrono::duration<double, std::milli> duration(10);
             std::this_thread::sleep_for(duration);
@@ -264,7 +264,7 @@ namespace ix
         auto duration = bench.getDuration();
         auto transferRate = 1000 * content.size() / duration;
         transferRate /= (1024 * 1024);
-        spdlog::info("ws_send: Send transfer rate: {} MB/s", transferRate);
+        std::cout << "ws_send: Send transfer rate: " << transferRate << "MB/s" << std::endl;
     }
 
     void wsSend(const std::string& url,
@@ -278,12 +278,12 @@ namespace ix
 
         webSocketSender.waitForConnection();
 
-        spdlog::info("ws_send: Sending...");
+        std::cout << "ws_send: Sending..." << std::endl;
         webSocketSender.sendMessage(path, throttle);
 
         webSocketSender.waitForAck();
 
-        spdlog::info("ws_send: Done !");
+        std::cout << "ws_send: Done !" << std::endl;
         webSocketSender.stop();
     }
 

ws/ws_snake.cpp

@@ -5,8 +5,8 @@
  */
 
 #include <fstream>
+#include <iostream>
 #include <ixsnake/IXSnakeServer.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
 
 namespace
@@ -58,11 +58,11 @@ namespace ix
         auto str = readAsString(appsConfigPath);
         if (str.empty())
         {
-            spdlog::error("Cannot read content of {}", appsConfigPath);
+            std::cout << "Cannot read content of " << appsConfigPath << std::endl;
             return 1;
         }
 
-        spdlog::error(str);
+        std::cout << str << std::endl;
         auto apps = nlohmann::json::parse(str);
         appConfig.apps = apps["apps"];
 

ws/ws_transfer.cpp

@@ -4,8 +4,8 @@
  *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
  */
 
+#include <iostream>
 #include <ixwebsocket/IXWebSocketServer.h>
-#include <spdlog/spdlog.h>
 #include <sstream>
 
 namespace ix
@@ -14,7 +14,7 @@ namespace ix
                          const std::string& hostname,
                          const ix::SocketTLSOptions& tlsOptions)
     {
-        spdlog::info("Listening on {}:{}", hostname, port);
+        std::cout << "ws_transfer: Listening on " << hostname << ":" << port << std::endl;
 
         ix::WebSocketServer server(port, hostname);
         server.setTLSOptions(tlsOptions);
@@ -25,23 +25,22 @@ namespace ix
                                                 const WebSocketMessagePtr& msg) {
                 if (msg->type == ix::WebSocketMessageType::Open)
                 {
-                    spdlog::info("ws_transfer: New connection");
-                    spdlog::info("id: {}", connectionState->getId());
-                    spdlog::info("Uri: {}", msg->openInfo.uri);
-                    spdlog::info("Headers:");
+                    std::cerr << "ws_transfer: New connection" << std::endl;
+                    std::cerr << "id: " << connectionState->getId() << std::endl;
+                    std::cerr << "Uri: " << msg->openInfo.uri << std::endl;
+                    std::cerr << "Headers:" << std::endl;
                     for (auto it : msg->openInfo.headers)
                     {
-                        spdlog::info("{}: {}", it.first, it.second);
+                        std::cerr << it.first << ": " << it.second << std::endl;
                     }
                 }
                 else if (msg->type == ix::WebSocketMessageType::Close)
                 {
-                    spdlog::info("ws_transfer: Closed connection: client id {} code {} reason {}",
-                                 connectionState->getId(),
-                                 msg->closeInfo.code,
-                                 msg->closeInfo.reason);
+                    std::cerr << "ws_transfer: [client " << connectionState->getId()
+                              << "]: Closed connection, code " << msg->closeInfo.code << " reason "
+                              << msg->closeInfo.reason << std::endl;
                     auto remaining = server.getClients().erase(webSocket);
-                    spdlog::info("ws_transfer: {} remaining clients", remaining);
+                    std::cerr << "ws_transfer: " << remaining << " remaining clients " << std::endl;
                 }
                 else if (msg->type == ix::WebSocketMessageType::Error)
                 {
@@ -50,39 +49,40 @@ namespace ix
                     ss << "#retries: " << msg->errorInfo.retries << std::endl;
                     ss << "Wait time(ms): " << msg->errorInfo.wait_time << std::endl;
                     ss << "HTTP Status: " << msg->errorInfo.http_status << std::endl;
-                    spdlog::info(ss.str());
+                    std::cerr << ss.str();
                 }
                 else if (msg->type == ix::WebSocketMessageType::Fragment)
                 {
-                    spdlog::info("ws_transfer: Received message fragment ");
+                    std::cerr << "ws_transfer: Received message fragment " << std::endl;
                 }
                 else if (msg->type == ix::WebSocketMessageType::Message)
                 {
-                    spdlog::info("ws_transfer: Received {} bytes", msg->wireSize);
+                    std::cerr << "ws_transfer: Received " << msg->wireSize << " bytes" << std::endl;
                     size_t receivers = 0;
                     for (auto&& client : server.getClients())
                     {
                         if (client != webSocket)
                         {
                             auto readyState = client->getReadyState();
-                            auto id = connectionState->getId();
-
                             if (readyState == ReadyState::Open)
                             {
                                 ++receivers;
                                 client->send(msg->str,
                                              msg->binary,
-                                             [&id](int current, int total) -> bool {
-                                                 spdlog::info("{}: [client {}]: Step {} out of {}",
-                                                              "ws_transfer", id, current, total);
+                                             [id = connectionState->getId()](int current,
+                                                                             int total) -> bool {
+                                                 std::cerr << "ws_transfer: [client " << id
+                                                           << "]: Step " << current << " out of "
+                                                           << total << std::endl;
                                                  return true;
                                              });
+
                                 do
                                 {
                                     size_t bufferedAmount = client->bufferedAmount();
-
-                                    spdlog::info("{}: [client {}]: {} bytes left to send",
-                                                 "ws_transfer", id, bufferedAmount);
+                                    std::cerr << "ws_transfer: [client " << connectionState->getId()
+                                              << "]: " << bufferedAmount
+                                              << " bytes left to be sent, " << std::endl;
 
                                     std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
@@ -96,15 +96,16 @@ namespace ix
                                         ? "Connecting"
                                         : readyState == ReadyState::Closing ? "Closing" : "Closed";
                                 size_t bufferedAmount = client->bufferedAmount();
-
-                                spdlog::info("{}: [client {}]: has readystate {} bytes left to be sent",
-                                             "ws_transfer", id, readyStateString, bufferedAmount);
+                                std::cerr << "ws_transfer: [client " << connectionState->getId()
+                                          << "]: has readystate '" << readyStateString << "' and "
+                                          << bufferedAmount << " bytes left to be sent, "
+                                          << std::endl;
                             }
                         }
                     }
                     if (!receivers)
                     {
-                        spdlog::info("ws_transfer: no remaining receivers");
+                        std::cerr << "ws_transfer: no remaining receivers" << std::endl;
                     }
                 }
             });
@@ -113,7 +114,7 @@ namespace ix
         auto res = server.listen();
         if (!res.first)
         {
-            spdlog::info(res.second);
+            std::cerr << res.second << std::endl;
             return 1;
         }