@technoculture/safeserial 0.1.0 → 0.1.2

package/core/src/CMakeLists.txt

@@ -0,0 +1,21 @@
+add_library(safeserial STATIC
+    safeserial.cpp
+    resilient_bridge.cpp
+)
+
+safeserial_apply_sanitizers(safeserial)
+
+# Platform specific sources
+if(WIN32)
+    target_sources(safeserial PRIVATE transport/platform/windows/windows_serial.cpp)
+else()
+    target_sources(safeserial PRIVATE transport/platform/linux/linux_serial.cpp)
+endif()
+
+target_include_directories(safeserial PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+# Export the library name for other subdirectories
+set(SAFESERIAL_LIB safeserial PARENT_SCOPE)

package/core/src/protocol/packet.cpp

@@ -0,0 +1 @@
+#include "protocol/packet.hpp"

package/core/src/resilient_bridge.cpp

@@ -0,0 +1,338 @@
+#include <safeserial/resilient_bridge.hpp>
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <stdexcept>
+
+ResilientDataBridge::ResilientDataBridge()
+    : options_(Options::Defaults()) {}
+
+ResilientDataBridge::ResilientDataBridge(const Options& options)
+    : options_(options) {}
+
+ResilientDataBridge::ResilientDataBridge(
+    const Options& options,
+    std::function<std::shared_ptr<ISerialPort>()> serial_factory)
+    : options_(options),
+      serial_factory_(std::move(serial_factory)) {}
+
+ResilientDataBridge::~ResilientDataBridge() {
+    close();
+}
+
+bool ResilientDataBridge::open(const std::string& port) {
+    std::lock_guard<std::mutex> lock(state_mutex_);
+    if (connected_) {
+        return true;
+    }
+
+    port_ = port;
+    stop_ = false;
+    bool ok = connect();
+    if (!ok && options_.reconnect) {
+        start_reconnect_thread();
+    }
+    return ok;
+}
+
+void ResilientDataBridge::close() {
+    stop_ = true;
+    if (reconnect_thread_.joinable()) {
+        reconnect_thread_.join();
+    }
+    reconnect_thread_running_ = false;
+
+    {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        if (bridge_) {
+            bridge_->close();
+            bridge_.reset();
+        }
+        connected_ = false;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(queue_mutex_);
+        for (auto& msg : queue_) {
+            std::lock_guard<std::mutex> msg_lock(msg->mutex);
+            msg->failed = true;
+            msg->error = "Connection closed";
+            msg->done = true;
+            msg->cv.notify_all();
+        }
+        queue_.clear();
+    }
+
+    std::function<void()> cb;
+    {
+        std::lock_guard<std::mutex> lock(callback_mutex_);
+        cb = on_close_;
+    }
+    if (cb) {
+        cb();
+    }
+}
+
+bool ResilientDataBridge::connect() {
+    if (port_.empty()) {
+        notify_error("Port not set");
+        return false;
+    }
+
+    if (serial_factory_) {
+        auto serial = serial_factory_();
+        bridge_ = std::make_unique<DataBridge>(serial, options_.bridge);
+    } else {
+        bridge_ = std::make_unique<DataBridge>(options_.bridge);
+    }
+    bridge_->set_on_data([this](const std::vector<uint8_t>& data) {
+        std::function<void(const std::vector<uint8_t>&)> cb;
+        {
+            std::lock_guard<std::mutex> lock(callback_mutex_);
+            cb = on_data_;
+        }
+        if (cb) {
+            cb(data);
+        }
+    });
+
+    if (!bridge_->open(port_, options_.bridge.baud_rate)) {
+        bridge_.reset();
+        return false;
+    }
+
+    connected_ = true;
+    reconnect_attempt_ = 0;
+
+    std::function<void()> cb;
+    {
+        std::lock_guard<std::mutex> lock(callback_mutex_);
+        cb = on_reconnected_;
+    }
+    if (cb && reconnect_thread_running_) {
+        cb();
+    }
+
+    flush_queue();
+    return true;
+}
+
+void ResilientDataBridge::handle_disconnect(const std::string& reason) {
+    {
+        std::lock_guard<std::mutex> lock(state_mutex_);
+        if (!connected_) {
+            return;
+        }
+        connected_ = false;
+        if (bridge_) {
+            bridge_->close();
+            bridge_.reset();
+        }
+    }
+
+    std::function<void()> cb;
+    {
+        std::lock_guard<std::mutex> lock(callback_mutex_);
+        cb = on_disconnect_;
+    }
+    if (cb) {
+        cb();
+    }
+
+    notify_error(reason);
+
+    if (options_.reconnect && !stop_) {
+        start_reconnect_thread();
+    }
+}
+
+void ResilientDataBridge::start_reconnect_thread() {
+    if (reconnect_thread_running_) {
+        return;
+    }
+
+    reconnect_thread_running_ = true;
+    reconnect_thread_ = std::thread(&ResilientDataBridge::reconnect_loop, this);
+}
+
+void ResilientDataBridge::reconnect_loop() {
+    while (!stop_ && options_.reconnect) {
+        if (connected_) {
+            break;
+        }
+
+        reconnect_attempt_++;
+        uint32_t base_delay = options_.reconnect_delay_ms;
+        uint32_t max_delay = options_.max_reconnect_delay_ms;
+        uint32_t backoff = base_delay * static_cast<uint32_t>(std::pow(2, reconnect_attempt_ - 1));
+        uint32_t jitter = static_cast<uint32_t>(rng_() % 1000);
+        uint32_t delay = std::min(max_delay, backoff + jitter);
+
+        std::function<void(uint32_t, uint32_t)> cb;
+        {
+            std::lock_guard<std::mutex> lock(callback_mutex_);
+            cb = on_reconnecting_;
+        }
+        if (cb) {
+            cb(reconnect_attempt_, delay);
+        }
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(delay));
+        if (stop_) {
+            break;
+        }
+
+        bool ok = false;
+        if (!connected_) {
+            ok = connect();
+        } else {
+            ok = true;
+        }
+        if (ok) {
+            break;
+        }
+    }
+
+    reconnect_thread_running_ = false;
+}
+
+void ResilientDataBridge::flush_queue() {
+    while (!stop_ && connected_) {
+        std::shared_ptr<QueuedMessage> msg;
+        {
+            std::lock_guard<std::mutex> lock(queue_mutex_);
+            if (queue_.empty()) {
+                break;
+            }
+            msg = queue_.front();
+            queue_.erase(queue_.begin());
+        }
+
+        try {
+            int written = bridge_->send(
+                msg->data,
+                options_.bridge.ack_timeout_ms,
+                options_.bridge.max_retries,
+                options_.bridge.fragment_size);
+
+            {
+                std::lock_guard<std::mutex> msg_lock(msg->mutex);
+                msg->bytes_written = written;
+                msg->done = true;
+                msg->cv.notify_all();
+            }
+        } catch (const std::exception& ex) {
+            {
+                std::lock_guard<std::mutex> lock(queue_mutex_);
+                queue_.insert(queue_.begin(), msg);
+            }
+            handle_disconnect(ex.what());
+            break;
+        }
+    }
+}
+
+int ResilientDataBridge::send(const std::vector<uint8_t>& data) {
+    if (stop_) {
+        throw std::runtime_error("Connection closed");
+    }
+
+    if (connected_ && bridge_) {
+        try {
+            return bridge_->send(
+                data,
+                options_.bridge.ack_timeout_ms,
+                options_.bridge.max_retries,
+                options_.bridge.fragment_size);
+        } catch (const std::exception& ex) {
+            if (!options_.reconnect) {
+                throw;
+            }
+            handle_disconnect(ex.what());
+        }
+    } else if (!options_.reconnect) {
+        throw std::runtime_error("Not connected");
+    }
+
+    auto msg = std::make_shared<QueuedMessage>(data);
+    {
+        std::lock_guard<std::mutex> lock(queue_mutex_);
+        while (queue_.size() >= options_.max_queue_size) {
+            auto dropped = queue_.front();
+            queue_.erase(queue_.begin());
+            {
+                std::lock_guard<std::mutex> dropped_lock(dropped->mutex);
+                dropped->failed = true;
+                dropped->error = "Message dropped: queue overflow";
+                dropped->done = true;
+                dropped->cv.notify_all();
+            }
+        }
+        queue_.push_back(msg);
+    }
+
+    if (options_.reconnect && !reconnect_thread_running_) {
+        start_reconnect_thread();
+    }
+
+    std::unique_lock<std::mutex> lock(msg->mutex);
+    msg->cv.wait(lock, [&]() { return msg->done || stop_; });
+    if (stop_) {
+        throw std::runtime_error("Connection closed");
+    }
+    if (msg->failed) {
+        throw std::runtime_error(msg->error);
+    }
+    return msg->bytes_written;
+}
+
+bool ResilientDataBridge::is_connected() const {
+    return connected_.load();
+}
+
+size_t ResilientDataBridge::queue_length() const {
+    std::lock_guard<std::mutex> lock(queue_mutex_);
+    return queue_.size();
+}
+
+void ResilientDataBridge::set_on_data(std::function<void(const std::vector<uint8_t>&)> callback) {
+    std::lock_guard<std::mutex> lock(callback_mutex_);
+    on_data_ = std::move(callback);
+}
+
+void ResilientDataBridge::set_on_error(std::function<void(const std::string&)> callback) {
+    std::lock_guard<std::mutex> lock(callback_mutex_);
+    on_error_ = std::move(callback);
+}
+
+void ResilientDataBridge::set_on_disconnect(std::function<void()> callback) {
+    std::lock_guard<std::mutex> lock(callback_mutex_);
+    on_disconnect_ = std::move(callback);
+}
+
+void ResilientDataBridge::set_on_reconnecting(std::function<void(uint32_t, uint32_t)> callback) {
+    std::lock_guard<std::mutex> lock(callback_mutex_);
+    on_reconnecting_ = std::move(callback);
+}
+
+void ResilientDataBridge::set_on_reconnected(std::function<void()> callback) {
+    std::lock_guard<std::mutex> lock(callback_mutex_);
+    on_reconnected_ = std::move(callback);
+}
+
+void ResilientDataBridge::set_on_close(std::function<void()> callback) {
+    std::lock_guard<std::mutex> lock(callback_mutex_);
+    on_close_ = std::move(callback);
+}
+
+void ResilientDataBridge::notify_error(const std::string& message) {
+    std::function<void(const std::string&)> cb;
+    {
+        std::lock_guard<std::mutex> lock(callback_mutex_);
+        cb = on_error_;
+    }
+    if (cb) {
+        cb(message);
+    }
+}

