Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

18.1 KB
Raw Blame
package mediaedge

import (
	"bytes"
	"context"
	"errors"
	"math"
	"net"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/livekit/livekit-server/pkg/sfu"
	"github.com/pion/ice/v4"
	"github.com/pion/stun/v4"
	"github.com/pion/transport/v5/vnet"
	"github.com/pion/webrtc/v4"
)

var sequentialPunchNAT = vnet.NATType{MappingBehavior: vnet.EndpointAddrPortDependent, FilteringBehavior: vnet.EndpointAddrPortDependent}

func punchEngine(t *testing.T, network *punchLab, side int) *Engine {
	t.Helper()
	engine, err := NewEngine(EngineOptions{BindAddress: network.private[side] + ":0"})
	if err != nil {
		t.Fatal(err)
	}
	engine.listenPacket = func(_, address string) (net.PacketConn, error) {
		return network.nets[side].ListenPacket("udp4", address)
	}
	engine.settings.SetNet(network.nets[side])
	engine.settings.SetNetworkTypes([]webrtc.NetworkType{webrtc.NetworkTypeUDP4})
	engine.settings.SetICEMulticastDNSMode(ice.MulticastDNSModeDisabled)
	t.Cleanup(func() { _ = engine.Close() })
	return engine
}

func preparePunch(t *testing.T, engine *Engine, source *Source, id, secret string) (*PunchPreparation, *PunchPrediction) {
	t.Helper()
	preparation, err := engine.BeginPunch(id, source, []webrtc.ICEServer{{URLs: []string{
		"stun:" + punchSTUNIP + ":3478", "stun:" + punchSTUNIP + ":3479", "stun:" + punchSTUNIP + ":3480",
	}}}, secret)
	if err != nil {
		t.Fatal(err)
	}
	prediction, err := preparation.Prepare()
	if err != nil {
		t.Fatal(err)
	}
	return preparation, prediction
}

