Replace TCPThread with RAII ConnectionManager + Incoming/Outgoing threads

.github/workflows/build-debian.yml

@@ -19,11 +19,19 @@ jobs:
     - name: install_dependencies
       run: |
            sudo apt update
-           sudo apt install cmake debhelper devscripts qt6-base-dev qt6-base-dev-tools qt6-tools-dev build-essential
+           sudo apt install cmake debhelper devscripts qt6-base-dev qt6-base-dev-tools qt6-tools-dev build-essential qt6-translations-l10n libgl1-mesa-dev
+    - name: unit tests
+      env:
+        QT_QPA_PLATFORM: offscreen
+      run: |
+        cmake -S src -B build-tests \
+          -DCMAKE_BUILD_TYPE=Release \
+          -DPACKETSENDER_BUILD_TESTS=ON
+        cmake --build build-tests -j"$(nproc)"
+        ctest --test-dir build-tests --output-on-failure
     - name: build
       run: |
            debuild --no-lintian --no-sign
-
     - name: Collect Debian Artifacts
       run: |
         mkdir -p artifacts

.github/workflows/debian/control

@@ -2,7 +2,7 @@ Source: packetsender
 Section: net
 Priority: optional
 Maintainer: Joao Eriberto Mota Filho <eriberto@debian.org>
-Build-Depends: debhelper-compat (= 12), cmake, qt6-base-dev
+Build-Depends: debhelper-compat (= 12), cmake, build-essential, pkg-config, qt6-base-dev, qt6-base-dev-tools, qt6-tools-dev, qt6-tools-dev-tools, libgl1-mesa-dev, libssl-dev, qt6-translations-l10n
 Standards-Version: 4.5.0
 Homepage: https://packetsender.com/
 Rules-Requires-Root: no

.github/workflows/debian/rules

@@ -5,8 +5,15 @@ export QT_SELECT = qt6
 export DEB_BUILD_MAINT_OPTIONS = hardening=+all
 
 %:
-	dh $@ --sourcedirectory=src
+	dh $@ --buildsystem=cmake --sourcedirectory=src
+
+override_dh_auto_configure:
+	dh_auto_configure --buildsystem=cmake --sourcedirectory=src -- \
+	-DCMAKE_BUILD_TYPE=Release
 
 override_dh_auto_install:
 	dh_auto_install
-	mv debian/packetsender/usr/bin/PacketSender debian/packetsender/usr/bin/packetsender
+	# CMake target is PacketSender; package expects packetsender
+	if [ -f debian/packetsender/usr/bin/PacketSender ]; then \
+	mv debian/packetsender/usr/bin/PacketSender debian/packetsender/usr/bin/packetsender; \
+	fi

src/CMakeLists.txt

