《Steam 游戏平台:开发与商业化》8.1 网络层全景

Steam 网络层以连接状态机为主线:CreateListenSocketP2P 绑定端口、ConnectP2P 进入 Connecting、AcceptConnection 转 Connected、CloseConnection 使对端观察 ClosedByPeer。本节讲 ISteamNetworkingSockets 状态机与两个接口家族(Sockets/Messages)的分工,lab 用 C++ mock 复现连接生命周期与对端状态观察。

8.1 网络层全景

从这一节开始进入 Steam 网络接入。Steam 网络层的骨架是连接状态机:客户端 ConnectP2P 发起、进入 Connecting;服务器侧 AcceptConnection 接受、转 Connected;任一端 CloseConnection,对端观察到 ClosedByPeer。两个接口家族各司其职:ISteamNetworkingSockets 管「连接」,ISteamNetworkingMessages 管「带频道的消息」。本节先把状态机讲透。

本卷所有接口口径以 Steamworks SDK v1.65(2026-07-23) 为准。本节摘录的签名对照该版本 public/steam/isteamnetworkingsockets.h 与 public/steam/steamnetworkingtypes.h。

本章与站内既有内容的分工

  • 卷一与Steam 发行专题 讲联机游戏类型与网络拓扑选型;本节讲「接入代码里的连接状态机语义」。
  • 8.2/8.3 分别在 Sockets 与 Messages 之上深入;本节先给状态机全景与接口家族分工。
  • lab 用纯 C++ 复现「监听 → 连接 → 接受 → 关闭」的连接生命周期,不依赖 Steam 客户端运行。

连接状态机:ESteamNetworkingConnectionState

所有网络接入工程共享同一个状态模型。v1.65 枚举(steamnetworkingtypes.h):

// steamnetworkingtypes.h:ESteamNetworkingConnectionState(SDK v1.65 头文件摘录,已删减)
enum ESteamNetworkingConnectionState
{
	k_ESteamNetworkingConnectionState_None = 0,
	k_ESteamNetworkingConnectionState_Connecting = 1,
	k_ESteamNetworkingConnectionState_FindingRoute = 2,
	k_ESteamNetworkingConnectionState_Connected = 3,
	k_ESteamNetworkingConnectionState_ClosedByPeer = 4,
	k_ESteamNetworkingConnectionState_ProblemDetectedLocally = 5,
	k_ESteamNetworkingConnectionState_FinWait = -1,
	k_ESteamNetworkingConnectionState_Linger = -2,
	k_ESteamNetworkingConnectionState_Dead = -3,
};

工程语义:

  1. 状态是单向推进的:None → Connecting → FindingRoute → Connected 是正向路径;关闭后走向 ClosedByPeer(对端关)或 ProblemDetectedLocally(本端发现问题),最终回到 None。接入工程要能读 GetConnectionInfo/GetConnectionRealTimeStatus 拿当前状态。
  2. ClosedByPeer 与 ProblemDetectedLocally 含义不同:前者是对端主动关(游戏逻辑收到 SteamNetConnectionStatusChangedCallback_t 后要体面退出房间);后者是本端检测到连接问题(要准备重连策略)。
  3. 关闭后句柄状态归 None:连接结束要清理句柄。接入工程用「状态 + 回调」双通道判断连接生死,不要只信一次轮询。

Sockets 与 Messages:两个接口家族

Steam 网络层有两套接口,都建立在同一状态模型上。v1.65 的 Sockets 家族核心签名:

