《Steam 游戏平台:开发与商业化》8.2 P2P 会话与消息

P2P 消息接入选 ISteamNetworkingMessages:SendMessageToUser 隐式建会话并触发 SessionRequest、ReceiveMessagesOnChannel 按频道取消息、可靠消息恰好一次按序、不可靠可能丢失、CloseSessionWithUser 结束会话。本节讲会话与消息的接口语义,lab 用 C++ mock 复现双对端收发、频道路由与丢包。

8.2 P2P 会话与消息

8.1 讲了连接状态机,这一节讲最常见的 P2P 接入方式:ISteamNetworkingMessages。它不需要显式管理连接句柄——SendMessageToUser 第一次发给某用户时隐式创建会话,对端收到 SteamNetworkingMessagesSessionRequest_t 会话请求;消息按频道路由,ReceiveMessagesOnChannel 按频道取。可靠消息保证恰好一次、按序到达;不可靠消息可能丢。适合配对、信令、房主发现这类「只要能送达」的场景。

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

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

  • 8.1 给连接状态机与两个接口家族的分工;本节深入 Messages 家族——隐式会话、频道、可靠/不可靠。
  • 8.3 讲可靠性工程细节(消息号、重传、单消息上限);本节先讲会话与频道的收发语义。
  • lab 用纯 C++ 复现双对端收发、频道路由与丢包标记,不依赖 Steam 客户端运行。

隐式会话与消息发送

SendMessageToUser 是 Messages 家族的核心入口。v1.65 签名:

// isteamnetworkingmessages.h:SendMessageToUser(SDK v1.65 头文件摘录,已删减)
virtual EResult SendMessageToUser( const SteamNetworkingIdentity &identityRemote, const void *pubData, uint32 cubData, int nSendFlags, int nRemoteChannel ) = 0;

工程语义:

  1. 第一次发送隐式建会话:发给一个「还没建立会话」的用户时,SDK 自动创建会话,并给对端投递 SteamNetworkingMessagesSessionRequest_t 会话请求回调。对端可以用 AcceptSessionWithUser 响应,或忽略请求。
  2. SendMessageToUser 返回 EResult:k_EResultOK 表示已排队;k_EResultInvalidParam/k_EResultNoConnection 表示参数错误或不可送达。调用前要判返回值——尤其「对端不存在/未在 Steam 上」这类场景,发送是失败的。
  3. 频道是路由键:消息带 nRemoteChannel,对端用同一个频道号 ReceiveMessagesOnChannel 接收。不同频道互不干扰,是隔离「不同协议消息」的自然手段(如 0 号主协议、1 号信令、2 号聊天)。

频道接收与会话响应

对端按频道取消息,并响应会话请求。v1.65 签名:

// isteamnetworkingmessages.h:ReceiveMessagesOnChannel / AcceptSessionWithUser / CloseSessionWithUser(SDK v1.65 头文件摘录,已删减)
/// Reads the next message that has been sent from another user via SendMessageToUser() on the given channel.
/// Returns number of messages returned into your list.  (0 if no message are available on that channel.)
virtual int ReceiveMessagesOnChannel( int nLocalChannel, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0;
/// Call this in response to a SteamNetworkingMessagesSessionRequest_t callback.
virtual bool AcceptSessionWithUser( const SteamNetworkingIdentity &identityRemote ) = 0;
virtual bool CloseSessionWithUser( const SteamNetworkingIdentity &identityRemote ) = 0;

工程语义:

  1. 接收后要释放消息对象:ReceiveMessagesOnChannel 返回 SteamNetworkingMessage_t**,用完必须调用 Release()——这是 Steam 网络层最常见的泄漏点。mock 用 std::string 数组简化了这一点,接入工程不能省。
  2. AcceptSessionWithUser 幂等:头文件注释明确「若已有活跃会话,即使不在 pending 也会返回 true」。响应会话请求是一次性动作,重复响应不报错。
  3. 会话关闭是显式的:CloseSessionWithUser 结束与某用户的会话。关闭后再发消息会重新触发会话请求——接入工程要用「关闭 → 重建」的流程处理重连,而不是长期悬挂无效会话。

可靠与不可靠:发送标志

消息的投递保障由发送标志决定。v1.65 标志(steamnetworkingtypes.h):

// steamnetworkingtypes.h:k_nSteamNetworkingSend_Reliable / k_nSteamNetworkingSend_Unreliable(SDK v1.65 头文件摘录,已删减)
const int k_nSteamNetworkingSend_Unreliable = 0;
// Reliable message send. Can send up to k_cbMaxSteamNetworkingSocketsMessageSizeSend bytes in a single message.
const int k_nSteamNetworkingSend_Reliable = 8;

工程语义:

  1. 可靠 ≠ 快:k_nSteamNetworkingSend_Reliable 保证恰好一次、按序到达,代价是可能重传与排队。用于游戏状态、确认等不能丢的协议。
  2. 不可靠 = 尽力而为:k_nSteamNetworkingSend_Unreliable 可能丢、可能乱序。用于高频可替换的数据(位置、心跳),丢了就发下一帧。mock 用「标记下一条不可靠消息丢失」复现丢包。
  3. 混用要小心:同一条消息只选一个标志。若把「关键确认」发成不可靠,可靠性就名存实亡;把「高频位置」发成可靠,会堵管道。协议设计时按消息语义选标志。

接口签名对照

头文件条目语义
isteamnetworkingmessages.hISteamNetworkingMessages::SendMessageToUser发送(隐式建会话 + 频道)
isteamnetworkingmessages.hISteamNetworkingMessages::ReceiveMessagesOnChannel按频道取消息
isteamnetworkingmessages.hISteamNetworkingMessages::AcceptSessionWithUser响应会话请求(幂等)
isteamnetworkingmessages.hISteamNetworkingMessages::CloseSessionWithUser结束会话
isteamnetworkingmessages.hSteamNetworkingMessagesSessionRequest_t隐式建会话时对端收到的回调
steamnetworkingtypes.hk_nSteamNetworkingSend_Reliable可靠发送标志(=8)
steamnetworkingtypes.hk_nSteamNetworkingSend_Unreliable不可靠发送标志(=0)

数据口径与来源

  • 接口签名、返回语义、会话请求注释:SDK v1.65 public/steam/isteamnetworkingmessages.h 可实证(本机镜像已核对)。
  • 发送标志常量值:public/steam/steamnetworkingtypes.h 明示。
  • 具体网络丢包率、延迟、带宽:运行时数据,以官方当前为准。

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

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

下面的仿真复现「P2P 会话与消息」的接口工程语义:SendMessageToUser 隐式建会话、会话请求回调、AcceptSessionWithUser 幂等响应、ReceiveMessagesOnChannel 频道路由、可靠消息恰好一次按序、不可靠消息丢包、CloseSessionWithUser 关闭后重新触发会话请求、对未知对端发送失败。它与 src/08-2-p2p-session-messages.cpp 逐字节一致,mock 签名对照 SDK v1.65 头文件:

// file: src/08-2-p2p-session-messages.cpp
// tier: L1
// verify: clang++ -std=c++20 -Wall -I. src/08-2-p2p-session-messages.cpp -o bin/08-2-p2p-session-messages && ./bin/08-2-p2p-session-messages
//
// mock:复现 ISteamNetworkingMessages 的 P2P 会话与消息语义——SendMessageToUser 隐式建会话、
// 会话请求回调、ReceiveMessagesOnChannel 频道路由、可靠消息同一频道恰好一次按序、
// 不可靠可能丢失、CloseSessionWithUser 会话关闭。
// 签名对照 SDK v1.65 isteamnetworkingmessages.h,非 Valve 实现。
#include "verify.h"

#include <map>
#include <string>
#include <vector>

namespace steam_repro {

// k_nSteamNetworkingSend_Reliable 对照 steamnetworkingtypes.h(=8)
const int kSendReliable = 8;
const int kSendUnreliable = 0;

enum MockEResult {
  kOK = 1,
  kNoConnection = 2,
  kInvalidParam = 3,
};

struct MockInboxMessage {
  std::string data;
  int channel = 0;
  bool reliable = false;
};

struct MockPeer {
  uint64_t id = 0;
  std::vector<MockInboxMessage> inbox;
  std::vector<uint64_t> sessionRequests;
  std::vector<uint64_t> sessions;
  bool dropNextUnreliable = false;
};

class MockNetwork {
 public:
  uint64_t registerPeer() {
    MockPeer p;
    p.id = ++nextId_;
    peers_[p.id] = p;
    return p.id;
  }

  // ISteamNetworkingMessages::SendMessageToUser:无会话则隐式创建并触发对端会话请求。
  // 可靠消息同一频道按发送顺序恰好一次;不可靠消息可能丢失(模拟网络丢包)。
  MockEResult sendMessageToUser(uint64_t from, uint64_t to, const std::string& data,
                                int flags, int channel) {
    auto itTo = peers_.find(to);
    if (itTo == peers_.end()) return kInvalidParam;
    if (peers_.find(from) == peers_.end()) return kInvalidParam;
    MockPeer& toP = itTo->second;
    if (!hasSession(toP, from)) {
      toP.sessionRequests.push_back(from);
      toP.sessions.push_back(from);
      peers_[from].sessions.push_back(to);
    }
    bool reliable = (flags & kSendReliable) != 0;
    if (reliable) {
      toP.inbox.push_back({data, channel, true});
    } else {
      if (!toP.dropNextUnreliable) toP.inbox.push_back({data, channel, false});
      toP.dropNextUnreliable = false;
    }
    return kOK;
  }

  // 模拟发送方标记下一条不可靠消息将丢失
  void markNextUnreliableDrop(uint64_t to) {
    auto it = peers_.find(to);
    if (it != peers_.end()) it->second.dropNextUnreliable = true;
  }

  // ISteamNetworkingMessages::ReceiveMessagesOnChannel:按频道取消息
  int receiveMessagesOnChannel(uint64_t peerId, int channel, std::string* out, int max) {
    auto it = peers_.find(peerId);
    if (it == peers_.end()) return 0;
    std::vector<MockInboxMessage> keep;
    int n = 0;
    for (const MockInboxMessage& m : it->second.inbox) {
      if (m.channel == channel && n < max) {
        out[n++] = m.data;
      } else {
        keep.push_back(m);
      }
    }
    it->second.inbox = keep;
    return n;
  }

  // ISteamNetworkingMessages::AcceptSessionWithUser:响应会话请求
  bool acceptSessionWithUser(uint64_t peerId, uint64_t remote) {
    auto it = peers_.find(peerId);
    if (it == peers_.end()) return false;
    for (size_t i = 0; i < it->second.sessionRequests.size(); ++i) {
      if (it->second.sessionRequests[i] == remote) {
        it->second.sessionRequests.erase(it->second.sessionRequests.begin() + static_cast<long>(i));
        return true;
      }
    }
    // 已有活跃会话时也返回 true(头文件语义)
    return hasSession(it->second, remote);
  }

  // ISteamNetworkingMessages::CloseSessionWithUser:结束会话
  bool closeSessionWithUser(uint64_t peerId, uint64_t remote) {
    auto it = peers_.find(peerId);
    if (it == peers_.end()) return false;
    auto& s = it->second.sessions;
    for (size_t i = 0; i < s.size(); ++i) {
      if (s[i] == remote) {
        s.erase(s.begin() + static_cast<long>(i));
        return true;
      }
    }
    return false;
  }

  uint32_t sessionRequestCount(uint64_t peerId) const {
    auto it = peers_.find(peerId);
    return it == peers_.end() ? 0 : static_cast<uint32_t>(it->second.sessionRequests.size());
  }
  uint32_t sessionCount(uint64_t peerId) const {
    auto it = peers_.find(peerId);
    return it == peers_.end() ? 0 : static_cast<uint32_t>(it->second.sessions.size());
  }

 private:
  static bool hasSession(const MockPeer& p, uint64_t remote) {
    for (uint64_t r : p.sessions) {
      if (r == remote) return true;
    }
    return false;
  }

  uint64_t nextId_ = 0;
  std::map<uint64_t, MockPeer> peers_;
};

}  // namespace steam_repro

int main() {
  using namespace steam_repro;
  MockNetwork net;
  uint64_t a = net.registerPeer();
  uint64_t b = net.registerPeer();

  std::string out[8];

  // 1. SendMessageToUser:隐式创建会话,对端收到会话请求
  CHECK(net.sendMessageToUser(a, b, "hi", kSendReliable, 0) == kOK);
  CHECK(net.sessionRequestCount(b) == 1);
  CHECK(net.sessionCount(b) == 1);

  // 2. AcceptSessionWithUser:响应请求,排空建会话时的首条消息
  CHECK(net.acceptSessionWithUser(b, a));
  CHECK(net.receiveMessagesOnChannel(b, 0, out, 8) == 1);
  CHECK(out[0] == "hi");

  // 3. 可靠消息同一频道:恰好一次、按序投递
  CHECK(net.sendMessageToUser(a, b, "m1", kSendReliable, 0) == kOK);
  CHECK(net.sendMessageToUser(a, b, "m2", kSendReliable, 0) == kOK);
  CHECK(net.sendMessageToUser(a, b, "m3", kSendReliable, 0) == kOK);
  int n = net.receiveMessagesOnChannel(b, 0, out, 8);
  CHECK(n == 3);
  CHECK(out[0] == "m1" && out[1] == "m2" && out[2] == "m3");

  // 4. 再次取该频道为空(每条恰好一次)
  CHECK(net.receiveMessagesOnChannel(b, 0, out, 8) == 0);

  // 5. 频道路由:不同频道互不干扰
  CHECK(net.sendMessageToUser(a, b, "chan1", kSendReliable, 1) == kOK);
  CHECK(net.sendMessageToUser(a, b, "chan2", kSendReliable, 2) == kOK);
  CHECK(net.receiveMessagesOnChannel(b, 2, out, 8) == 1);
  CHECK(out[0] == "chan2");
  CHECK(net.receiveMessagesOnChannel(b, 1, out, 8) == 1);
  CHECK(out[0] == "chan1");

  // 6. 不可靠消息:正常投递
  CHECK(net.sendMessageToUser(a, b, "udp-ok", kSendUnreliable, 3) == kOK);
  CHECK(net.receiveMessagesOnChannel(b, 3, out, 8) == 1);
  CHECK(out[0] == "udp-ok");

  // 7. 不可靠消息:被标记丢失后不再到达
  net.markNextUnreliableDrop(b);
  CHECK(net.sendMessageToUser(a, b, "udp-lost", kSendUnreliable, 3) == kOK);
  CHECK(net.receiveMessagesOnChannel(b, 3, out, 8) == 0);

  // 8. 可靠消息在不可靠丢失后仍按序(可靠语义不受丢包影响)
  CHECK(net.sendMessageToUser(a, b, "r-after", kSendReliable, 3) == kOK);
  CHECK(net.receiveMessagesOnChannel(b, 3, out, 8) == 1);
  CHECK(out[0] == "r-after");

  // 9. CloseSessionWithUser:关闭会话后不再有活跃会话
  CHECK(net.closeSessionWithUser(b, a));
  CHECK(net.sessionCount(b) == 0);

  // 10. 会话关闭后再发消息:重新触发会话请求(头文件语义)
  CHECK(net.sendMessageToUser(a, b, "again", kSendReliable, 0) == kOK);
  CHECK(net.sessionRequestCount(b) == 1);

  // 11. 对未知对端发送失败
  CHECK(net.sendMessageToUser(a, 9999, "x", kSendReliable, 0) == kInvalidParam);

  return lab::report("08-2 P2P 会话与消息");
}

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

小结

  • SendMessageToUser 隐式建会话并给对端投递会话请求;对端 AcceptSessionWithUser 响应。
  • 消息按频道路由,ReceiveMessagesOnChannel 按频道取,收到的消息对象要 Release()。
  • 可靠发送恰好一次按序,不可靠可能丢;协议设计按消息语义选标志。
  • CloseSessionWithUser 结束会话,再发送会重新触发会话请求(重连流程用「关闭 → 重建」)。

阅读导航:上一节:8.1 网络层全景 · 下一节:8.3 网络可靠性工程 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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