本文档描述了如何在现有网络协议系统中使用 WebRTC 支持。

WebRTC（Web Real-Time Communication）是一个开源项目，支持在浏览器和移动应用程序中进行实时语音、视频和数据通信。本实现基于 github.com/pion/webrtc 库，提供与现有 UDP、QUIC、KCP 协议一致的接口。

• 🔌 统一接口 - 实现标准的 net.Listener 和 net.Conn 接口
• 📊 指标监控 - 提供连接数、传输字节等详细指标
• 🔒 并发安全 - 完整的并发控制和资源管理
• ⚡ 高性能 - 基于数据通道的高效数据传输
• 🛡️ 安全可靠 - 内置错误处理和资源清理

package main

import (
    "github.com/pion/webrtc/v4"
    netpkg "github.com/sigcn/pg/net"
)

// 实现信令处理器
type MySignalingHandler struct {
    // 实现信令交换逻辑
}

func (h *MySignalingHandler) HandleOffer(offer webrtc.SessionDescription) (*webrtc.SessionDescription, error) {
    // 处理接收到的 Offer，返回 Answer
}

func (h *MySignalingHandler) HandleAnswer(answer webrtc.SessionDescription) error {
    // 处理接收到的 Answer
}

func (h *MySignalingHandler) HandleICECandidate(candidate *webrtc.ICECandidate) error {
    // 处理 ICE 候选者
}

func (h *MySignalingHandler) WaitForPeer(ctx context.Context) (*webrtc.PeerConnection, error) {
    // 等待新的对等方连接
}

func main() {
    signaling := &MySignalingHandler{}

    config := netpkg.ProtocolConfig{
        Network: netpkg.ProtocolWebRTC,
        Addr:    "webrtc://localhost:8080",
        WebRTCICEServers: []webrtc.ICEServer{
            {
                URLs: []string{"stun:stun.l.google.com:19302"},
            },
        },
        WebRTCSignaling: signaling,
    }

    listener, err := netpkg.NewListener(config)
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("Accept error: %v", err)
            continue
        }

        go handleConnection(conn)
    }
}

func handleConnection(conn net.Conn) {
    defer conn.Close()
    
    buffer := make([]byte, 1024)
    for {
        n, err := conn.Read(buffer)
        if err != nil {
            break
        }
        
        // 回显数据
        conn.Write(buffer[:n])
    }
}

func dialWebRTC() {
    signaling := &MySignalingHandler{}

    config := netpkg.ProtocolConfig{
        Network: netpkg.ProtocolWebRTC,
        Addr:    "webrtc://remote:8080",
        WebRTCSignaling: signaling,
    }

    conn, err := netpkg.Dial(config)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    // 发送数据
    conn.Write([]byte("Hello WebRTC!"))

    // 读取响应
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        log.Printf("Read error: %v", err)
        return
    }

    fmt.Printf("Received: %s\n", string(buffer[:n]))
}

type WebRTCConfig struct {
    Addr       string                // 监听地址（用于标识）
    ICEServers []webrtc.ICEServer    // ICE服务器配置
    Config     *webrtc.Configuration // WebRTC配置
    Signaling  SignalingHandler      // 信令处理器

    // 高级选项
    MaxConnections    int           // 最大连接数，默认100
    ConnectionTimeout time.Duration // 连接超时，默认30秒
    DataChannelLabel  string        // 数据通道标签，默认"data"
}

iceServers := []webrtc.ICEServer{
    {
        URLs: []string{"stun:stun.l.google.com:19302"},
    },
    {
        URLs: []string{"turn:turn.example.com:3478"},
        Username: "user",
        Credential: "pass",
    },
}

WebRTC 需要信令服务器来交换 SDP 和 ICE 候选者。您需要实现 SignalingHandler 接口：

type SignalingHandler interface {
    // HandleOffer 处理接收到的Offer
    HandleOffer(offer webrtc.SessionDescription) (*webrtc.SessionDescription, error)
    
    // HandleAnswer 处理接收到的Answer
    HandleAnswer(answer webrtc.SessionDescription) error
    
    // HandleICECandidate 处理ICE候选者
    HandleICECandidate(candidate *webrtc.ICECandidate) error
    
    // WaitForPeer 等待对等方连接
    WaitForPeer(ctx context.Context) (*webrtc.PeerConnection, error)
}

