Files
marqdo/plugins/web/internal/ws/route.go
T
cflmyandCursor 86b183e2d7 fix(web): harden WebSocket and net host boundaries
- WS handshake: same-origin CheckOrigin instead of allow-all
- route_ws require_auth/需要登录: broadcast/room need a session by default,
  explicit opt-out for public feeds; unauthenticated handshakes get 401
- WS limits: 1 MiB per message, 256 replies per connect; transport errors
  return {ok:false, error} instead of an empty success; empty rooms GC'd
- net host: enforce the 8 MiB response cap while reading (incl. error and
  SSE error paths) so a peer cannot exhaust memory
- url_encode: %20 for space (URL segment semantics, not form +)
- docs: sync 网页 (route_ws 需要登录, connect caps) and CHANGELOG
- tests: gold expectations, live fixture opt-out, hub GC, ws auth gate

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-22 15:14:35 +08:00

190 lines
4.8 KiB
Go

package ws
import (
"fmt"
"strings"
"github.com/marqdo/marqdo/plugins/web/internal/app"
)
// RouteSpec is one ws_routes entry (mode + optional room_key / on_message / presence).
type RouteSpec struct {
Mode Mode
RoomKey string
OnMessage string
Presence bool
RequireAuth bool
}
// RouteWS registers path → {mode, room_key?, on_message?, presence?} on app.ws_routes.
func RouteWS(appBag map[string]any, path string, args map[string]any) (map[string]any, error) {
path, err := app.NormalizeRoutePath(path, appBag)
if err != nil {
return nil, err
}
mode := ModeFromArgs(args)
roomKey := RoomKeyFromArgs(args)
if mode == ModeRoom && roomKey == "" {
return nil, fmt.Errorf("mode=room requires room_key")
}
onMsg := OnMessageFromArgs(args)
presence := PresenceFromArgs(args)
// Stateful fan-out routes are private by default. Echo and drain remain
// useful for public health checks and demos; authors can opt out explicitly.
requireAuth := mode == ModeBroadcast || mode == ModeRoom
if v, ok := first(args, "require_auth", "需要登录"); ok && v != nil {
requireAuth = boolish(v)
}
out := clone(appBag)
wsRoutes := map[string]any{}
if r, ok := out["ws_routes"].(map[string]any); ok {
wsRoutes = clone(r)
}
spec := map[string]any{"mode": string(mode)}
if roomKey != "" {
spec["room_key"] = roomKey
}
if onMsg != "" {
spec["on_message"] = onMsg
}
if presence {
spec["presence"] = true
}
if requireAuth {
spec["require_auth"] = true
}
wsRoutes[path] = spec
out["ws_routes"] = wsRoutes
return out, nil
}
// RoomKeyFromArgs reads room_key / 房间 from route_ws ABI args.
func RoomKeyFromArgs(args map[string]any) string {
if v, ok := first(args, "room_key", "房间"); ok {
return strings.TrimSpace(fmt.Sprint(v))
}
return ""
}
// OnMessageFromArgs reads on_message / 消息钩子 (lib.member path).
func OnMessageFromArgs(args map[string]any) string {
if v, ok := first(args, "on_message", "消息钩子", "钩子"); ok {
return strings.TrimSpace(fmt.Sprint(v))
}
return ""
}
// PresenceFromArgs reads presence / 在场 flag.
func PresenceFromArgs(args map[string]any) bool {
if v, ok := first(args, "presence", "在场"); ok {
return boolish(v)
}
return false
}
// ExpandTemplate replaces `{name}` tokens using values from PathValue-style map.
func ExpandTemplate(tmpl string, values map[string]string) string {
if tmpl == "" || len(values) == 0 {
return tmpl
}
out := tmpl
for k, v := range values {
out = strings.ReplaceAll(out, "{"+k+"}", v)
}
return out
}
// RoutesOf reads ws_routes from an app bag.
func RoutesOf(appBag map[string]any) map[string]Mode {
out := map[string]Mode{}
obj, ok := appBag["ws_routes"].(map[string]any)
if !ok {
return out
}
for path, spec := range obj {
switch t := spec.(type) {
case map[string]any:
if m, ok := t["mode"]; ok {
out[path] = ParseMode(m)
continue
}
out[path] = ParseMode(t)
case string:
out[path] = ParseMode(t)
default:
out[path] = ParseMode(spec)
}
}
return out
}
func clone(m map[string]any) map[string]any {
out := make(map[string]any, len(m))
for k, v := range m {
out[k] = v
}
return out
}
// ModeOf returns the mode for one ws route path, or error if missing.
func ModeOf(appBag map[string]any, path string) (Mode, error) {
spec, err := RouteSpecOf(appBag, path)
if err != nil {
return "", err
}
return spec.Mode, nil
}
// RouteSpecOf returns mode and room_key for one ws route path.
func RouteSpecOf(appBag map[string]any, path string) (RouteSpec, error) {
routes, ok := appBag["ws_routes"].(map[string]any)
if !ok {
return RouteSpec{}, fmt.Errorf("missing ws route %s", path)
}
spec, ok := routes[path]
if !ok {
return RouteSpec{}, fmt.Errorf("missing ws route %s", path)
}
return parseRouteSpec(spec), nil
}
// ParseRouteSpec reads mode and room_key from a ws_routes value.
func ParseRouteSpec(spec any) RouteSpec {
return parseRouteSpec(spec)
}
func parseRouteSpec(spec any) RouteSpec {
out := RouteSpec{Mode: ModeEcho}
switch t := spec.(type) {
case map[string]any:
if mode, ok := t["mode"]; ok {
out.Mode = ParseMode(mode)
} else {
out.Mode = ParseMode(t)
}
if rk, ok := t["room_key"]; ok {
out.RoomKey = strings.TrimSpace(fmt.Sprint(rk))
}
if om, ok := t["on_message"]; ok {
out.OnMessage = strings.TrimSpace(fmt.Sprint(om))
} else if om, ok := t["消息钩子"]; ok {
out.OnMessage = strings.TrimSpace(fmt.Sprint(om))
}
if p, ok := t["presence"]; ok {
out.Presence = boolish(p)
} else if p, ok := t["在场"]; ok {
out.Presence = boolish(p)
}
if a, ok := t["require_auth"]; ok {
out.RequireAuth = boolish(a)
} else if a, ok := t["需要登录"]; ok {
out.RequireAuth = boolish(a)
}
case string:
out.Mode = ParseMode(t)
default:
out.Mode = ParseMode(spec)
}
return out
}