Fix: Make the WebSocket transport reachable and bounded on every platform

The POSIX clients were built without a connection config - Linux, macOS and
Android all construct IOCPClient without the injected CONNECT_ADDRESS - so
ConnectServer saw protoType -1 and quietly dialled the master port in plain
TCP. Setting protoType to WS in their settings did nothing and logged nothing,
and since CLIENT_CAP_PROTO_SWITCH is Windows-only the server could not move
them either. Give the client a SetDefaultProto() for that construction path
and call it from all three mains before the reconnect loop, with a one-shot
log when neither a conn nor a default protocol is available so the silent
fallback becomes visible next time.

Bound what a peer can make the client read. ReadHeader accepted the 8-byte
extended length and rejected only the sign bit, so a frame length of nearly
2^63 kept the connection streaming into a frame that would never end - alive
but never delivering another packet. Cap single frames at 256 MB, the same
value ServerWsSession already applies to client frames, and drop the
connection past it; real traffic is far below that.

Stop Reset() from writing the receive thread's frame state. Disconnect() can
run from the heartbeat or command thread, not just the receive thread, so
Reset() now only flips the atomic ready flag and a new ResetFrames() clears
m_remaining, m_masked and m_maskPos from Handshake() alone, before the
receive thread starts reading the socket. Those fields keep a single owner
without adding a lock to the receive hot path.

Finish a dead WS session instead of leaving it to the keepalive timer. When
the session had closed but wsState was still WS_Ready, sends were dropped and
nothing woke the pending recv, so a peer that closed and then went quiet held
the context for the 3-minute keepalive. shutdown() the socket there so the
recv returns zero bytes and the normal -2 teardown runs; RemoveStaleContext
would deadlock against the caller's own IoRefCount and can hand back a reused
context.

That shutdown only finishes the connection if a zero-byte read still tears it
down, and on the plain path it no longer did. DispatchPlain answers an empty
buffer with "handled", so a peer's FIN left the connection in CLOSE_WAIT
until keepalive - holding an IOCP context, a pending WSARecv and a rate-limit
slot - where the pre-WS code called ParseReceivedData and tore down at once.
Restore that teardown on the TLS_Plain branch, matching the other two. Checked
against a Debug server: a plain socket that half-closes used to sit in
CLOSE_WAIT with the peer's recv timing out, and now disappears immediately
with recv returning zero.

Two smaller cleanups from the same review. Give the WS upgrade its own prefix
buffer (wsPreClassify) instead of borrowing the TLS sniffer's, which was
serially reused for two state machines and read as if it were one. And stop
deriving the build dialog's protoType from the combo box index: items now
carry the protocol value as item data, keyed off the index AddString returns,
so inserting an option in the middle can no longer write the wrong number into
the generated client without any error. ApplyProtoSwitch loses its bool
return, which contradicted its own side effects and was ignored by every
caller.

Co-Authored-By: deepseek-flash
This commit was merged in pull request #5.
This commit is contained in:
yuanyuanxianganddeepseek-flash committed 2026-10-30 19:15:14 +01:00
1 parent 50a489e316
commit 46f4bf2dfb
12 files changed
+149 -38

No files matched your search

