webrtc peerconnection_server 模块介绍

peerconnection_server是webrtc一个简单的信令服务器示例，它位于 src/examples/peerconnection/server/ 目录下。它的主要目的是配合 peerconnection_client（另一个示例客户端）使用，演示两个 WebRTC 对等端（Peer）如何通过一个中间服务器交换建立连接所需的元数据（SDP 和 ICE Candidates），从而完成 P2P 握手。

• 它仅用于学习和测试 WebRTC 的信令流程。

• 它不支持大规模并发、没有身份验证、没有加密（HTTPS/WSS）、功能非常有限。

• 在实际产品中，你需要使用专业的信令服务器（如基于 WebSocket 的 Node.js/Go/Python 服务，或使用 SIP 协议的服务）。

一、核心功能

peerconnection_server 的主要职责是消息中转。它不处理任何媒体数据（音频/视频），只处理文本信令。

1.1. 用户注册与发现:

• 客户端启动时连接到服务器并注册一个名字（例如 "Alice"）。

• 服务器维护一个在线用户列表。

• 当新用户加入或旧用户离开时，服务器会通知所有其他在线用户更新他们的成员列表。

1.2. 消息路由:

• 当 Alice 想呼叫 Bob 时，她通过服务器发送一条消息给 Bob。

• 服务器根据 Bob 的名字或 ID，将消息转发给 Bob 的连接。

1.3. 支持的信令类型:

• SDP Offer/Answer: 用于协商媒体能力（编解码器、分辨率等）。

• ICE Candidates: 用于网络穿透，交换双方的网络地址信息。

二、实现架构

该服务器是一个单线程、非阻塞 I/O 的 HTTP 服务器。

2.1. 网络层:

• 使用原生 BSD Socket API（跨平台封装在 SocketBase, DataSocket, ListeningSocket 中）。

• 使用 select() (Linux/Mac) 或 WSAPoll (Windows)进行 I/O 多路复用，在一个线程中同时处理多个客户端连接。

2.2. 应用层协议:

• 基于 HTTP/1.1。

• 使用长轮询（Long-Polling）机制来实现服务器向客户端的"推送"。

• 客户端发送一个 /wait 请求。

• 服务器挂起该请求，直到有发给该客户端的消息到达，或者超时。

• 一旦有消息，服务器立即响应 HTTP 200 OK 并带上消息体。

• 客户端收到后立即发起下一个 /wait 请求。

2.3. 核心类:

• ChannelMember:

这个类代表一个已连接到信令服务器的特定用户/客户端。每个浏览器标签页或应用程序实例在服务器上都有一个对应的 ChannelMember 对象。

• PeerChannel :

这个类代表整个聊天室或信令房间。它管理所有当前连接的 ChannelMember。在示例代码中，通常只有一个全局的 PeerChannel 实例，所有用户都在同一个"房间"里。

cpp 复制代码

// Represents a single peer connected to the server.
class ChannelMember {
 public:
  explicit ChannelMember(DataSocket* socket);
  ~ChannelMember();

  bool connected() const { return connected_; }
  int id() const { return id_; }
  void set_disconnected() { connected_ = false; }
  bool is_wait_request(DataSocket* ds) const;
  const std::string& name() const { return name_; }

  bool TimedOut();

  std::string GetPeerIdHeader() const;

  bool NotifyOfOtherMember(const ChannelMember& other);

  // Returns a string in the form "name,id\n".
  std::string GetEntry() const;

  void ForwardRequestToPeer(DataSocket* ds, ChannelMember* peer);

  void OnClosing(DataSocket* ds);

  void QueueResponse(const std::string& status,
                     const std::string& content_type,
                     const std::string& extra_headers,
                     const std::string& data);

  void SetWaitingSocket(DataSocket* ds);

 protected:
  struct QueuedResponse {
    std::string status, content_type, extra_headers, data;
  };

  DataSocket* waiting_socket_;
  int id_;
  bool connected_;
  time_t timestamp_;
  std::string name_;
  std::queue<QueuedResponse> queue_;
  static int s_member_id_;
};

// Manages all currently connected peers.
class PeerChannel {
 public:
  typedef std::vector<ChannelMember*> Members;

  PeerChannel() {}

  ~PeerChannel() { DeleteAll(); }

  const Members& members() const { return members_; }

  // Returns true if the request should be treated as a new ChannelMember
  // request.  Otherwise the request is not peerconnection related.
  static bool IsPeerConnection(const DataSocket* ds);

  // Finds a connected peer that's associated with the |ds| socket.
  ChannelMember* Lookup(DataSocket* ds) const;

  // Checks if the request has a "peer_id" parameter and if so, looks up the
  // peer for which the request is targeted at.
  ChannelMember* IsTargetedRequest(const DataSocket* ds) const;

  // Adds a new ChannelMember instance to the list of connected peers and
  // associates it with the socket.
  bool AddMember(DataSocket* ds);

  // Closes all connections and sends a "shutting down" message to all
  // connected peers.
  void CloseAll();

