Feature: WebSocket transport for clients behind restricted outbound ports #5

Merged
yuanyuanxiang merged 5 commits from ws_tls into main 2026-10-30 18:49:52 +00:00
12 changed files with 149 additions and 38 deletions
Showing only changes of commit 46f4bf2dfb - Show all commits

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));
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;
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, "");
}
// 在每次建连前应用入口覆盖;返回 true 表示本次用的覆盖入口。
// 覆盖撤销(还原命令 / 自动回退)→ 回到安装时的直连入口;
// 新入口超时(entry_try_at 未清零)→ 回退到切换前的入口并撤销覆盖。
bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
// 在每次建连前应用入口覆盖(就地改写 s,并落盘必要的状态)。没有返回值:它既会改 s 也会
// 改配置,用「是否用了覆盖入口」当返回值会与副作用矛盾——自动回退分支照样改写了 settings,
// 却没法用一个 bool 表达,调用方也确实不需要这个信息。
void ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
{
if (!g_bootCaptured) {
g_bootCaptured = true;
@@ -637,7 +637,7 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
ClearAllProtoSwitchKeys(cfg);
Mprintf("[proto-switch] injected entry changed (%s -> %s), cleared stale switch state\n",
baseHost.c_str(), g_bootHost.c_str());
return false;
return;
}
const std::string proto = cfg.GetStr("settings", "proto_override");
@@ -652,13 +652,13 @@ bool ApplyProtoSwitch(iniFile& cfg, CONNECT_ADDRESS& s)
s.protoType = (char)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());
if (!IsSwitchableProto(p)) {
ClearAllProtoSwitchKeys(cfg); // 坏值:撤销覆盖,按注入配置走
return false;
return;
}
// 自动回退:切换后一直没登录成功(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");
}
cfg.SetStr("settings", "entry_try_at", "0");
return false;
return;
Outdated
Review

返回值与副作用不一致。 这个分支已经把 s 改成了 prev_* 入口(SetServer + protoType),却 return false;而调用方 ApplyProtoSwitch(cfg, settings); 完全不看返回值。返回值从「是否用了覆盖入口」变成「是否还该继续用覆盖入口」,但副作用照样发生——后面维护的人很容易据此写出错误的分支。

建议改成 void,或在函数头把这两个返回值的含义写清(「返回 false 不代表 settings 未被修改」)。

**返回值与副作用不一致。** 这个分支已经把 `s` 改成了 `prev_*` 入口(`SetServer` + `protoType`),却 `return false`;而调用方 `ApplyProtoSwitch(cfg, settings);` 完全不看返回值。返回值从「是否用了覆盖入口」变成「是否还该继续用覆盖入口」,但副作用照样发生——后面维护的人很容易据此写出错误的分支。 建议改成 `void`,或在函数头把这两个返回值的含义写清(「返回 false 不代表 settings 未被修改」)。
}
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)
s.SetServer(host.c_str(), port);
s.protoType = (char)p;
return true;
}
// 新入口登录成功:撤销自动回退计时。入口覆盖本身保留——后续重连一直用它。
1
+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 等端口时,经反代
// 分流进来。与应用协议无关,位置和 TLS 相同(TLS 之下、应用协议之上);须在
// m_bConnected 置位前完成,确保工作线程不会在 Upgrade 尚未完成时就开始 recv。
const int protoType = m_conn ? (int)(unsigned char)m_conn->protoType : -1;
// Linux / macOS / Android 不传 conn,协议由 SetDefaultProto 给出(见 IOCPClient.h)。
Outdated
Review

protoType 为 -1 时静默退回明文。 m_conn 为空就取 -1,wsProto/wsTls 均为 false,后面完全跳过 WS 分支,也不会打任何日志。

Windows 的每条构造路径都传了 conn(ClientDll.cpp:104、Common.cpp:76、KernelManager.cpp 全部 new IOCPClient(..., conn, ...)),所以主路径没问题。但 linux/main.cpp:1380 与 macos/main.mm:943 都是 new IOCPClient(g_bExit, false)——m_conn 恒为 NULL。那两个平台即使把 g_SETTINGS.protoType 改成 PROTO_WS/PROTO_WSS,也只会默默走明文 TCP 直连,排查时看不到任何线索。

建议:m_conn 为空时回退读全局配置,或至少在这里加一行 Mprintf 说明「无 conn,传输按明文直连处理」。

