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"` } devices := []device{} b.mu.Lock() for id, a := range b.agents { if a.ws != nil { devices = append(devices, device{id, b.leases[id] != nil}) } } 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)) } }