func TestPunchAdoptsProvedTupleIntoMediaAndFeedback(t *testing.T) {
	stable := vnet.NATType{MappingBehavior: vnet.EndpointIndependent, FilteringBehavior: vnet.EndpointAddrPortDependent}
	for _, scenario := range []struct {
		name        string
		left, right vnet.NATType
		skew        time.Duration
		dropLate    bool
	}{
		{"sequential", sequentialPunchNAT, sequentialPunchNAT, 0, false},
		{"sequential-delayed", sequentialPunchNAT, sequentialPunchNAT, 250 * time.Millisecond, false},
		{"sequential-late", sequentialPunchNAT, sequentialPunchNAT, 900 * time.Millisecond, false},
		{"stable-sender", stable, sequentialPunchNAT, 250 * time.Millisecond, false},
		{"stable-sender-late-loss", stable, sequentialPunchNAT, 900 * time.Millisecond, true},
		{"stable-receiver", sequentialPunchNAT, stable, 250 * time.Millisecond, false},
		{"both-stable", stable, stable, 0, false},
	} {
		t.Run(scenario.name, func(t *testing.T) {
			network := newPunchLab(t, scenario.left, scenario.right)
			engines := [2]*Engine{punchEngine(t, network, 0), punchEngine(t, network, 1)}
			keyFrames := make(chan struct{}, 8)
			source, err := engines[0].NewSource("vp8", 1, 1, func([]int) {
				select {
				case keyFrames <- struct{}{}:
				default:
				}
			})
			if err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() { _ = source.Close() })
			left, leftPrediction := preparePunch(t, engines[0], source, "connection", strings.Repeat("42", 32))
			right, rightPrediction := preparePunch(t, engines[1], nil, "connection", strings.Repeat("42", 32))
			var observing, late atomic.Bool
			var checks, replies [2]atomic.Int32
			var lateChecks, dropped atomic.Int32
			observing.Store(true)
			network.wan.AddChunkFilter(func(chunk vnet.Chunk) bool {
				if !observing.Load() || chunk.Network() != "udp" {
					return true
				}
				message := &stun.Message{Raw: chunk.UserData()}
				if message.Decode() != nil {
					return true
				}
				for side := range 2 {
					if chunk.SourceAddr().(*net.UDPAddr).IP.String() != network.public[side] ||
						chunk.DestinationAddr().(*net.UDPAddr).IP.String() != network.public[1-side] {
						continue
					}
					switch message.Type {
					case stun.BindingRequest:
						checks[side].Add(1)
						if side == 0 && late.Load() && lateChecks.Add(1) == 1 && scenario.dropLate {
							dropped.Add(1)
							return false
						}
					case stun.BindingSuccess:
						replies[side].Add(1)
					}
				}
				return true
			})
			results := make(chan bool, 2)
			go func() { results <- left.Run(*rightPrediction) }()
			time.Sleep(scenario.skew)
			late.Store(true)
			go func() { results <- right.Run(*leftPrediction) }()
			for range 2 {
				if !<-results {
					t.Fatal("authenticated preparation failed")
				}
			}
			observing.Store(false)
			for side := range 2 {
				if checks[side].Load() > 64 || replies[side].Load() > 64 {
					t.Fatalf("preparation packet budget exceeded: requests=%d replies=%d", checks[side].Load(), replies[side].Load())
				}
			}
			if scenario.dropLate && (dropped.Load() != 1 || lateChecks.Load() < 2) {
				t.Fatalf("missing first triggered-check loss/retry: dropped=%d late=%d", dropped.Load(), lateChecks.Load())
			}
			t.Logf("preparation requests=%d/%d replies=%d/%d late-checks=%d dropped=%d", checks[0].Load(), checks[1].Load(), replies[0].Load(), replies[1].Load(), lateChecks.Load(), dropped.Load())
			// No fresh STUN mapping can replace the endpoint that proved this path.
			socket := engines[1].TakePunchedSocket("connection", nil)
			if socket == nil {
				t.Fatal("missing inbound winner")
			}
			t.Cleanup(func() { _ = socket.Close() })
			edge, err := engines[0].NewEdge(source, EdgeOptions{ConnectionID: "connection", Punched: true})
			if err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() { _ = edge.Close() })
			offer, err := edge.CreateOffer()
			if err != nil {
				t.Fatal(err)
			}
			receiver, answer, err := engines[1].NewReceiver(ReceiverOptions{Offer: offer, EdgeCapacity: 1, PunchedSocket: socket})
			if err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() { _ = receiver.Close() })
			if err := edge.SetAnswer(answer, ""); err != nil {
				t.Fatal(err)
			}
			waitConnected(t, edge.connection, "adopted Native edge")
			waitConnected(t, receiver.connection, "adopted Native receiver")
			deadline := time.Now().Add(3 * time.Second)
			timestamp := time.Second
			for {
				if err := writeSourceFrame(source, sfu.VP8KeyFrame8x8, timestamp, time.Second/30); err != nil {
					t.Fatal(err)
				}
				timestamp += time.Second / 30
				receiver.mu.Lock()
				received := receiver.videoSSRC != 0
				receiver.mu.Unlock()
				if received {
					break
				}
				if time.Now().After(deadline) {
					t.Fatal("adopted socket carried no SRTP video")
				}
				time.Sleep(20 * time.Millisecond)
			}
			for _, buffer := range source.media.GetAllBuffers() {
				if buffer != nil {
					buffer.SetPLIThrottle(0)
				}
			}
			for len(keyFrames) > 0 {
				<-keyFrames
			}
			receiver.RequestKeyFrame()
			waitSignal(t, keyFrames, "reverse SRTCP feedback")
			if engines[0].Punch("connection") != nil || engines[1].Punch("connection") != nil {
				t.Fatal("adoption retained a preparation owner")
			}
		})
	}
}