package/core/src/safeserial.cpp

@@ -0,0 +1,246 @@
+#include <safeserial/safeserial.hpp>
+
+#include <algorithm>
+#include <chrono>
+#include <stdexcept>
+
+namespace {
+std::vector<uint8_t> slice_payload(const std::vector<uint8_t>& data, size_t offset, size_t len) {
+    auto start = data.begin() + static_cast<std::vector<uint8_t>::difference_type>(offset);
+    auto end = data.begin() + static_cast<std::vector<uint8_t>::difference_type>(offset + len);
+    return std::vector<uint8_t>(start, end);
+}
+} // namespace
+
+DataBridge::DataBridge()
+    : serial_(std::make_shared<SerialPort>()),
+      options_(Options::Defaults()) {}
+
+DataBridge::DataBridge(const Options& options)
+    : serial_(std::make_shared<SerialPort>()),
+      options_(options) {}
+
+DataBridge::DataBridge(std::shared_ptr<ISerialPort> serial, const Options& options)
+    : serial_(std::move(serial)),
+      options_(options) {
+    if (!serial_) {
+        serial_ = std::make_shared<SerialPort>();
+    }
+}
+
+DataBridge::~DataBridge() {
+    close();
+}
+
+bool DataBridge::open(const std::string& port, int baud_rate_override) {
+    if (is_open_) {
+        return true;
+    }
+
+    int baud_rate = baud_rate_override > 0 ? baud_rate_override : options_.baud_rate;
+    if (!serial_->open(port, baud_rate)) {
+        return false;
+    }
+
+    stop_ = false;
+    is_open_ = true;
+    receive_thread_ = std::thread(&DataBridge::receive_loop, this);
+    return true;
+}
+
+void DataBridge::close() {
+    if (!is_open_) {
+        return;
+    }
+
+    stop_ = true;
+    {
+        std::lock_guard<std::mutex> lock(ack_mutex_);
+        waiting_for_ack_ = false;
+        acked_ = true;
+    }
+    ack_cv_.notify_all();
+
+    if (receive_thread_.joinable()) {
+        receive_thread_.join();
+    }
+
+    serial_->close();
+    is_open_ = false;
+}
+
+bool DataBridge::is_open() const {
+    return is_open_.load();
+}
+
+int DataBridge::send(const std::vector<uint8_t>& data,
+                     uint16_t ack_timeout_ms_override,
+                     uint8_t max_retries_override,
+                     uint16_t fragment_size_override) {
+    if (!is_open_) {
+        throw std::runtime_error("Port not open");
+    }
+
+    std::lock_guard<std::mutex> send_lock(send_mutex_);
+
+    uint16_t fragment_size = fragment_size_override > 0 ? fragment_size_override : options_.fragment_size;
+    uint16_t ack_timeout_ms = ack_timeout_ms_override > 0 ? ack_timeout_ms_override : options_.ack_timeout_ms;
+    uint8_t max_retries = max_retries_override > 0 ? max_retries_override : options_.max_retries;
+
+    if (fragment_size == 0) {
+        throw std::runtime_error("Invalid fragment size");
+    }
+
+    size_t total_frags = (data.empty() ? 1 : (data.size() + fragment_size - 1) / fragment_size);
+    uint8_t seq = 0;
+    {
+        std::lock_guard<std::mutex> lock(seq_mutex_);
+        seq = next_seq_;
+        next_seq_ = static_cast<uint8_t>((next_seq_ + 1) % 256);
+    }
+
+    int total_written = 0;
+    for (size_t frag_id = 0; frag_id < total_frags; ++frag_id) {
+        size_t offset = frag_id * fragment_size;
+        size_t len = data.empty() ? 0 : std::min<size_t>(fragment_size, data.size() - offset);
+        std::vector<uint8_t> fragment = slice_payload(data, offset, len);
+
+        std::string payload;
+        if (!fragment.empty()) {
+            payload.assign(reinterpret_cast<const char*>(fragment.data()), fragment.size());
+        }
+        std::vector<uint8_t> packet = Packet::serialize(
+            Packet::TYPE_DATA,
+            seq,
+            payload,
+            static_cast<uint16_t>(frag_id),
+            static_cast<uint16_t>(total_frags));
+
+        uint8_t retries = 0;
+        bool acked = false;
+        int bytes_written = 0;
+        while (retries <= max_retries && !acked) {
+            {
+                std::lock_guard<std::mutex> lock(ack_mutex_);
+                waiting_for_ack_ = true;
+                acked_ = false;
+                waiting_seq_ = seq;
+                waiting_frag_ = static_cast<uint16_t>(frag_id);
+            }
+
+            {
+                std::lock_guard<std::mutex> lock(write_mutex_);
+                bytes_written = serial_->write(packet);
+            }
+
+            std::unique_lock<std::mutex> lock(ack_mutex_);
+            bool notified = ack_cv_.wait_for(
+                lock,
+                std::chrono::milliseconds(ack_timeout_ms),
+                [this]() { return acked_ || stop_; });
+
+            if (stop_) {
+                throw std::runtime_error("Connection closed");
+            }
+
+            if (notified && acked_) {
+                acked = true;
+                waiting_for_ack_ = false;
+                total_written += bytes_written;
+            } else {
+                retries++;
+            }
+        }
+
+        if (!acked) {
+            throw std::runtime_error("Send failed after retries");
+        }
+    }
+
+    return total_written;
+}
+
+void DataBridge::set_on_data(std::function<void(const std::vector<uint8_t>&)> callback) {
+    std::lock_guard<std::mutex> lock(callback_mutex_);
+    on_data_ = std::move(callback);
+}
+
+size_t DataBridge::get_buffered_size() const {
+    return reassembler_.get_buffered_size();
+}
+
+void DataBridge::receive_loop() {
+    uint8_t buffer[1024];
+    while (!stop_) {
+        int n = serial_->read(buffer, sizeof(buffer));
+        if (n > 0) {
+            rx_buffer_.insert(rx_buffer_.end(), buffer, buffer + n);
+
+            while (true) {
+                size_t before = rx_buffer_.size();
+                Packet::Frame frame = Packet::deserialize(rx_buffer_);
+                if (!frame.valid) {
+                    if (rx_buffer_.size() == before) {
+                        break;
+                    }
+                    continue;
+                }
+                handle_frame(frame);
+            }
+        }
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+void DataBridge::handle_frame(const Packet::Frame& frame) {
+    if (frame.header.type == Packet::TYPE_ACK) {
+        std::lock_guard<std::mutex> lock(ack_mutex_);
+        if (waiting_for_ack_ &&
+            frame.header.seq_id == waiting_seq_ &&
+            frame.header.fragment_id == waiting_frag_) {
+            acked_ = true;
+            waiting_for_ack_ = false;
+            ack_cv_.notify_all();
+        }
+        return;
+    }
+
+    if (frame.header.type != Packet::TYPE_DATA) {
+        return;
+    }
+
+    bool should_ack = false;
+    if (reassembler_.process_fragment(frame)) {
+        should_ack = true;
+        if (reassembler_.is_complete(frame)) {
+            auto data = reassembler_.get_data();
+            std::function<void(const std::vector<uint8_t>&)> cb;
+            {
+                std::lock_guard<std::mutex> lock(callback_mutex_);
+                cb = on_data_;
+            }
+            if (cb) {
+                cb(data);
+            }
+        }
+    } else if (reassembler_.is_duplicate(frame)) {
+        should_ack = true;
+    }
+
+    if (should_ack) {
+        send_ack(frame);
+    }
+}
+
+void DataBridge::send_ack(const Packet::Frame& frame) {
+    std::vector<uint8_t> ack = Packet::serialize(
+        Packet::TYPE_ACK,
+        frame.header.seq_id,
+        "",
+        frame.header.fragment_id,
+        frame.header.total_frags);
+
+    std::lock_guard<std::mutex> lock(write_mutex_);
+    serial_->write(ack);
+}

package/core/src/transport/platform/linux/linux_serial.cpp

@@ -0,0 +1,53 @@
+#include <safeserial/transport/serial_port.hpp>
+#include <fcntl.h>
+#include <termios.h>
+#include <unistd.h>
+
+struct SerialPort::Impl {
+    int fd = -1;
+};
+
+SerialPort::SerialPort() : pimpl(std::make_unique<Impl>()) {}
+SerialPort::~SerialPort() { close(); }
+
+bool SerialPort::open(const std::string& port, int baud) {
+    pimpl->fd = ::open(port.c_str(), O_RDWR | O_NOCTTY | O_NDELAY);
+    if (pimpl->fd == -1) return false;
+
+    // Clear O_NDELAY to make it blocking (uses VTIME)
+    fcntl(pimpl->fd, F_SETFL, 0);
+
+    struct termios tty;
+    if (tcgetattr(pimpl->fd, &tty) != 0) return false;
+
+    cfsetospeed(&tty, B115200);
+    cfsetispeed(&tty, B115200);
+
+    // RAW MODE - Essential for binary/JSON data
+    cfmakeraw(&tty);
+    tty.c_cflag |= (CLOCAL | CREAD);
+    
+    // Explicitly disable flow control just in case cfmakeraw doesn't (it should)
+    tty.c_cflag &= ~CRTSCTS;
+
+    tty.c_cc[VMIN]  = 0;  // Non-blocking
+    tty.c_cc[VTIME] = 1;  // 0.1 second timeout (faster polling)
+
+    tcflush(pimpl->fd, TCIOFLUSH); // Flush on open to clear old buffer garbage
+    return tcsetattr(pimpl->fd, TCSANOW, &tty) == 0;
+}
+
+int SerialPort::write(const std::vector<uint8_t>& data) {
+    int written = ::write(pimpl->fd, data.data(), data.size());
+    // Note: tcdrain() removed - it blocks indefinitely on PTYs (used for testing)
+    // For real serial ports, the write() is sufficient as our protocol handles ACKs
+    return written;
+}
+
+int SerialPort::read(uint8_t* buffer, size_t size) {
+    return ::read(pimpl->fd, buffer, size);
+}
+
+void SerialPort::close() {
+    if (pimpl->fd != -1) { ::close(pimpl->fd); pimpl->fd = -1; }
+}

package/core/src/transport/platform/windows/windows_serial.cpp

@@ -0,0 +1,51 @@
+#include <safeserial/transport/serial_port.hpp>
+#include <windows.h>
+
+struct SerialPort::Impl {
+    HANDLE hSerial = INVALID_HANDLE_VALUE;
+};
+
+SerialPort::SerialPort() : pimpl(std::make_unique<Impl>()) {}
+SerialPort::~SerialPort() { close(); }
+
+bool SerialPort::open(const std::string& port, int baud) {
+    pimpl->hSerial = CreateFileA(port.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
+    if (pimpl->hSerial == INVALID_HANDLE_VALUE) return false;
+
+    DCB dcb = {0};
+    dcb.DCBlength = sizeof(dcb);
+    GetCommState(pimpl->hSerial, &dcb);
+    dcb.BaudRate = CBR_115200;
+    dcb.ByteSize = 8;
+    dcb.StopBits = ONESTOPBIT;
+    dcb.Parity   = NOPARITY;
+    SetCommState(pimpl->hSerial, &dcb);
+
+    // TIMEOUTS - Prevents the app from freezing
+    COMMTIMEOUTS timeouts = { 0 };
+    timeouts.ReadIntervalTimeout = 50;
+    timeouts.ReadTotalTimeoutConstant = 50;
+    timeouts.ReadTotalTimeoutMultiplier = 10;
+    SetCommTimeouts(pimpl->hSerial, &timeouts);
+
+    return true;
+}
+
+int SerialPort::write(const std::vector<uint8_t>& data) {
+    DWORD written;
+    WriteFile(pimpl->hSerial, data.data(), (DWORD)data.size(), &written, NULL);
+    return (int)written;
+}
+
+int SerialPort::read(uint8_t* buffer, size_t size) {
+    DWORD read;
+    if (!ReadFile(pimpl->hSerial, buffer, (DWORD)size, &read, NULL)) return -1;
+    return (int)read;
+}
+
+void SerialPort::close() {
+    if (pimpl->hSerial != INVALID_HANDLE_VALUE) {
+        CloseHandle(pimpl->hSerial);
+        pimpl->hSerial = INVALID_HANDLE_VALUE;
+    }
+}