@threadedstack/wmd-web 0.0.0-stage → 0.1.13

package/relay/v1.ts

@@ -0,0 +1,107 @@
+// W59: the wmd-relay.v1 adapter (src/net/proto.js) over the relay engine (engine.ts).
+// Its bytes, close codes, HTTP refusals and log lines are pinned by test/unit/relay-v1-golden.test.js.
+
+import { E, MAX_DATA, PROTOCOL, T, WINDOW, abortMsg, connectedMsg, dnsReplyMsg, msg, parse, u32Msg } from '../src/net/proto.js'
+import type { Engine, Principal, Session, Wire } from './engine.ts'
+import { verifyToken } from './token.ts'
+
+function send(s: Session, m: Uint8Array) {
+  if (s.closed) return
+  s.ws.send(m)
+}
+
+const wire: Wire = {
+  connected(s, st, detail) {
+    // the first window is upload credit too: it comes out of the bucket (the rest is owed)
+    const g = s.p.up.take(WINDOW)
+    st.ourGrant = g
+    send(s, connectedMsg(st.id, E.OK, g, detail))
+    if (g < WINDOW) s.w.engine.owe(s, st.id, WINDOW - g)
+  },
+  refused: (s, id, code, why) => send(s, connectedMsg(id, code, 0, why)),
+  data: (s, st, bytes) => send(s, msg(T.RDATA, st.id, bytes)),
+  end: (s, st) => send(s, msg(T.REND, st.id)),
+  abort: (s, st, code, why) => send(s, abortMsg(st.id, code, why)),
+  grant(s, st, n) {
+    st.ourGrant += n
+    send(s, u32Msg(T.RCREDIT, st.id, n))
+  },
+  dnsReply: (s, id, rcode, ttl, addrs, why) => send(s, dnsReplyMsg(id, rcode, ttl, addrs, why)),
+}
+
+export function createV1(engine: Engine, o: { secret: string; origins?: string[] }) {
+  const stats = engine.stats
+
+  /** The HTTP upgrade at /relay: origin, subprotocol, token, then the engine's admission. */
+  function fetch(req: Request, srv: any): Response | undefined {
+    const origin = req.headers.get('origin') || ''
+    if (o.origins?.length && !o.origins.includes(origin)) {
+      stats.refusedSessions++
+      return new Response('origin not allowed\n', { status: 403 })
+    }
+    const protos = (req.headers.get('sec-websocket-protocol') || '').split(',').map(x => x.trim())
+    if (!protos.includes(PROTOCOL)) return new Response(`subprotocol ${PROTOCOL} required\n`, { status: 400 })
+    const tok = protos.find(p => p.startsWith('t.'))
+    const info = tok ? verifyToken(o.secret, tok.slice(2)) : 'no token'
+    if (typeof info === 'string') {
+      engine.refusedSession(info, { origin })
+      return new Response(`${info}\n`, { status: 401 })
+    }
+    if (engine.hasSession(info.sid)) {
+      stats.refusedSessions++
+      return new Response('session already connected\n', { status: 409 })
+    }
+    const uid = info.uid || info.sid
+    const a = engine.admit(uid, info.grp || uid, info.exp)
+    if (!a.ok) return new Response(a.body, { status: a.status })
+    const ok = srv.upgrade(req, { data: { kind: 'v1', sid: info.sid, exp: info.exp, p: a.p }, headers: { 'Sec-WebSocket-Protocol': PROTOCOL } })
+    return ok ? undefined : new Response('upgrade failed\n', { status: 400 })
+  }
+
+  function open(ws: any) {
+    const { sid, exp, p } = ws.data as { sid: string; exp: number; p: Principal }
+    const s = engine.open(ws, sid, p, exp, wire, WINDOW)
+    if (!s) return
+    s.w = { engine }
+    ws.data.session = s
+    ws.send(JSON.stringify({ t: 'hello', protocol: PROTOCOL, limits: engine.limits(p) }))
+  }
+
+  function message(ws: any, raw: ArrayBuffer | Uint8Array | string) {
+    const s = ws.data.session as Session
+    if (!s || typeof raw === 'string') return
+    const u8 = raw instanceof Uint8Array ? raw : new Uint8Array(raw)
+    if (u8.length > MAX_DATA + 1024) return s.ws.close(1009, 'message too large') // the server's frame limit may be higher for Wisp
+    const m: any = parse(u8)
+    if (!m) return s.ws.close(4002, 'malformed message')
+    switch (m.type) {
+      case T.CONNECT:
+        engine.connectSafe(s, m.id, m.host, m.port)
+        break
+      case T.DATA: {
+        const st = s.streams.get(m.id)
+        if (!st || !st.connected || !st.sock || st.clientEnded) return // a stream that just failed: its ABORT is on the way
+        if (m.payload.length > st.ourGrant) return engine.fail(s, st, E.BAD, 'data over the granted credit')
+        st.ourGrant -= m.payload.length
+        engine.write(s, st, m.payload)
+        break
+      }
+      case T.END:
+        engine.clientEnd(s, m.id)
+        break
+      case T.ABORT:
+        engine.clientAbort(s, m.id)
+        break
+      case T.CREDIT:
+        engine.credit(s, m.id, m.n)
+        break
+      case T.DNS:
+        engine.dns(s, m.id, m.name, m.qtype).catch(e => engine.log({ ev: 'error', sid: s.sid, error: String(e) }))
+        break
+      default:
+        s.ws.close(4002, 'unknown message type')
+    }
+  }
+
+  return { fetch, open, message }
+}