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

17.3 KB
Raw Blame
package launcher

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"log/slog"
	"mime"
	"net"
	"net/http"
	"net/url"
	"slices"
	"strings"
	"sync"
	"time"

	"github.com/TNTcraftHIM/Piik/internal/app/buildinfo"
	appconfig "github.com/TNTcraftHIM/Piik/internal/app/config"
	"github.com/TNTcraftHIM/Piik/internal/app/failure"
	"github.com/TNTcraftHIM/Piik/internal/app/lan"
	"github.com/TNTcraftHIM/Piik/internal/diagnostics"
	"github.com/TNTcraftHIM/Piik/internal/httpassets"
)

const (
	maxRequestBytes = 2 << 10
	shutdownTimeout = 2 * time.Second
	// launcherIndex is the Browser entry document. /client serves it directly
	// because that route belongs to the client-side router, not to the assets.
	launcherIndex = "index.html"
)

type Mode string

const (
	ModeLocal Mode = "local"
	ModeLink  Mode = "link"
)

type Selection struct {
	Mode                Mode    `json:"mode"`
	Language            string  `json:"language"`
	LocalAccessPassword string  `json:"localAccessPassword"`
	Debug               bool    `json:"debug,omitempty"`
	LANAddress          *string `json:"lanAddress,omitempty"`
}

type Options struct {
	Modes               []Mode
	DefaultMode         Mode
	Sites               []string
	StartupSite         string
	Version             string
	Revision            string
	ControlPort         int
	LocalAccessPassword string
	Debug               bool
	LANAddress          string
	ChangeSite          func(string, bool) ([]string, error)
	SaveStartupSite     func(string) error
	EnableDebug         func() error
}

var listLANAddresses = lan.List

type Server struct {
	ctx                 context.Context
	cancel              context.CancelFunc
	listener            net.Listener
	httpServer          *http.Server
	assets              fs.FS
	static              http.Handler
	client              http.Handler
	sites               []string
	startupSite         string
	modes               []Mode
	defaultMode         Mode
	localAccessPassword string
	version             string
	revision            string
	controlPort         int
	debug               bool
	lanAddress          string
	changeSite          func(string, bool) ([]string, error)
	saveStartupSite     func(string) error
	enableDebug         func() error
	selection           chan Selection
	done                chan error
	ready               chan struct{}

	mu        sync.Mutex
	attempt   *launchAttempt
	closeOnce sync.Once
}

type launchAttempt struct {
	ready     chan struct{}
	completed bool
	target    string
	err       error
}

// Start serves the launcher page and its API on a loopback port. assets is the
// built Browser UI, which the App embeds; a nil file system means the binary
// carries no build and the launcher cannot run.
func Start(parent context.Context, assets fs.FS, options Options) (*Server, error) {
	if parent == nil {
		parent = context.Background()
	}
	normalizedSites, err := appconfig.NormalizeSites(options.Sites)
	if err != nil {
		return nil, fmt.Errorf("App launcher Site is invalid: %w", err)
	}
	if assets == nil {
		return nil, errors.New("App launcher assets are unavailable")
	}
	if metadata, err := fs.Stat(assets, launcherIndex); err != nil || !metadata.Mode().IsRegular() {
		return nil, errors.New("App launcher assets are unavailable")
	}
	listener, err := net.Listen("tcp4", "127.0.0.1:0")
	if err != nil {
		return nil, fmt.Errorf("App launcher could not start: %w", err)
	}
	ctx, cancel := context.WithCancel(parent)
	server := &Server{
		ctx:                 ctx,
		cancel:              cancel,
		listener:            listener,
		assets:              assets,
		static:              httpassets.Compress(http.FileServer(http.FS(assets))),
		sites:               normalizedSites,
		startupSite:         options.StartupSite,
		defaultMode:         options.DefaultMode,
		modes:               slices.Clone(options.Modes),
		localAccessPassword: options.LocalAccessPassword,
		version:             options.Version,
		revision:            strings.TrimSpace(options.Revision),
		controlPort:         options.ControlPort,
		debug:               options.Debug,
		lanAddress:          options.LANAddress,
		changeSite:          options.ChangeSite,
		saveStartupSite:     options.SaveStartupSite,
		enableDebug:         options.EnableDebug,
		selection:           make(chan Selection, 1),
		done:                make(chan error, 1),
		ready:               make(chan struct{}),
	}
	server.client = httpassets.Compress(http.HandlerFunc(server.serveClient))
	server.httpServer = &http.Server{
		Handler:           server,
		ReadHeaderTimeout: 5 * time.Second,
		IdleTimeout:       30 * time.Second,
	}
	go server.serve()
	<-server.ready
	go func() {
		<-ctx.Done()
		_ = server.Close()
	}()
	return server, nil
}

