重构MultiplexManager，使用字符串ID替代uint32_t，优化TCPClient和TCPServer的客户端管理

tcp/tcp_client.cpp

@@ -1,7 +1,8 @@
 #include "tcp_client.h"
+#include "../steam/steam_networking_manager.h"
 #include <iostream>
 
-TCPClient::TCPClient(const std::string& host, int port) : host_(host), port_(port), connected_(false), disconnected_(false), socket_(std::make_shared<tcp::socket>(io_context_)), work_(boost::asio::make_work_guard(io_context_)), buffer_(1024) {}
+TCPClient::TCPClient(const std::string& host, int port, SteamNetworkingManager* manager) : host_(host), port_(port), connected_(false), disconnected_(false), socket_(std::make_shared<tcp::socket>(io_context_)), work_(boost::asio::make_work_guard(io_context_)), buffer_(1024), manager_(manager) {}
 
 TCPClient::~TCPClient() { disconnect(); }
 
@@ -11,12 +12,15 @@ bool TCPClient::connect() {
         auto endpoints = resolver.resolve(host_, std::to_string(port_));
         boost::asio::connect(*socket_, endpoints);
         connected_ = true;
+        multiplexManager_ = std::make_unique<MultiplexManager>(manager_->getInterface(), manager_->getConnection(),
+                                                                io_context_, manager_->getIsHost(), *manager_->getLocalPort());
+        std::string id = multiplexManager_->addClient(socket_);
         clientThread_ = std::thread([this]() { 
             std::cout << "Client thread started" << std::endl;
             io_context_.run(); 
             std::cout << "Client thread stopped" << std::endl;
         });
-        start_read();
+        start_read(id);
         std::cout << "Connected to " << host_ << ":" << port_ << std::endl;
         return true;
     } catch (const std::exception& e) {
@@ -44,6 +48,7 @@ void TCPClient::disconnect() {
     } catch (const std::exception& e) {
         std::cerr << "Error closing socket: " << e.what() << std::endl;
     }
+    multiplexManager_.reset();
 }
 
 void TCPClient::send(const std::string& message) {
@@ -69,32 +74,39 @@ void TCPClient::setReceiveCallback(std::function<void(const char*, size_t)> call
     receiveCallbackBytes_ = callback;
 }
 
-void TCPClient::setDisconnectCallback(std::function<void()> callback) {
-    disconnectCallback_ = callback;
-}
-
-void TCPClient::start_read() {
-    socket_->async_read_some(boost::asio::buffer(buffer_), [this](const boost::system::error_code& error, std::size_t bytes_transferred) {
-        handle_read(error, bytes_transferred);
+void TCPClient::start_read(std::string id) {
+    socket_->async_read_some(boost::asio::buffer(buffer_), [this, id](const boost::system::error_code& error, std::size_t bytes_transferred) {
+        handle_read(id, error, bytes_transferred);
     });
 }
 
-void TCPClient::handle_read(const boost::system::error_code& error, std::size_t bytes_transferred) {
+void TCPClient::handle_read(std::string id, const boost::system::error_code& error, std::size_t bytes_transferred) {
     if (!error) {
-        // std::cout << "Received " << bytes_transferred << " bytes" << std::endl;
+        std::cout << "Received " << bytes_transferred << " bytes from TCP server" << std::endl;
+        if (manager_->isConnected()) {
+            multiplexManager_->sendTunnelPacket(id, buffer_.data(), bytes_transferred, 0);
+        } else {
+            std::cout << "Not connected to Steam, skipping forward" << std::endl;
+        }
         if (receiveCallbackBytes_) {
             receiveCallbackBytes_(buffer_.data(), bytes_transferred);
         } else if (receiveCallback_) {
             std::string message(buffer_.data(), bytes_transferred);
             receiveCallback_(message);
         }
-        start_read();
+        start_read(id);
     } else {
         if (error == boost::asio::error::eof) {
             std::cout << "Connection closed by peer" << std::endl;
         } else {
             std::cerr << "Read failed: " << error.message() << std::endl;
         }
+        // Send disconnect packet
+        if (manager_->isConnected()) {
+            multiplexManager_->sendTunnelPacket(id, nullptr, 0, 1);
+        }
+        // Remove client
+        multiplexManager_->removeClient(id);
         if (disconnectCallback_) {
             disconnectCallback_();
         }

tcp/tcp_client.h

@@ -6,13 +6,16 @@
 #include <thread>
 #include <mutex>
 #include <functional>
+#include "../multiplex/multiplex_manager.h"
 
 using boost::asio::ip::tcp;
 
+class SteamNetworkingManager;
+
 // TCP Client class
 class TCPClient {
 public:
-    TCPClient(const std::string& host, int port);
+    TCPClient(const std::string& host, int port, SteamNetworkingManager* manager);
     ~TCPClient();
 
     bool connect();
@@ -22,10 +25,11 @@ public:
     void setReceiveCallback(std::function<void(const std::string&)> callback);
     void setReceiveCallback(std::function<void(const char*, size_t)> callback);
     void setDisconnectCallback(std::function<void()> callback);
+    MultiplexManager* getMultiplexManager() { return multiplexManager_.get(); }
 
 private:
-    void start_read();
-    void handle_read(const boost::system::error_code& error, std::size_t bytes_transferred);
+    void start_read(std::string id);
+    void handle_read(std::string id, const boost::system::error_code& error, std::size_t bytes_transferred);
 
     std::string host_;
     int port_;
@@ -40,4 +44,6 @@ private:
     std::function<void(const char*, size_t)> receiveCallbackBytes_;
     std::function<void()> disconnectCallback_;
     std::vector<char> buffer_;
+    SteamNetworkingManager* manager_;
+    std::unique_ptr<MultiplexManager> multiplexManager_;
 };

tcp/tcp_server.cpp

@@ -66,7 +66,7 @@ void TCPServer::start_accept() {
     acceptor_.async_accept(*socket, [this, socket](const boost::system::error_code& error) {
         if (!error) {
             std::cout << "New client connected" << std::endl;
-            uint32_t id = multiplexManager_->addClient(socket);
+            std::string id = multiplexManager_->addClient(socket);
             {
                 std::lock_guard<std::mutex> lock(clientsMutex_);
                 clients_.push_back(socket);
@@ -79,7 +79,7 @@ void TCPServer::start_accept() {
     });
 }
 
-void TCPServer::start_read(std::shared_ptr<tcp::socket> socket, uint32_t id) {
+void TCPServer::start_read(std::shared_ptr<tcp::socket> socket, std::string id) {
     auto buffer = std::make_shared<std::vector<char>>(1024);
     socket->async_read_some(boost::asio::buffer(*buffer), [this, socket, buffer, id](const boost::system::error_code& error, std::size_t bytes_transferred) {
         if (!error) {

tcp/tcp_server.h

@@ -31,7 +31,7 @@ public:
 
 private:
     void start_accept();
-    void start_read(std::shared_ptr<tcp::socket> socket, uint32_t id);
+    void start_read(std::shared_ptr<tcp::socket> socket, std::string id);
 
     int port_;
     bool running_;