snapshot of https://github.com/pion/webrtc.git (main, 2026-09-15; blobs > 131072B omitted)

examples/data-channels-whip-whep-like/main.go

@@ -0,0 +1,257 @@
+// SPDX-FileCopyrightText: 2026 The Pion community <https://pion.ly>
+// SPDX-License-Identifier: MIT
+
+//go:build !js
+
+// whip-whep demonstrates how to use the WHIP/WHEP specifications to exchange SPD descriptions
+// and stream media to a WebRTC client in the browser or OBS.
+package main
+
+import (
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"sync"
+
+	"github.com/pion/webrtc/v4"
+)
+
+// nolint: gochecknoglobals
+var (
+	peerConnectionConfiguration = webrtc.Configuration{
+		ICEServers: []webrtc.ICEServer{
+			{
+				URLs: []string{"stun:stun.l.google.com:19302"},
+			},
+		},
+	}
+
+	// Broadcast hub to forward messages between all connected clients.
+	broadcastHub = &Hub{
+		connections: make(map[*webrtc.DataChannel]bool),
+		usernames:   make(map[*webrtc.DataChannel]string),
+		mu:          sync.RWMutex{},
+	}
+)
+
+// Hub manages all connected DataChannels for broadcasting.
+type Hub struct {
+	connections map[*webrtc.DataChannel]bool
+	usernames   map[*webrtc.DataChannel]string
+	mu          sync.RWMutex
+}
+
+// nolint: gochecknoglobals
+var (
+	adjectives = []string{
+		"Quick", "Swift", "Bright", "Bold", "Calm", "Cool", "Fast", "Happy",
+		"Lucky", "Shy", "Sneaky", "Wise", "Brave", "Clever", "Kind", "Proud",
+	}
+	nouns = []string{
+		"Fox", "Eagle", "Lion", "Tiger", "Wolf", "Dragon", "Hawk", "Bear",
+		"Shark", "Falcon", "Leopard", "Panther", "Phoenix", "Raven", "Crow", "Owl",
+	}
+)
+
+// Register adds a DataChannel to the broadcast hub and assigns a random username.
+func (h *Hub) Register(channel *webrtc.DataChannel) string {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	h.connections[channel] = true
+
+	username := h.generateUniqueUsername()
+	h.usernames[channel] = username
+
+	return username
+}
+
+// Unregister removes a DataChannel from the broadcast hub.
+func (h *Hub) Unregister(channel *webrtc.DataChannel) {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	delete(h.connections, channel)
+	delete(h.usernames, channel)
+}
+
+// generateUniqueUsername generates a unique username by combining an adjective and a noun.
+// It checks existing usernames and regenerates until it finds a unique one.
+// Must be called while holding h.mu.Lock().
+// nolint: gosec
+func (h *Hub) generateUniqueUsername() string {
+	var username string
+	for {
+		adjective := adjectives[rand.Intn(len(adjectives))]
+		noun := nouns[rand.Intn(len(nouns))]
+		number := rand.Intn(1000)
+		username = fmt.Sprintf("%s%s%d", adjective, noun, number)
+
+		// Check if this username already exists by iterating over map values directly
+		exists := false
+		for _, existingUsername := range h.usernames {
+			if existingUsername == username {
+				exists = true
+
+				break
+			}
+		}
+
+		if !exists {
+			break
+		}
+	}
+
+	return username
+}
+
+// GetUsername returns the username for a DataChannel.
+func (h *Hub) GetUsername(channel *webrtc.DataChannel) string {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+
+	return h.usernames[channel]
+}
+
+// Broadcast sends a message to all registered DataChannels including the sender.
+func (h *Hub) Broadcast(message string, sender *webrtc.DataChannel) {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+
+	// Get the sender's username
+	senderUsername := h.usernames[sender]
+	formattedMessage := fmt.Sprintf("%s: %s", senderUsername, message)
+
+	for channel := range h.connections {
+		// Check if channel is still open
+		if channel.ReadyState() != webrtc.DataChannelStateOpen {
+			continue
+		}
+
+		// Send message in goroutine to avoid blocking
+		go func(ch *webrtc.DataChannel, msg string) {
+			if err := ch.SendText(msg); err != nil {
+				fmt.Printf("Failed to send broadcast message: %v\n", err)
+			}
+		}(channel, formattedMessage)
+	}
+}
+
+// Count returns the number of connected clients.
+func (h *Hub) Count() int {
+	h.mu.RLock()
+	defer h.mu.RUnlock()
+
+	return len(h.connections)
+}
+
+// nolint:gocognit
+func main() {
+	// Everything below is the Pion WebRTC API! Thanks for using it ❤️.
+	http.Handle("/", http.FileServer(http.Dir(".")))
+	http.HandleFunc("/whep", whepHandler)
+	http.HandleFunc("/whip", whipHandler)
+
+	fmt.Println("Open http://localhost:8080 to access this demo")
+	panic(http.ListenAndServe(":8080", nil)) // nolint: gosec
+}
+
+func whipHandler(res http.ResponseWriter, req *http.Request) {
+	// Read the offer from HTTP Request
+	offer, err := io.ReadAll(req.Body)
+	if err != nil {
+		panic(err)
+	}
+
+	// Create a new RTCPeerConnection
+	peerConnection, err := webrtc.NewPeerConnection(peerConnectionConfiguration)
+	if err != nil {
+		panic(err)
+	}
+
+	// Send answer via HTTP Response
+	writeAnswer(res, peerConnection, offer, "/whip")
+}
+
+func whepHandler(res http.ResponseWriter, req *http.Request) {
+	// Read the offer from HTTP Request
+	offer, err := io.ReadAll(req.Body)
+	if err != nil {
+		panic(err)
+	}
+
+	// Create a new RTCPeerConnection
+	peerConnection, err := webrtc.NewPeerConnection(peerConnectionConfiguration)
+	if err != nil {
+		panic(err)
+	}
+
+	// Send answer via HTTP Response
+	writeAnswer(res, peerConnection, offer, "/whep")
+}
+
+func writeAnswer(res http.ResponseWriter, peerConnection *webrtc.PeerConnection, offer []byte, path string) {
+	// Set the handler for ICE connection state
+	// This will notify you when the peer has connected/disconnected
+	peerConnection.OnICEConnectionStateChange(func(connectionState webrtc.ICEConnectionState) {
+		fmt.Printf("ICE Connection State has changed: %s\n", connectionState.String())
+
+		if connectionState == webrtc.ICEConnectionStateFailed ||
+			connectionState == webrtc.ICEConnectionStateClosed {
+			_ = peerConnection.Close()
+		}
+	})
+
+	peerConnection.OnDataChannel(func(dataChannel *webrtc.DataChannel) {
+		fmt.Printf("New DataChannel %s %d\n", dataChannel.Label(), dataChannel.ID())
+
+		dataChannel.OnOpen(func() {
+			// register this channel in the broadcast hub and get assigned username
+			username := broadcastHub.Register(dataChannel)
+			fmt.Printf("Data channel '%s'-'%d' opened. Username: %s, Total clients: %d\n",
+				dataChannel.Label(), dataChannel.ID(), username, broadcastHub.Count())
+		})
+
+		dataChannel.OnClose(func() {
+			fmt.Printf("Data channel '%s'-'%d' closed\n", dataChannel.Label(), dataChannel.ID())
+			// unregister this channel from the broadcast hub
+			broadcastHub.Unregister(dataChannel)
+		})
+
+		dataChannel.OnMessage(func(msg webrtc.DataChannelMessage) {
+			message := string(msg.Data)
+			fmt.Printf("Message from DataChannel '%s': '%s'\n", dataChannel.Label(), message)
+
+			// broadcast the message to all other connected clients
+			broadcastHub.Broadcast(message, dataChannel)
+		})
+	})
+
+	if err := peerConnection.SetRemoteDescription(webrtc.SessionDescription{
+		Type: webrtc.SDPTypeOffer, SDP: string(offer),
+	}); err != nil {
+		panic(err)
+	}
+
+	// Create channel that is blocked until ICE Gathering is complete
+	gatherComplete := webrtc.GatheringCompletePromise(peerConnection)
+
+	// Create answer
+	answer, err := peerConnection.CreateAnswer(nil)
+	if err != nil {
+		panic(err)
+	} else if err = peerConnection.SetLocalDescription(answer); err != nil {
+		panic(err)
+	}
+
+	// Block until ICE Gathering is complete, disabling trickle ICE
+	// we do this because we only can exchange one signaling message
+	// in a production application you should exchange ICE Candidates via OnICECandidate
+	<-gatherComplete
+
+	// WHIP+WHEP expects a Location header and a HTTP Status Code of 201
+	res.Header().Add("Location", path)
+	res.WriteHeader(http.StatusCreated)
+
+	// Write Answer with Candidates as HTTP Response
+	fmt.Fprint(res, peerConnection.LocalDescription().SDP) //nolint: errcheck
+}