Remove every CMake FetchContent dependency (#605)

CI has been failing because FetchContent clones break: the pinned
cpp-linenoise commit is no longer reachable, and the windows_gcc job dies
at configure time with "fatal: unable to read tree 67be78f3...". Rather
than repin, drop the four fetches entirely so that cmake configures
offline.

  spdlog          -> common/IXLog.h, a small header only logger. It keeps
                     the {} placeholder syntax so the ws call sites are
                     unchanged, is mutex guarded, and can be redirected to
                     a file (--logfile). No colored output anymore.
  msgpack11       -> common/IXPdu.h, a line based "<name> <hex value>"
                     format used by ws send/receive/transfer and ws chat.
                     Values are hex encoded so binary payloads need no
                     escaping. This is not compatible with the msgpack
                     based format used up to 12.0.1.
  cpp-linenoise   -> plain std::getline in ws connect, like ws chat and
                     ws ping already did. No history, no line editing.
  Catch2 v3.15.1  -> third_party/catch_amalgamated.{hpp,cpp} v3.15.3
  CLI11 v2.6.2    -> third_party/CLI11.hpp, same version, so the ws
                     command line is unchanged.

Catch2 v3 needs C++14, which the fetched target used to require
implicitly, so the vendored Catch2 target carries cxx_std_14 as a usage
requirement. The library itself stays C++11. Vendored headers are
included as system headers, third_party has a .clang-format that
disables formatting, and the Catch2 target disables unity builds since
those otherwise collide on main().

Also fix ws send, which never transferred a file intact: load() read
files with a std::istream_iterator<char>, which skips whitespace bytes,
so a 2MB random file was sent as 1999903 bytes. The djb2 check did not
catch it because the sender hashed its own truncated read. Read the file
with an unformatted binary read, and write output files in binary mode.

Drop git from the alpine docker image (it was only needed by
FetchContent) and delete the now unused CMake/FindSpdLog.cmake.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: bsergean

CMake/FindSpdLog.cmake

@@ -313,38 +313,19 @@ if (IXWEBSOCKET_INSTALL)
   )
 endif()
 
-if (USE_WS OR USE_TEST)
-  include(FetchContent)
-
-  set(MSGPACK11_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-  set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "" FORCE)
-
-  FetchContent_Declare(msgpack11
-      GIT_REPOSITORY "https://github.com/ar90n/msgpack11"
-      GIT_TAG "892264112b52b75b37cb1f83c41abfb5aff765af"
-      GIT_SHALLOW 1)
-
-  FetchContent_Declare(spdlog
-      GIT_REPOSITORY "https://github.com/gabime/spdlog"
-      GIT_TAG "v1.17.0"
-      GIT_SHALLOW 1) 
-
-  FetchContent_MakeAvailable(spdlog msgpack11)
-
-  if (USE_WS)
-    add_subdirectory(ws)
-  endif()
-  if (USE_TEST)
-    FetchContent_Declare(Catch2
-      GIT_REPOSITORY "https://github.com/catchorg/Catch2"
-      GIT_TAG "v3.15.1"
-      GIT_SHALLOW 1)
-    
-    FetchContent_MakeAvailable(Catch2)
+#
+# ws and the unittest have no external dependency: everything they need is
+# either vendored in third_party (CLI11 and Catch2, as single files) or lives
+# in common/ (a tiny logger and serialization format). Nothing is downloaded at
+# configure time.
+#
+if (USE_WS)
+  add_subdirectory(ws)
+endif()
 
-    enable_testing()
-    add_subdirectory(test)
-  endif()
+if (USE_TEST)
+  enable_testing()
+  add_subdirectory(test)
 endif()
 
 if (BUILD_DEMO) 

CMakeLists.txt

