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. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

8.9 KB
Raw Blame
//go:build windows

package nativehost

import (
	"context"
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"encoding/binary"
	"encoding/hex"
	"encoding/json"
	"net"
	"strings"
	"sync/atomic"
	"testing"
	"time"

	"github.com/TNTcraftHIM/Piik/internal/app/mediaedge"
	"github.com/TNTcraftHIM/Piik/internal/app/nativecapture"
	"github.com/TNTcraftHIM/Piik/internal/app/remoteinput"
	"github.com/TNTcraftHIM/Piik/internal/media/forwarding"
	"github.com/TNTcraftHIM/Piik/internal/media/inputroute"
	"github.com/TNTcraftHIM/Piik/internal/server/protocol"
	"github.com/pion/ice/v4"
	"github.com/pion/webrtc/v4"
)

type inputLossSocket struct {
	net.PacketConn
	drop atomic.Bool
}

func (s *inputLossSocket) WriteTo(p []byte, addr net.Addr) (int, error) {
	if s.drop.Load() {
		return len(p), nil
	}
	return s.PacketConn.WriteTo(p, addr)
}
func (s *inputLossSocket) ReadFrom(p []byte) (int, net.Addr, error) {
	for {
		n, addr, err := s.PacketConn.ReadFrom(p)
		if err != nil || !s.drop.Load() {
			return n, addr, err
		}
	}
}