@@ -25,6 +25,7 @@ set(
   mainwindow.h
   panel.h
   globals.h
+  settingnames.h
   panelgenerator.h
   persistentconnection.h
   persistenthttp.h
@@ -62,6 +63,11 @@ set(
   PACKETSENDER_SRCS
   about.cpp
   brucethepoodle.cpp
+  connections/connection.cpp
+  connections/basetcpconnection.cpp
+  connections/incomingtcpconnection.cpp
+  connections/outgoingtcpconnection.cpp
+  connectionmanager.cpp
   irisandmarigold.cpp
   cloudui.cpp
   main.cpp
@@ -79,7 +85,6 @@ set(
   sendpacketbutton.cpp
   settings.cpp
   subnetcalc.cpp
-  tcpthread.cpp
   threadedtcpserver.cpp
   udpflooding.cpp
   languagechooser.cpp
@@ -88,6 +93,14 @@ set(
   association.cpp
   dtlsserver.cpp
   dtlsthread.cpp
+  packetsenderqsslsocketinterface.h
+  realqsslsocket.cpp
+  tcpThreads/basetcpthread.cpp
+  tcpThreads/outgoingtcpthread.cpp
+  tcpThreads/incomingtcpthread.cpp
+  fileutils.cpp
+  ConnectionStatusMessages.h
+  connections/persistentconnectionwiring.cpp
 )
 
 
@@ -178,6 +191,17 @@ if(APPLE)
   )
 endif()
 
+# ==================== UNIT TESTS (QtTest) ====================
+option(PACKETSENDER_BUILD_TESTS "Build unit tests (QtTest)" OFF)
+
+if(PACKETSENDER_BUILD_TESTS)
+  find_package(Qt6 REQUIRED COMPONENTS Test)
+
+  enable_testing()
+
+  add_subdirectory(tests/unit)
+endif()
+
 # -------------------
 # Packaging
 # -------------------

src/ConnectionStatusMessages.h

@@ -0,0 +1,24 @@
+//
+// Created by Tomas Gallucci on 7/4/26.
+//
+
+#ifndef CONNECTIONSTATUSMESSAGES_H
+#define CONNECTIONSTATUSMESSAGES_H
+#include <QString>
+
+class ConnectionStatusMessages
+{
+public:
+    static QString INCOMING_CONNECTION_ACCEPTED() { return QStringLiteral("Incoming connection accepted"); }
+    static QString ERROR_NO_SOCKET_AVAILABLE() { return QStringLiteral("Error: No socket available"); }
+    static QString ERROR_SOCKET_NOT_CONNECTED() { return QStringLiteral("Error: Socket not connected"); }
+    static QString SENDING_DATA() { return QStringLiteral("Sending data: "); }
+    static QString DISCONNECTED() { return QStringLiteral("Disconnected"); }
+    static QString SSL_CONNECTED() { return QStringLiteral("SSL Connected"); }
+    static QString SSL_HANDSHAKE_FAILED() { return QStringLiteral("SSL Handshake Failed"); }
+    static QString CONNECTED() { return QStringLiteral("Connected"); }
+    static QString COULD_NOT_CONNECT() { return QStringLiteral("Could not connect."); }
+    static QString CONNECTED_AND_IDLE() { return QStringLiteral("Connected and idle."); }
+    static QString WAITING_FOR_DATA_BEFORE_SEND() { return QStringLiteral("Waiting for data before send"); }
+};
+#endif //CONNECTIONSTATUSMESSAGES_H

src/connectionmanager.cpp

@@ -0,0 +1,130 @@
+//
+// Created by Tomas Gallucci on 3/5/26.
+//
+
+#include "connectionmanager.h"
+
+#include "connections/incomingtcpconnection.h"
+
+ConnectionManager::ConnectionManager(QObject *parent)
+    : QObject(parent)
+{
+}
+
+ConnectionManager::~ConnectionManager()
+{
+    shutdownAll();  // RAII: clean up on manager destruction
+}
+
+bool ConnectionManager::hasConnection(quint64 id)
+{
+    return connections.find(id) != connections.end();
+}
+
+void ConnectionManager::setupConnectionSignals(Connection* conn, quint64 id)
+{
+    if (!conn) return;
+
+    connect(conn, &Connection::dataReceived,
+            this, [this, id](const Packet& p) {
+                emit dataReceived(id, p);
+            });
+    connect(conn, &Connection::packetSent,
+            this, [this, id](const Packet& p) {
+                emit packetSent(id, p);
+            });
+
+    connect(conn, &Connection::stateChanged,
+            this, [this, id](const QString& msg) {
+                emit stateChanged(id, msg);
+            });
+
+    connect(conn, &Connection::errorOccurred,
+            this, [this, id](const QString& err) {
+                emit errorOccurred(id, err);
+            });
+
+    connect(conn, &Connection::disconnected,
+            this, [this, id]() {
+                if (
+                    const auto it = connections.find(id);
+                    it != connections.end() && it->second->isConnected())
+                {
+                    // QDEBUG() << "calling close() on connection in ConnectionManager::disconnect()";
+                    QDEBUG() << "removing connection from map in ConnectionManager::disconnect()";
+                    it->second->close();
+                    connections.erase(id);
+                    emit disconnected(id);
+                }
+            });
+}
+
+std::unique_ptr<OutgoingTcpConnection> ConnectionManager::createOutgoingTcpConnectionObject()
+{
+    return std::make_unique<OutgoingTcpConnection>(this);
+}
+
+std::unique_ptr<IncomingTcpConnection> ConnectionManager::createIncomingTcpConnectionObject()
+{
+    return std::make_unique<IncomingTcpConnection>(this);
+}
+
+std::pair<quint64, IncomingTcpConnection*> ConnectionManager::createIncomingTcpConnection()
+{
+    auto conn = createIncomingTcpConnectionObject();
+    quint64 id = nextId++;
+
+    IncomingTcpConnection* rawPtr = conn.get();
+    connections[id] = std::move(conn);
+    setupConnectionSignals(connections[id].get(), id);
+
+    return {id, rawPtr};
+}
+
+std::pair<quint64, OutgoingTcpConnection*> ConnectionManager::createOutgoingTcpConnection()
+{
+    auto conn = createOutgoingTcpConnectionObject();
+
+    quint64 id = nextId++;
+
+    OutgoingTcpConnection* rawPtr = conn.get();
+    connections[id] = std::move(conn);
+    setupConnectionSignals(connections[id].get(), id);
+
+    return {id, rawPtr};
+}
+
+void ConnectionManager::send(quint64 id, const Packet &packet)
+{
+    auto it = connections.find(id);
+    if (it != connections.end()) {
+        it->second->send(packet);
+    }
+}
+
+void ConnectionManager::close(quint64 id)
+{
+    QMutexLocker locker(&mutex);
+    const auto it = connections.find(id);
+
+    if (it == connections.end()) {
+        QDEBUG() << "returning early from ConnectionManager::close()";
+        return;                     // early return — very clear
+    }
+
+    if (it->second->isConnected()) {
+        QDEBUG() << "calling close on thread in ConnectionManager::close()";
+        it->second->close();
+        QDEBUG() << "called close on thread in ConnectionManager::close()";
+    }
+
+    QDEBUG() << "about to erase thread in ConnectionManager::close()";
+    connections.erase(it);
+    QDEBUG() << "erased thread in ConnectionManager::close()";
+}
+
+void ConnectionManager::shutdownAll()
+{
+    // Deleting unique_ptrs triggers Connection dtors → threads close/wait
+    connections.clear();
+}

src/connectionmanager.h

@@ -0,0 +1,66 @@
+//
+// Created by Tomas Gallucci on 3/5/26.
+//
+
+#ifndef CONNECTIONMANAGER_H
+#define CONNECTIONMANAGER_H
+
+
+#include <memory>
+#include <QMutex>
+#include <unordered_map>
+#include <utility>
+
+#include "packet.h"
+#include "connections/connection.h"
+#include "connections/incomingtcpconnection.h"
+#include "connections/outgoingtcpconnection.h"
+
+class ConnectionManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ConnectionManager(QObject *parent = nullptr);
+    ~ConnectionManager() override;
+
+    bool hasConnection(quint64 id);
+
+    // Factory methods - explicit about type for future extensibility
+    std::pair<quint64, IncomingTcpConnection*> createIncomingTcpConnection();
+    std::pair<quint64, OutgoingTcpConnection*> createOutgoingTcpConnection();
+
+    // Send data to connection by ID
+    void send(quint64 id, const Packet &packet);
+
+    // Close a specific connection
+    void close(quint64 id);
+
+    // Shut down all connections (called on app quit or server disable)
+    void shutdownAll();
+
+signals:
+    // Forwarded with connection ID prefix
+    void packetSent(quint64 id, const Packet& packet);
+    void dataReceived(quint64 id, const Packet& packet);
+    void stateChanged(quint64 id, const QString& message);
+    void errorOccurred(quint64 id, const QString& errorString);
+    void disconnected(quint64 id);
+
+protected:
+    std::unordered_map<quint64, std::unique_ptr<Connection>> connections;
+    quint64 nextId = 1;
+
+    virtual void setupConnectionSignals(Connection* conn, quint64 id);
+
+    // these methods exist so I didn't have to make the public API virtual, but we can
+    // still override the creation of objects in test doubles
+    virtual std::unique_ptr<OutgoingTcpConnection> createOutgoingTcpConnectionObject();
+    virtual std::unique_ptr<IncomingTcpConnection> createIncomingTcpConnectionObject();
+
+private:
+    QMutex mutex;   // protects thread shutdown
+};
+
+
+#endif //CONNECTIONMANAGER_H