func TestPunchRetiresStableObservationSocket(t *testing.T) {
	stable := vnet.NATType{MappingBehavior: vnet.EndpointIndependent, FilteringBehavior: vnet.EndpointAddrPortDependent}
	for _, scenario := range []string{"connection", "source", "engine", "cancel-during", "no-response"} {
		t.Run(scenario, func(t *testing.T) {
			network := newPunchLab(t, stable, sequentialPunchNAT)
			engine := punchEngine(t, network, 0)
			var connections []*countedPunchConn
			engine.listenPacket = func(_, address string) (net.PacketConn, error) {
				conn, err := network.nets[0].ListenPacket("udp4", address)
				if err != nil {
					return nil, err
				}
				counted := &countedPunchConn{PacketConn: conn}
				connections = append(connections, counted)
				return counted, nil
			}
			source, err := engine.NewSource("vp8", 1, 1, nil)
			if err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() { _ = source.Close() })
			preparation, prediction := preparePunch(t, engine, source, "stable", strings.Repeat("42", 32))
			if prediction.Step != 0 || len(connections) != 1 || connections[0].closed.Load() {
				t.Fatal("stable observation did not retain its original socket")
			}
			if engine.TakePunchedSocket("stable", source) != nil {
				t.Fatal("observation alone authorized socket adoption")
			}
			before := connections[0].writes.Load()
			switch scenario {
			case "connection":
				engine.ClosePunch("stable")
			case "source":
				_ = source.Close()
			case "engine":
				_ = engine.Close()
			default:
				if scenario == "cancel-during" {
					connections[0].firstWrite = preparation.cancel
				}
				if preparation.Run(PunchPrediction{Address: network.public[1], Port: 5000, Step: 1}) {
					t.Fatal("unreachable peer completed preparation")
				}
				engine.ClosePunch("stable")
			}
			if len(connections) != 1 || !connections[0].closed.Load() || connections[0].writes.Load()-before > 8 {
				t.Fatal("stable preparation replaced or leaked its socket, or exceeded its send budget")
			}
		})
	}
}

func TestPunchRejectsAnotherGenerationOnStableMapping(t *testing.T) {
	stable := vnet.NATType{MappingBehavior: vnet.EndpointIndependent, FilteringBehavior: vnet.EndpointIndependent}
	network := newPunchLab(t, stable, stable)
	leftEngine, rightEngine := punchEngine(t, network, 0), punchEngine(t, network, 1)
	left, leftPrediction := preparePunch(t, leftEngine, nil, "left", strings.Repeat("42", 32))
	right, rightPrediction := preparePunch(t, rightEngine, nil, "right", strings.Repeat("24", 32))
	results := make(chan bool, 2)
	go func() { results <- left.Run(*rightPrediction) }()
	go func() { results <- right.Run(*leftPrediction) }()
	for range 2 {
		if <-results {
			t.Fatal("another generation's packets authorized adoption")
		}
	}
	if leftEngine.TakePunchedSocket("left", nil) != nil || rightEngine.TakePunchedSocket("right", nil) != nil {
		t.Fatal("unauthenticated preparation exposed a socket")
	}
}

func TestPunchSurveyViewRetiresWithoutClosingRetainedSocket(t *testing.T) {
	network := newPunchLab(t, sequentialPunchNAT, sequentialPunchNAT)
	socket, err := network.nets[0].ListenPacket("udp4", network.private[0]+":0")
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = socket.Close() })
	view := &punchSurveySocket{PacketConn: socket}
	if err := view.Close(); err != nil {
		t.Fatal(err)
	}
	if err := socket.SetDeadline(time.Now().Add(500 * time.Millisecond)); err != nil {
		t.Fatal(err)
	}
	buffer := make([]byte, 1024)
	remote := &net.UDPAddr{IP: net.ParseIP(punchSTUNIP), Port: 3478}
	if _, _, err := view.ReadFrom(buffer); !errors.Is(err, net.ErrClosed) {
		t.Fatalf("closed survey view can read the next owner's socket: %v", err)
	}
	if _, err := view.WriteTo(buffer, remote); !errors.Is(err, net.ErrClosed) {
		t.Fatalf("closed survey view can write the next owner's socket: %v", err)
	}
	if err := view.Close(); err != nil {
		t.Fatal(err)
	}
	request := stun.MustBuild(stun.TransactionID, stun.BindingRequest)
	if _, err := socket.WriteTo(request.Raw, remote); err != nil {
		t.Fatal(err)
	}
	if _, _, err := socket.ReadFrom(buffer); err != nil {
		t.Fatalf("retiring the view damaged the retained socket: %v", err)
	}
}

// A pipe models a backpressured write without timing-sensitive UDP buffers.
// The first successful send may be dropped to exercise Pion's retransmitter.
type blockedSurveyConn struct {
	net.PacketConn
	writer  net.Conn
	entered chan struct{}
	blockAt int32
	writes  atomic.Int32
	closed  atomic.Bool
	once    sync.Once
}