func (server *Server) URL() string {
	return "http://" + server.listener.Addr().String() + "/client"
}

// EntryURL follows the current approved startup preference; URL always opens
// the launcher itself, including when returning from an existing room.
func (server *Server) EntryURL() string {
	server.mu.Lock()
	startup := server.startupSite
	server.mu.Unlock()
	if startup != "" {
		return EntryURL(startup+"/", server.controlPort)
	}
	return server.URL()
}

func (server *Server) Selection() <-chan Selection {
	return server.selection
}

func (server *Server) Done() <-chan error {
	return server.done
}

func (server *Server) Begin() bool {
	_, fresh := server.begin()
	return fresh
}

func (server *Server) begin() (*launchAttempt, bool) {
	server.mu.Lock()
	defer server.mu.Unlock()
	if server.attempt != nil && server.attempt.err == nil {
		return server.attempt, false
	}
	server.attempt = &launchAttempt{ready: make(chan struct{})}
	return server.attempt, true
}

// SetResult is called by the serial room owner after readiness or full retirement.
func (server *Server) SetResult(target string, resultErr error) {
	if resultErr == nil && !validTarget(target) {
		resultErr = errors.New("App target is invalid")
	}
	server.mu.Lock()
	defer server.mu.Unlock()
	attempt := server.attempt
	attempt.target = target
	attempt.err = resultErr
	if !attempt.completed {
		attempt.completed = true
		close(attempt.ready)
	}
}

func (server *Server) Close() error {
	server.closeOnce.Do(server.cancel)
	ctx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
	defer cancel()
	return server.httpServer.Shutdown(ctx)
}

func (server *Server) serve() {
	close(server.ready)
	err := server.httpServer.Serve(server.listener)
	if errors.Is(err, http.ErrServerClosed) {
		err = nil
	}
	server.done <- err
	close(server.done)
}

func (server *Server) ServeHTTP(response http.ResponseWriter, request *http.Request) {
	if !server.requestAllowed(request) {
		http.NotFound(response, request)
		return
	}
	response.Header().Set("X-Content-Type-Options", "nosniff")
	response.Header().Set("Content-Security-Policy", "frame-ancestors 'none'")
	response.Header().Set("X-Frame-Options", "DENY")
	response.Header().Set("Referrer-Policy", "no-referrer")
	switch request.URL.Path {
	case "/api/client-launcher":
		server.handleState(response, request)
	case "/api/client-launcher/launch":
		server.handleLaunch(response, request)
	case "/api/client-launcher/site":
		server.handleSite(response, request, false)
	case "/api/client-launcher/startup-site":
		server.handleSite(response, request, true)
	case "/api/client-launcher/debug":
		server.handleDebug(response, request)
	case "/client", "/client/":
		server.client.ServeHTTP(response, request)
	default:
		server.static.ServeHTTP(response, request)
	}
}

func (server *Server) serveClient(response http.ResponseWriter, request *http.Request) {
	if request.Method != http.MethodGet && request.Method != http.MethodHead {
		response.Header().Set("Allow", "GET, HEAD")
		http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	response.Header().Set("Cache-Control", "no-store")
	http.ServeFileFS(response, request, server.assets, launcherIndex)
}

func (server *Server) handleState(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
	}
	addresses, err := listLANAddresses()
	if err != nil {
		slog.DebugContext(request.Context(), "launcher-lan-unavailable", diagnostics.Error(err))
	}
	if addresses == nil {
		addresses = []lan.Address{}
	}
	values := make([]string, 0, len(addresses))
	for _, address := range addresses {
		values = append(values, address.Address)
	}
	selected, _ := lan.Select(values, server.lanAddress)
	server.mu.Lock()
	var target string
	var resultErr error
	starting := false
	if attempt := server.attempt; attempt != nil {
		target, resultErr = attempt.target, attempt.err
		starting = !attempt.completed
	}
	state := map[string]any{
		"sites":               slices.Clone(server.sites),
		"startupSite":         server.startupSite,
		"localAccessPassword": server.localAccessPassword,
		"version":             server.version,
		"revision":            server.revision,
		"packageTarget":       buildinfo.PackageTarget(),
		"controlPort":         server.controlPort,
		"target":              target,
		"starting":            starting,
		"detail":              errorDetail(resultErr),
		"reason":              failure.Of(resultErr),
		"lan":                 map[string]any{"addresses": addresses, "selected": selected},
		"modes": func() []Mode {
			if len(server.modes) > 0 {
				return slices.Clone(server.modes)
			}
			return []Mode{ModeLocal, ModeLink}
		}(),
		"defaultMode": func() Mode {
			if server.defaultMode == ModeLocal || server.defaultMode == ModeLink {
				return server.defaultMode
			}
			return ModeLink
		}(),
	}
	if server.enableDebug != nil || server.debug {
		state["debug"] = server.debug
	}
	server.mu.Unlock()
	writeJSON(response, http.StatusOK, state)
}

