@threadedstack/wmd-web 0.0.0-stage → 0.1.12

package/src/host/yamux.js

@@ -0,0 +1,387 @@
+// P-B11 (ROADMAP 2.2b): a hashicorp/yamux client, the host side of wmd's control
+// session (internal/engine/control.go: the host is the yamux client, the guest init the
+// server, github.com/hashicorp/yamux v0.1.2 with its default config).
+//
+// Synchronous and transport-free: feed() takes the bytes the guest sent, send() is called
+// with the bytes for the guest, tick() runs the keepalive. The channel service Worker
+// (chan-services.js ControlSession) drives it from its step(); the unit tests drive it
+// against Go's own yamux server.
+//
+// The wire format (yamux spec.md, const.go): a 12-byte header, version 0 | type |
+// flags (2, BE) | stream id (4, BE) | length (4, BE); Data frames carry `length` bytes.
+// Types: 0 Data, 1 Window Update, 2 Ping, 3 Go Away. Flags: SYN 1, ACK 2, FIN 4, RST 8.
+// The client's streams have odd ids, from 1. Every stream starts with a 256 KiB window
+// each way; a sender may not have more unacknowledged bytes in flight.
+//
+// As hashicorp/yamux:
+// - open() sends a Window Update with SYN (delta 0); data may follow at once.
+// - A stream's receive window is given back as the consumer takes the bytes (consume()),
+//   in one Window Update once at least half of it is free (Stream.sendWindowUpdate).
+// - closeWrite() sends FIN (after the queued data); a stream is gone once both sides sent
+//   FIN, or on RST.
+// - Pings from the guest (SYN) are answered at once (ACK, same opaque value). The guest's
+//   server pings every 30 s and closes the session if an answer takes over 10 s
+//   (ConnectionWriteTimeout): answering from the service Worker, never the page, keeps a
+//   stalled page from losing the session.
+// - The client pings every keepAliveMs (5 s, as the engine); an unanswered ping is only
+//   counted (pingTimeouts): a slow emulated guest is not a dead one.
+// - Data past a stream's receive window, a bad version or type, a duplicate SYN: Go Away
+//   (protocol error) and the session is closed.
+// - Streams the guest opens (op "edge", unused here) are refused with RST.
+
+export const YAMUX_HEADER = 12
+export const T_DATA = 0
+export const T_WINDOW = 1
+export const T_PING = 2
+export const T_GOAWAY = 3
+export const F_SYN = 1
+export const F_ACK = 2
+export const F_FIN = 4
+export const F_RST = 8
+export const INITIAL_WINDOW = 256 * 1024
+/** Go keeps a stream's send window in a uint32: never more credit than that. */
+export const MAX_WINDOW = 0xffffffff
+export const GOAWAY_NORMAL = 0
+export const GOAWAY_PROTO = 1
+export const GOAWAY_INTERNAL = 2
+
+/** One yamux header. */
+export function yamuxHeader(type, flags, id, length) {
+  const h = new Uint8Array(YAMUX_HEADER)
+  const dv = new DataView(h.buffer)
+  h[0] = 0
+  h[1] = type
+  dv.setUint16(2, flags)
+  dv.setUint32(4, id)
+  dv.setUint32(8, length >>> 0)
+  return h
+}
+
+const concat = (a, b) => { // one frame: header + payload
+  if (!a.length) return b
+  const o = new Uint8Array(a.length + b.length)
+  o.set(a)
+  o.set(b, a.length)
+  return o
+}
+
+export class YamuxStream {
+  constructor(session, id) {
+    this.session = session
+    this.id = id
+    this.sendWindow = INITIAL_WINDOW // bytes we may still send
+    this.recvWindow = INITIAL_WINDOW // bytes the guest may still send
+    this.unconsumed = 0 // received, not yet consume()d
+    this.pending = [] // data waiting for send window
+    this.pendingBytes = 0
+    this.localFin = false // closeWrite() called
+    this.finSent = false
+    this.remoteFin = false
+    this.reset = false
+    this.acked = false
+    this.closed = false // both sides done, or reset: removed from the session
+    this.bytesIn = 0
+    this.bytesOut = 0
+    // callbacks
+    this.onData = null // (u8) => void
+    this.onFin = null // () => void: the guest will send nothing more
+    this.onClose = null // (reason|null) => void: the stream is gone (null: both FINs)
+    this.onSent = null // (n) => void: n queued bytes went out (the guest's window let them)
+  }
+
+  /** Queue bytes for the guest; sent as the guest's window allows. */
+  write(u8) {
+    if (this.closed || this.localFin) throw new Error(`yamux stream ${this.id}: write after ${this.closed ? 'close' : 'closeWrite'}`)
+    if (!u8.length) return
+    this.pending.push(u8)
+    this.pendingBytes += u8.length
+    this.#flush()
+  }
+
+  /** Half-close: FIN once the queued data is out. */
+  closeWrite() {
+    if (this.closed || this.localFin) return
+    this.localFin = true
+    this.#flush()
+  }
+
+  /** Abort the stream (RST). */
+  abort(reason = 'reset by the host') {
+    if (this.closed) return
+    this.session._send(yamuxHeader(T_WINDOW, F_RST, this.id, 0))
+    this.reset = true
+    this.session._remove(this, reason)
+  }
+
+  /** The consumer took n bytes: give the window back (as hashicorp's Stream.Read). */
+  consume(n) {
+    if (this.closed || !Number.isFinite(n) || n <= 0) return
+    this.unconsumed = Math.max(0, this.unconsumed - n)
+    const delta = INITIAL_WINDOW - this.unconsumed - this.recvWindow
+    if (delta < INITIAL_WINDOW / 2) return
+    this.recvWindow += delta
+    this.session._send(yamuxHeader(T_WINDOW, 0, this.id, delta))
+  }
+
+  _flush() {
+    this.#flush()
+  }
+
+  #flush() {
+    while (this.pending.length && this.sendWindow > 0 && !this.closed) {
+      const c = this.pending[0]
+      const n = Math.min(c.length, this.sendWindow, 1 << 20)
+      const fin = this.localFin && !this.finSent && n === c.length && this.pending.length === 1
+      this.session._send(concat(yamuxHeader(T_DATA, fin ? F_FIN : 0, this.id, n), c.subarray(0, n)))
+      if (fin) this.finSent = true
+      this.sendWindow -= n
+      this.bytesOut += n
+      this.pendingBytes -= n
+      this.onSent?.(n)
+      if (n === c.length) this.pending.shift()
+      else this.pending[0] = c.subarray(n)
+    }
+    if (this.localFin && !this.finSent && !this.pending.length && !this.closed) {
+      this.finSent = true
+      this.session._send(yamuxHeader(T_WINDOW, F_FIN, this.id, 0))
+    }
+    if (this.finSent && this.remoteFin) this.session._remove(this, null)
+  }
+
+  _flags(flags) {
+    if (flags & F_ACK) this.acked = true
+    if (flags & F_FIN && !this.remoteFin) {
+      this.remoteFin = true
+      this.onFin?.()
+      if (this.finSent) this.session._remove(this, null)
+    }
+    if (flags & F_RST) {
+      this.reset = true
+      this.session._remove(this, 'reset by the guest')
+    }
+  }
+}
+
+export class YamuxClient {
+  /**
+   * @param {object} o
+   * @param {(u8: Uint8Array) => void} o.send    bytes for the guest
+   * @param {() => number} [o.now]               ms clock (performance.now)
+   * @param {number} [o.keepAliveMs]             client pings (5000, as the engine); 0: none
+   * @param {number} [o.pingTimeoutMs]           an unanswered ping counts as a timeout after this
+   * @param {(reason: string) => void} [o.onClose]
+   */
+  constructor({ send, now = () => performance.now(), keepAliveMs = 5000, pingTimeoutMs = 10_000, onClose = null } = {}) {
+    this.sendFn = send
+    this.now = now
+    this.keepAliveMs = keepAliveMs
+    this.pingTimeoutMs = pingTimeoutMs
+    this.onClose = onClose
+    this.streams = new Map()
+    this.nextId = 1
+    this.hdr = new Uint8Array(YAMUX_HEADER) // the header being read
+    this.hlen = 0
+    this.body = null // the stream whose data frame body is arriving (null: discard it)
+    this.bodyFlags = 0
+    this.bodyLeft = 0 // bytes of that body still to come
+    this.parts = [] // the body's pieces so far
+    this.closed = null // the reason, once closed
+    this.remoteGoAway = false
+    this.lastPingAt = now()
+    this.pingId = 0
+    this.pings = new Map() // id -> sent at
+    this.stats = { pingsSent: 0, pingsAnswered: 0, pingTimeouts: 0, pingRttMs: [], guestPings: 0, refused: 0, discarded: 0, opened: 0, bytesIn: 0, bytesOut: 0 }
+  }
+
+  _send(u8) {
+    if (this.closed) return
+    this.stats.bytesOut += u8.length
+    this.sendFn(u8)
+  }
+
+  /** A new stream (SYN). */
+  open() {
+    if (this.closed) throw new Error(`yamux session closed: ${this.closed}`)
+    if (this.remoteGoAway) throw new Error('yamux: the guest is not accepting streams (go away)')
+    const id = this.nextId
+    this.nextId += 2
+    const s = new YamuxStream(this, id)
+    this.streams.set(id, s)
+    this.stats.opened++
+    this._send(yamuxHeader(T_WINDOW, F_SYN, id, 0))
+    return s
+  }
+
+  _remove(s, reason) {
+    if (s.closed) return
+    s.closed = true
+    this.streams.delete(s.id)
+    s.onClose?.(reason)
+  }
+
+  /** Keepalive; call often (the service calls it every step). */
+  tick() {
+    if (this.closed) return
+    const t = this.now()
+    for (const [id, at] of this.pings) {
+      if (t - at > this.pingTimeoutMs) {
+        this.pings.delete(id)
+        this.stats.pingTimeouts++
+      }
+    }
+    if (this.keepAliveMs > 0 && t - this.lastPingAt >= this.keepAliveMs) {
+      this.lastPingAt = t
+      const id = this.pingId++ >>> 0
+      this.pings.set(id, t)
+      this.stats.pingsSent++
+      this._send(yamuxHeader(T_PING, F_SYN, 0, id))
+    }
+  }
+
+  /** Close the session: Go Away, every stream ends with `reason`. */
+  close(reason = 'closed by the host', code = GOAWAY_NORMAL, sendGoAway = true) {
+    if (this.closed) return
+    if (sendGoAway) this._send(yamuxHeader(T_GOAWAY, 0, 0, code))
+    this.closed = reason
+    for (const s of [...this.streams.values()]) this._remove(s, reason)
+    this.onClose?.(reason)
+  }
+
+  #protoError(why) {
+    this.close(`yamux protocol error: ${why}`, GOAWAY_PROTO)
+  }
+
+  /**
+   * Bytes from the guest. Linear in the bytes fed, however they are cut: a header is
+   * collected in a 12-byte buffer; a data frame's body is kept as the pieces it arrived in
+   * (never re-copied per feed) and delivered once whole, which holds at most the stream's
+   * receive window (256 KiB); As hashicorp's readData: the length is checked against
+   * the stream's receive window when the header arrives (Go Away before any of the body
+   * is read), and data for a stream that is gone is discarded as it comes.
+   */
+  feed(u8) {
+    if (this.closed || !u8.length) return
+    this.stats.bytesIn += u8.length
+    let at = 0
+    while (at < u8.length && !this.closed) {
+      if (this.bodyLeft > 0) {
+        const n = Math.min(this.bodyLeft, u8.length - at)
+        if (this.body) this.parts.push(u8.slice(at, at + n)) // at most the stream's window (checked at the header)
+        at += n
+        this.bodyLeft -= n
+        if (this.bodyLeft === 0) this.#bodyDone()
+        continue
+      }
+      const n = Math.min(YAMUX_HEADER - this.hlen, u8.length - at)
+      this.hdr.set(u8.subarray(at, at + n), this.hlen)
+      this.hlen += n
+      at += n
+      if (this.hlen < YAMUX_HEADER) break
+      this.hlen = 0
+      this.#header()
+    }
+  }
+
+  /** The header bytes collected so far (a partial header between feeds). */
+  get buf() {
+    return this.hdr.subarray(0, this.hlen)
+  }
+
+  #header() {
+    const h = this.hdr
+    const dv = new DataView(h.buffer)
+    const ver = h[0]
+    const type = h[1]
+    const flags = dv.getUint16(2)
+    const id = dv.getUint32(4)
+    const len = dv.getUint32(8)
+    if (ver !== 0) return this.#protoError(`version ${ver}`)
+    if (type > T_GOAWAY) return this.#protoError(`message type ${type}`)
+    if (type === T_PING) return this.#ping(flags, len)
+    if (type === T_GOAWAY) return this.#goAway(len)
+    if (flags & F_SYN) {
+      // the guest opening a stream (only op "edge" does; not served here): refuse it, and
+      // skip any body it sent with the SYN
+      if (this.streams.has(id)) return this.#protoError(`duplicate stream ${id}`)
+      this.stats.refused++
+      this._send(yamuxHeader(T_WINDOW, F_RST, id, 0))
+      if (type === T_DATA) this.#discard(len)
+      return
+    }
+    const s = this.streams.get(id)
+    if (type === T_WINDOW) {
+      if (!s) return // a frame for a stream already gone: dropped, as hashicorp does
+      s.sendWindow = Math.min(MAX_WINDOW, s.sendWindow + len) // Go's window is a uint32
+      s._flags(flags)
+      if (!s.closed) s._flush()
+      return
+    }
+    // data
+    if (!s) return this.#discard(len)
+    if (len > s.recvWindow) return this.#protoError(`stream ${id}: ${len} bytes over a window of ${s.recvWindow}`)
+    s.recvWindow -= len
+    s.unconsumed += len
+    this.body = s
+    this.bodyFlags = flags
+    this.bodyLeft = len
+    if (len === 0) this.#bodyDone()
+  }
+
+  #discard(len) {
+    this.body = null
+    this.bodyFlags = 0
+    this.bodyLeft = len
+    this.stats.discarded += len
+  }
+
+  #bodyDone() {
+    const s = this.body
+    const parts = this.parts
+    this.body = null
+    this.parts = []
+    if (!s || s.closed) return
+    // one delivery per frame, as Go's stream buffers a frame before Read: the window
+    // given back by consume() is then counted in whole frames
+    const n = parts.reduce((a, p) => a + p.length, 0)
+    if (n) {
+      let data = parts[0]
+      if (parts.length > 1) {
+        data = new Uint8Array(n)
+        let o = 0
+        for (const p of parts) {
+          data.set(p, o)
+          o += p.length
+        }
+      }
+      s.bytesIn += n
+      s.onData?.(data)
+    }
+    s._flags(this.bodyFlags)
+  }
+
+  #ping(flags, value) {
+    if (flags & F_SYN) {
+      this.stats.guestPings++
+      this._send(yamuxHeader(T_PING, F_ACK, 0, value))
+      return
+    }
+    const at = this.pings.get(value)
+    if (at !== undefined) {
+      this.pings.delete(value)
+      this.stats.pingsAnswered++
+      const r = this.stats.pingRttMs
+      r.push(this.now() - at)
+      if (r.length > 64) r.shift()
+    }
+  }
+
+  #goAway(code) {
+    if (code === GOAWAY_NORMAL) {
+      this.remoteGoAway = true
+      return
+    }
+    this.close(code === GOAWAY_PROTO ? 'the guest reported a yamux protocol error' : `the guest went away (code ${code})`, GOAWAY_NORMAL, false)
+  }
+
+
+}