  // Called when a socket was determined to be closing by the peer (or if the
  // connection went dead).
  void OnClosing(DataSocket* ds);

  void CheckForTimeout();

 protected:
  void DeleteAll();
  void BroadcastChangedState(const ChannelMember& member,
                             Members* delivery_failures);
  void HandleDeliveryFailures(Members* failures);

  // Builds a simple list of "name,id\n" entries for each member.
  std::string BuildResponseForNewMember(const ChannelMember& member,
                                        std::string* content_type);

 protected:
  Members members_;
};

• DataSocket:

这个类代表一个已建立的客户端连接。当 ListeningSocket 接受一个新连接后，会创建一个 DataSocket 实例来处理该连接上的 HTTP 请求和响应。

• ListeningSocket :

这个类代表服务器的监听端点。它负责等待新的传入连接.

三、通信流程示例

3.1 信令工作流程

启动: PeerConnectionServer 创建一个 ListeningSocket 并调用 Listen(8888)。
事件循环: 服务器进入主循环，使用 select() 监视 ListeningSocket 和所有活跃的 DataSocket。
新连接:

• 如果 ListeningSocket 可读，调用 Accept()。

• 获取新的 DataSocket*，将其添加到活跃连接列表中。

接收数据:

• 如果某个 DataSocket 可读，调用其 OnDataAvailable()。

• DataSocket 内部解析 HTTP。

• 如果 request_received() 变为 true，主循环检测到该 socket 就绪且请求完整。

业务处理:

• 服务器读取 DataSocket->request_path() 和 DataSocket->data()。

• 根据路径（如 /message）将数据转发给目标用户的 DataSocket。

• 调用 DataSocket->Send("200 OK", ...) 回复当前客户端。

关闭:

• 如果 OnDataAvailable 返回错误，或业务逻辑决定关闭，从列表中移除该 DataSocket，其析构函数会关闭底层 socket。

3.2 用户A发生SDP给用户B

用户 B 等待:

• 用户 B 的客户端发送 HTTP GET /wait。

• 服务器找到 B 的 ChannelMember，调用 SetWaitingSocket(socket_B)。

• Socket B 保持打开，不返回数据，进入挂起状态。

用户 A 发送消息:

• 用户 A 的客户端发送 HTTP POST /message?peer_id=B_ID，Body 包含 SDP Offer。

• 服务器主循环收到请求，通过 PeerChannel::Lookup(socket_A) 找到用户 A。

• 通过 PeerChannel::IsTargetedRequest 解析出目标 ID 是 B。

• 找到用户 B 的 ChannelMember 对象。

转发:

• 服务器调用 member_B->ForwardRequestToPeer(socket_A, member_B) (实际逻辑在 PeerChannel 中协调)。

• 在 ChannelMember::ForwardRequestToPeer 内部，它会将 SDP 数据包装。

• 检查 member_B->waiting_socket_。发现不为空（即步骤 1 中的 Socket B）。

• 立即通过 Socket B 发送 HTTP 200 OK + SDP 数据。

• 清空 member_B->waiting_socket_。

用户 B 接收:

• 用户 B 的客户端收到 HTTP 响应，解析出 SDP。

• 用户 B 的 WebRTC 引擎处理 SDP，生成 Answer。

• 用户 B 再次发起 /wait 或发送 Answer，循环继续。

3.3 视频会话流程

连接与注册:

• Alice 连接服务器: POST /sign_in?name=Alice

• Bob 连接服务器: POST /sign_in?name=Bob

• 服务器回复 Alice: 200 OK， body 包含当前在线用户列表（包含 Bob）。

• 服务器回复 Bob: 200 OK， body 包含当前在线用户列表（包含 Alice）。

• 此时，Alice 和 Bob 都知道对方在线了。

发起呼叫 (Alice -> Bob):

• Alice 的 WebRTC 引擎生成 SDP Offer。

• Alice 客户端发送: POST /message?peer_id=Bob_ID， Body 为 SDP Offer JSON。

• 服务器收到请求，查找 Bob 的连接。

• 如果 Bob 正处于 /wait 挂起状态，服务器立即通过该连接返回 SDP Offer。

• 如果 Bob 没在等待，服务器将消息存入 Bob 的消息队列，待 Bob 下次 /wait 时发送。

接收与回应 (Bob -> Alice):

• Bob 收到 SDP Offer，WebRTC 引擎生成 SDP Answer。

• Bob 客户端发送: POST /message?peer_id=Alice_ID， Body 为 SDP Answer。

• 服务器转发给 Alice。

交换 ICE Candidates:

• 双方不断收集本地网络候选者（Host, Srflx, Relay）。

• 每收集到一个，就通过 POST /message 发送给对方。

• 服务器持续中转这些 JSON 消息。

P2P 建立:

• 一旦 SDP 和足够的 ICE Candidates 交换完毕，且连通性检查成功，Alice 和 Bob 之间建立起直接的 UDP 连接。

• 此后，所有的音频、视频和数据通道流量都直接在对等端之间传输，不再经过 peerconnection_server。