285 lines
7.7 KiB
Go
285 lines
7.7 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"github.com/coder/websocket"
|
|
"io"
|
|
"net/http"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
type managedDevice struct {
|
|
ID string `json:"id"`
|
|
Target *string `json:"target,omitempty"`
|
|
ADBSerial *string `json:"adb_serial,omitempty"`
|
|
ADBServer *string `json:"adb_server,omitempty"`
|
|
DevicePort uint16 `json:"device_port"`
|
|
Enabled bool `json:"enabled"`
|
|
Connected bool `json:"connected"`
|
|
LastError *string `json:"last_error"`
|
|
}
|
|
type managedStatus struct {
|
|
ID string `json:"id"`
|
|
Name string `json:"name"`
|
|
Hostname string `json:"hostname"`
|
|
OS string `json:"os"`
|
|
Arch string `json:"arch"`
|
|
Version string `json:"version"`
|
|
PID uint32 `json:"pid"`
|
|
Uptime uint64 `json:"uptime_seconds"`
|
|
Supervised bool `json:"supervised"`
|
|
Revision uint64 `json:"revision"`
|
|
Instance string `json:"instance"`
|
|
Devices []managedDevice `json:"devices"`
|
|
}
|
|
type manager struct {
|
|
id string
|
|
ws *websocket.Conn
|
|
status managedStatus
|
|
lastSeen int64
|
|
ctx context.Context
|
|
cancel context.CancelFunc
|
|
pending map[string]chan json.RawMessage
|
|
}
|
|
|
|
func (b *broker) managementAuth(handler http.HandlerFunc) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
if len(b.adminToken) < 32 {
|
|
http.Error(w, "management admin token is not configured", 503)
|
|
return
|
|
}
|
|
b.auth(b.adminToken, handler)(w, r)
|
|
}
|
|
}
|
|
func (b *broker) redactManagement(data []byte) []byte {
|
|
text := string(data)
|
|
for _, secret := range []string{b.agentToken, b.clientToken, b.adminToken} {
|
|
if secret != "" {
|
|
text = strings.ReplaceAll(text, secret, "[REDACTED]")
|
|
}
|
|
}
|
|
return []byte(text)
|
|
}
|
|
func (b *broker) managerRegister(w http.ResponseWriter, r *http.Request) {
|
|
id := r.URL.Query().Get("agent")
|
|
if !validID(id) {
|
|
http.Error(w, "invalid agent ID", 400)
|
|
return
|
|
}
|
|
b.mu.Lock()
|
|
if old := b.managers[id]; old != nil && old.ctx.Err() == nil {
|
|
b.mu.Unlock()
|
|
http.Error(w, "agent already registered", 409)
|
|
return
|
|
}
|
|
if b.managers[id] == nil && len(b.managers) >= 128 {
|
|
b.mu.Unlock()
|
|
http.Error(w, "agent registry full", 429)
|
|
return
|
|
}
|
|
ctx, cancel := context.WithCancel(b.ctx)
|
|
m := &manager{id: id, ctx: ctx, cancel: cancel, pending: map[string]chan json.RawMessage{}, status: managedStatus{ID: id, Devices: []managedDevice{}}, lastSeen: time.Now().Unix()}
|
|
b.managers[id] = m
|
|
b.mu.Unlock()
|
|
defer func() { cancel(); b.mu.Lock(); m.ws = nil; b.mu.Unlock() }()
|
|
ws, err := accept(w, r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer ws.CloseNow()
|
|
b.mu.Lock()
|
|
m.ws = ws
|
|
b.mu.Unlock()
|
|
if writeJSON(ctx, ws, map[string]string{"type": "registered", "agent": id}) != nil {
|
|
return
|
|
}
|
|
go func() {
|
|
ticker := time.NewTicker(20 * time.Second)
|
|
defer ticker.Stop()
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
case <-ticker.C:
|
|
deadline, stop := context.WithTimeout(ctx, 10*time.Second)
|
|
err := ws.Ping(deadline)
|
|
stop()
|
|
if err != nil {
|
|
cancel()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}()
|
|
for {
|
|
typ, data, err := ws.Read(ctx)
|
|
if err != nil || typ != websocket.MessageText {
|
|
return
|
|
}
|
|
var message struct {
|
|
Type string `json:"type"`
|
|
RequestID string `json:"request_id"`
|
|
Status managedStatus `json:"status"`
|
|
Response json.RawMessage `json:"response"`
|
|
}
|
|
if json.Unmarshal(b.redactManagement(data), &message) != nil {
|
|
return
|
|
}
|
|
switch message.Type {
|
|
case "status":
|
|
s := message.Status
|
|
if s.ID != id || len(s.Name) > 128 || len(s.Hostname) > 256 || len(s.OS) > 64 || len(s.Arch) > 64 || len(s.Version) > 64 || len(s.Instance) > 128 || len(s.Devices) > 128 {
|
|
return
|
|
}
|
|
for _, d := range s.Devices {
|
|
if !validID(d.ID) || (d.Target != nil && len(*d.Target) > 256) || (d.ADBSerial != nil && len(*d.ADBSerial) > 256) || (d.LastError != nil && len(*d.LastError) > 2048) {
|
|
return
|
|
}
|
|
}
|
|
if s.Devices == nil {
|
|
s.Devices = []managedDevice{}
|
|
}
|
|
b.mu.Lock()
|
|
m.status = s
|
|
m.lastSeen = time.Now().Unix()
|
|
b.mu.Unlock()
|
|
case "result":
|
|
if len(message.Response) == 0 {
|
|
return
|
|
}
|
|
var check struct {
|
|
OK bool `json:"ok"`
|
|
}
|
|
if json.Unmarshal(message.Response, &check) != nil {
|
|
return
|
|
}
|
|
b.mu.Lock()
|
|
ch := m.pending[message.RequestID]
|
|
b.mu.Unlock()
|
|
if ch != nil {
|
|
select {
|
|
case ch <- message.Response:
|
|
default:
|
|
}
|
|
}
|
|
default:
|
|
return
|
|
}
|
|
}
|
|
}
|
|
func isWebSocket(r *http.Request) bool {
|
|
return strings.EqualFold(r.Header.Get("Upgrade"), "websocket")
|
|
}
|
|
func (b *broker) managersEndpoint(w http.ResponseWriter, r *http.Request) {
|
|
type record struct {
|
|
ID string `json:"id"`
|
|
Online bool `json:"online"`
|
|
LastSeen int64 `json:"last_seen"`
|
|
Status managedStatus `json:"status"`
|
|
}
|
|
b.mu.Lock()
|
|
records := []record{}
|
|
for _, m := range b.managers {
|
|
records = append(records, record{m.id, m.ws != nil, m.lastSeen, m.status})
|
|
}
|
|
b.mu.Unlock()
|
|
sort.Slice(records, func(i, j int) bool { return records[i].ID < records[j].ID })
|
|
if isWebSocket(r) {
|
|
ws, err := accept(w, r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer ws.CloseNow()
|
|
writeJSON(r.Context(), ws, records)
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(records)
|
|
}
|
|
func validManagementRequest(raw []byte) bool {
|
|
var request struct {
|
|
Op string `json:"op"`
|
|
}
|
|
if json.Unmarshal(raw, &request) != nil {
|
|
return false
|
|
}
|
|
switch request.Op {
|
|
case "status", "devices_list", "device_add", "device_remove", "device_enable", "config_get", "config_set", "logs", "restart":
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
func (b *broker) managerRPC(ctx context.Context, id string, request json.RawMessage) json.RawMessage {
|
|
failure := func(reason string) json.RawMessage {
|
|
data, _ := json.Marshal(map[string]any{"ok": false, "error": reason})
|
|
return data
|
|
}
|
|
if !validID(id) || !validManagementRequest(request) {
|
|
return failure("invalid management request")
|
|
}
|
|
b.mu.Lock()
|
|
m := b.managers[id]
|
|
if m == nil || m.ws == nil {
|
|
b.mu.Unlock()
|
|
return failure("agent is offline")
|
|
}
|
|
if len(m.pending) >= 16 {
|
|
b.mu.Unlock()
|
|
return failure("agent management request limit reached")
|
|
}
|
|
requestID := newID()
|
|
response := make(chan json.RawMessage, 1)
|
|
m.pending[requestID] = response
|
|
ws := m.ws
|
|
b.mu.Unlock()
|
|
defer func() { b.mu.Lock(); delete(m.pending, requestID); b.mu.Unlock() }()
|
|
deadline, cancel := context.WithTimeout(ctx, 15*time.Second)
|
|
defer cancel()
|
|
if writeJSON(deadline, ws, map[string]any{"type": "request", "request_id": requestID, "request": request}) != nil {
|
|
return failure("cannot reach agent")
|
|
}
|
|
select {
|
|
case data := <-response:
|
|
return data
|
|
case <-m.ctx.Done():
|
|
return failure("agent disconnected")
|
|
case <-deadline.Done():
|
|
return failure("agent management request timed out")
|
|
}
|
|
}
|
|
func (b *broker) managerRPCEndpoint(w http.ResponseWriter, r *http.Request) {
|
|
var request []byte
|
|
if isWebSocket(r) {
|
|
ws, err := accept(w, r)
|
|
if err != nil {
|
|
return
|
|
}
|
|
defer ws.CloseNow()
|
|
deadline, cancel := context.WithTimeout(r.Context(), 5*time.Second)
|
|
defer cancel()
|
|
typ, data, err := ws.Read(deadline)
|
|
if err != nil || typ != websocket.MessageText || len(data) > 64*1024 {
|
|
return
|
|
}
|
|
response := b.managerRPC(r.Context(), r.URL.Query().Get("agent"), data)
|
|
writeJSON(r.Context(), ws, json.RawMessage(response))
|
|
return
|
|
}
|
|
if r.Method != "POST" {
|
|
http.Error(w, "POST required", 405)
|
|
return
|
|
}
|
|
var err error
|
|
request, err = io.ReadAll(http.MaxBytesReader(w, r.Body, 64*1024))
|
|
if err != nil {
|
|
http.Error(w, "request too large", 413)
|
|
return
|
|
}
|
|
response := b.managerRPC(r.Context(), r.URL.Query().Get("agent"), request)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write(response)
|
|
}
|