package/src/image-files.js

@@ -0,0 +1,154 @@
+// W63/W66: an image's files, read on the page without a boot. The layers (packs, top first) are opened
+// read-only through the overlay the 9P service serves them with, so whiteouts and opaque directories
+// count as they do in the guest. W63: the image's /etc/passwd and /etc/group, so a caller can apply
+// `USER name`, devcontainer `remoteUser` or `--chown=app:app` (resolveUser). W66: another image's files,
+// for `COPY --from` and multi-stage builds (walk).
+
+import { ENOENT, FsError } from './fs/errno.js'
+import { Overlay } from './fs/overlay.js'
+import { Pack, bytesSource } from './fs/pack.js'
+
+const S_IFMT = 0o170000
+const TYPES = { 0o100000: 'file', 0o040000: 'dir', 0o120000: 'symlink', 0o020000: 'char', 0o060000: 'block', 0o010000: 'fifo', 0o140000: 'socket' }
+
+async function layerBytes(l, i, fetchFn) {
+  if (typeof l === 'string') {
+    const r = await fetchFn(l)
+    if (!r.ok) throw new Error(`layer ${i}: ${l}: HTTP ${r.status}`)
+    return new Uint8Array(await r.arrayBuffer())
+  }
+  if (l instanceof Uint8Array) return l
+  if (l instanceof ArrayBuffer || (typeof SharedArrayBuffer !== 'undefined' && l instanceof SharedArrayBuffer)) return new Uint8Array(l)
+  if (typeof Blob !== 'undefined' && l instanceof Blob) return new Uint8Array(await l.arrayBuffer())
+  throw new TypeError(`layer ${i}: a URL, bytes or a Blob, not ${Object.prototype.toString.call(l)}`)
+}
+
+const missing = e => e instanceof FsError && e.errno === ENOENT
+
+/**
+ * Opens an image's layers: (url | Uint8Array | ArrayBuffer | Blob)[], top first, as bootWmd's 9P service
+ * takes them. Each pack is held whole in memory while the result is in use.
+ * @returns {Promise<ImageFiles>}
+ */
+export async function openImage(layers, { fetch: fetchFn = globalThis.fetch } = {}) {
+  const packs = await Promise.all(layers.map(async (l, i) => new Pack(bytesSource(await layerBytes(l, i, fetchFn)), `layer ${i}`)))
+  return new ImageFiles(new Overlay({ layers: packs }))
+}
+
+export class ImageFiles {
+  constructor(fs) {
+    this.fs = fs
+  }
+
+  /** A file's bytes (symlinks followed inside the image), or null when it does not exist. Throws for a directory. */
+  readFile(path) {
+    try {
+      return this.fs.readFile(path)
+    } catch (e) {
+      if (missing(e)) return null
+      throw e
+    }
+  }
+
+  /** A file's text (UTF-8), or null when it does not exist. */
+  readText(path) {
+    const b = this.readFile(path)
+    return b && new TextDecoder().decode(b)
+  }
+
+  /** {type ('file', 'dir', 'symlink', ...), mode (permission bits), uid, gid, size, mtime (BigInt ns), target?}, or null. */
+  stat(path, follow = true) {
+    let n
+    try {
+      n = this.fs.resolve(path, follow)
+    } catch (e) {
+      if (missing(e)) return null
+      throw e
+    }
+    return this.#info(n)
+  }
+
+  #info(n) {
+    const st = { type: TYPES[n.mode & S_IFMT] || 'other', mode: n.mode & 0o7777, uid: n.uid, gid: n.gid, size: this.fs.size(n), mtime: n.mtime }
+    if (st.type === 'symlink') st.target = n.target
+    return st
+  }
+
+  /**
+   * Every entry at and under path (not following symlinks; a symlink at path itself is followed), depth
+   * first, names in byte order: {path (relative to path; '' for path itself), ...stat, data? (a file's
+   * bytes, unless {data: false})}. Nothing when path does not exist.
+   */
+  *walk(path, { data = true } = {}) {
+    let top
+    try {
+      top = this.fs.resolve(path, true)
+    } catch (e) {
+      if (missing(e)) return
+      throw e
+    }
+    const fs = this.fs
+    const self = this
+    function* visit(n, rel) {
+      const e = { path: rel, ...self.#info(n) }
+      if (data && e.type === 'file') e.data = fs.read(n, 0, fs.size(n))
+      yield e
+      if (n.isDir()) for (const [name, c] of fs.list(n)) yield* visit(c, rel ? `${rel}/${name}` : name)
+    }
+    yield* visit(top, '')
+  }
+
+  /** {users, groups} from the image's /etc/passwd and /etc/group (empty lists when a file is missing). */
+  accounts() {
+    return { users: parsePasswd(this.readText('/etc/passwd') || ''), groups: parseGroup(this.readText('/etc/group') || '') }
+  }
+}
+
+/** /etc/passwd lines: [{name, uid, gid, home, shell}] (comments and malformed lines skipped). */
+export function parsePasswd(text) {
+  const out = []
+  for (const line of text.split('\n')) {
+    const f = line.split(':')
+    if (f.length < 7 || line.startsWith('#') || !/^\d+$/.test(f[2]) || !/^\d+$/.test(f[3])) continue
+    out.push({ name: f[0], uid: Number(f[2]), gid: Number(f[3]), home: f[5], shell: f[6] })
+  }
+  return out
+}
+
+/** /etc/group lines: [{name, gid, members}]. */
+export function parseGroup(text) {
+  const out = []
+  for (const line of text.split('\n')) {
+    const f = line.split(':')
+    if (f.length < 4 || line.startsWith('#') || !/^\d+$/.test(f[2])) continue
+    out.push({ name: f[0], gid: Number(f[2]), members: f[3] ? f[3].split(',').filter(Boolean) : [] })
+  }
+  return out
+}
+
+/**
+ * A Dockerfile `USER` / `--chown` value against an image's accounts, as Docker reads it: "name", "uid",
+ * "name:group", "uid:gid" (each side a name or a number). A user alone takes its passwd group (a uid
+ * that is not in passwd: group 0). A name that is not in the image throws, as Docker refuses it.
+ * @returns {{uid: number, gid: number, name: string|null, home: string|null}}
+ */
+export function resolveUser(spec, { users = [], groups = [] } = {}) {
+  const s = String(spec).trim()
+  if (!s) throw new Error('empty user')
+  const colon = s.indexOf(':')
+  const u = colon < 0 ? s : s.slice(0, colon)
+  const g = colon < 0 ? null : s.slice(colon + 1)
+  const numeric = x => /^\d+$/.test(x)
+  const pw = numeric(u) ? users.find(x => x.uid === Number(u)) : users.find(x => x.name === u)
+  if (!pw && !numeric(u)) throw new Error(`unable to find user ${u}: no matching entries in passwd file`)
+  const uid = pw ? pw.uid : Number(u)
+  let gid
+  if (g === null || g === '') gid = pw ? pw.gid : 0
+  else if (numeric(g)) gid = Number(g)
+  else {
+    const gr = groups.find(x => x.name === g)
+    if (!gr) throw new Error(`unable to find group ${g}: no matching entries in group file`)
+    gid = gr.gid
+  }
+  return { uid, gid, name: pw ? pw.name : null, home: pw ? pw.home : null }
+}