func (c *blockedSurveyConn) WriteTo(p []byte, _ net.Addr) (int, error) {
	if c.writes.Add(1) < c.blockAt {
		return len(p), nil
	}
	c.once.Do(func() { close(c.entered) })
	return c.writer.Write(p)
}

func (c *blockedSurveyConn) SetDeadline(deadline time.Time) error {
	return errors.Join(c.writer.SetWriteDeadline(deadline), c.PacketConn.SetDeadline(deadline))
}

func (c *blockedSurveyConn) Close() error {
	c.closed.Store(true)
	return errors.Join(c.writer.Close(), c.PacketConn.Close())
}

func TestPunchSurveyRetiresBlockedWrites(t *testing.T) {
	for _, phase := range []struct {
		name    string
		blockAt int32
	}{{"initial", 1}, {"retransmission", 2}} {
		for _, retirement := range []string{"cancel", "timeout"} {
			t.Run(phase.name+"/"+retirement, func(t *testing.T) {
				network := newPunchLab(t, sequentialPunchNAT, sequentialPunchNAT)
				engine := punchEngine(t, network, 0)
				packet, err := network.nets[0].ListenPacket("udp4", network.private[0]+":0")
				if err != nil {
					t.Fatal(err)
				}
				writer, reader := net.Pipe()
				socket := &blockedSurveyConn{PacketConn: packet, writer: writer, entered: make(chan struct{}), blockAt: phase.blockAt}
				t.Cleanup(func() { _ = socket.Close(); _ = reader.Close() })
				engine.listenPacket = func(_, _ string) (net.PacketConn, error) { return socket, nil }
				preparation, err := engine.BeginPunch("blocked", nil, []webrtc.ICEServer{{URLs: []string{
					"stun:" + punchSTUNIP + ":3478", "stun:" + punchSTUNIP + ":3479", "stun:" + punchSTUNIP + ":3480",
				}}}, strings.Repeat("42", 32))
				if err != nil {
					t.Fatal(err)
				}
				done := make(chan error, 1)
				go func() { _, err := preparation.Prepare(); done <- err }()
				waitSignal(t, socket.entered, "blocked STUN write")
				closed := make(chan struct{})
				wait := 2 * time.Second
				if retirement == "cancel" {
					wait = 500 * time.Millisecond
					go func() { engine.ClosePunch("blocked"); close(closed) }()
				}
				select {
				case err := <-done:
					if err == nil || !socket.closed.Load() {
						t.Fatal("failed survey succeeded or retained its socket")
					}
				case <-time.After(wait):
					t.Fatal("retirement did not release a blocked STUN write")
				}
				if retirement == "cancel" {
					waitSignal(t, closed, "blocked survey owner retirement")
				} else {
					engine.ClosePunch("blocked")
				}
				if engine.TakePunchedSocket("blocked", nil) != nil {
					t.Fatal("failed survey exposed a socket")
				}
			})
		}
	}
}

func TestPunchRetirementJoinsBeforeSlotReuse(t *testing.T) {
	for _, retire := range []string{"connection", "source", "engine", "context"} {
		t.Run(retire, func(t *testing.T) {
			network := newPunchLab(t, sequentialPunchNAT, sequentialPunchNAT)
			engine := punchEngine(t, network, 0)
			source, err := engine.NewSource("vp8", 1, 1, nil)
			if err != nil {
				t.Fatal(err)
			}
			t.Cleanup(func() { _ = source.Close() })
			preparation, _ := preparePunch(t, engine, source, "current", strings.Repeat("42", 32))
			// A worker held at an allocation boundary cannot be overtaken by a
			// premature commit or a replacement connection.
			entered, release := make(chan struct{}), make(chan struct{})
			var once sync.Once
			engine.listenPacket = func(_, _ string) (net.PacketConn, error) {
				once.Do(func() { close(entered); <-release })
				return nil, errors.New("retired fixture")
			}
			done := make(chan struct{})
			go func() { preparation.Run(PunchPrediction{Address: network.public[1], Port: 5000, Step: 1}); close(done) }()
			<-entered
			if engine.TakePunchedSocket("current", source) != nil || engine.Punch("current") != preparation {
				t.Fatal("premature commit released the worker's slot")
			}
			closed := make(chan struct{})
			go func() {
				switch retire {
				case "connection":
					engine.ClosePunch("current")
				case "source":
					_ = source.Close()
				case "engine":
					_ = engine.Close()
				case "context":
					preparation.cancel()
					preparation.close()
				}
				close(closed)
			}()
			select {
			case <-closed:
				t.Fatal("retirement returned before joining its worker")
			case <-time.After(10 * time.Millisecond):
			}
			if _, err := engine.BeginPunch("replacement", nil, nil, strings.Repeat("24", 32)); err == nil {
				t.Fatal("replacement overtook retiring worker")
			}
			close(release)
			waitSignal(t, done, "preparation worker retirement")
			waitSignal(t, closed, "preparation owner retirement")
		})
	}
}