+3
View File
@@ -591,6 +591,9 @@ static void ConnectionThread()
std::unique_ptr<IOCPClient> client(new IOCPClient(g_bExit, false)); std::unique_ptr<IOCPClient> client(new IOCPClient(g_bExit, false));
client->setManagerCallBack(nullptr, DataProcess, nullptr); client->setManagerCallBack(nullptr, DataProcess, nullptr);
// 同 Linux/macOS:不传 conn 的构造路径拿不到注入的 CONNECT_ADDRESS,协议必须显式喂进去,
// 否则配成 WS/WSS 也只会静默按明文 TCP 直连。Android 没有 TLS 通道,WSS 会 fail-closed。
client->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType);
int g_connAttempt = 0; int g_connAttempt = 0;
while (S_CLIENT_NORMAL == g_bExit && g_running.load()) { while (S_CLIENT_NORMAL == g_bExit && g_running.load()) {
+8 -9
View File
@@ -620,10 +620,10 @@ void ClearAllProtoSwitchKeys(iniFile& cfg)
cfg.SetStr("settings", k, ""); cfg.SetStr("settings", k, "");
} }
// 在每次建连前应用入口覆盖;返回 true 表示本次用的覆盖入口。 // 在每次建连前应用入口覆盖(就地改写 s,并落盘必要的状态)。没有返回值:它既会改 s 也会
// 覆盖撤销(还原命令 / 自动回退)→ 回到安装时的直连入口; // 改配置,用「是否用了覆盖入口」当返回值会与副作用矛盾——自动回退分支照样改写了 settings,
// 新入口超时(entry_try_at 未清零)→ 回退到切换前的入口并撤销覆盖。 // 却没法用一个 bool 表达,调用方也确实不需要这个信息。
bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s) void ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
{ {
if (!g_bootCaptured) { if (!g_bootCaptured) {
g_bootCaptured = true; g_bootCaptured = true;
@@ -637,7 +637,7 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
ClearAllProtoSwitchKeys(cfg); ClearAllProtoSwitchKeys(cfg);
Mprintf("[proto-switch] injected entry changed (%s -> %s), cleared stale switch state\n", Mprintf("[proto-switch] injected entry changed (%s -> %s), cleared stale switch state\n",
baseHost.c_str(), g_bootHost.c_str()); baseHost.c_str(), g_bootHost.c_str());
return false; return;
} }
const std::string proto = cfg.GetStr("settings", "proto_override"); const std::string proto = cfg.GetStr("settings", "proto_override");
@@ -652,13 +652,13 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
s.protoType = (char)baseProto; s.protoType = (char)baseProto;
Mprintf("[proto-switch] restored direct entry %s:%d proto=%d\n", host.c_str(), port, baseProto); Mprintf("[proto-switch] restored direct entry %s:%d proto=%d\n", host.c_str(), port, baseProto);
} }
return false; return;
} }
const int p = atoi(proto.c_str()); const int p = atoi(proto.c_str());
if (!IsSwitchableProto(p)) { if (!IsSwitchableProto(p)) {
ClearAllProtoSwitchKeys(cfg); // 坏值:撤销覆盖,按注入配置走 ClearAllProtoSwitchKeys(cfg); // 坏值:撤销覆盖,按注入配置走
return false; return;
} }
// 自动回退:切换后一直没登录成功(entry_try_at 由服务端下发时写入,登录成功后清零) // 自动回退:切换后一直没登录成功(entry_try_at 由服务端下发时写入,登录成功后清零)
@@ -686,7 +686,7 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
Mprintf("[proto-switch] new entry unreachable and no previous entry, override dropped\n"); Mprintf("[proto-switch] new entry unreachable and no previous entry, override dropped\n");
} }
cfg.SetStr("settings", "entry_try_at", "0"); cfg.SetStr("settings", "entry_try_at", "0");
return false; return;
} }
const std::string host = cfg.GetStr("settings", "entry_host"); const std::string host = cfg.GetStr("settings", "entry_host");
@@ -694,7 +694,6 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
if (!host.empty() && port > 0) if (!host.empty() && port > 0)
s.SetServer(host.c_str(), port); s.SetServer(host.c_str(), port);
s.protoType = (char)p; s.protoType = (char)p;
return true;
} }
// 新入口登录成功:撤销自动回退计时。入口覆盖本身保留——后续重连一直用它。 // 新入口登录成功:撤销自动回退计时。入口覆盖本身保留——后续重连一直用它。
+9 -1
View File
@@ -496,7 +496,15 @@ BOOL IOCPClient::ConnectServer(const char* szServerIP, unsigned short uPort)
// WebSocket 传输(PROTO_WS / PROTO_WSS):出站被限制在 80/443/8080 等端口时,经反代 // WebSocket 传输(PROTO_WS / PROTO_WSS):出站被限制在 80/443/8080 等端口时,经反代
// 分流进来。与应用协议无关,位置和 TLS 相同(TLS 之下、应用协议之上);须在 // 分流进来。与应用协议无关,位置和 TLS 相同(TLS 之下、应用协议之上);须在
// m_bConnected 置位前完成,确保工作线程不会在 Upgrade 尚未完成时就开始 recv。 // m_bConnected 置位前完成,确保工作线程不会在 Upgrade 尚未完成时就开始 recv。
const int protoType = m_conn ? (int)(unsigned char)m_conn->protoType : -1; // Linux / macOS / Android 不传 conn,协议由 SetDefaultProto 给出(见 IOCPClient.h)。
// 两边都没有时按明文直连,并留一行日志——否则「改成 WS 却毫无反应」无从排查。
const int protoType = m_conn ? (int)(unsigned char)m_conn->protoType : m_defaultProto;
if (!m_conn && m_defaultProto < 0) {
// 只记一次:重连循环每轮都会走到这里,否则日志会被刷满。
static std::atomic<bool> logged{false};
if (!logged.exchange(true))
Mprintf("[WS] 无连接配置(m_conn 为空)且未设置默认协议,本次按明文 TCP 直连\n");
}
const bool wsProto = (protoType == PROTO_WS || protoType == PROTO_WSS); const bool wsProto = (protoType == PROTO_WS || protoType == PROTO_WSS);
const bool wsTls = (protoType == PROTO_WSS); const bool wsTls = (protoType == PROTO_WSS);
m_useWs = false; m_useWs = false;
+8
View File
@@ -208,6 +208,12 @@ public:
m_nHostPort = uPort; m_nHostPort = uPort;
} }
// 没有 conn 的构造路径(Linux / macOS / Android 的 main 都是 new IOCPClient(exit, false))
// 用它给出传输协议:直接取外壳注入的 CONNECT_ADDRESS.protoType。不调用则保持 -1,
// ConnectServer 按明文 TCP 直连——那正是「配置成 WS 却毫无反应」的来源,故三个平台
// 的 main 都要在进入重连循环前调一次。
void SetDefaultProto(int p) { m_defaultProto = p; }
std::string ServerIP() const std::string ServerIP() const
{ {
return m_sCurIP; return m_sCurIP;
@@ -355,6 +361,8 @@ protected:
// 无害,但换成别的架构就不能再依赖这个巧合)。 // 无害,但换成别的架构就不能再依赖这个巧合)。
std::atomic<bool> m_useWs{false}; std::atomic<bool> m_useWs{false};
std::atomic<bool> m_loginAcked{false}; std::atomic<bool> m_loginAcked{false};
// m_conn 为空时的协议来源(见 SetDefaultProto)。-1 = 未设置,按明文 TCP 处理。
int m_defaultProto = -1;
#ifdef YAMA_TLS_CHANNEL #ifdef YAMA_TLS_CHANNEL
TlsChannel m_tls; // TLS 会话(证书存在时才启用,见 TlsChannel.h) TlsChannel m_tls; // TLS 会话(证书存在时才启用,见 TlsChannel.h)
// 本连接是否走 TLS:在 ConnectServer 里握手成功时置位、Disconnect 时清除,Send/Recv // 本连接是否走 TLS:在 ConnectServer 里握手成功时置位、Disconnect 时清除,Send/Recv
+2
View File
@@ -305,6 +305,8 @@ bool TlsChannel::VerifyServerCert()
return false; return false;
// 与 TlsReload 互斥:校验期间持有 g_tlsMtx,重建时释放的旧 store/engine 不会正被使用。 // 与 TlsReload 互斥:校验期间持有 g_tlsMtx,重建时释放的旧 store/engine 不会正被使用。
// 持锁时间很短:建链全是本地操作(DISABLE_AIA 禁联网取中间证书,也不带任何
// CERT_CHAIN_REVOCATION_CHECK_* 位),不会因为网络等待而卡住 TlsReload。
std::lock_guard<std::mutex> lk(g_tlsMtx); std::lock_guard<std::mutex> lk(g_tlsMtx);
if (!g_tlsStore || !g_tlsEngine) { if (!g_tlsStore || !g_tlsEngine) {
CertFreeCertificateContext(remote); CertFreeCertificateContext(remote);
+22 -6
View File
@@ -51,13 +51,12 @@ public:
void SetTls(TlsChannel* tls) { m_tls = tls; } void SetTls(TlsChannel* tls) { m_tls = tls; }
#endif #endif
// 每次连接前清理上一轮的帧状态。 // 让 Recv/Send 立刻失效。**可由任意线程调用**(Disconnect 可能来自心跳/命令线程,
// 不只是接收线程),因此这里只碰原子量;帧解析状态留给 ResetFrames()——它只在
// Handshake 里、接收线程还没起来时清。
void Reset() void Reset()
{ {
m_ready = false; m_ready = false;
m_remaining = 0;
m_masked = false;
m_maskPos = 0;
} }
bool IsReady() const { return m_ready; } bool IsReady() const { return m_ready; }
@@ -67,7 +66,7 @@ public:
bool Handshake(SOCKET sock, const std::string& host, int port, const char* path, std::string* err = NULL) bool Handshake(SOCKET sock, const std::string& host, int port, const char* path, std::string* err = NULL)
{ {
Reset(); Reset();
ResetFrames();
char hostPort[120] = { 0 }; char hostPort[120] = { 0 };
if (port == 80 || port == 443) if (port == 80 || port == 443)
snprintf(hostPort, sizeof(hostPort), "%s", host.c_str()); snprintf(hostPort, sizeof(hostPort), "%s", host.c_str());
@@ -257,6 +256,8 @@ private:
} }
// 读帧头(含扩展长度与掩码键)。服务端发来的帧不应带掩码,带了也照样解。 // 读帧头(含扩展长度与掩码键)。服务端发来的帧不应带掩码,带了也照样解。
static const long long kMaxFramePayload = 256LL * 1024 * 1024;
bool ReadHeader(SOCKET sock, unsigned char& opcode, long long& frameLen) bool ReadHeader(SOCKET sock, unsigned char& opcode, long long& frameLen)
{ {
unsigned char h[2] = { 0, 0 }; unsigned char h[2] = { 0, 0 };
@@ -284,6 +285,12 @@ private:
if (frameLen < 0) if (frameLen < 0)
return false; return false;
} }
// 单帧载荷上限,与主控端 ServerWsSession 的 kMaxFramePayload 取同一个值(256 MB)。
// 没有上限时,一个错误/被篡改的长度字段就能把 m_remaining 定在天文数字上,此后
// 所有字节都被当成该帧的内容吞掉,连接表面上还活着却永远收不到新包——比直接断线
// 难查得多。正常业务的最大单包远小于此值,故不会挡住既有功能。
if (frameLen > kMaxFramePayload)
return false;
if (m_masked && !ReadExact(sock, m_mask, 4)) if (m_masked && !ReadExact(sock, m_mask, 4))
return false; return false;
m_maskPos = 0; m_maskPos = 0;
@@ -377,7 +384,16 @@ private:
std::mutex m_sendMtx; std::mutex m_sendMtx;
std::vector<char> m_frame; std::vector<char> m_frame;
// 当前数据帧的剩余载荷长度与掩码状态(只由接收线程读写,无需加锁) // 当前数据帧的剩余载荷长度与掩码状态(只由接收线程读写,无需加锁)。
// 只能在接收线程未运行时清(见 public Reset()):Handshake 在连接线程上、m_bConnected
// 置位之前调用,那时接收线程还没开始读 socket。
void ResetFrames()
{
m_remaining = 0;
m_masked = false;
m_maskPos = 0;
}
long long m_remaining = 0; long long m_remaining = 0;
bool m_masked = false; bool m_masked = false;
unsigned char m_mask[4] = { 0, 0, 0, 0 }; unsigned char m_mask[4] = { 0, 0, 0, 0 };
+28 -6
View File
@@ -79,6 +79,10 @@ XOR、zstd、HTTP 伪装层)。WS 与 HTTP 伪装的 `MaskType` 互斥:选 W
线程都会写帧。 线程都会写帧。
- 不校验 `Sec-WebSocket-Accept`(设计上由 TLS + 隧道内登录承担)。明文 `PROTO_WS` 下这意味着 - 不校验 `Sec-WebSocket-Accept`(设计上由 TLS + 隧道内登录承担)。明文 `PROTO_WS` 下这意味着
中间人可以伪造 101 接管字节流——这正是「裸 WS 只适合内网」的另一半理由。 中间人可以伪造 101 接管字节流——这正是「裸 WS 只适合内网」的另一半理由。
- 没有 `conn` 的构造路径(Linux / macOS / Android 的 `main` 都是 `new IOCPClient(exit, false)`)
拿不到外壳注入的 `CONNECT_ADDRESS`,协议由 `IOCPClient::SetDefaultProto()` 显式给出;
三个平台的 `main` 都在进入重连循环前调一次。不调则保持 `-1`、按明文直连——那正是
「配置成 WS 却毫无反应」的来源,所以这里留了一行日志便于排查。
### 3.1 信任模型:不换锚,靠 SNI 分流 ### 3.1 信任模型:不换锚,靠 SNI 分流
@@ -197,7 +201,8 @@ WS 叠在同一层状态机之上,**与 TLS 是分层而不是并列**(`wss`
- 状态机:`ServerWsState { WS_Undecided → WS_Handshaking → WS_Ready | WS_None }` 与既有的 - 状态机:`ServerWsState { WS_Undecided → WS_Handshaking → WS_Ready | WS_None }` 与既有的
`ServerTlsState` 并存;`CONTEXT_OBJECT` 复用(`InitMember`)时一并复位并释放会话。 `ServerTlsState` 并存;`CONTEXT_OBJECT` 复用(`InitMember`)时一并复位并释放会话。
- 判定点:**明文的第一段有 ≥6 字节**才开始分类(与 ClientHello 嗅探同一下限), - 判定点:**明文的第一段有 ≥6 字节**才开始分类(与 ClientHello 嗅探同一下限),
避免把「请求头还没到齐」误判掉;阈值内的字节攒在 `tlsPreClassify` 里。 避免把「请求头还没到齐」误判掉;阈值内的字节攒在 `wsPreClassify` 里(与 TLS 嗅探的
`tlsPreClassify` 分开,两者服务不同状态机,串行使用但字段不共用)。
- 升级线程与 TLS 握手线程同构:`FIONBIO=0`(该套接字常是非阻塞的,`ioctlsocket` 会以 - 升级线程与 TLS 握手线程同构:`FIONBIO=0`(该套接字常是非阻塞的,`ioctlsocket` 会以
`WSAEINVAL` 失败),15 s 收发超时,遇 `WSAEWOULDBLOCK` 用 `select` 等可读/可写再试; `WSAEINVAL` 失败),15 s 收发超时,遇 `WSAEWOULDBLOCK` 用 `select` 等可读/可写再试;
线程持有一枚 `IoRefCount`,结束后把 socket 交还 IOCP(`PostRecv`)。升级响应之后同批 线程持有一枚 `IoRefCount`,结束后把 socket 交还 IOCP(`PostRecv`)。升级响应之后同批
@@ -218,8 +223,15 @@ WS 叠在同一层状态机之上,**与 TLS 是分层而不是并列**(`wss`
- fail-closed 的两处:握手期间(`wsState == WS_Handshaking`)收到 IORead 直接断开(判断 - fail-closed 的两处:握手期间(`wsState == WS_Handshaking`)收到 IORead 直接断开(判断
放在 `OnClientReceiving` 最开头,WSS 下 `tlsState` 已是 `TLS_Ready`,放在 TLS 分支之后 放在 `OnClientReceiving` 最开头,WSS 下 `tlsState` 已是 `TLS_Ready`,放在 TLS 分支之后
就不生效);`wsState == WS_Ready` 但会话已关时,应用字节**丢弃而不是裸发**,否则对端 就不生效);`wsState == WS_Ready` 但会话已关时,应用字节**丢弃而不是裸发**,否则对端
解帧错位。 解帧错位;同时对该 socket 做一次 `shutdown(SD_BOTH)`,让挂起的 recv 立刻返回 0 字节,
由接收路径走正常的 `-2` 收尾(不在这里直接 `RemoveStaleContext`——调用方往往本身就
持有 `IoRefCount`,自己等自己会超时,且可能把已回收复用的上下文交回给调用者)。
- 既有客户端零影响:非 `GET ` 首包在攒够 6 字节后原样进入 `ParseReceivedData`。 - 既有客户端零影响:非 `GET ` 首包在攒够 6 字节后原样进入 `ParseReceivedData`。
- 收尾一致:`dwTrans == 0`(对端 FIN)在 `TLS_Unclassified` / `TLS_Ready` / `TLS_Plain`
三条分支上都必须 `RemoveStaleContext`。WS 改造把 `TLS_Plain` 的 `ParseReceivedData`
换成 `DispatchPlain` 后,`DispatchPlain` 对空数据返回「已处理」,这个判断一度丢了,
连接会停在 CLOSE_WAIT 直到 keepalive(3 分钟),期间占着 IOCP 上下文、一枚挂起的
`WSARecv` 和限流槽。现已补回。
## 5. nginx 最小改动 ## 5. nginx 最小改动
@@ -426,7 +438,9 @@ server {
- 客户端落盘(`settings` 下):`proto_override` / `entry_host` / `entry_port` / - 客户端落盘(`settings` 下):`proto_override` / `entry_host` / `entry_port` /
`entry_try_at` 为当前覆盖;`base_*` 是首次切换时记下的安装入口(「还原」用它);`prev_*` `entry_try_at` 为当前覆盖;`base_*` 是首次切换时记下的安装入口(「还原」用它);`prev_*`
是每次切换前的入口(自动回退用它)。重连循环在建连前 `ApplyProtoSwitch` 覆盖入口——位置 是每次切换前的入口(自动回退用它)。重连循环在建连前 `ApplyProtoSwitch` 覆盖入口——位置
在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去。 在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去。(该函数返回 `void`:它既写
配置也改 `CONNECT_ADDRESS`,返回值无法表达「部分完成」,早期版本里的 `return false`
只是提前退出,调用方一直忽略它。)
- 撤销自动回退的判据是**登录被接受**,不是「连接建立」。客户端在收到 - 撤销自动回退的判据是**登录被接受**,不是「连接建立」。客户端在收到
`CMD_MASTERSETTING` 时把当前连接标记为已登录(服务端只有在把本机加入在线列表之后才下发 `CMD_MASTERSETTING` 时把当前连接标记为已登录(服务端只有在把本机加入在线列表之后才下发
它),重连循环每轮心跳都检查一次,命中才 `ConfirmProtoSwitch` 把 `entry_try_at` 清零。 它),重连循环每轮心跳都检查一次,命中才 `ConfirmProtoSwitch` 把 `entry_try_at` 清零。
@@ -444,13 +458,21 @@ server {
## 10. 审查遗留(已知边界,未改动) ## 10. 审查遗留(已知边界,未改动)
以下条目来自 PR 审查,评估后保留现状,记录在此以免重复讨论: 以下条目来自 PR 审查,记录在此以免重复讨论。带「已处理」的是复查后**已经改掉**的,
留在这里说明当时的判断,其余评估后保留现状:
- **`GetPeerName(SOCKET)` 只走 `sockaddr_in`(IPv4)**:`ServerWsSession.cpp::IsLoopbackPeer` - **`GetPeerName(SOCKET)` 只走 `sockaddr_in`(IPv4)**:`ServerWsSession.cpp::IsLoopbackPeer`
里的 `::1` / `::ffff:127.0.0.1` 分支目前是死代码。将来若监听 IPv6,转发头信任也需要跟着 里的 `::1` / `::ffff:127.0.0.1` 分支目前是死代码。将来若监听 IPv6,转发头信任也需要跟着
改,否则会静默失效。 改,否则会静默失效。
- **`tlsPreClassify` 名不副实**:它现在同时承担 ClientHello 嗅探与 WS 前缀("GET ")buffering。 - **`tlsPreClassify` 名不副实**:已处理——WS 的 "GET " 前缀缓冲拆成独立的 `wsPreClassify`,
改名会牵动状态机注释与多处引用,暂保留原名字,语义见 §4.2。 `tlsPreClassify` 回归 ClientHello 嗅探单一职责(两条路径仍按先后串行,互不重叠)。
- **`WsChannel::Reset()` 与接收线程的帧状态**:已处理——`Disconnect()` 可能来自心跳/命令线程,
不只是接收线程,所以 `Reset()` 现在只翻转原子的 `m_ready`;`m_remaining` / `m_masked` /
`m_maskPos` 改由 `ResetFrames()` 清,且只在 `Handshake()` 里(连接线程、接收线程尚未起来)
调用。这样这几个字段始终只有一个线程访问,不用加锁。
- **客户端单帧载荷上限 256 MB**(`WsChannel::kMaxFramePayload`,与 `ServerWsSession` 同值):
超过即按错误断开。没有上限时一个错误长度字段就能把 `m_remaining` 定在天文数字上,
连接「活着但永远收不到新包」。正常业务的最大单包远小于此值。
- **`DispatchPlain` 对明文首包引入「攒够 6 字节再解析」**:这是既有路径的行为变更。当前首包 - **`DispatchPlain` 对明文首包引入「攒够 6 字节再解析」**:这是既有路径的行为变更。当前首包
是登录包(远大于 6 字节),实际无影响;极端情况下(<6 字节的合法首包)会多等一轮收包。 是登录包(远大于 6 字节),实际无影响;极端情况下(<6 字节的合法首包)会多等一轮收包。
- **客户端不校验 `Sec-WebSocket-Accept`**:见 §3;明文 WS 下中间人可伪造 101,已在 §8 明确 - **客户端不校验 `Sec-WebSocket-Accept`**:见 §3;明文 WS 下中间人可伪造 101,已在 §8 明确
+7
View File
@@ -1379,6 +1379,13 @@ int main(int argc, char* argv[])
std::unique_ptr<IOCPClient> ClientObject(new IOCPClient(g_bExit, false)); std::unique_ptr<IOCPClient> ClientObject(new IOCPClient(g_bExit, false));
ClientObject->setManagerCallBack(NULL, DataProcess, NULL); ClientObject->setManagerCallBack(NULL, DataProcess, NULL);
// 不传 conn 的构造路径拿不到注入的 CONNECT_ADDRESS,协议只能显式喂进去:否则哪怕
// g_SETTINGS.protoType 配成 WS/WSS,也会静默按明文 TCP 直连(日志里一个字都没有)。
ClientObject->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType);
if (g_SETTINGS.protoType == PROTO_WS || g_SETTINGS.protoType == PROTO_WSS) {
Mprintf("[WS] 按配置的传输协议连接: proto=%d(WSS 需要 TLS 支持,不支持的平台会 fail-closed)\n",
(int)(unsigned char)g_SETTINGS.protoType);
}
g_pMainClient = ClientObject.get(); // 自升级失败回报用 g_pMainClient = ClientObject.get(); // 自升级失败回报用
while (!g_bExit) { while (!g_bExit) {
clock_t c = clock(); clock_t c = clock();
+7
View File
@@ -942,6 +942,13 @@ int main(int argc, const char* argv[])
// Create client // Create client
auto ClientObject = std::make_unique<IOCPClient>(g_bExit, false); auto ClientObject = std::make_unique<IOCPClient>(g_bExit, false);
ClientObject->setManagerCallBack(NULL, DataProcess, NULL); ClientObject->setManagerCallBack(NULL, DataProcess, NULL);
// 同 Linux:不传 conn 就取不到注入的 CONNECT_ADDRESS,协议必须显式喂进去,
// 否则配成 WS/WSS 也只会静默按明文 TCP 直连。
ClientObject->SetDefaultProto((int)(unsigned char)g_SETTINGS.protoType);
if (g_SETTINGS.protoType == PROTO_WS || g_SETTINGS.protoType == PROTO_WSS) {
Mprintf("[WS] 按配置的传输协议连接: proto=%d(WSS 需要 TLS 支持,不支持的平台会 fail-closed)\n",
(int)(unsigned char)g_SETTINGS.protoType);
}
// Main event loop // Main event loop
NSLog(@"Starting main loop..."); NSLog(@"Starting main loop...");
+25 -10
View File
@@ -542,7 +542,14 @@ void CBuildDlg::OnBnClickedOk()
g_ConnectAddress.SetAdminId(GetMasterHash().c_str()); g_ConnectAddress.SetAdminId(GetMasterHash().c_str());
g_ConnectAddress.SetServer(m_strIP, atoi(m_strPort)); g_ConnectAddress.SetServer(m_strIP, atoi(m_strPort));
g_ConnectAddress.runningType = m_ComboRunType.GetCurSel(); g_ConnectAddress.runningType = m_ComboRunType.GetCurSel();
g_ConnectAddress.protoType = m_ComboProto.GetCurSel(); // 协议值取自 item data(见 OnInitDialog 里的 addProto)。取不到时退回序号,保持旧行为。
int protoSel = m_ComboProto.GetCurSel();
if (protoSel >= 0) {
DWORD_PTR protoData = m_ComboProto.GetItemData(protoSel);
if (protoData != (DWORD_PTR)CB_ERR)
protoSel = (int)protoData;
}
g_ConnectAddress.protoType = protoSel;
g_ConnectAddress.iHeaderEnc = m_ComboEncrypt.GetCurSel(); g_ConnectAddress.iHeaderEnc = m_ComboEncrypt.GetCurSel();
memcpy(g_ConnectAddress.pwdHash, GetPwdHash().c_str(), sizeof(g_ConnectAddress.pwdHash)); memcpy(g_ConnectAddress.pwdHash, GetPwdHash().c_str(), sizeof(g_ConnectAddress.pwdHash));
memcpy(g_ConnectAddress.szGroupName, m_sGroupName, m_sGroupName.GetLength()); memcpy(g_ConnectAddress.szGroupName, m_sGroupName, m_sGroupName.GetLength());
@@ -837,15 +844,23 @@ BOOL CBuildDlg::OnInitDialog()
m_ComboRunType.InsertStringL(RUNNING_PARALLEL, "并发上线"); m_ComboRunType.InsertStringL(RUNNING_PARALLEL, "并发上线");
m_ComboRunType.SetCurSel(RUNNING_RANDOM); m_ComboRunType.SetCurSel(RUNNING_RANDOM);
m_ComboProto.InsertStringL(PROTO_TCP, "TCP"); // 协议值挂在 item data 上,不再依赖「下拉框序号 == protoType」。两者目前确实相等,
m_ComboProto.InsertStringL(PROTO_UDP, "UDP"); // 但只要以后有 PROTO_* 常量没进这个下拉框(PROTO_HTTPS 就已经是这种情况),
m_ComboProto.InsertStringL(PROTO_HTTP, "HTTP"); // 后加项序号与协议值就会错位,而错误的值只会在客户端连不上时才暴露。
m_ComboProto.InsertStringL(PROTO_RANDOM, "随机"); auto addProto = [this](int proto, LPCSTR text) {
m_ComboProto.InsertStringL(PROTO_KCP, "KCP"); // AddString 追加到末尾并返回新条目下标;用它定位,不依赖任何「下标 == 枚举值」约定。
// 序号即 protoType,中间不能有空洞(下方 GetCurSel 直接当协议值用) int idx = m_ComboProto.AddStringL(text);
m_ComboProto.InsertStringL(PROTO_WS, "WebSocket"); if (idx >= 0)
m_ComboProto.InsertStringL(PROTO_WSS, "WS+TLS"); m_ComboProto.SetItemData(idx, (DWORD_PTR)proto);
m_ComboProto.SetCurSel(PROTO_TCP); };
addProto(PROTO_TCP, "TCP");
addProto(PROTO_UDP, "UDP");
addProto(PROTO_HTTP, "HTTP");
addProto(PROTO_RANDOM, "随机");
addProto(PROTO_KCP, "KCP");
addProto(PROTO_WS, "WebSocket");
addProto(PROTO_WSS, "WS+TLS");
m_ComboProto.SetCurSel(0);
m_ComboEncrypt.InsertStringL(PROTOCOL_SHINE, "Shine"); m_ComboEncrypt.InsertStringL(PROTOCOL_SHINE, "Shine");
m_ComboEncrypt.InsertStringL(PROTOCOL_HELL, "HELL"); m_ComboEncrypt.InsertStringL(PROTOCOL_HELL, "HELL");
+24 -5
View File
@@ -1258,6 +1258,16 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans
} }
// TLS_Plain:明文直通(原路径)。WS 连接在这里先解帧。 // TLS_Plain:明文直通(原路径)。WS 连接在这里先解帧。
// dwTrans == 0 是对端干净关闭(FIN)。WS 改造前这条分支直接调 ParseReceivedData,
// 它对 dataLen == 0 返回 FALSE 从而拆连接;换成 DispatchPlain 后该语义丢了——0 字节
// 一路返回 1 → PostRecv,而 FIN 已经消费掉,这条连接就停在 CLOSE_WAIT 里,直到
// keepalive(3 分钟)才回收(实测:对端 FIN 后连接一直留在 CLOSE_WAIT,进程不空转)。
// 期间它占着 IOCP 上下文、挂着一枚 WSARecv 和限流槽。这里补回与另外两条分支一致的收尾。
if (dwTrans == 0) {
ContextObject->IoRefCount.fetch_sub(1);
RemoveStaleContext(ContextObject);
return -2;
}
{ {
int r = DispatchPlain(ContextObject, (const BYTE*)ContextObject->szBuffer, dwTrans, ctx, z); int r = DispatchPlain(ContextObject, (const BYTE*)ContextObject->szBuffer, dwTrans, ctx, z);
if (r < 0) { if (r < 0) {
@@ -1290,13 +1300,14 @@ int IOCPServer::DispatchPlain(CONTEXT_OBJECT* ContextObject, const BYTE* data, D
} }
if (ws == WS_Undecided) { if (ws == WS_Undecided) {
ContextObject->tlsPreClassify.insert(ContextObject->tlsPreClassify.end(), data, data + len); // WS 有自己的缓冲(该状态机在 HTTPS 升级 / 反代路径上也会用到),不再借 tlsPreClassify。
if (ContextObject->tlsPreClassify.size() < 6) { ContextObject->wsPreClassify.insert(ContextObject->wsPreClassify.end(), data, data + len);
if (ContextObject->wsPreClassify.size() < 6) {
return 1; // 头还没攒够,继续收 return 1; // 头还没攒够,继续收
} }
std::vector<BYTE> first; std::vector<BYTE> first;
first.swap(ContextObject->tlsPreClassify); first.swap(ContextObject->wsPreClassify);
ContextObject->tlsPreClassify.clear(); ContextObject->wsPreClassify.clear();
if (first.size() >= 4 && memcmp(first.data(), "GET ", 4) == 0) { if (first.size() >= 4 && memcmp(first.data(), "GET ", 4) == 0) {
if (!StartWsHandshake(ContextObject, first)) { if (!StartWsHandshake(ContextObject, first)) {
Mprintf("[WS] StartWsHandshake failed for %s (fail-closed)\n", Mprintf("[WS] StartWsHandshake failed for %s (fail-closed)\n",
@@ -1440,8 +1451,16 @@ BOOL IOCPServer::OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffe
const bool wsStateReady = (ContextObject->wsState.load(std::memory_order_acquire) == WS_Ready); const bool wsStateReady = (ContextObject->wsState.load(std::memory_order_acquire) == WS_Ready);
if (wsStateReady && (ContextObject->ws == NULL || !ContextObject->ws->IsOpen())) { if (wsStateReady && (ContextObject->ws == NULL || !ContextObject->ws->IsOpen())) {
// 升级过 WS 但会话已关(Feed 报错 / 收到 close)而状态还没降级:绝不能把应用字节 // 升级过 WS 但会话已关(Feed 报错 / 收到 close)而状态还没降级:绝不能把应用字节
// 当裸字节发出去,对端会解帧错位。丢弃本次发送,由接收路径的 RemoveStaleContext 收尾。 // 当裸字节发出去,对端会解帧错位。丢弃本次发送,并主动 shutdown 让挂起的 recv
// 立刻返回 0 字节——否则接收路径要等对端 FIN 才醒,期间这条连接既发不出也收不到,
// 只能靠心跳超时兜底(最坏要几分钟)。
//
// 这里不能直接调 RemoveStaleContext:它会等待 IoRefCount 归零,而本函数的调用方
// 常常就处在一个 IoRef 里(发送失败→兜底发送),等于自己等自己,5 秒后超时放行,
// 反而可能把已回收复用的 CONTEXT_OBJECT 交回给调用者。shutdown 是异步且无阻塞的,
// 真正的收尾仍由接收路径的 -2 返回值触发。
Mprintf("[WS] session closed for %s, dropping send\n", ContextObject->GetPeerName().c_str()); Mprintf("[WS] session closed for %s, dropping send\n", ContextObject->GetPeerName().c_str());
shutdown(ContextObject->sClientSocket, SD_BOTH);
return FALSE; return FALSE;
} }
bool wsReady = wsStateReady; bool wsReady = wsStateReady;
+6 -1
View File
@@ -429,6 +429,10 @@ public:
// ---- WebSocket 传输层状态(分层在 TLS 之上:WSS = TLS 里的 WS)---- // ---- WebSocket 传输层状态(分层在 TLS 之上:WSS = TLS 里的 WS)----
std::atomic<int> wsState{ WS_Undecided }; // ServerWsState std::atomic<int> wsState{ WS_Undecided }; // ServerWsState
ServerWsSession* ws = nullptr; // 每连接 WS 会话(升级线程独占→就绪后共用) ServerWsSession* ws = nullptr; // 每连接 WS 会话(升级线程独占→就绪后共用)
// WS 升级前的首包缓冲(判定 "GET " 用)。与 tlsPreClassify 刻意分开:两者服务于不同的
// 状态机,此前串行复用同一个 vector(TLS 判定完 move 走再 clear,WS 又塞回来),字段名
// 与用途对不上,排查时容易误读。两条路径仍按先后串行,互不重叠。
std::vector<BYTE> wsPreClassify;
// 子连接身份校验:客户端发 TOKEN_CONN_AUTH 通过验证后置位。 // 子连接身份校验:客户端发 TOKEN_CONN_AUTH 通过验证后置位。
// 主连接(走 TOKEN_LOGIN 流程)不参与此机制。当前阶段宽容(未通过也接受), // 主连接(走 TOKEN_LOGIN 流程)不参与此机制。当前阶段宽容(未通过也接受),
@@ -591,9 +595,10 @@ public:
FreeTls(); FreeTls();
tlsState.store(TLS_Unclassified, std::memory_order_release); tlsState.store(TLS_Unclassified, std::memory_order_release);
tlsPreClassify.clear(); tlsPreClassify.clear();
// 复用对象池时重置 WebSocket 状态:释放旧会话、回到未判定。 // 复用对象池时重置 WebSocket 状态:释放旧会话、回到未判定、清空首包缓冲。
FreeWs(); FreeWs();
wsState.store(WS_Undecided, std::memory_order_release); wsState.store(WS_Undecided, std::memory_order_release);
wsPreClassify.clear();
// 复用对象池时清空发送进行中标志,避免上次连接残留的 bSendPending 抑制新连接的发送。 // 复用对象池时清空发送进行中标志,避免上次连接残留的 bSendPending 抑制新连接的发送。
bSendPending = false; bSendPending = false;
} }