// Real ICE/DTLS/SCTP and the production permission owner. Approving control
// does not inject input; no key, button or pointer event is sent by this fixture.
func TestInputTransportLossRetiresOnlyItsPreviousApproval(t *testing.T) {
	for _, kind := range []string{"edge", "publication"} {
		t.Run(kind, func(t *testing.T) { checkInputTransportOwner(t, kind) })
	}
}
func checkInputTransportOwner(t *testing.T, kind string) {
	ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second)
	defer cancel()
	check := func(err error) {
		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}
	wait := func(check func() bool, what string) {
		t.Helper()
		for !check() {
			select {
			case <-ctx.Done():
				t.Fatal("timeout: " + what)
			case <-time.After(10 * time.Millisecond):
			}
		}
	}
	engine, err := mediaedge.NewEngine(mediaedge.EngineOptions{BindAddress: "127.0.0.1:0", IncludeLoopback: true})
	check(err)
	defer engine.Close()
	source, err := engine.NewSource("vp8", 1, 1, nil)
	check(err)
	defer source.Close()
	check(source.SetFormat(0, 320, 180))
	check(source.ConfigureOutputs([]uint32{300000}))
	manager, err := remoteinput.New(ctx, false)
	check(err)
	defer manager.Close()
	input := manager.NewSession()
	input.SetTarget(nativecapture.CaptureTarget{Kind: "display", SourceID: "1"}, nil)
	policy, err := input.BeginPolicy(ctx, "ask", "", false)
	check(err)
	check(policy.Apply())
	binding := protocol.RemoteInputPeer{PeerID: "test-viewer", EndpointID: strings.Repeat("a", 32), Secret: strings.Repeat("b", 64)}
	check(input.SetPeers([]protocol.RemoteInputPeer{binding}))
	events := make(chan Event, 64)
	session := &Session{shareID: "input-loss", engine: engine, source: source, remoteInput: input, ctx: ctx, edges: map[string]*mediaedge.Edge{}, events: func(_ context.Context, event Event) { events <- event }}
	defer session.CloseEdge("input-edge")
	defer session.ClosePublication("input-generation", "input-edge")
	packet, err := net.ListenPacket("udp4", "127.0.0.1:0")
	check(err)
	socket := &inputLossSocket{PacketConn: packet}
	defer socket.Close()
	mux := forwarding.NewUDPMux(ice.UDPMuxParams{UDPConn: socket})
	defer mux.Close()
	settings := webrtc.SettingEngine{}
	settings.SetICEUDPMux(mux)
	settings.SetIncludeLoopbackCandidate(true)
	settings.SetICETimeouts(time.Second, 15*time.Second, 100*time.Millisecond)
	viewer, err := webrtc.NewAPI(webrtc.WithSettingEngine(settings)).NewPeerConnection(webrtc.Configuration{})
	check(err)
	defer viewer.Close()
	viewer.OnICECandidate(func(candidate *webrtc.ICECandidate) {
		if candidate != nil {
			value := candidate.ToJSON()
			if kind == "publication" {
				publication, e := session.Publication("input-generation", "input-edge")
				if e == nil {
					_ = publication.AddRemoteCandidate(&value)
				}
			} else {
				_ = session.AddCandidate("input-edge", &value)
			}
		}
	})
	channel := make(chan *webrtc.DataChannel, 1)
	viewer.OnDataChannel(func(dc *webrtc.DataChannel) { dc.OnOpen(func() { channel <- dc }) })
	var offer webrtc.SessionDescription
	var setAnswer func(webrtc.SessionDescription) error
	var localState func() webrtc.PeerConnectionState
	if kind == "publication" {
		offer, _, err = session.PreparePublication("input-generation", "input-edge", nil)
		check(err)
		publication, e := session.Publication("input-generation", "input-edge")
		check(e)
		setAnswer = publication.SetAnswer
	} else {
		offer, err = session.PrepareEdge("input-edge", nil, false)
		check(err)
		localState = session.edge("input-edge").State
		setAnswer = func(answer webrtc.SessionDescription) error { return session.SetAnswer("input-edge", answer, "") }
	}
	check(viewer.SetRemoteDescription(offer))
	answer, err := viewer.CreateAnswer(nil)
	check(err)
	check(viewer.SetLocalDescription(answer))
	check(setAnswer(answer))
	// Native trickle candidates can precede the remote description, so drain them only now.
	connected := false
	for !connected {
		select {
		case event := <-events:
			if event.Candidate != nil {
				check(viewer.AddICECandidate(*event.Candidate))
			}
			connected = event.State == "connected"
		case <-ctx.Done():
			t.Fatal("edge never connected")
		}
	}
	var dc *webrtc.DataChannel
	select {
	case dc = <-channel:
	case <-ctx.Done():
		t.Fatal("input channel did not open")
	}
	key, _ := hex.DecodeString(binding.Secret)
	block, _ := aes.NewCipher(key)
	aead, _ := cipher.NewGCM(block)
	epoch := strings.Repeat("c", 32)
	type inputReply struct {
		Grant  string `json:"grant"`
		CoPlay *bool  `json:"coPlay"`
	}
	replies := make(chan inputReply, 64)
	dc.OnMessage(func(message webrtc.DataChannelMessage) {
		var packet inputroute.Packet
		if json.Unmarshal(message.Data, &packet) != nil {
			return
		}
		data, e := base64.StdEncoding.DecodeString(packet.Data)
		if e != nil || len(data) < 36 {
			return
		}
		aad := append(append([]byte{1}, data[:8]...), []byte(packet.Epoch)...)
		plain, e := aead.Open(nil, data[8:20], data[20:], aad)
		if e != nil {
			return
		}
		var reply inputReply
		if json.Unmarshal(plain, &reply) == nil {
			replies <- reply
		}
	})
	var sequence uint64
	send := func(plain []byte, epoch string) {
		t.Helper()
		sequence++
		header := make([]byte, 20)
		binary.BigEndian.PutUint64(header, sequence)
		_, err := rand.Read(header[8:20])
		check(err)
		aad := append(append([]byte{0}, header[:8]...), []byte(epoch)...)
		encrypted := aead.Seal(header, header[8:20], plain, aad)
		data, _ := json.Marshal(inputroute.Packet{ID: binding.EndpointID, Epoch: epoch, Data: base64.StdEncoding.EncodeToString(encrypted)})
		check(dc.SendText(string(data)))
	}
	send([]byte(`{"type":"request","intent":"dddddddddddddddddddddddddddddddd"}`), epoch)
	wait(func() bool { return len(input.State().Requests) == 1 }, "pending approval")
	oldRequest := input.State().Requests[0].ID

	session.mu.Lock()
	locked := true
	defer func() {
		if locked {
			session.mu.Unlock()
		}
	}()
	socket.drop.Store(true)
	// Pion default disconnect timeout is five seconds. Keep the fixture outage
	// beyond it while the Host lock delays asynchronous media projections.
	select {
	case <-time.After(9 * time.Second):
	case <-ctx.Done():
		t.Fatal("outage deadline")
	}
	if requests := input.State().Requests; len(requests) != 0 {
		t.Errorf("transport loss kept its previous approval while Host projection was queued: %+v", requests)
	}
	socket.drop.Store(false)
	wait(func() bool { return viewer.ConnectionState() == webrtc.PeerConnectionStateConnected }, "remote recovered while native callback delayed")
	if localState != nil {
		wait(func() bool { return localState() == webrtc.PeerConnectionStateConnected }, "native recovered while callback delayed")
	}
	freshEpoch := strings.Repeat("e", 32)
	send([]byte(`{"type":"request","intent":"ffffffffffffffffffffffffffffffff"}`), freshEpoch)
	wait(func() bool {
		requests := input.State().Requests
		return len(requests) == 1 && requests[0].ID != oldRequest
	}, "new epoch request before native loss cleanup")
	freshRequest := input.State().Requests[0]
	check(input.Decide(freshRequest.ID, true))
	session.mu.Unlock()
	locked = false
	for {
		select {
		case event := <-events:
			if event.State == "disconnected" {
				goto observed
			}
		case <-ctx.Done():
			t.Fatal("missing loss callback")
		}
	}
observed:
	if requests := input.State().Requests; len(requests) != 1 {
		t.Fatalf("delayed old loss revoked new post-recovery grant: %+v", requests)
	}
	// The new grant must remain usable over the same physical SCTP channel.
	// A capability reply has an explicit coPlay field, unlike earlier replies.
	send([]byte(`{"type":"capabilities"}`), freshEpoch)
	for {
		select {
		case reply := <-replies:
			if reply.CoPlay != nil && reply.Grant != "" {
				goto acknowledged
			}
		case <-ctx.Done():
			t.Fatal("new grant did not survive capability round trip")
		}
	}
acknowledged:
	if kind == "publication" {
		session.ClosePublication("input-generation", "input-edge")
	} else {
		session.CloseEdge("input-edge")
	}
	wait(func() bool { return len(input.State().Requests) == 0 }, "closed transport permission release")
}