type WebSocketSignaling struct {
    conn *websocket.Conn
    peers chan *webrtc.PeerConnection
}

func (w *WebSocketSignaling) HandleOffer(offer webrtc.SessionDescription) (*webrtc.SessionDescription, error) {
    // 通过WebSocket发送Offer
    if err := w.conn.WriteJSON(map[string]interface{}{
        "type": "offer",
        "sdp":  offer,
    }); err != nil {
        return nil, err
    }

    // 等待Answer
    var msg map[string]interface{}
    if err := w.conn.ReadJSON(&msg); err != nil {
        return nil, err
    }

    if msg["type"] == "answer" {
        answer := webrtc.SessionDescription{}
        // 解析Answer...
        return &answer, nil
    }

    return nil, fmt.Errorf("unexpected message type")
}

if webrtcListener, ok := listener.(*netpkg.WebRTCListener); ok {
    metrics := webrtcListener.Metrics()
    fmt.Printf("活跃连接数: %d\n", metrics.ActiveConnections)
    fmt.Printf("发送字节数: %d\n", metrics.BytesSent)
    fmt.Printf("接收字节数: %d\n", metrics.BytesReceived)
    fmt.Printf("数据通道数: %d\n", metrics.DataChannelsOpened)
}

type WebRTCMetrics struct {
    AcceptedConnections int64 // 已接受的连接总数
    FailedConnections   int64 // 失败的连接总数
    ActiveConnections   int64 // 当前活跃连接数
    BytesReceived       int64 // 接收的总字节数
    BytesSent           int64 // 发送的总字节数
    DataChannelsOpened  int64 // 打开的数据通道总数
}

var (
    ErrWebRTCNotSupported = errors.New("webrtc operation not supported")
    ErrDataChannelClosed  = errors.New("data channel closed")
    ErrSignalingRequired  = errors.New("signaling exchange required")
)

conn, err := listener.Accept()
if err != nil {
    switch err {
    case netpkg.ErrListenerClosed:
        // 监听器已关闭，正常退出
        return
    case netpkg.ErrMaxConnectionsReached:
        // 达到连接数限制，记录日志但继续
        log.Printf("Max connections reached")
        continue
    default:
        // 其他错误
        log.Printf("Accept error: %v", err)
        continue
    }
}

config := WebRTCConfig{
    MaxConnections:    500,  // 根据系统资源调整
    ConnectionTimeout: 30 * time.Second,
    DataChannelLabel:  "data",
}

WebRTC 连接使用内部缓冲区来处理数据传输：

• 读取缓冲区：100个消息
• 写入缓冲区：100个消息

如果您的应用需要更大的缓冲区，可以修改 webrtcConn 的缓冲区大小。

1. 信令安全：确保信令通道使用加密连接（WSS/HTTPS）
2. ICE 服务器：使用可信任的 STUN/TURN 服务器
3. 数据验证：验证接收到的数据格式和大小
4. 资源限制：设置合理的连接数和超时限制

import "log/slog"

// 设置日志级别
slog.SetLogLevel(slog.LevelDebug)

1. 连接超时

   • 检查 ICE 服务器配置
   • 确认网络防火墙设置
   • 增加连接超时时间

2. 信令失败

   • 验证信令服务器连接
   • 检查 SDP 格式
   • 确认对等方在线状态

3. 数据传输问题

   • 检查数据通道状态
   • 验证缓冲区大小
   • 监控网络质量

WebRTC 协议与现有的 UDP、QUIC、KCP 协议使用相同的接口，可以轻松切换：

// 协议切换示例
protocols := []string{"udp", "quic", "kcp", "webrtc"}

for _, protocol := range protocols {
    config := ProtocolConfig{
        Network: protocol,
        Addr:    "localhost:8080",
        // 根据协议设置特定配置...
    }

    listener, err := NewListener(config)
    if err != nil {
        continue
    }
    
    // 使用相同的处理逻辑
    handleListener(listener)
}

查看 examples/net/webrtc_example.go 文件获取完整的使用示例。

运行 WebRTC 相关测试：

go test -v ./net -run TestWebRTC

运行基准测试：

go test -bench=BenchmarkWebRTC ./net

本实现基于 MIT 许可证，使用了 Pion WebRTC 库。