**protoType 为 -1 时静默退回明文。** `m_conn` 为空就取 -1,`wsProto`/`wsTls` 均为 false,后面完全跳过 WS 分支,也不会打任何日志。 Windows 的每条构造路径都传了 `conn`(`ClientDll.cpp:104`、`Common.cpp:76`、`KernelManager.cpp` 全部 `new IOCPClient(..., conn, ...)`),所以主路径没问题。但 `linux/main.cpp:1380` 与 `macos/main.mm:943` 都是 `new IOCPClient(g_bExit, false)`——`m_conn` 恒为 NULL。那两个平台即使把 `g_SETTINGS.protoType` 改成 `PROTO_WS`/`PROTO_WSS`,也只会默默走明文 TCP 直连,排查时看不到任何线索。 建议:`m_conn` 为空时回退读全局配置,或至少在这里加一行 `Mprintf` 说明「无 conn,传输按明文直连处理」。
// 两边都没有时按明文直连,并留一行日志——否则「改成 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 wsTls = (protoType == PROTO_WSS);
m_useWs = false;
1
+8
View File
@@ -208,6 +208,12 @@ public:
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
{
return m_sCurIP;
@@ -355,6 +361,8 @@ protected:
// 无害,但换成别的架构就不能再依赖这个巧合)。
std::atomic<bool> m_useWs{false};
std::atomic<bool> m_loginAcked{false};
// m_conn 为空时的协议来源(见 SetDefaultProto)。-1 = 未设置,按明文 TCP 处理。
int m_defaultProto = -1;
#ifdef YAMA_TLS_CHANNEL
TlsChannel m_tls; // TLS 会话(证书存在时才启用,见 TlsChannel.h)
// 本连接是否走 TLS:在 ConnectServer 里握手成功时置位、Disconnect 时清除,Send/Recv
+2
View File
@@ -305,6 +305,8 @@ bool TlsChannel::VerifyServerCert()
return false;
// 与 TlsReload 互斥:校验期间持有 g_tlsMtx,重建时释放的旧 store/engine 不会正被使用。
// 持锁时间很短:建链全是本地操作(DISABLE_AIA 禁联网取中间证书,也不带任何
// CERT_CHAIN_REVOCATION_CHECK_* 位),不会因为网络等待而卡住 TlsReload。
std::lock_guard<std::mutex> lk(g_tlsMtx);
if (!g_tlsStore || !g_tlsEngine) {
CertFreeCertificateContext(remote);
+22 -6
View File
@@ -51,13 +51,12 @@ public:
void SetTls(TlsChannel* tls) { m_tls = tls; }
#endif
// 每次连接前清理上一轮的帧状态。
// 让 Recv/Send 立刻失效。**可由任意线程调用**(Disconnect 可能来自心跳/命令线程,
// 不只是接收线程),因此这里只碰原子量;帧解析状态留给 ResetFrames()——它只在
// Handshake 里、接收线程还没起来时清。
void Reset()
{
m_ready = false;
m_remaining = 0;
m_masked = false;
m_maskPos = 0;
}
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)
{
Reset();
ResetFrames();
char hostPort[120] = { 0 };
if (port == 80 || port == 443)
snprintf(hostPort, sizeof(hostPort), "%s", host.c_str());
1
@@ -257,6 +256,8 @@ private:
}
// 读帧头(含扩展长度与掩码键)。服务端发来的帧不应带掩码,带了也照样解。
static const long long kMaxFramePayload = 256LL * 1024 * 1024;
bool ReadHeader(SOCKET sock, unsigned char& opcode, long long& frameLen)
{
unsigned char h[2] = { 0, 0 };
@@ -284,6 +285,12 @@ private:
if (frameLen < 0)
return false;
}
// 单帧载荷上限,与主控端 ServerWsSession 的 kMaxFramePayload 取同一个值(256 MB)。
// 没有上限时,一个错误/被篡改的长度字段就能把 m_remaining 定在天文数字上,此后
// 所有字节都被当成该帧的内容吞掉,连接表面上还活着却永远收不到新包——比直接断线
// 难查得多。正常业务的最大单包远小于此值,故不会挡住既有功能。
if (frameLen > kMaxFramePayload)
return false;
if (m_masked && !ReadExact(sock, m_mask, 4))
return false;
m_maskPos = 0;
1
@@ -377,7 +384,16 @@ private:
std::mutex m_sendMtx;
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;
bool m_masked = false;
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` 下这意味着
中间人可以伪造 101 接管字节流——这正是「裸 WS 只适合内网」的另一半理由。
- 没有 `conn` 的构造路径(Linux / macOS / Android 的 `main` 都是 `new IOCPClient(exit, false)`)
拿不到外壳注入的 `CONNECT_ADDRESS`,协议由 `IOCPClient::SetDefaultProto()` 显式给出;
三个平台的 `main` 都在进入重连循环前调一次。不调则保持 `-1`、按明文直连——那正是
「配置成 WS 却毫无反应」的来源,所以这里留了一行日志便于排查。
### 3.1 信任模型:不换锚,靠 SNI 分流
@@ -197,7 +201,8 @@ WS 叠在同一层状态机之上,**与 TLS 是分层而不是并列**(`wss`
- 状态机:`ServerWsState { WS_Undecided → WS_Handshaking → WS_Ready | WS_None }` 与既有的
`ServerTlsState` 并存;`CONTEXT_OBJECT` 复用(`InitMember`)时一并复位并释放会话。
- 判定点:**明文的第一段有 ≥6 字节**才开始分类(与 ClientHello 嗅探同一下限),
避免把「请求头还没到齐」误判掉;阈值内的字节攒在 `tlsPreClassify` 里。
避免把「请求头还没到齐」误判掉;阈值内的字节攒在 `wsPreClassify` 里(与 TLS 嗅探的
`tlsPreClassify` 分开,两者服务不同状态机,串行使用但字段不共用)。
- 升级线程与 TLS 握手线程同构:`FIONBIO=0`(该套接字常是非阻塞的,`ioctlsocket` 会以
`WSAEINVAL` 失败),15 s 收发超时,遇 `WSAEWOULDBLOCK` 用 `select` 等可读/可写再试;
线程持有一枚 `IoRefCount`,结束后把 socket 交还 IOCP(`PostRecv`)。升级响应之后同批
@@ -218,8 +223,15 @@ WS 叠在同一层状态机之上,**与 TLS 是分层而不是并列**(`wss`
- fail-closed 的两处:握手期间(`wsState == WS_Handshaking`)收到 IORead 直接断开(判断
放在 `OnClientReceiving` 最开头,WSS 下 `tlsState` 已是 `TLS_Ready`,放在 TLS 分支之后
就不生效);`wsState == WS_Ready` 但会话已关时,应用字节**丢弃而不是裸发**,否则对端
解帧错位。
解帧错位;同时对该 socket 做一次 `shutdown(SD_BOTH)`,让挂起的 recv 立刻返回 0 字节,
由接收路径走正常的 `-2` 收尾(不在这里直接 `RemoveStaleContext`——调用方往往本身就
持有 `IoRefCount`,自己等自己会超时,且可能把已回收复用的上下文交回给调用者)。
- 既有客户端零影响:非 `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 最小改动
@@ -426,7 +438,9 @@ server {
- 客户端落盘(`settings` 下):`proto_override` / `entry_host` / `entry_port` /
`entry_try_at` 为当前覆盖;`base_*` 是首次切换时记下的安装入口(「还原」用它);`prev_*`
是每次切换前的入口(自动回退用它)。重连循环在建连前 `ApplyProtoSwitch` 覆盖入口——位置
在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去。
在「外壳注入完配置之后、建连之前」,因此换 DLL 也压不回去。(该函数返回 `void`:它既写
配置也改 `CONNECT_ADDRESS`,返回值无法表达「部分完成」,早期版本里的 `return false`
只是提前退出,调用方一直忽略它。)
- 撤销自动回退的判据是**登录被接受**,不是「连接建立」。客户端在收到
`CMD_MASTERSETTING` 时把当前连接标记为已登录(服务端只有在把本机加入在线列表之后才下发
它),重连循环每轮心跳都检查一次,命中才 `ConfirmProtoSwitch` 把 `entry_try_at` 清零。
@@ -444,13 +458,21 @@ server {
## 10. 审查遗留(已知边界,未改动)
以下条目来自 PR 审查,评估后保留现状,记录在此以免重复讨论:
以下条目来自 PR 审查,记录在此以免重复讨论。带「已处理」的是复查后**已经改掉**的,
留在这里说明当时的判断,其余评估后保留现状:
- **`GetPeerName(SOCKET)` 只走 `sockaddr_in`(IPv4)**:`ServerWsSession.cpp::IsLoopbackPeer`
里的 `::1` / `::ffff:127.0.0.1` 分支目前是死代码。将来若监听 IPv6,转发头信任也需要跟着
改,否则会静默失效。
- **`tlsPreClassify` 名不副实**:它现在同时承担 ClientHello 嗅探与 WS 前缀("GET ")buffering。
改名会牵动状态机注释与多处引用,暂保留原名字,语义见 §4.2。
- **`tlsPreClassify` 名不副实**:已处理——WS 的 "GET " 前缀缓冲拆成独立的 `wsPreClassify`,
`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 字节再解析」**:这是既有路径的行为变更。当前首包
是登录包(远大于 6 字节),实际无影响;极端情况下(<6 字节的合法首包)会多等一轮收包。
- **客户端不校验 `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));
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(); // 自升级失败回报用
while (!g_bExit) {
clock_t c = clock();
+7
View File
@@ -942,6 +942,13 @@ int main(int argc, const char* argv[])
// Create client
auto ClientObject = std::make_unique<IOCPClient>(g_bExit, false);
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
NSLog(@"Starting main loop...");
+25 -10
View File
@@ -542,7 +542,14 @@ void CBuildDlg::OnBnClickedOk()
g_ConnectAddress.SetAdminId(GetMasterHash().c_str());
g_ConnectAddress.SetServer(m_strIP, atoi(m_strPort));
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();
memcpy(g_ConnectAddress.pwdHash, GetPwdHash().c_str(), sizeof(g_ConnectAddress.pwdHash));
memcpy(g_ConnectAddress.szGroupName, m_sGroupName, m_sGroupName.GetLength());
@@ -837,15 +844,23 @@ BOOL CBuildDlg::OnInitDialog()
m_ComboRunType.InsertStringL(RUNNING_PARALLEL, "并发上线");
m_ComboRunType.SetCurSel(RUNNING_RANDOM);
Outdated
Review

index 与 protoType 是隐式强耦合,这次恰好对上属于巧合。

InsertStringL(index, text) 展开是 InsertString(index, _TR(text)),第一参数是插入位置,不是 item data。而 g_ConnectAddress.protoType = m_ComboProto.GetCurSel() 取的是 index。所以「序号即 protoType」这个约定成立的前提是:调用顺序必须严格等于枚举值,且中间不能有任何一项被跳过。

PROTO_WS=5、PROTO_WSS=6 正好是第 6、7 个插入项,所以现在对得上。将来若有人在 HTTP 与随机之间插一项(比如恢复 HTTPS),后面所有选项会静默错位,GetCurSel() 会把错的数字写进 protoType,且编译期、运行期都不会报错——生成出来的客户端会连错协议。

建议改用 SetItemData / GetItemData:插入时 SetItemData(idx, PROTO_WS),读取时 GetItemData(GetCurSel())。这样顺序可以随便调。

**index 与 protoType 是隐式强耦合,这次恰好对上属于巧合。** `InsertStringL(index, text)` 展开是 `InsertString(index, _TR(text))`,第一参数是**插入位置**,不是 item data。而 `g_ConnectAddress.protoType = m_ComboProto.GetCurSel()` 取的是 **index**。所以「序号即 protoType」这个约定成立的前提是:调用顺序必须严格等于枚举值,且中间不能有任何一项被跳过。 `PROTO_WS=5`、`PROTO_WSS=6` 正好是第 6、7 个插入项,所以现在对得上。将来若有人在 HTTP 与随机之间插一项(比如恢复 HTTPS),后面所有选项会静默错位,`GetCurSel()` 会把错的数字写进 `protoType`,且编译期、运行期都不会报错——生成出来的客户端会连错协议。 建议改用 `SetItemData` / `GetItemData`:插入时 `SetItemData(idx, PROTO_WS)`,读取时 `GetItemData(GetCurSel())`。这样顺序可以随便调。
m_ComboProto.InsertStringL(PROTO_TCP, "TCP");
m_ComboProto.InsertStringL(PROTO_UDP, "UDP");
m_ComboProto.InsertStringL(PROTO_HTTP, "HTTP");
m_ComboProto.InsertStringL(PROTO_RANDOM, "随机");
m_ComboProto.InsertStringL(PROTO_KCP, "KCP");
// 序号即 protoType,中间不能有空洞(下方 GetCurSel 直接当协议值用)
m_ComboProto.InsertStringL(PROTO_WS, "WebSocket");
m_ComboProto.InsertStringL(PROTO_WSS, "WS+TLS");
m_ComboProto.SetCurSel(PROTO_TCP);
// 协议值挂在 item data 上,不再依赖「下拉框序号 == protoType」。两者目前确实相等,
// 但只要以后有 PROTO_* 常量没进这个下拉框(PROTO_HTTPS 就已经是这种情况),
// 后加项序号与协议值就会错位,而错误的值只会在客户端连不上时才暴露。
auto addProto = [this](int proto, LPCSTR text) {
// AddString 追加到末尾并返回新条目下标;用它定位,不依赖任何「下标 == 枚举值」约定。
int idx = m_ComboProto.AddStringL(text);
if (idx >= 0)
m_ComboProto.SetItemData(idx, (DWORD_PTR)proto);
};
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_HELL, "HELL");
+24 -5
View File
3
@@ -1258,6 +1258,16 @@ BOOL IOCPServer::OnClientReceiving(PCONTEXT_OBJECT ContextObject, DWORD dwTrans
}
// 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);
if (r < 0) {
1
@@ -1290,13 +1300,14 @@ int IOCPServer::DispatchPlain(CONTEXT_OBJECT* ContextObject, const BYTE* data, D
}
if (ws == WS_Undecided) {
ContextObject->tlsPreClassify.insert(ContextObject->tlsPreClassify.end(), data, data + len);
if (ContextObject->tlsPreClassify.size() < 6) {
// WS 有自己的缓冲(该状态机在 HTTPS 升级 / 反代路径上也会用到),不再借 tlsPreClassify。
ContextObject->wsPreClassify.insert(ContextObject->wsPreClassify.end(), data, data + len);
if (ContextObject->wsPreClassify.size() < 6) {
return 1; // 头还没攒够,继续收
}
std::vector<BYTE> first;
first.swap(ContextObject->tlsPreClassify);
ContextObject->tlsPreClassify.clear();
first.swap(ContextObject->wsPreClassify);
ContextObject->wsPreClassify.clear();
if (first.size() >= 4 && memcmp(first.data(), "GET ", 4) == 0) {
if (!StartWsHandshake(ContextObject, first)) {
Mprintf("[WS] StartWsHandshake failed for %s (fail-closed)\n",
1
@@ -1440,8 +1451,16 @@ BOOL IOCPServer::OnClientPreSending(CONTEXT_OBJECT* ContextObject, PBYTE szBuffe
const bool wsStateReady = (ContextObject->wsState.load(std::memory_order_acquire) == WS_Ready);
if (wsStateReady && (ContextObject->ws == NULL || !ContextObject->ws->IsOpen())) {
// 升级过 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());
shutdown(ContextObject->sClientSocket, SD_BOTH);
return FALSE;
}
bool wsReady = wsStateReady;
+6 -1
View File
@@ -429,6 +429,10 @@ public:
// ---- WebSocket 传输层状态(分层在 TLS 之上:WSS = TLS 里的 WS)----
std::atomic<int> wsState{ WS_Undecided }; // ServerWsState
ServerWsSession* ws = nullptr; // 每连接 WS 会话(升级线程独占→就绪后共用)
// WS 升级前的首包缓冲(判定 "GET " 用)。与 tlsPreClassify 刻意分开:两者服务于不同的
// 状态机,此前串行复用同一个 vector(TLS 判定完 move 走再 clear,WS 又塞回来),字段名
// 与用途对不上,排查时容易误读。两条路径仍按先后串行,互不重叠。
std::vector<BYTE> wsPreClassify;
// 子连接身份校验:客户端发 TOKEN_CONN_AUTH 通过验证后置位。
// 主连接(走 TOKEN_LOGIN 流程)不参与此机制。当前阶段宽容(未通过也接受),
@@ -591,9 +595,10 @@ public:
FreeTls();
tlsState.store(TLS_Unclassified, std::memory_order_release);
tlsPreClassify.clear();
// 复用对象池时重置 WebSocket 状态:释放旧会话、回到未判定。
// 复用对象池时重置 WebSocket 状态:释放旧会话、回到未判定、清空首包缓冲。
FreeWs();
wsState.store(WS_Undecided, std::memory_order_release);
wsPreClassify.clear();
// 复用对象池时清空发送进行中标志,避免上次连接残留的 bSendPending 抑制新连接的发送。
bSendPending = false;
}