package/src/net/dhcp-dns.js

@@ -0,0 +1,126 @@
+// P-B10: the guest-facing DHCP server (one static lease, as the engine's netstack gives)
+// and DNS message parsing/encoding (queries are answered through the relay, stack.js).
+
+import { rd16, rd32, wr16, wr32 } from './packet.js'
+
+const MAGIC = 0x63825363
+export const DHCP = { DISCOVER: 1, OFFER: 2, REQUEST: 3, DECLINE: 4, ACK: 5, NAK: 6, RELEASE: 7, INFORM: 8 }
+
+/** Parse a BOOTP/DHCP request; null if it is not one. */
+export function parseDhcp(p) {
+  if (p.length < 240 || p[0] !== 1 || p[1] !== 1 || p[2] !== 6 || rd32(p, 236) !== MAGIC) return null
+  const m = { xid: rd32(p, 4), flags: rd16(p, 10), ciaddr: rd32(p, 12), chaddr: p.slice(28, 34), type: 0, requested: 0 }
+  for (let i = 240; i < p.length; ) {
+    const code = p[i]
+    if (code === 255) break
+    if (code === 0) {
+      i++
+      continue
+    }
+    const len = p[i + 1]
+    if (i + 2 + len > p.length) break
+    if (code === 53 && len === 1) m.type = p[i + 2]
+    else if (code === 50 && len === 4) m.requested = rd32(p, i + 2)
+    i += 2 + len
+  }
+  return m
+}
+
+/** A DHCP reply (OFFER/ACK) giving `ip` with the router and DNS server at `gw`. */
+export function dhcpReply(req, type, { ip, gw, mask, leaseS = 86400, mtu = 0 }) {
+  const opts = [
+    [53, [type]],
+    [54, u32b(gw)],
+    [51, u32b(leaseS)],
+    [58, u32b(Math.floor(leaseS / 2))],
+    [59, u32b(Math.floor((leaseS * 7) / 8))],
+    [1, u32b(mask)],
+    [3, u32b(gw)],
+    [6, u32b(gw)],
+    [28, u32b((ip & mask) | (~mask >>> 0))],
+  ]
+  if (mtu) opts.push([26, [mtu >> 8, mtu & 255]])
+  const olen = opts.reduce((s, [, v]) => s + 2 + v.length, 0) + 1
+  const p = new Uint8Array(Math.max(300, 240 + olen))
+  p[0] = 2
+  p[1] = 1
+  p[2] = 6
+  wr32(p, 4, req.xid)
+  wr16(p, 10, req.flags)
+  if (type !== DHCP.NAK && req.type !== DHCP.INFORM) wr32(p, 16, ip)
+  if (req.type === DHCP.INFORM) wr32(p, 12, req.ciaddr)
+  wr32(p, 20, gw)
+  p.set(req.chaddr, 28)
+  wr32(p, 236, MAGIC)
+  let o = 240
+  for (const [c, v] of opts) {
+    p[o++] = c
+    p[o++] = v.length
+    for (const x of v) p[o++] = x
+  }
+  p[o] = 255
+  return p
+}
+
+function u32b(v) {
+  return [(v >>> 24) & 255, (v >>> 16) & 255, (v >>> 8) & 255, v & 255]
+}
+
+export const QTYPE = { A: 1, AAAA: 28 }
+export const RC = { NOERROR: 0, FORMERR: 1, SERVFAIL: 2, NXDOMAIN: 3, NOTIMP: 4, REFUSED: 5 }
+
+/** Parse a DNS query with one question; null if malformed. */
+export function parseDnsQuery(p) {
+  if (p.length < 12) return null
+  const id = rd16(p, 0)
+  const flags = rd16(p, 2)
+  if (flags & 0x8000) return null // a response
+  const qd = rd16(p, 4)
+  const q = { id, flags, opcode: (flags >> 11) & 15, rd: !!(flags & 0x100), qdcount: qd, name: '', qtype: 0, qclass: 0, qend: 12 }
+  if (qd !== 1) return q
+  const labels = []
+  let i = 12
+  for (;;) {
+    if (i >= p.length) return null
+    const len = p[i]
+    if (len === 0) {
+      i++
+      break
+    }
+    if (len > 63) return null // compression is not used in a question
+    if (i + 1 + len > p.length) return null
+    labels.push(String.fromCharCode(...p.subarray(i + 1, i + 1 + len)))
+    i += 1 + len
+    if (i - 12 > 255) return null
+  }
+  if (i + 4 > p.length) return null
+  q.name = labels.join('.')
+  q.qtype = rd16(p, i)
+  q.qclass = rd16(p, i + 2)
+  q.qend = i + 4
+  return q
+}
+
+/** A response to query q (the request bytes p): rcode and A/AAAA answers (byte arrays). */
+export function dnsResponse(p, q, rcode, answers = [], ttl = 60) {
+  const question = q.qdcount === 1 ? p.subarray(12, q.qend) : new Uint8Array(0)
+  const alen = answers.reduce((s, a) => s + 12 + a.length, 0)
+  const r = new Uint8Array(12 + question.length + alen)
+  wr16(r, 0, q.id)
+  // QR, the opcode, RD copied, RA; AA off
+  wr16(r, 2, 0x8000 | (q.opcode << 11) | (q.rd ? 0x100 : 0) | 0x80 | (rcode & 15))
+  wr16(r, 4, q.qdcount === 1 ? 1 : 0)
+  wr16(r, 6, answers.length)
+  r.set(question, 12)
+  let o = 12 + question.length
+  for (const a of answers) {
+    wr16(r, o, 0xc00c) // the name in the question
+    wr16(r, o + 2, a.length === 16 ? QTYPE.AAAA : QTYPE.A)
+    wr16(r, o + 4, 1)
+    wr32(r, o + 6, ttl)
+    wr16(r, o + 10, a.length)
+    r.set(a, o + 12)
+    o += 12 + a.length
+  }
+  return r
+}