// isteamnetworkingsockets.h:CreateListenSocketP2P / ConnectP2P / AcceptConnection / CreateSocketPair / CloseConnection / CloseListenSocket(SDK v1.65 头文件摘录,已删减)
virtual HSteamListenSocket CreateListenSocketP2P( int nLocalVirtualPort, int nVirtualPortRange, bool bAllowUseOfP2P, SteamNetworkingConfigValue_t *pSteamNetworkingConfigData, int cbSteamNetworkingConfigData ) = 0;
virtual HSteamNetConnection ConnectP2P( const SteamNetworkingIdentity &identityRemote, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
virtual EResult AcceptConnection( HSteamNetConnection hConn ) = 0;
virtual bool CloseConnection( HSteamNetConnection hPeer, int nReason, const char *pszDebug, bool bEnableLinger ) = 0;
virtual bool CloseListenSocket( HSteamListenSocket hSocket ) = 0;

两大家族的工程定位:

接口家族定位典型场景
ISteamNetworkingSockets面向连接的流式收发(SendMessageToConnection/ReceiveMessagesOnConnection)房间制联机、服务器转发
ISteamNetworkingMessages面向用户的带频道消息(SendMessageToUser/ReceiveMessagesOnChannel)P2P 配对、信令、不关心连接形态的收发
  1. Sockets 给显式连接:连接有状态、有句柄、可管理。服务器 CreateListenSocketP2P 绑定虚拟端口,客户端 ConnectP2P 去连;服务器收到连接请求后 AcceptConnection。
  2. Messages 隐式建会话:SendMessageToUser 会给目标用户隐式创建会话并触发 SteamNetworkingMessagesSessionRequest_t。工程上若「只要把消息送达」选 Messages,若「要管理连接生命周期」选 Sockets。
  3. 本地开发用 CreateSocketPair:创建一对立即 Connected 的回环连接,适合单元测试消息管道(本节 lab 用它验证对端关闭观察)。

连接生命周期:监听、发起、接受、关闭

P2P 连接的完整生命周期(Sockets):

  1. 监听方:CreateListenSocketP2P 绑定虚拟端口(多数游戏只用端口 0,头文件注释点名这是常见做法)。CloseListenSocket 结束监听。
  2. 发起方:ConnectP2P 指定对端身份与端口,连接对象创建即 Connecting;服务器侧会收到待接受的连接。
  3. 接受方:AcceptConnection 把连接转 Connected。重复接受失败(状态已变),对无效句柄接受也失败。
  4. 任一端关闭:CloseConnection(hConn, nReason, ...) 关闭本端,对端在状态回调里观察到 ClosedByPeer。

接口签名对照

头文件条目语义
steamnetworkingtypes.hESteamNetworkingConnectionState连接状态机枚举
isteamnetworkingsockets.hISteamNetworkingSockets::CreateListenSocketP2P绑定虚拟端口监听
isteamnetworkingsockets.hISteamNetworkingSockets::ConnectP2P发起 P2P 连接
isteamnetworkingsockets.hISteamNetworkingSockets::AcceptConnection接受连接(Connecting → Connected)
isteamnetworkingsockets.hISteamNetworkingSockets::CreateSocketPair本地回环连接对(测试用)
isteamnetworkingsockets.hISteamNetworkingSockets::CloseConnection关闭本端,对端观察 ClosedByPeer
isteamnetworkingsockets.hISteamNetworkingSockets::CloseListenSocket结束监听
isteamnetworkingmessages.hISteamNetworkingMessages带频道的面向用户消息(8.2)

数据口径与来源

  • 接口签名、状态枚举值、回调字段:SDK v1.65 public/steam/isteamnetworkingsockets.h 与 public/steam/steamnetworkingtypes.h 可实证(本机镜像已核对)。
  • 注意:SDK v1.65 不存在 ReceiveMessagesOnListenSocket/GetSteamConnectionInfo(旧教程常见的接口);连接状态的读取用 GetConnectionInfo/GetConnectionRealTimeStatus/GetSessionConnectionInfo,消息读取用 ReceiveMessagesOnConnection。
  • 具体网络指标(延迟、丢包、带宽):运行时数据,以官方当前为准。

以上接口口径撰写时对照 Steamworks SDK v1.65 头文件与 partner.steamgames.com 官方文档核对;登录后可见数据以官方当前为准。

可运行产物:C++ 最小验证

下面的仿真复现「网络层全景」的接口工程语义:监听端口绑定、ConnectP2P 进入 Connecting、AcceptConnection 转 Connected、无效句柄防御、CreateSocketPair 回环对、CloseConnection 使对端观察 ClosedByPeer、监听关闭后无法再连接。它与 src/08-1-networking-overview.cpp 逐字节一致,mock 签名对照 SDK v1.65 头文件:

// file: src/08-1-networking-overview.cpp
// tier: L1
// verify: clang++ -std=c++20 -Wall -I. src/08-1-networking-overview.cpp -o bin/08-1-networking-overview && ./bin/08-1-networking-overview
//
// mock:复现 ISteamNetworkingSockets 的连接状态机语义——CreateListenSocketP2P、
// ConnectP2P 进入 Connecting、服务器 AcceptConnection 转 Connected、
// CreateSocketPair 本地回环对、CloseConnection 使对端观察 ClosedByPeer。
// 签名对照 SDK v1.65 isteamnetworkingsockets.h 与 steamnetworkingtypes.h,非 Valve 实现。
#include "verify.h"

#include <map>
#include <vector>

namespace steam_repro {

// ESteamNetworkingConnectionState 对照 steamnetworkingtypes.h
enum MockConnectionState {
  kNone = 0,
  kConnecting = 1,
  kFindingRoute = 2,
  kConnected = 3,
  kClosedByPeer = 4,
  kProblemDetectedLocally = 5,
};

struct MockConnection {
  bool active = false;
  MockConnectionState state = kNone;
  int linkedTo = 0;
  int listenPort = 0;
};

class MockSteamNetworkingSockets {
 public:
  MockSteamNetworkingSockets() : nextConn_(1), nextListen_(100) {}

  // ISteamNetworkingSockets::CreateListenSocketP2P:绑定本地虚拟端口
  uint32_t createListenSocketP2P(int nLocalVirtualPort) {
    uint32_t ls = nextListen_++;
    listens_[ls] = nLocalVirtualPort;
    return ls;
  }

  // ISteamNetworkingSockets::ConnectP2P:发起连接,进入 Connecting 并触发服务器侧连接请求
  uint32_t connectP2P(int nRemoteVirtualPort) {
    uint32_t ls = 0;
    for (const auto& kv : listens_) {
      if (kv.second == nRemoteVirtualPort) {
        ls = kv.first;
        break;
      }
    }
    if (ls == 0) return 0;  // 无监听端口 → 连接失败
    uint32_t c = nextConn_++;
    MockConnection m;
    m.active = true;
    m.state = kConnecting;
    m.listenPort = nRemoteVirtualPort;
    conns_[c] = m;
    pendingAccept_.push_back(c);
    return c;
  }

  // ISteamNetworkingSockets::AcceptConnection:接受连接,Connecting → Connected
  bool acceptConnection(uint32_t hConn) {
    auto it = conns_.find(hConn);
    if (it == conns_.end() || !it->second.active) return false;
    if (it->second.state != kConnecting) return false;
    it->second.state = kConnected;
    return true;
  }

  // ISteamNetworkingSockets::GetConnectionInfo 的 m_eState 语义
  MockConnectionState getConnectionState(uint32_t hConn) const {
    auto it = conns_.find(hConn);
    if (it == conns_.end() || !it->second.active) return kNone;
    return it->second.state;
  }

  // ISteamNetworkingSockets::CreateSocketPair:本地回环对,双双立即进入 Connected
  bool createSocketPair(uint32_t* pOutConnection1, uint32_t* pOutConnection2) {
    uint32_t a = nextConn_++;
    uint32_t b = nextConn_++;
    MockConnection ma;
    ma.active = true;
    ma.state = kConnected;
    conns_[a] = ma;
    MockConnection mb;
    mb.active = true;
    mb.state = kConnected;
    conns_[b] = mb;
    conns_[a].linkedTo = static_cast<int>(b);
    conns_[b].linkedTo = static_cast<int>(a);
    *pOutConnection1 = a;
    *pOutConnection2 = b;
    return true;
  }

  // ISteamNetworkingSockets::CloseConnection:关闭本端,对端观察 ClosedByPeer
  bool closeConnection(uint32_t hConn, int nReason) {
    auto it = conns_.find(hConn);
    if (it == conns_.end() || !it->second.active) return false;
    int peer = it->second.linkedTo;
    if (peer != 0) {
      auto p = conns_.find(static_cast<uint32_t>(peer));
      if (p != conns_.end() && p->second.active && p->second.state == kConnected) {
        p->second.state = kClosedByPeer;
      }
    }
    it->second.active = false;
    it->second.state = kNone;
    return true;
  }

  // ISteamNetworkingSockets::CloseListenSocket
  bool closeListenSocket(uint32_t hSocket) { return listens_.erase(hSocket) > 0; }

  uint32_t pendingAcceptCount() const { return static_cast<uint32_t>(pendingAccept_.size()); }
  uint32_t takePendingAccept() {
    if (pendingAccept_.empty()) return 0;
    uint32_t c = pendingAccept_.front();
    pendingAccept_.erase(pendingAccept_.begin());
    return c;
  }

 private:
  uint32_t nextConn_;
  uint32_t nextListen_;
  std::map<uint32_t, int> listens_;
  std::map<uint32_t, MockConnection> conns_;
  std::vector<uint32_t> pendingAccept_;
};

}  // namespace steam_repro

int main() {
  using namespace steam_repro;
  MockSteamNetworkingSockets net;

  // 1. CreateListenSocketP2P:绑定端口 0(默认唯一监听)
  uint32_t ls = net.createListenSocketP2P(0);
  CHECK(ls != 0);

  // 2. ConnectP2P:连接存在的端口 → 进入 Connecting,服务器侧出现待接受连接
  uint32_t c = net.connectP2P(0);
  CHECK(c != 0);
  CHECK(net.getConnectionState(c) == kConnecting);
  CHECK(net.pendingAcceptCount() == 1);

  // 3. 服务器 AcceptConnection:Connecting → Connected
  uint32_t pending = net.takePendingAccept();
  CHECK(pending == c);
  CHECK(net.acceptConnection(pending));
  CHECK(net.getConnectionState(c) == kConnected);

  // 4. 重复 Accept 失败(状态已变)
  CHECK(!net.acceptConnection(c));

  // 5. 无效连接句柄:Accept 失败、状态为 None
  CHECK(!net.acceptConnection(9999));
  CHECK(net.getConnectionState(9999) == kNone);

  // 6. ConnectP2P 到不存在的端口:返回 0(连接失败)
  CHECK(net.connectP2P(42) == 0);

  // 7. CreateSocketPair:本地回环对双双立即 Connected
  uint32_t a = 0, b = 0;
  CHECK(net.createSocketPair(&a, &b));
  CHECK(a != 0 && b != 0);
  CHECK(net.getConnectionState(a) == kConnected);
  CHECK(net.getConnectionState(b) == kConnected);

  // 8. CloseConnection 一侧:对端观察 ClosedByPeer
  CHECK(net.closeConnection(a, 1));
  CHECK(net.getConnectionState(b) == kClosedByPeer);

  // 9. 已关闭句柄:状态为 None,再次关闭失败
  CHECK(net.getConnectionState(a) == kNone);
  CHECK(!net.closeConnection(a, 1));

  // 10. CloseListenSocket:未知句柄失败,已知句柄成功
  CHECK(!net.closeListenSocket(9999));
  CHECK(net.closeListenSocket(ls));
  CHECK(net.connectP2P(0) == 0);  // 监听已关,无法连接

  return lab::report("08-1 网络层全景");
}

本机实测(Apple clang 16,clang++ -std=c++20 -Wall):编译通过(零警告),断言 22/22 通过。

小结

  • 连接状态机单向推进:Connecting → FindingRoute → Connected,关闭后对端看 ClosedByPeer、本端看 ProblemDetectedLocally。
  • ISteamNetworkingSockets 管显式连接(句柄 + 状态),ISteamNetworkingMessages 管隐式会话 + 频道消息。
  • 生命周期四步:监听方绑定端口、发起方 Connect、接受方 Accept、任一端 Close。
  • SDK v1.65 没有 ReceiveMessagesOnListenSocket/GetSteamConnectionInfo,用真实存在的接口替代。

阅读导航:上一节:7.3 创意工坊商业 · 下一节:8.2 P2P 会话与消息 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图