type countedPunchConn struct {
	net.PacketConn
	closed     atomic.Bool
	writes     atomic.Int32
	firstWrite func()
}

func (c *countedPunchConn) Close() error { c.closed.Store(true); return c.PacketConn.Close() }
func (c *countedPunchConn) WriteTo(p []byte, a net.Addr) (int, error) {
	c.writes.Add(1)
	if c.firstWrite != nil {
		c.firstWrite()
	}
	return c.PacketConn.WriteTo(p, a)
}

func TestPunchSocketResourcesAreBoundedOnFailure(t *testing.T) {
	for _, scenario := range []string{"cancel-before", "cancel-during", "timeout", "allocation-failure", "invalid-secret"} {
		t.Run(scenario, func(t *testing.T) {
			network := newPunchLab(t, sequentialPunchNAT, sequentialPunchNAT)
			ctx, cancel := context.WithCancel(context.Background())
			defer cancel()
			if scenario == "cancel-before" {
				cancel()
			}
			var connections []*countedPunchConn
			listen := func() (net.PacketConn, error) {
				if scenario == "allocation-failure" && len(connections) == 3 {
					return nil, errors.New("fixture allocation failure")
				}
				conn, err := network.nets[0].ListenPacket("udp4", network.private[0]+":0")
				if err != nil {
					return nil, err
				}
				counted := &countedPunchConn{PacketConn: conn}
				if scenario == "cancel-during" {
					counted.firstWrite = cancel
				}
				connections = append(connections, counted)
				return counted, nil
			}
			secret := bytes.Repeat([]byte{42}, 32)
			if scenario == "invalid-secret" {
				secret = nil
			}
			winner, err := punchSocketArray(ctx, listen, &net.UDPAddr{IP: net.ParseIP(network.public[1]), Port: 50000}, secret, nil)
			if err == nil || winner != nil {
				t.Fatal("failed preparation transferred a socket")
			}
			var writes int32
			for _, conn := range connections {
				if !conn.closed.Load() {
					t.Error("preparation leaked a socket")
				}
				writes += conn.writes.Load()
			}
			if len(connections) > 8 || writes > 64 {
				t.Fatalf("resource bound exceeded: sockets=%d writes=%d", len(connections), writes)
			}
			if (scenario == "invalid-secret" || scenario == "cancel-before") && len(connections) != 0 {
				t.Fatal("invalid attempt allocated sockets")
			}
		})
	}
}

func TestPunchPredictionRejectsUnsafeDestinationsAndOverflow(t *testing.T) {
	for _, prediction := range []PunchPrediction{
		{Address: "127.0.0.1", Port: 5000, Step: 1}, {Address: "10.0.0.1", Port: 5000, Step: 1},
		{Address: "224.0.0.1", Port: 5000, Step: 1}, {Address: "::1", Port: 5000, Step: 1},
		{Address: "198.51.100.1", Port: math.MaxInt, Step: 1}, {Address: "198.51.100.1", Port: 65534, Step: 1},
		{Address: "198.51.100.1", Port: 1000, Step: 1}, {Address: "198.51.100.1", Port: 5000, Step: 17},
		{Address: "10.0.0.1", Port: 5000, Step: 0}, {Address: "198.51.100.1", Port: 5000, Step: -1},
	} {
		if _, err := prediction.Target(); err == nil {
			t.Fatalf("accepted unsafe prediction: %+v", prediction)
		}
	}
}