Files
AndroidDeviceStreaming/server/main.go
T

461 lines
12 KiB
Go

package main
import (
"context"
"crypto/rand"
"crypto/subtle"
"encoding/hex"
"encoding/json"
"errors"
"flag"
"fmt"
"io"
"log"
"net/http"
"os"
"os/signal"
"strings"
"sync"
"syscall"
"time"
"github.com/coder/websocket"
)
type agent struct {
id string
ws *websocket.Conn
v2 bool
}
type lease struct {
id string
device string
ws *websocket.Conn
}
type session struct {
id string
agent *agent
lease *lease
ready chan *websocket.Conn
ctx context.Context
cancel context.CancelFunc
claimed bool
v2 bool
signalKey string
}
type broker struct {
mu sync.Mutex
agents map[string]*agent
leases map[string]*lease // indexed by device, one owner per device
sessions map[string]*session
agentToken, clientToken string
adminToken string
managers map[string]*manager
ctx context.Context
cluster *cluster
}
func newBroker(ctx context.Context, agentToken, clientToken string) *broker {
return &broker{agents: make(map[string]*agent), leases: make(map[string]*lease),
sessions: make(map[string]*session), managers: make(map[string]*manager), agentToken: agentToken, clientToken: clientToken, ctx: ctx}
}
func newID() string {
var data [24]byte
if _, err := rand.Read(data[:]); err != nil {
panic(err)
}
return hex.EncodeToString(data[:])
}
func validID(id string) bool {
if len(id) < 1 || len(id) > 128 {
return false
}
for _, c := range id {
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || strings.ContainsRune("-_.", c)) {
return false
}
}
return true
}
func (b *broker) auth(token string, handler http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if subtle.ConstantTimeCompare([]byte(r.Header.Get("Authorization")), []byte("Bearer "+token)) != 1 {
http.Error(w, "unauthorized", http.StatusUnauthorized)
return
}
handler(w, r)
}
}
func accept(w http.ResponseWriter, r *http.Request) (*websocket.Conn, error) {
conn, err := websocket.Accept(w, r, nil)
if err == nil {
conn.SetReadLimit(128 * 1024)
}
return conn, err
}
func writeJSON(ctx context.Context, ws *websocket.Conn, value any) error {
data, err := json.Marshal(value)
if err != nil {
return err
}
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
return ws.Write(ctx, websocket.MessageText, data)
}
// A reader must be running while Ping waits for a pong.
func hold(ctx context.Context, ws *websocket.Conn) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
go func() {
ticker := time.NewTicker(20 * time.Second)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
pingCtx, stop := context.WithTimeout(ctx, 10*time.Second)
err := ws.Ping(pingCtx)
stop()
if err != nil {
cancel()
return
}
}
}
}()
for {
if _, _, err := ws.Read(ctx); err != nil {
return
}
}
}
func (b *broker) agentEndpoint(w http.ResponseWriter, r *http.Request) {
id := r.URL.Query().Get("device")
if !validID(id) {
http.Error(w, "invalid device ID", 400)
return
}
// Reserve before upgrading, so duplicate agents never replace an existing one.
a := &agent{id: id, v2: r.URL.Query().Get("v") == "2"}
b.mu.Lock()
if b.agents[id] != nil {
b.mu.Unlock()
http.Error(w, "device already registered", 409)
return
}
b.agents[id] = a
b.mu.Unlock()
defer func() {
b.mu.Lock()
if b.agents[id] == a {
delete(b.agents, id)
}
for _, s := range b.sessions {
if s.agent == a {
s.cancel()
}
}
l := b.leases[id]
var leaseConn *websocket.Conn
if l != nil {
leaseConn = l.ws
}
b.mu.Unlock()
if leaseConn != nil {
leaseConn.CloseNow()
}
}()
ws, err := accept(w, r)
if err != nil {
return
}
defer ws.CloseNow()
b.mu.Lock()
a.ws = ws
b.mu.Unlock()
registered := map[string]any{"type": "registered", "device": id}
if a.v2 {
registered["protocol"] = 2
}
if err := writeJSON(b.ctx, ws, registered); err != nil {
return
}
log.Printf("agent online: %s", id)
hold(b.ctx, ws)
log.Printf("agent offline: %s", id)
}
func (b *broker) devicesEndpoint(w http.ResponseWriter, r *http.Request) {
type device struct {
ID string `json:"id"`
Busy bool `json:"busy"`
AgentID string `json:"agent_id,omitempty"`
ComputerName string `json:"computer_name,omitempty"`
}
devices := []device{}
b.mu.Lock()
for id, a := range b.agents {
if a.ws != nil {
item := device{ID: id, Busy: b.leases[id] != nil}
for agentID, m := range b.managers {
if m.ws == nil {
continue
}
for _, phone := range m.status.Devices {
if phone.ID == id {
item.AgentID = agentID
item.ComputerName = m.status.Name
if item.ComputerName == "" {
item.ComputerName = m.status.Hostname
}
break
}
}
if item.AgentID != "" {
break
}
}
devices = append(devices, item)
}
}
b.mu.Unlock()
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(devices)
}
func (b *broker) leaseEndpoint(w http.ResponseWriter, r *http.Request) {
id := r.URL.Query().Get("device")
b.mu.Lock()
a := b.agents[id]
if a == nil || a.ws == nil {
b.mu.Unlock()
http.Error(w, "device offline", 404)
return
}
if b.leases[id] != nil {
b.mu.Unlock()
http.Error(w, "device busy", 409)
return
}
l := &lease{id: newID(), device: id}
b.leases[id] = l
b.mu.Unlock()
defer func() {
b.mu.Lock()
if b.leases[id] == l {
delete(b.leases, id)
}
for _, s := range b.sessions {
if s.lease == l {
s.cancel()
}
}
b.mu.Unlock()
b.cluster.revoke(l.id)
}()
ws, err := accept(w, r)
if err != nil {
return
}
defer ws.CloseNow()
b.mu.Lock()
if b.agents[id] != a {
b.mu.Unlock()
return
}
l.ws = ws
b.mu.Unlock()
protocol := 1
if b.cluster != nil && a.v2 && r.URL.Query().Get("v") == "2" {
protocol = 2
}
leased := map[string]any{"type": "leased", "lease": l.id}
if r.URL.Query().Get("v") == "2" {
leased["protocol"] = protocol
}
if err := writeJSON(b.ctx, ws, leased); err != nil {
return
}
hold(b.ctx, ws)
}
func (b *broker) connectEndpoint(w http.ResponseWriter, r *http.Request) {
id, leaseID := r.URL.Query().Get("device"), r.URL.Query().Get("lease")
b.mu.Lock()
a, l := b.agents[id], b.leases[id]
if a == nil || a.ws == nil || l == nil || l.ws == nil || l.id != leaseID {
b.mu.Unlock()
http.Error(w, "no active lease", 409)
return
}
// Bound pending and active streams for each device.
count := 0
for _, s := range b.sessions {
if s.agent == a {
count++
}
}
if count >= 32 {
b.mu.Unlock()
http.Error(w, "stream limit reached", 429)
return
}
ctx, cancel := context.WithCancel(b.ctx)
s := &session{id: newID(), agent: a, lease: l, ready: make(chan *websocket.Conn, 1), ctx: ctx, cancel: cancel}
b.sessions[s.id] = s
b.mu.Unlock()
defer func() { s.cancel(); b.mu.Lock(); delete(b.sessions, s.id); b.mu.Unlock() }()
client, err := accept(w, r)
if err != nil {
return
}
defer client.CloseNow()
if err := writeJSON(ctx, a.ws, map[string]string{"type": "open", "session": s.id}); err != nil {
return
}
timer := time.NewTimer(15 * time.Second)
defer timer.Stop()
select {
case upstream := <-s.ready:
defer upstream.CloseNow()
bridgeWebSockets(ctx, client, upstream)
case <-timer.C:
client.Close(websocket.StatusTryAgainLater, "device connection timed out")
case <-ctx.Done():
}
}
func (b *broker) dataEndpoint(w http.ResponseWriter, r *http.Request) {
ticket, id := r.URL.Query().Get("session"), r.URL.Query().Get("device")
b.mu.Lock()
s := b.sessions[ticket]
if s == nil || s.v2 || s.agent.id != id || b.agents[id] != s.agent || s.claimed || s.ctx.Err() != nil {
b.mu.Unlock()
http.Error(w, "invalid or expired session", 404)
return
}
s.claimed = true
b.mu.Unlock()
ws, err := accept(w, r)
if err != nil {
s.cancel()
return
}
defer ws.CloseNow()
select {
case s.ready <- ws:
case <-s.ctx.Done():
return
}
<-s.ctx.Done()
}
func bridgeWebSockets(ctx context.Context, left, right *websocket.Conn) {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
copyMessages := func(dst, src *websocket.Conn) {
defer cancel()
for {
typ, data, err := src.Read(ctx)
if err != nil {
return
}
if typ != websocket.MessageBinary {
return
}
writeCtx, stop := context.WithTimeout(ctx, 30*time.Second)
err = dst.Write(writeCtx, typ, data)
stop()
if err != nil {
return
}
}
}
var wg sync.WaitGroup
wg.Add(2)
go func() { defer wg.Done(); copyMessages(left, right) }()
go func() { defer wg.Done(); copyMessages(right, left) }()
wg.Wait()
}
func (b *broker) handler() http.Handler {
mux := http.NewServeMux()
mux.HandleFunc("GET /v3/agents/register", b.auth(b.agentToken, b.managerRegister))
mux.HandleFunc("GET /v3/agents", b.managementAuth(b.managersEndpoint))
mux.HandleFunc("/v3/rpc", b.managementAuth(b.managerRPCEndpoint))
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, "ok\n") })
mux.HandleFunc("GET /v1/agent", b.auth(b.agentToken, b.agentEndpoint))
mux.HandleFunc("GET /v1/data", b.auth(b.agentToken, b.dataEndpoint))
mux.HandleFunc("GET /v1/devices", b.auth(b.clientToken, b.devicesEndpoint))
mux.HandleFunc("GET /v1/lease", b.auth(b.clientToken, b.leaseEndpoint))
mux.HandleFunc("GET /v1/connect", b.auth(b.clientToken, b.connectEndpoint))
mux.HandleFunc("GET /v2/nodes", b.auth(b.clientToken, b.nodesEndpoint))
mux.HandleFunc("GET /v2/connect", b.auth(b.clientToken, b.clusterConnectEndpoint))
mux.HandleFunc("GET /v2/signal", b.auth(b.agentToken, b.signalEndpoint))
return mux
}
func main() {
listen := flag.String("listen", "127.0.0.1:8080", "HTTP listen address (use a TLS reverse proxy for public access)")
cert := flag.String("tls-cert", "", "TLS certificate PEM path")
key := flag.String("tls-key", "", "TLS private key PEM path")
clusterFile := flag.String("cluster-config", "", "Cluster configuration JSON; empty preserves standalone v1 mode")
insecureNodes := flag.Bool("allow-insecure-nodes", false, "Allow ws relay URLs for isolated integration tests")
flag.Parse()
agentToken, clientToken := os.Getenv("ADS_AGENT_TOKEN"), os.Getenv("ADS_CLIENT_TOKEN")
if len(agentToken) < 32 || len(clientToken) < 32 || agentToken == clientToken {
log.Fatal("set distinct ADS_AGENT_TOKEN and ADS_CLIENT_TOKEN, at least 32 characters each")
}
if (*cert == "") != (*key == "") {
log.Fatal("provide both --tls-cert and --tls-key")
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
b := newBroker(ctx, agentToken, clientToken)
b.adminToken = os.Getenv("ADS_ADMIN_TOKEN")
if b.adminToken != "" && (len(b.adminToken) < 32 || b.adminToken == agentToken || b.adminToken == clientToken) {
log.Fatal("ADS_ADMIN_TOKEN must be distinct and at least 32 characters")
}
if *clusterFile != "" {
configured, err := loadCluster(*clusterFile, os.Getenv("ADS_RELAY_SECRET"), *insecureNodes)
if err != nil {
log.Fatal(err)
}
b.cluster = configured
go configured.monitor(ctx)
}
server := &http.Server{Addr: *listen, Handler: b.handler(), ReadHeaderTimeout: 10 * time.Second, IdleTimeout: 60 * time.Second, MaxHeaderBytes: 16 * 1024}
go func() {
<-ctx.Done()
b.mu.Lock()
for _, m := range b.managers {
m.cancel()
if m.ws != nil {
m.ws.CloseNow()
}
}
for _, a := range b.agents {
if a.ws != nil {
a.ws.CloseNow()
}
}
for _, l := range b.leases {
if l.ws != nil {
l.ws.CloseNow()
}
}
for _, s := range b.sessions {
s.cancel()
}
b.mu.Unlock()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
server.Shutdown(shutdownCtx)
}()
log.Printf("ADS relay listening on %s", *listen)
var err error
if *cert != "" {
err = server.ListenAndServeTLS(*cert, *key)
} else {
err = server.ListenAndServe()
}
if err != nil && !errors.Is(err, http.ErrServerClosed) {
log.Fatal(fmt.Errorf("server: %w", err))
}
}