func (server *Server) handleSite(response http.ResponseWriter, request *http.Request, startupOnly bool) {
	if request.Method != http.MethodPost {
		response.Header().Set("Allow", http.MethodPost)
		http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	request.Body = http.MaxBytesReader(response, request.Body, maxRequestBytes)
	var change struct {
		Site    string `json:"site"`
		Allowed *bool  `json:"allowed,omitempty"`
	}
	decoder := json.NewDecoder(request.Body)
	decoder.DisallowUnknownFields()
	if decoder.Decode(&change) != nil || decoder.Decode(&struct{}{}) != io.EOF ||
		(startupOnly && change.Allowed != nil) || (!startupOnly && change.Allowed == nil) {
		http.Error(response, "invalid site request", http.StatusBadRequest)
		return
	}
	site, err := appconfig.NormalizeSite(change.Site)
	if err != nil || (!startupOnly && site == "") {
		http.Error(response, "invalid site origin", http.StatusBadRequest)
		return
	}
	server.mu.Lock()
	defer server.mu.Unlock()
	result := func() map[string]any {
		return map[string]any{"sites": slices.Clone(server.sites), "startupSite": server.startupSite}
	}
	if startupOnly {
		if site != "" && !slices.Contains(server.sites, site) {
			writeJSON(response, http.StatusConflict, result())
			return
		}
		if server.saveStartupSite == nil {
			http.Error(response, "startup preference is unavailable", http.StatusServiceUnavailable)
			return
		}
		if err := server.saveStartupSite(site); err != nil {
			writeJSON(response, http.StatusServiceUnavailable, result())
			return
		}
		server.startupSite = site
		writeJSON(response, http.StatusOK, result())
		return
	}
	if server.changeSite == nil {
		http.Error(response, "site approval is unavailable", http.StatusServiceUnavailable)
		return
	}
	current, err := server.changeSite(site, *change.Allowed)
	// Permission can be revoked even if its media cleanup times out.
	server.sites = current
	if server.startupSite != "" && !slices.Contains(current, server.startupSite) {
		server.startupSite = ""
		err = errors.Join(err, server.saveStartupSite(""))
	}
	if err != nil {
		failure := result()
		failure["detail"] = errorDetail(err)
		writeJSON(response, http.StatusServiceUnavailable, failure)
		return
	}
	writeJSON(response, http.StatusOK, result())
}

func (server *Server) handleDebug(response http.ResponseWriter, request *http.Request) {
	if request.Method != http.MethodPost {
		response.Header().Set("Allow", http.MethodPost)
		http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	server.mu.Lock()
	if !server.debug {
		if (server.attempt != nil && server.attempt.err == nil) || server.enableDebug == nil {
			server.mu.Unlock()
			http.Error(response, "enable diagnostics before starting a local room", http.StatusConflict)
			return
		}
		if err := server.enableDebug(); err != nil {
			server.mu.Unlock()
			writeJSON(response, http.StatusServiceUnavailable, map[string]string{"detail": errorDetail(err)})
			return
		}
		server.debug = true
	}
	server.mu.Unlock()
	writeJSON(response, http.StatusOK, map[string]bool{"debug": true})
}

func (server *Server) handleLaunch(response http.ResponseWriter, request *http.Request) {
	if request.Method != http.MethodPost {
		response.Header().Set("Allow", http.MethodPost)
		http.Error(response, "method not allowed", http.StatusMethodNotAllowed)
		return
	}
	request.Body = http.MaxBytesReader(response, request.Body, maxRequestBytes)
	selection, err := decodeSelection(request.Body)
	if err != nil {
		writeJSON(response, http.StatusBadRequest, map[string]string{
			"error": "invalid launch request", "detail": errorDetail(err),
		})
		return
	}
	if len(server.modes) > 0 && !slices.Contains(server.modes, selection.Mode) {
		http.Error(response, "unsupported launch mode", http.StatusBadRequest)
		return
	}
	attempt, fresh := server.begin()
	if fresh {
		// Each accepted attempt outlives its page request and owns its own result.
		// The single-slot queue cannot block: only the accepted request writes it.
		server.selection <- selection
	}
	// Reentry joins this exact attempt, including an accepted startup whose
	// original page has gone away. It cannot start another room or join a retry.
	select {
	case <-attempt.ready:
	case <-request.Context().Done():
		return
	case <-server.ctx.Done():
		return
	}
	server.mu.Lock()
	target, resultErr := attempt.target, attempt.err
	server.mu.Unlock()
	if resultErr != nil {
		writeJSON(response, http.StatusServiceUnavailable, map[string]string{
			"error": "Piik App could not start", "detail": errorDetail(resultErr), "reason": string(failure.Of(resultErr)),
		})
		return
	}
	writeJSON(response, http.StatusOK, map[string]string{"target": target})
}

func errorDetail(err error) string {
	if err == nil {
		return ""
	}
	// Redact before truncation so a long credential cannot lose its delimiter.
	detail := []rune(diagnostics.SafeText(err.Error()))
	if len(detail) > 2048 {
		return string(detail[:2048]) + "..."
	}
	return string(detail)
}

func (server *Server) requestAllowed(request *http.Request) bool {
	_, port, err := net.SplitHostPort(request.Host)
	if err != nil {
		return false
	}
	_, listenerPort, listenerErr := net.SplitHostPort(server.listener.Addr().String())
	if listenerErr != nil || port != listenerPort {
		return false
	}
	host := strings.TrimSuffix(strings.ToLower(request.Host), ":"+port)
	if host != "127.0.0.1" && host != "localhost" {
		return false
	}
	origin := strings.TrimSpace(request.Header.Get("Origin"))
	if request.Method == http.MethodPost {
		mediaType, _, err := mime.ParseMediaType(request.Header.Get("Content-Type"))
		return err == nil && mediaType == "application/json" && sameOrigin(origin, "http://"+request.Host)
	}
	return origin == "" || sameOrigin(origin, "http://"+request.Host)
}

func sameOrigin(actual, expected string) bool {
	actualURL, actualErr := url.Parse(actual)
	expectedURL, expectedErr := url.Parse(expected)
	return actualErr == nil && expectedErr == nil &&
		actualURL.Scheme == expectedURL.Scheme &&
		strings.EqualFold(actualURL.Host, expectedURL.Host) &&
		actualURL.Path == "" && actualURL.RawQuery == "" && actualURL.Fragment == ""
}

func decodeSelection(reader io.Reader) (Selection, error) {
	var selection Selection
	decoder := json.NewDecoder(reader)
	decoder.DisallowUnknownFields()
	if decoder.Decode(&selection) != nil || decoder.Decode(&struct{}{}) != io.EOF {
		return Selection{}, errors.New("invalid launch request")
	}
	if selection.Language != "zh" && selection.Language != "en" && selection.Language != "vis" {
		return Selection{}, errors.New("invalid launch language")
	}
	if selection.LANAddress != nil {
		if selection.Mode != ModeLocal {
			return Selection{}, errors.New("only Local launch can select a LAN invitation address")
		}
		value := strings.TrimSpace(*selection.LANAddress)
		if ip := net.ParseIP(value); ip == nil || ip.To4() == nil {
			return Selection{}, errors.New("Local invitation address must be an active IPv4 address")
		}
		selection.LANAddress = &value
	}
	switch selection.Mode {
	case ModeLocal, ModeLink:
	default:
		return Selection{}, errors.New("unknown launch mode")
	}
	return selection, nil
}

func validTarget(raw string) bool {
	parsed, err := url.Parse(raw)
	return err == nil && (parsed.Scheme == "http" || parsed.Scheme == "https") && parsed.Host != ""
}

func writeJSON(response http.ResponseWriter, status int, value any) {
	payload, err := json.Marshal(value)
	if err != nil {
		http.Error(response, "response unavailable", http.StatusInternalServerError)
		return
	}
	response.Header().Set("Cache-Control", "no-store")
	response.Header().Set("Content-Type", "application/json; charset=utf-8")
	response.WriteHeader(status)
	_, _ = response.Write(payload)
}