#include "stdafx.h" #include "ProxyConnectServer.h" #define PROXY_RECV_CHUNK (16 * 1024) // 单次 recv 的上限 #define PROXY_POLL_MS 200 // select 轮询周期,决定 Shutdown/Disconnect 的响应时延 #define PROXY_SEND_TIMEOUT_MS 5000 // 向本机连接发送的超时,避免卡住调用方线程 CProxyConnectServer::CProxyConnectServer() { Mprintf("CProxyConnectServer\r\n"); } CProxyConnectServer::~CProxyConnectServer() { Shutdown(); Mprintf("~CProxyConnectServer\r\n"); } BOOL CProxyConnectServer::SetSocketOptions(SOCKET s) const { BOOL bNoDelay = TRUE; setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (const char*)&bNoDelay, sizeof(bNoDelay)); DWORD dwSendTimeout = PROXY_SEND_TIMEOUT_MS; setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (const char*)&dwSendTimeout, sizeof(dwSendTimeout)); return TRUE; } BOOL CProxyConnectServer::Initialize(PROXYNOTIFYPROC pNotifyProc, void* pUser, int nMaxConnections, int nPort) { if (m_bRunning.load(std::memory_order_acquire)) return FALSE; if (pNotifyProc == nullptr || nPort <= 0 || nPort > 65535) return FALSE; SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (s == INVALID_SOCKET) { Mprintf("CProxyConnectServer: socket() failed: %d\n", WSAGetLastError()); return FALSE; } // 用 SO_EXCLUSIVEADDRUSE 而不是 SO_REUSEADDR:Windows 上 SO_REUSEADDR 允许绑定一个 // 已被别人监听的端口(甚至会抢走对方的连接),对话框「端口被占用就换随机端口」的重试 // 逻辑会失效。EXCLUSIVE 让 bind 如实失败。 BOOL bExclusive = TRUE; setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&bExclusive, sizeof(bExclusive)); sockaddr_in addr = {}; addr.sin_family = AF_INET; addr.sin_addr.s_addr = INADDR_ANY; // 与原 HP-Socket 版一致:0.0.0.0 addr.sin_port = htons((u_short)nPort); if (bind(s, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) { Mprintf("CProxyConnectServer: bind(%d) failed: %d\n", nPort, WSAGetLastError()); closesocket(s); return FALSE; } if (listen(s, SOMAXCONN) == SOCKET_ERROR) { Mprintf("CProxyConnectServer: listen(%d) failed: %d\n", nPort, WSAGetLastError()); closesocket(s); return FALSE; } // 非阻塞:select 报可读后仍可能有竞争(对端在 accept 前 RST),避免 accept 卡住。 u_long ulNonBlock = 1; ioctlsocket(s, FIONBIO, &ulNonBlock); SetSocketOptions(s); m_pNotifyProc = pNotifyProc; m_pUser = pUser; m_nMaxConnection = nMaxConnections; m_nPort = (USHORT)nPort; m_listenSocket = s; m_bRunning.store(true, std::memory_order_release); m_acceptThread = std::thread(&CProxyConnectServer::AcceptLoop, this); Mprintf("CProxyConnectServer: listening on 0.0.0.0:%d\n", nPort); return TRUE; } void CProxyConnectServer::AcceptLoop() { while (m_bRunning.load(std::memory_order_acquire)) { fd_set readSet; FD_ZERO(&readSet); FD_SET(m_listenSocket, &readSet); timeval tv = {}; tv.tv_sec = 0; tv.tv_usec = PROXY_POLL_MS * 1000; int sel = select(0, &readSet, nullptr, nullptr, &tv); if (!m_bRunning.load(std::memory_order_acquire)) break; if (sel == SOCKET_ERROR) { Mprintf("CProxyConnectServer: select() failed: %d\n", WSAGetLastError()); break; } ReapFinished(); if (sel == 0) continue; sockaddr_in peer = {}; int peerLen = sizeof(peer); SOCKET s = accept(m_listenSocket, (sockaddr*)&peer, &peerLen); if (s == INVALID_SOCKET) { // 非阻塞 accept 的竞争(对端已断开)属正常,继续。 if (WSAGetLastError() != WSAEWOULDBLOCK) Mprintf("CProxyConnectServer: accept() failed: %d\n", WSAGetLastError()); continue; } if (m_nMaxConnection > 0 && GetConnectionCount() >= m_nMaxConnection) { Mprintf("CProxyConnectServer: reject, max connections (%d) reached\n", m_nMaxConnection); closesocket(s); continue; } SetSocketOptions(s); auto pConn = std::make_shared(); pConn->sock = s; { std::lock_guard lock(m_connLock); CONNID id = m_nextId++; if (m_nextId == 0) m_nextId = 1; // 回绕后仍跳过 0 while (m_conns.find(id) != m_conns.end()) { id = m_nextId++; if (m_nextId == 0) m_nextId = 1; } pConn->id = id; m_conns[id] = pConn; } char szPeer[64] = {}; inet_ntop(AF_INET, &peer.sin_addr, szPeer, sizeof(szPeer)); Mprintf("CProxyConnectServer: new connection #%u from %s:%u\n", pConn->id, szPeer, (UINT)ntohs(peer.sin_port)); // 先通知「新连接」(对话框据此建立会话状态),再开始收数据。 m_pNotifyProc(m_pUser, pConn->id, nullptr, 0, NC_CLIENT_CONNECT); pConn->thread = std::thread(&CProxyConnectServer::RelayLoop, this, pConn); } } void CProxyConnectServer::RelayLoop(std::shared_ptr pConn) { std::vector buf(PROXY_RECV_CHUNK); while (!pConn->stop.load(std::memory_order_acquire)) { fd_set readSet; FD_ZERO(&readSet); FD_SET(pConn->sock, &readSet); timeval tv = {}; tv.tv_sec = 0; tv.tv_usec = PROXY_POLL_MS * 1000; int sel = select(0, &readSet, nullptr, nullptr, &tv); if (sel == SOCKET_ERROR) break; if (sel == 0) continue; int nRecv = recv(pConn->sock, (char*)buf.data(), (int)buf.size(), 0); if (nRecv <= 0) break; // 0 = 对端关闭;<0 = 出错/已 shutdown m_pNotifyProc(m_pUser, pConn->id, buf.data(), (UINT)nRecv, NC_RECEIVE); } { std::lock_guard lock(pConn->sendLock); if (pConn->sock != INVALID_SOCKET) { closesocket(pConn->sock); pConn->sock = INVALID_SOCKET; } } Mprintf("CProxyConnectServer: connection #%u closed\n", pConn->id); m_pNotifyProc(m_pUser, pConn->id, nullptr, 0, NC_CLIENT_DISCONNECT); { std::lock_guard lock(m_connLock); m_conns.erase(pConn->id); std::lock_guard grave(m_graveLock); m_graveyard.push_back(pConn); // 由 accept 线程或 Shutdown 负责 join } pConn->finished.store(true, std::memory_order_release); } void CProxyConnectServer::ReapFinished() { std::vector> done; { std::lock_guard lock(m_graveLock); done.swap(m_graveyard); } for (auto& pConn : done) { if (pConn->thread.joinable()) pConn->thread.join(); } } BOOL CProxyConnectServer::Send(CONNID id, const BYTE* pData, UINT nSize) { if (pData == nullptr || nSize == 0) return FALSE; std::shared_ptr pConn; { std::lock_guard lock(m_connLock); auto it = m_conns.find(id); if (it == m_conns.end()) return FALSE; pConn = it->second; } std::lock_guard lock(pConn->sendLock); if (pConn->sock == INVALID_SOCKET) return FALSE; UINT sent = 0; while (sent < nSize) { int n = send(pConn->sock, (const char*)pData + sent, (int)(nSize - sent), 0); if (n <= 0) { Mprintf("CProxyConnectServer: send #%u failed: %d\n", id, WSAGetLastError()); return FALSE; } sent += (UINT)n; } return TRUE; } BOOL CProxyConnectServer::Disconnect(CONNID id) { std::shared_ptr pConn; { std::lock_guard lock(m_connLock); auto it = m_conns.find(id); if (it == m_conns.end()) return FALSE; pConn = it->second; } pConn->stop.store(true, std::memory_order_release); // 只 shutdown 不 close:关闭权归中继线程。这里与中继线程的 close 共用 sendLock, // 免得句柄已被关闭、又被系统复用给别的 socket 之后 shutdown 到别人身上。 std::lock_guard lock(pConn->sendLock); if (pConn->sock != INVALID_SOCKET) shutdown(pConn->sock, SD_BOTH); return TRUE; } int CProxyConnectServer::GetConnectionCount() { std::lock_guard lock(m_connLock); return (int)m_conns.size(); } void CProxyConnectServer::Shutdown() { if (!m_bRunning.exchange(false, std::memory_order_acq_rel)) return; // 1) 停 accept:accept 线程的 select 有 200ms 超时,靠 m_bRunning 自然退出, // 避免在其他线程里 close 一个正被 select 的监听句柄。 if (m_acceptThread.joinable()) m_acceptThread.join(); if (m_listenSocket != INVALID_SOCKET) { closesocket(m_listenSocket); m_listenSocket = INVALID_SOCKET; } // 2) 断开并等待所有中继线程。 std::vector> conns; { std::lock_guard lock(m_connLock); for (auto& kv : m_conns) conns.push_back(kv.second); m_conns.clear(); } for (auto& pConn : conns) { pConn->stop.store(true, std::memory_order_release); // 与 Disconnect 同理:shutdown 必须和中继线程的 closesocket 互斥, // 否则可能对一个已被回收复用的句柄动手。 std::lock_guard lock(pConn->sendLock); if (pConn->sock != INVALID_SOCKET) shutdown(pConn->sock, SD_BOTH); } for (auto& pConn : conns) { if (pConn->thread.joinable()) pConn->thread.join(); } // 3) 收割自然退出但还没 join 的连接。 ReapFinished(); Mprintf("CProxyConnectServer: shutdown, %d connection(s) closed\n", (int)conns.size()); }