Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。
package loopback
import (
"context"
"crypto/rand"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"net"
"net/http"
"net/url"
"strconv"
"strings"
"sync"
"time"
"github.com/TNTcraftHIM/Piik/internal/app/buildinfo"
appconfig "github.com/TNTcraftHIM/Piik/internal/app/config"
"github.com/TNTcraftHIM/Piik/internal/server/protocol"
"github.com/coder/websocket"
)
const (
defaultBindAddress = "127.0.0.1"
instanceTokenBytes = 32
helloTimeout = 5 * time.Second
shutdownTimeout = 2 * time.Second
controlQueueSize = 64 // MaxControlMessageBytes * 64 = 16 MiB worst-case.
maxControlSessions = 2
)
type Options struct {
PortStart int
PortEnd int
// Zero keeps the desktop default. Single-source platforms may admit one.
MaxControlSessions int
AllowedOrigins []string
ActivationURL string
NativeMedia NativeMediaCapabilities
NewControl func() ControlSession
Presentation func(language string)
QualityPreference *appconfig.QualityPreference
}
type ControlSession interface {
// Errors reject protocol violations and close this control connection.
// Valid operation failures return a response instead of ending the session.
// A nil response with no error is completed later through Events, using the request ID.
Handle(context.Context, []byte) (any, error)
Events() <-chan any
Close() error
}
// ControlEvent revalidates its owner or current transport fact after queues.
// Current must be read-only; it runs under the WebSocket write lock.
type ControlEvent struct {
Value any
Current func() bool
// BeforeWrite releases an operation's admission before its ACK can trigger
// the next command. It must not block on I/O or send another event.
BeforeWrite func()
}
type Endpoint struct {
URL string `json:"url"`
Host string `json:"host"`
Port int `json:"port"`
InstanceToken string `json:"instanceToken"`
}
type Health struct {
Version string `json:"version"`
Revision string `json:"revision"`
PackageTarget string `json:"packageTarget"`
Protocol int `json:"protocol"`
Service string `json:"service"`
Port int `json:"port"`
InstanceToken string `json:"instanceToken"`
NativeMedia NativeMediaCapabilities `json:"nativeMedia"`
QualityPreference bool `json:"qualityPreference,omitempty"`
ActivationURL string `json:"activationURL,omitempty"`
}
type NativeMediaCapabilities struct {
MaxVideoResolution protocol.QualityResolution `json:"maxVideoResolution,omitzero"`
MaxVideoPixels int `json:"maxVideoPixels,omitempty"`
MaxVideoMacroblocksPerSecond int `json:"maxVideoMacroblocksPerSecond,omitempty"`
MaxVideoFramerate int `json:"maxVideoFramerate,omitempty"`
MaxVideoBitrate int `json:"maxVideoBitrate,omitempty"`
MaxAudioBitrate int `json:"maxAudioBitrate,omitempty"`
ReceiverReuse bool `json:"receiverReuse,omitempty"`
MaxRelayChildren int `json:"maxRelayChildren,omitempty"`
RemoteInput bool `json:"remoteInput,omitempty"`
RemoteStopShortcut bool `json:"remoteStopShortcut,omitempty"`
RemoteCoPlay bool `json:"remoteCoPlay,omitempty"`
Video bool `json:"video"`
CaptureBorderControl bool `json:"captureBorderControl,omitempty"`
Microphone bool `json:"microphone,omitempty"`
SourceCancellation bool `json:"sourceCancellation,omitempty"`
CaptureFailureDetails bool `json:"captureFailureDetails,omitempty"`
ShareVolume bool `json:"shareVolume,omitempty"`
ProcessAudio bool `json:"processAudio"`
ProcessAudioExclusion bool `json:"processAudioExclusion,omitempty"`
SystemAudio bool `json:"systemAudio"`
HardwareH264 bool `json:"hardwareH264"`
SoftwareVP8 bool `json:"softwareVP8"`
}
type Server struct {
ctx context.Context
cancel context.CancelFunc
listener net.Listener
httpServer *http.Server
endpoint Endpoint
allowedOrigins []string
nativeMedia NativeMediaCapabilities
activationURL string
newControl func() ControlSession
maxSessions int
presentation func(string)
qualityPreference *appconfig.QualityPreference
connectURL string
done chan error
mu sync.Mutex
connections map[*controlConnection]struct{}
closed bool
controls sync.WaitGroup
closeOnce sync.Once
closeErr error
}
// Claims start before the WebSocket upgrade so revocation also retires a
// pending handshake, even if that same origin is approved again later.
type controlConnection struct {
origin string
ctx context.Context
cancel context.CancelFunc
socket *websocket.Conn
done chan struct{}
}
func Start(parent context.Context, options Options) (*Server, error) {
if parent == nil {
parent = context.Background()
}
sessionLimit := options.MaxControlSessions
if sessionLimit == 0 {
sessionLimit = maxControlSessions
}
if sessionLimit < 1 || sessionLimit > maxControlSessions {
return nil, errors.New("native control session limit is invalid")
}
portStart, portEnd := normalizePortRange(options.PortStart, options.PortEnd)
listener, err := listenInRange(defaultBindAddress, portStart, portEnd)
if err != nil {
return nil, err
}
address, ok := listener.Addr().(*net.TCPAddr)
if !ok {
_ = listener.Close()
return nil, errors.New("loopback listener returned an unexpected address")
}
instanceToken, err := newInstanceToken()
if err != nil {
_ = listener.Close()
return nil, fmt.Errorf("create helper instance token: %w", err)
}
ctx, cancel := context.WithCancel(parent)
server := &Server{
ctx: ctx, cancel: cancel, listener: listener,
endpoint: Endpoint{
URL: "http://" + listener.Addr().String(),
Host: listener.Addr().String(),
Port: address.Port,
InstanceToken: instanceToken,
},
allowedOrigins: normalizedOrigins(options.AllowedOrigins),
nativeMedia: options.NativeMedia,
activationURL: options.ActivationURL,
newControl: options.NewControl,
maxSessions: sessionLimit,
presentation: options.Presentation,
qualityPreference: options.QualityPreference,
done: make(chan error, 1),
connections: make(map[*controlConnection]struct{}),
}
server.httpServer = &http.Server{
Handler: server,
ReadHeaderTimeout: 5 * time.Second,
IdleTimeout: 30 * time.Second,
}
go server.serve()
go func() {
<-ctx.Done()
_ = server.Close()
}()
return server, nil
}
func (server *Server) Endpoint() Endpoint {
return server.endpoint
}
func (server *Server) Done() <-chan error {
return server.done
}
func (server *Server) SetAllowedOrigins(origins []string) error {
server.mu.Lock()
retired := server.setAllowedOriginsLocked(origins)
server.mu.Unlock()
return server.retireConnections(retired)
}
// RemoveAllowedOrigin retires one authority without replaying other origins.
func (server *Server) RemoveAllowedOrigin(origin string) error {
server.mu.Lock()
origins := make([]string, 0, len(server.allowedOrigins))
for _, allowed := range server.allowedOrigins {
if !sameOrigin(allowed, origin) {
origins = append(origins, allowed)
}
}
retired := server.setAllowedOriginsLocked(origins)
server.mu.Unlock()
return server.retireConnections(retired)
}
func (server *Server) setAllowedOriginsLocked(origins []string) []*controlConnection {
server.allowedOrigins = normalizedOrigins(origins)
var retired []*controlConnection
for connection := range server.connections {
if connection.ctx.Err() != nil || !server.originAllowedLocked(connection.origin) {
connection.cancel()
retired = append(retired, connection)
}
}
return retired
}
func (server *Server) retireConnections(retired []*controlConnection) error {
ctx, cancel := context.WithTimeout(server.ctx, shutdownTimeout)
defer cancel()
for _, connection := range retired {
// A cancelled claim cannot attach a socket after leaving the lock.
if connection.socket != nil {
_ = connection.socket.CloseNow()
}
}
for _, connection := range retired {
select {
case <-connection.done:
case <-ctx.Done():
// Permission already changed. Never restore a revoked origin because
// one of its media resources is slow to close.
return errors.New("App is still releasing the previous site's media; try again shortly")
}
}
return nil
}
func (server *Server) SetConnectURL(value string) {
server.mu.Lock()
server.connectURL = value
server.mu.Unlock()
}
func (server *Server) Close() error {
server.closeOnce.Do(func() {
server.mu.Lock()
server.closed = true
connections := make([]*websocket.Conn, 0, len(server.connections))
for connection := range server.connections {
connection.cancel()
if connection.socket != nil {
connections = append(connections, connection.socket)
}
}
server.mu.Unlock()
server.cancel()
ctx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
defer cancel()
for _, connection := range connections {
_ = connection.CloseNow()
}
server.closeErr = server.httpServer.Shutdown(ctx)
retired := make(chan struct{})
go func() {
server.controls.Wait()
close(retired)
}()
select {
case <-retired:
case <-ctx.Done():
server.closeErr = errors.Join(server.closeErr, ctx.Err())
}
})
return server.closeErr
}
func (server *Server) serve() {
err := server.httpServer.Serve(server.listener)
if errors.Is(err, http.ErrServerClosed) {
err = nil
}
if err != nil {
server.cancel()
}
server.done <- err
close(server.done)
}
func (server *Server) ServeHTTP(response http.ResponseWriter, request *http.Request) {
if request.URL.Path == "/connect-discovery" {
server.handleConnectDiscovery(response, request)
return
}
if !server.requestAllowed(response, request) {
return
}
switch request.URL.Path {
case "/health":
server.handleHealth(response, request)
case "/control":
server.handleControl(response, request)
case "/presentation":
server.handlePresentation(response, request)
case "/quality-preference":
server.handleQualityPreference(response, request)
default:
http.NotFound(response, request)
}
}
// Discovery is the only cross-origin endpoint available before local approval.
// It exposes process identity and its local approval page, never capabilities,
// source lists, settings, or control access. A GET has no side effects.
func (server *Server) handleConnectDiscovery(response http.ResponseWriter, request *http.Request) {
if !server.hostAllowed(request.Host) {
http.NotFound(response, request)
return
}
origin := request.Header.Get("Origin")
normalized, err := appconfig.NormalizeSite(origin)
if err != nil || origin == "" || normalized != origin {
http.Error(response, "forbidden", http.StatusForbidden)
return
}
response.Header().Set("Access-Control-Allow-Origin", origin)
response.Header().Add("Vary", "Origin")
response.Header().Set("Cache-Control", "no-store")
if request.Method == http.MethodOptions {
response.Header().Set("Access-Control-Allow-Methods", http.MethodGet)
allowPrivateNetwork(response, request)
response.WriteHeader(http.StatusNoContent)
return
}
if request.Method != http.MethodGet {
response.Header().Set("Allow", "GET, OPTIONS")
http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
return
}
server.mu.Lock()
connectURL := server.connectURL
server.mu.Unlock()
if connectURL == "" {
http.NotFound(response, request)
return
}
writeJSON(response, http.StatusOK, map[string]any{
"protocol": ProtocolVersion, "service": ServiceName,
"port": server.endpoint.Port, "instanceToken": server.endpoint.InstanceToken,
"connectURL": connectURL,
})
}
func (server *Server) handlePresentation(response http.ResponseWriter, request *http.Request) {
if request.Method == http.MethodOptions {
response.Header().Set("Access-Control-Allow-Methods", http.MethodPost)
response.Header().Set("Access-Control-Allow-Headers", "Content-Type")
allowPrivateNetwork(response, request)
response.WriteHeader(http.StatusNoContent)
return
}
if request.Method != http.MethodPost {
response.Header().Set("Allow", "POST, OPTIONS")
http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
return
}
request.Body = http.MaxBytesReader(response, request.Body, 256)
var presentation struct {
Language string `json:"language"`
}
decoder := json.NewDecoder(request.Body)
decoder.DisallowUnknownFields()
if decoder.Decode(&presentation) != nil || decoder.Decode(&struct{}{}) != io.EOF ||
(presentation.Language != "zh" && presentation.Language != "en" && presentation.Language != "vis") {
http.Error(response, "invalid presentation", http.StatusBadRequest)
return
}
if server.presentation != nil {
server.presentation(presentation.Language)
}
response.WriteHeader(http.StatusNoContent)
}
func (server *Server) handleHealth(response http.ResponseWriter, request *http.Request) {
if request.Method == http.MethodOptions {
response.Header().Set("Access-Control-Allow-Methods", http.MethodGet)
allowPrivateNetwork(response, request)
response.WriteHeader(http.StatusNoContent)
return
}
if request.Method != http.MethodGet {
response.Header().Set("Allow", "GET, OPTIONS")
http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
return
}
response.Header().Set("Cache-Control", "no-store")
writeJSON(response, http.StatusOK, Health{
Version: buildinfo.Version(),
Revision: buildinfo.Revision,
PackageTarget: buildinfo.PackageTarget(),
Protocol: ProtocolVersion,
Service: ServiceName,
Port: server.endpoint.Port,
InstanceToken: server.endpoint.InstanceToken,
NativeMedia: server.nativeMedia,
QualityPreference: server.qualityPreference != nil,
ActivationURL: server.activationURL,
})
}
func allowPrivateNetwork(response http.ResponseWriter, request *http.Request) {
if strings.EqualFold(strings.TrimSpace(request.Header.Get("Access-Control-Request-Private-Network")), "true") {
response.Header().Set("Access-Control-Allow-Private-Network", "true")
}
}
func (server *Server) handleControl(response http.ResponseWriter, request *http.Request) {
if request.Method != http.MethodGet {
response.Header().Set("Allow", http.MethodGet)
http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
return
}
claim := server.claimConnection(request.Header.Get("Origin"))
if claim == nil {
http.Error(response, "native control capacity is occupied", http.StatusConflict)
return
}
var connection *websocket.Conn
defer server.releaseConnection(claim)
expectedSubprotocol := ControlSubprotocol + "." + server.endpoint.InstanceToken
var err error
connection, err = websocket.Accept(response, request.WithContext(claim.ctx), &websocket.AcceptOptions{
Subprotocols: []string{expectedSubprotocol},
OriginPatterns: server.originPatterns(),
})
if err != nil {
return
}
defer connection.CloseNow()
if connection.Subprotocol() != expectedSubprotocol {
closeControl(connection, "unsupported control protocol")
return
}
if !server.setConnection(claim, connection) {
return
}
connection.SetReadLimit(MaxControlMessageBytes)
helloContext, cancelHello := context.WithTimeout(claim.ctx, helloTimeout)
messageType, payload, err := connection.Read(helloContext)
cancelHello()
if err != nil {
return
}
if messageType != websocket.MessageText {
closeControl(connection, "hello frame required")
return
}
message, err := decodeRequest(payload)
if err != nil {
closeControl(connection, "invalid control message")
return
}
if validateHello(message) != nil {
closeControl(connection, "hello required")
return
}
var writeMutex sync.Mutex
write := func(ctx context.Context, value any) error {
writeMutex.Lock()
defer writeMutex.Unlock()
if event, ok := value.(ControlEvent); ok {
if event.Current != nil && !event.Current() {
return nil
}
if event.BeforeWrite != nil {
event.BeforeWrite()
}
value = event.Value
}
encoded, encodeErr := encodeMessage(value)
if encodeErr != nil {
return encodeErr
}
return connection.Write(ctx, websocket.MessageText, encoded)
}
if err = write(claim.ctx, controlMessage{
Version: ProtocolVersion, ID: message.ID, Type: "ready",
}); err != nil {
return
}
controlContext, cancelControl := claim.ctx, claim.cancel
var extension ControlSession
if server.newControl != nil {
extension = server.newControl()
}
if extension != nil {
defer extension.Close()
go func() {
for {
select {
case event, open := <-extension.Events():
if !open {
return
}
if write(controlContext, event) != nil {
cancelControl()
return
}
case <-controlContext.Done():
return
}
}
}()
}
reads := make(chan []byte, controlQueueSize)
go func() {
for {
messageType, payload, readErr := connection.Read(controlContext)
if readErr != nil || messageType != websocket.MessageText {
cancelControl()
return
}
select {
case reads <- payload:
case <-controlContext.Done():
return
}
}
}()
for {
if controlContext.Err() != nil {
return
}
select {
case <-controlContext.Done():
return
case payload = <-reads:
messageType = websocket.MessageText
}
if controlContext.Err() != nil {
return
}
message, err = decodeEnvelope(payload)
if err != nil {
closeControl(connection, "invalid control message")
return
}
if message.Type == "ping" {
strict, strictErr := decodeRequest(payload)
if strictErr != nil || validatePing(strict) != nil {
closeControl(connection, "invalid control message")
return
}
if write(controlContext, controlMessage{
Version: ProtocolVersion, ID: message.ID, Type: "pong",
}) != nil {
return
}
continue
}
if extension == nil {
closeControl(connection, "unsupported control message")
return
}
value, handleErr := extension.Handle(controlContext, payload)
if handleErr != nil {
closeControl(connection, "invalid control message")
return
}
if value == nil {
continue
}
if err = write(controlContext, value); err != nil {
return
}
}
}
func (server *Server) originPatterns() []string {
server.mu.Lock()
origins := append([]string(nil), server.allowedOrigins...)
server.mu.Unlock()
patterns := make([]string, 0, len(origins)+2)
for _, origin := range origins {
if parsed, err := url.Parse(origin); err == nil && parsed.Host != "" {
patterns = append(patterns, parsed.Scheme+"://"+parsed.Host)
}
}
port := strconv.Itoa(server.endpoint.Port)
patterns = append(patterns, "http://localhost:"+port, "http://127.0.0.1:"+port)
return patterns
}
func closeControl(connection *websocket.Conn, reason string) {
_ = connection.Close(websocket.StatusPolicyViolation, reason)
}
func (server *Server) requestAllowed(response http.ResponseWriter, request *http.Request) bool {
origin := strings.TrimSpace(request.Header.Get("Origin"))
if origin != "" && !server.allowedOrigin(origin) && !server.localOrigin(origin) {
http.Error(response, "forbidden", http.StatusForbidden)
return false
}
if !server.hostAllowed(request.Host) {
http.NotFound(response, request)
return false
}
if origin != "" {
response.Header().Set("Access-Control-Allow-Origin", origin)
response.Header().Add("Vary", "Origin")
}
return true
}
func (server *Server) allowedOrigin(origin string) bool {
server.mu.Lock()
defer server.mu.Unlock()
for _, allowed := range server.allowedOrigins {
if sameOrigin(origin, allowed) {
return true
}
}
return false
}
// Caller holds mu. Empty Origin is reserved for per-user native tooling;
// browsers always send it when opening a cross-origin control connection.
func (server *Server) originAllowedLocked(origin string) bool {
if origin == "" || server.localOrigin(origin) {
return true
}
for _, allowed := range server.allowedOrigins {
if sameOrigin(origin, allowed) {
return true
}
}
return false
}
func (server *Server) hostAllowed(host string) bool {
if host == server.endpoint.Host {
return true
}
return host == net.JoinHostPort("localhost", strconv.Itoa(server.endpoint.Port))
}
func (server *Server) localOrigin(origin string) bool {
port := strconv.Itoa(server.endpoint.Port)
return sameOrigin(origin, "http://127.0.0.1:"+port) || sameOrigin(origin, "http://localhost:"+port)
}
func (server *Server) claimConnection(origin string) *controlConnection {
server.mu.Lock()
defer server.mu.Unlock()
if server.closed || len(server.connections) >= server.maxSessions || !server.originAllowedLocked(origin) {
return nil
}
ctx, cancel := context.WithCancel(server.ctx)
claim := &controlConnection{origin: origin, ctx: ctx, cancel: cancel, done: make(chan struct{})}
server.connections[claim] = struct{}{}
server.controls.Add(1)
return claim
}
func (server *Server) setConnection(claim *controlConnection, connection *websocket.Conn) bool {
server.mu.Lock()
defer server.mu.Unlock()
if server.closed || claim.ctx.Err() != nil {
return false
}
claim.socket = connection
return true
}
func (server *Server) releaseConnection(connection *controlConnection) {
connection.cancel()
server.mu.Lock()
delete(server.connections, connection)
server.mu.Unlock()
server.controls.Done()
close(connection.done)
}
func listenInRange(bindAddress string, start, end int) (net.Listener, error) {
var lastErr error
for port := start; port <= end; port++ {
listener, err := net.Listen("tcp4", net.JoinHostPort(bindAddress, strconv.Itoa(port)))
if err == nil {
return listener, nil
}
lastErr = err
}
return nil, fmt.Errorf("helper could not bind port range %d-%d: %w", start, end, lastErr)
}
func normalizePortRange(start, end int) (int, int) {
if start <= 0 && end <= 0 {
return DefaultPortStart, DefaultPortEnd
}
if start <= 0 {
start = end
}
if start < 1 {
start = 1
}
if start > 65535 {
start = 65535
}
if end < start {
end = start
}
if end > 65535 {
end = 65535
}
return start, end
}
func sameOrigin(actual, expected string) bool {
return strings.EqualFold(strings.TrimRight(actual, "/"), strings.TrimRight(expected, "/"))
}
func normalizedOrigins(origins []string) []string {
result := make([]string, 0, len(origins))
seen := make(map[string]struct{}, len(origins))
for _, origin := range origins {
origin = strings.TrimRight(strings.TrimSpace(origin), "/")
if origin == "" {
continue
}
if _, found := seen[strings.ToLower(origin)]; found {
continue
}
seen[strings.ToLower(origin)] = struct{}{}
result = append(result, origin)
}
return result
}
func newInstanceToken() (string, error) {
buffer := make([]byte, instanceTokenBytes)
if _, err := rand.Read(buffer); err != nil {
return "", err
}
return base64.RawURLEncoding.EncodeToString(buffer), nil
}
func writeJSON(response http.ResponseWriter, status int, value any) {
payload, err := encodeMessage(value)
if err != nil {
http.Error(response, "response unavailable", http.StatusInternalServerError)
return
}
response.Header().Set("Content-Type", "application/json; charset=utf-8")
response.WriteHeader(status)
_, _ = response.Write(payload)
}