@@ -0,0 +1,175 @@
+/*
+ *  IXLog.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2026 Machine Zone, Inc. All rights reserved.
+ *
+ *  A minimal, dependency free logger used by the ws utility and by the
+ *  unittest. It supports the {} placeholder syntax, writing to stdout/stderr
+ *  or to a log file, and is safe to call from multiple threads.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <ctime>
+#include <fstream>
+#include <iostream>
+#include <mutex>
+#include <sstream>
+#include <string>
+
+namespace ix
+{
+    namespace logger
+    {
+        enum class Level
+        {
+            Debug = 0,
+            Info = 1,
+            Warn = 2,
+            Error = 3
+        };
+
+        namespace detail
+        {
+            struct State
+            {
+                std::mutex mutex;
+                Level level = Level::Debug;
+                std::ofstream file;
+            };
+
+            inline State& state()
+            {
+                static State state;
+                return state;
+            }
+
+            // No argument left, the rest of the format string is written as is.
+            inline void format(std::ostream& os, const char* fmt)
+            {
+                os << fmt;
+            }
+
+            template<typename T, typename... Args>
+            void format(std::ostream& os, const char* fmt, const T& value, const Args&... args)
+            {
+                for (; *fmt != '\0'; ++fmt)
+                {
+                    if (fmt[0] == '{' && fmt[1] == '}')
+                    {
+                        os << value;
+                        format(os, fmt + 2, args...);
+                        return;
+                    }
+
+                    os << *fmt;
+                }
+            }
+
+            inline const char* levelName(Level level)
+            {
+                switch (level)
+                {
+                    case Level::Debug: return "debug";
+                    case Level::Warn: return "warning";
+                    case Level::Error: return "error";
+                    case Level::Info:
+                    default: return "info";
+                }
+            }
+
+            inline std::string timestamp()
+            {
+                auto now = std::chrono::system_clock::now();
+                auto time = std::chrono::system_clock::to_time_t(now);
+
+                // std::localtime is the only portable option (localtime_r and
+                // localtime_s are not available everywhere). It returns a
+                // pointer to a shared buffer, which is fine here since all our
+                // callers hold the logger mutex.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4996)
+#endif
+                struct tm tm = *std::localtime(&time);
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+                auto ms =
+                    std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) %
+                    1000;
+
+                char buffer[32];
+                std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", &tm);
+
+                std::stringstream ss;
+                ss << buffer << '.';
+                ss.fill('0');
+                ss.width(3);
+                ss << ms.count();
+                return ss.str();
+            }
+
+            template<typename... Args>
+            void write(Level level, const std::string& fmt, const Args&... args)
+            {
+                auto& s = state();
+                std::lock_guard<std::mutex> lock(s.mutex);
+
+                if (level < s.level) return;
+
+                std::stringstream ss;
+                format(ss, fmt.c_str(), args...);
+
+                std::ostream& os = s.file.is_open()
+                                       ? static_cast<std::ostream&>(s.file)
+                                       : (level == Level::Error ? std::cerr : std::cout);
+
+                os << '[' << timestamp() << "] [" << levelName(level) << "] " << ss.str()
+                   << std::endl;
+            }
+        } // namespace detail
+
+        inline void setLevel(Level level)
+        {
+            auto& s = detail::state();
+            std::lock_guard<std::mutex> lock(s.mutex);
+            s.level = level;
+        }
+
+        // Redirect all logs to a file. Returns false if the file cannot be opened.
+        inline bool setLogFile(const std::string& path)
+        {
+            auto& s = detail::state();
+            std::lock_guard<std::mutex> lock(s.mutex);
+
+            s.file.open(path.c_str(), std::ios::out | std::ios::trunc);
+            return s.file.is_open();
+        }
+    } // namespace logger
+
+    template<typename... Args>
+    void logDebug(const std::string& fmt, const Args&... args)
+    {
+        logger::detail::write(logger::Level::Debug, fmt, args...);
+    }
+
+    template<typename... Args>
+    void logInfo(const std::string& fmt, const Args&... args)
+    {
+        logger::detail::write(logger::Level::Info, fmt, args...);
+    }
+
+    template<typename... Args>
+    void logWarn(const std::string& fmt, const Args&... args)
+    {
+        logger::detail::write(logger::Level::Warn, fmt, args...);
+    }
+
+    template<typename... Args>
+    void logError(const std::string& fmt, const Args&... args)
+    {
+        logger::detail::write(logger::Level::Error, fmt, args...);
+    }
+} // namespace ix

common/IXLog.h

@@ -0,0 +1,140 @@
+/*
+ *  IXPdu.h
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2026 Machine Zone, Inc. All rights reserved.
+ *
+ *  A minimal, dependency free serialization format, used by the ws utility to
+ *  exchange structured messages (the chat, send, receive and transfer modes).
+ *
+ *  A pdu is a set of named fields, each one written on its own line as:
+ *
+ *      <name> <hex encoded value>
+ *
+ *  Names are plain ascii identifiers, values are hex encoded so that binary
+ *  payloads (a file content) can be carried without any escaping. This is not
+ *  compact (values take twice their size on the wire) but it is trivial to
+ *  produce, to parse and to eyeball while debugging.
+ *
+ *  This format is not compatible with the msgpack based one used by
+ *  IXWebSocket 12.0.1 and earlier.
+ */
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace ix
+{
+    typedef std::map<std::string, std::string> Pdu;
+
+    inline std::string hexEncode(const std::string& value)
+    {
+        static const char* digits = "0123456789abcdef";
+
+        std::string out;
+        out.reserve(value.size() * 2);
+
+        for (auto&& c : value)
+        {
+            auto byte = static_cast<unsigned char>(c);
+            out += digits[byte >> 4];
+            out += digits[byte & 0x0f];
+        }
+
+        return out;
+    }
+
+    inline std::string hexEncode(const std::vector<uint8_t>& value)
+    {
+        return hexEncode(std::string(value.begin(), value.end()));
+    }
+
+    inline bool hexDecode(const std::string& value, std::string& out)
+    {
+        if (value.size() % 2 != 0) return false;
+
+        out.clear();
+        out.reserve(value.size() / 2);
+
+        int nibbles[2];
+        for (size_t i = 0; i < value.size(); i += 2)
+        {
+            for (size_t j = 0; j < 2; ++j)
+            {
+                char c = value[i + j];
+
+                if (c >= '0' && c <= '9')
+                {
+                    nibbles[j] = c - '0';
+                }
+                else if (c >= 'a' && c <= 'f')
+                {
+                    nibbles[j] = c - 'a' + 10;
+                }
+                else if (c >= 'A' && c <= 'F')
+                {
+                    nibbles[j] = c - 'A' + 10;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            out += static_cast<char>((nibbles[0] << 4) | nibbles[1]);
+        }
+
+        return true;
+    }
+
+    inline std::string serializePdu(const Pdu& pdu)
+    {
+        std::string out;
+
+        for (auto&& it : pdu)
+        {
+            out += it.first;
+            out += ' ';
+            out += hexEncode(it.second);
+            out += '\n';
+        }
+
+        return out;
+    }
+
+    inline bool parsePdu(const std::string& str, Pdu& pdu)
+    {
+        pdu.clear();
+
+        std::string::size_type start = 0;
+        while (start < str.size())
+        {
+            auto end = str.find('\n', start);
+            if (end == std::string::npos) end = str.size();
+
+            auto line = str.substr(start, end - start);
+            start = end + 1;
+
+            if (line.empty()) continue;
+
+            auto sep = line.find(' ');
+            if (sep == std::string::npos) return false;
+
+            std::string value;
+            if (!hexDecode(line.substr(sep + 1), value)) return false;
+
+            pdu[line.substr(0, sep)] = value;
+        }
+
+        return true;
+    }
+
+    // Convenience accessor, returns an empty string for a missing field.
+    inline std::string getPduField(const Pdu& pdu, const std::string& name)
+    {
+        auto it = pdu.find(name);
+        return (it == pdu.end()) ? std::string() : it->second;
+    }
+} // namespace ix

common/IXPdu.h

@@ -2,7 +2,7 @@ FROM alpine:3.12 as build
 
 RUN apk add --no-cache \
     gcc g++ musl-dev linux-headers \
-    cmake mbedtls-dev make zlib-dev python3-dev ninja git
+    cmake mbedtls-dev make zlib-dev python3-dev ninja
 
 RUN addgroup -S app && \
     adduser -S -G app app && \