Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package mediaedge
import (
"context"
"errors"
"fmt"
"log/slog"
"net"
"net/netip"
"sync"
"time"
"github.com/TNTcraftHIM/Piik/internal/app/portmapping"
"github.com/TNTcraftHIM/Piik/internal/diagnostics"
"github.com/TNTcraftHIM/Piik/internal/media/forwarding"
"github.com/pion/ice/v4"
"github.com/pion/stun/v4"
"github.com/pion/webrtc/v4"
"golang.org/x/sync/singleflight"
)
const stunSurveyTimeout = 5 * time.Second
// One physical connection owns one socket: Pion's UDP mux cannot distinguish
// concurrent DTLS/SRTP sessions with the same remote IP:port. Discovery and
// media share this socket; ICE restart retains it, replacement never does.
type iceSocket struct {
engine *Engine
mux *ice.UDPMuxDefault
localPort int
portMapping *portmapping.Mapping
ctx context.Context
cancel context.CancelFunc
closeOnce sync.Once
punchedPeer *net.UDPAddr
}
func (engine *Engine) newICESocket(servers []webrtc.ICEServer, mapping bool) (*iceSocket, error) {
// Go keeps wildcard UDP dual-stack where supported; a concrete IPv4 bind
// remains IPv4-only. The same address family selection serves every edge.
connection, err := engine.listenPacket("udp", engine.bindAddress)
if err != nil {
return nil, errors.New("native media UDP socket is unavailable")
}
return engine.adoptICESocket(connection, servers, mapping)
}
// Adoption happens before the one PeerConnection is constructed. Discovery and
// media then keep this exact socket, including any authenticated punched tuple.
func (engine *Engine) adoptICESocket(connection net.PacketConn, servers []webrtc.ICEServer, mapping bool) (*iceSocket, error) {
var punchedPeer *net.UDPAddr
if prepared, ok := connection.(*PunchedSocket); ok {
punchedPeer = prepared.remote
connection = prepared.PacketConn
}
ctx, cancel := context.WithCancel(engine.ctx)
socket := &iceSocket{
engine: engine, ctx: ctx, cancel: cancel,
localPort: connection.LocalAddr().(*net.UDPAddr).Port,
punchedPeer: punchedPeer,
mux: forwarding.NewUDPMux(ice.UDPMuxParams{
Logger: diagnostics.PionLoggerFactory().NewLogger("piik-ice"), UDPConn: connection,
}),
}
if engine.portMapping && mapping && len(stunServers(servers)) > 0 {
socket.portMapping = portmapping.Start(socket.localPort)
}
engine.mu.Lock()
closed := engine.closed
if !closed {
engine.sockets[socket] = struct{}{}
}
engine.mu.Unlock()
if closed {
socket.close()
return nil, errors.New("native media engine is closed")
}
return socket, nil
}
func (socket *iceSocket) settings() webrtc.SettingEngine {
settings := socket.engine.settings
settings.SetICEUDPMux(socket.mux)
return settings
}
func (socket *iceSocket) newPeerConnection() (*webrtc.PeerConnection, error) {
return webrtc.NewAPI(
webrtc.WithMediaEngine(socket.engine.media),
webrtc.WithInterceptorRegistry(socket.engine.interceptors),
webrtc.WithSettingEngine(socket.settings()),
).NewPeerConnection(webrtc.Configuration{})
}
func (socket *iceSocket) addPunchedPeer(connection *webrtc.PeerConnection) error {
if socket.punchedPeer == nil {
return nil
}
mid := "0"
return forwarding.AddICECandidate(connection, webrtc.ICECandidateInit{SDPMid: &mid,
Candidate: fmt.Sprintf("candidate:sp0 1 udp 1694498815 %s %d typ srflx", socket.punchedPeer.IP, socket.punchedPeer.Port),
})
}
func (socket *iceSocket) close() {
if socket == nil {
return
}
socket.closeOnce.Do(func() {
socket.cancel()
// Keep the port reserved until gateway cleanup settles: a late deletion
// must not remove a replacement connection's mapping on a recycled port.
if socket.portMapping != nil {
socket.portMapping.Close()
}
_ = socket.mux.Close()
socket.engine.mu.Lock()
delete(socket.engine.sockets, socket)
socket.engine.mu.Unlock()
})
}
type mappedAddress struct {
address string
port int
// One-based position in the requested STUN list, independent of response order.
serverIndex int
}
func (socket *iceSocket) surveySTUN(
ctx context.Context,
servers []webrtc.ICEServer,
emit func(mappedAddress),
) {
surveyContext, cancel := context.WithTimeout(ctx, stunSurveyTimeout)
defer cancel()
// One survey retains its resolver even while canceled workers are settling.
resolver := net.DefaultResolver
// Duplicate destinations may share an observation only in this gathering.
var queries singleflight.Group
results := make(chan mappedAddress)
var pending sync.WaitGroup
index := 0
for _, server := range servers {
for _, rawURL := range server.URLs {
index++
serverIndex := index
uri, err := stun.ParseURI(rawURL)
if err != nil || uri.Scheme != stun.SchemeTypeSTUN ||
uri.Proto != stun.ProtoTypeUDP || uri.Port < 1 || uri.Port > 65_535 {
continue
}
pending.Add(1)
go func() {
defer pending.Done()
// Resolve each destination independently inside the same bound as
// its Binding request; one broken resolver must not stall healthy STUN.
addresses, err := resolver.LookupNetIP(surveyContext, "ip4", uri.Host)
if err != nil || len(addresses) == 0 {
slog.DebugContext(surveyContext, "nat-survey", "event", "resolve-failed", "host", uri.Host, diagnostics.Error(err))
return
}
address := net.UDPAddrFromAddrPort(netip.AddrPortFrom(addresses[0], uint16(uri.Port)))
started := time.Now()
mapped, err := socket.stunMapping(surveyContext, &queries, address)
if err != nil || mapped == nil || mapped.IP.To4() == nil ||
mapped.Port < 1 || mapped.Port > 65_535 {
slog.DebugContext(surveyContext, "nat-survey", "event", "binding-failed", "serverPort", address.Port,
"durationMs", time.Since(started).Milliseconds(), diagnostics.Error(err))
return
}
slog.DebugContext(surveyContext, "nat-survey", "event", "binding", "serverPort", address.Port,
"localPort", socket.localPort, "mappedAddress", diagnostics.ID(mapped.IP.String()), "mappedPort", mapped.Port,
"durationMs", time.Since(started).Milliseconds())
select {
case results <- mappedAddress{address: mapped.IP.String(), port: mapped.Port, serverIndex: serverIndex}:
case <-surveyContext.Done():
}
}()
}
}
go func() {
pending.Wait()
close(results)
}()
for {
select {
case value, ok := <-results:
if !ok {
return
}
// The consumer selects survey destinations before deduplicating
// mappings. An ordinary response must not hide a survey observation.
emit(value)
case <-surveyContext.Done():
return
}
}
}