@threadedstack/wmd-web 0.1.18 → 0.1.20

package/src/net/stack.js

@@ -57,6 +57,22 @@ const HALF_OPEN_IDLE_MS = 10 * 60_000
 const SYNACK_GIVE_UP_MS = 60_000 // Linux: tcp_synack_retries (5), about 63 s
 const GUEST_CLOSED_IDLE_MS = 120_000 // the guest's FIN is in, the remote says nothing: its kernel forgot it (FIN_WAIT2, 60 s)
 const MAX_PENDING = 32 // handshakes not finished at once (more get a RST), so abandoned ones cannot take every relay slot
+// D-551: npm's CDN ends (FIN) a connection whose TLS handshake is not done 15 s after the connect, and the relay
+// connects when the guest's SYN comes. A slow guest (WebKit) can miss that before its ClientHello. A remote that
+// ends a connection nothing has crossed, REDIAL_MIN_MS or more after it opened, is dialled once more instead.
+const REDIAL_MIN_MS = 5_000
+// D-552: a guest that runs many TLS handshakes at once (pnpm opens 16) splits its CPU among them, and in a slow guest
+// (WebKit) none ends inside npm's 15 s. At most TLS_HANDSHAKES run at once: a ClientHello waits here for its turn, then
+// goes out on a stream dialled again when the one it has is TLS_FRESH_MS old. A remote that ends a stream before it
+// answers the ClientHello gets the hello once more on a new stream. A handshake holds its turn at most TLS_TURN_MS.
+const TLS_HANDSHAKES = 4
+const TLS_FRESH_MS = 3_000
+const TLS_TURN_MS = 20_000
+const TLS_HELLO_MAX = 16 << 10 // bytes kept for a replay
+const T_NONE = 0 // no guest bytes yet
+const T_WAIT = 1 // a ClientHello waits for a turn
+const T_TURN = 2 // the handshake has a turn
+const T_DONE = 3 // past the handshake, or not TLS
 const INTERNAL_ZONE = 'wmd.internal'
 
 const P_CONNECTING = 1 // waiting for the relay's CONNECTED
@@ -122,6 +138,14 @@ class Conn {
     this.lastRemote = 0 // the last data or end from the relay
     this.bytesIn = 0 // guest -> relay
     this.bytesOut = 0 // relay -> guest
+    this.redialAt = 0 // D-551: when the stream was dialled again (0: not); its answer is pending while redialing
+    this.redialing = false
+    this.dialAt = 0 // when the relay stream the guest's bytes go to connected
+    this.tls = T_NONE // D-552
+    this.tlsAt = 0 // when the handshake got its turn
+    this.hello = null // the guest's bytes sent before the remote answered (a replay sends them again)
+    this.helloBytes = 0
+    this.helloReplayed = false
   }
   inflight() {
     return seqDiff(this.sndNxt, this.sndUna)
@@ -154,6 +178,9 @@ export class NetStack {
     this.peers = o.peers || null // W56: the switch's guests (peer.js)
     this.now = o.now || (() => performance.now())
     this.maxConns = o.maxConns ?? 256
+    this.tlsMax = o.tlsHandshakes ?? TLS_HANDSHAKES
+    this.tlsTurns = new Set() // D-552: handshakes with a turn
+    this.tlsWait = [] // and those waiting for one, oldest first
     this.log = o.log || (() => {})
     this.conns = new Map() // key -> Conn
     this.byId = new Map() // relay stream id -> Conn
@@ -473,6 +500,7 @@ export class NetStack {
   /** The relay's answer to a connect. */
   onConnected(id, code, credit, detail) {
     const c = this.byId.get(id)
+    if (c?.redialing) return this.#redialed(c, code, credit, detail)
     if (!c || c.phase !== P_CONNECTING) {
       if (!c && code === E.OK) this.relay.abort(id) // a connect that came back after we gave up on it
       return
@@ -494,7 +522,7 @@ export class NetStack {
     if (this.stats.connectMs.length > 100) this.stats.connectMs.shift()
     c.relayCredit = credit
     c.phase = P_SYNACK
-    c.synAckAt = this.now()
+    c.synAckAt = c.dialAt = this.now()
     c.sndNxt = seqAdd(c.iss, 1)
     this.#synAck(c)
   }
@@ -615,6 +643,8 @@ export class NetStack {
 
   /** Send held guest bytes to the relay as credit allows, in messages of up to MAX_DATA (one per segment cost a WebSocket message each). */
   #flushToRelay(c) {
+    if (c.redialing) return // D-551: the new stream has no answer yet; #redialed flushes
+    if (c.tls !== T_DONE && c.via === this.relay && !this.#tlsGate(c)) return
     while (c.toRelay.length && c.relayCredit > 0) {
       const n = Math.min(c.toRelayBytes, c.relayCredit, MAX_DATA)
       let part
@@ -637,6 +667,13 @@ export class NetStack {
       }
       c.toRelayBytes -= n
       c.relayCredit -= n
+      if (c.tls === T_TURN && !c.bytesOut && c.hello) {
+        // past the cap the hello is not kept at all (a replay with a gap would be garbage)
+        if (c.helloBytes + n <= TLS_HELLO_MAX) {
+          c.hello.push(part.slice())
+          c.helloBytes += n
+        } else c.hello = null
+      }
       c.via.data(c.id, part)
     }
     if (c.guestFin && !c.toRelay.length && !c.relayEndSent) {
@@ -676,16 +713,119 @@ export class NetStack {
   onRelayEnd(id) {
     const c = this.byId.get(id)
     if (!c) return
+    if (this.#redial(c) || this.#tlsReplay(c)) return
     c.remoteEnd = true
     c.lastRemote = this.now()
     this.wantsSend.add(c)
     this.#trySend(c)
   }
 
+  /** D-551: the remote ended a stream nothing has crossed, a while after it opened: dial it again, once, and say nothing to the guest. False when it does not qualify. */
+  #redial(c) {
+    if (c.redialAt || c.via !== this.relay || c.phase !== P_OPEN || c.bytesOut || c.bytesIn - c.toRelayBytes || c.guestFin) return false
+    if (this.now() - c.dialAt < REDIAL_MIN_MS) return false
+    this.stats.redials = (this.stats.redials || 0) + 1
+    this.#dialAgain(c, 'ended unused')
+    return true
+  }
+
+  /** A new relay stream for c, the old one aborted; the guest hears nothing. Its bytes wait in toRelay until #redialed. */
+  #dialAgain(c, why) {
+    this.relay.abort(c.id)
+    this.byId.delete(c.id)
+    c.id = this.nextId++
+    this.byId.set(c.id, c)
+    c.relayCredit = 0
+    c.redialing = true
+    c.redialAt = this.now()
+    this.#event({ ev: 'redial', why, to: `${u32ToIp(c.rip)}:${c.rport}`, afterMs: Math.round(c.redialAt - c.dialAt) })
+    this.relay.connect(c.id, u32ToIp(c.rip), c.rport)
+  }
+
+  /** D-552: may the guest's bytes go to the relay now? Sorts a stream's first bytes into TLS or not, and holds a ClientHello until it has a turn. */
+  #tlsGate(c) {
+    if (c.tls === T_TURN) {
+      // the guest's bytes after the server's first flight end its part of the handshake
+      if (c.bytesOut && c.toRelayBytes) this.#tlsDone(c)
+      return true
+    }
+    if (c.tls === T_WAIT) return false
+    if (!c.toRelayBytes) return true
+    const h = c.toRelay[0]
+    if (c.bytesOut || h[0] !== 0x16 || (h.length > 1 && h[1] !== 0x03)) {
+      c.tls = T_DONE // the remote spoke first, or not a TLS handshake record
+      return true
+    }
+    if (this.tlsTurns.size >= this.tlsMax) {
+      c.tls = T_WAIT
+      this.tlsWait.push(c)
+      this.stats.tlsWaits = (this.stats.tlsWaits || 0) + 1
+      return false
+    }
+    return this.#tlsStart(c)
+  }
+
+  /** The handshake gets a turn. False when its stream is dialled again first (#redialed sends the hello). */
+  #tlsStart(c) {
+    c.tls = T_TURN
+    c.tlsAt = this.now()
+    c.hello = []
+    c.helloBytes = 0
+    this.tlsTurns.add(c)
+    if (!c.redialing && c.phase === P_OPEN && c.bytesIn === c.toRelayBytes && this.now() - c.dialAt >= TLS_FRESH_MS) {
+      this.stats.tlsFresh = (this.stats.tlsFresh || 0) + 1
+      this.#dialAgain(c, 'fresh for a ClientHello')
+      return false
+    }
+    return true
+  }
+
+  #tlsDone(c) {
+    c.tls = T_DONE
+    c.hello = null
+    if (this.tlsTurns.delete(c)) this.#tlsNext()
+  }
+
+  /** Turns free: the oldest waiting hellos go. */
+  #tlsNext() {
+    while (this.tlsTurns.size < this.tlsMax && this.tlsWait.length) {
+      const c = this.tlsWait.shift()
+      if (c.tls !== T_WAIT || this.conns.get(c.key) !== c) continue // closed, or its 4-tuple reused by a new connection
+      if (this.#tlsStart(c)) this.#flushToRelay(c)
+    }
+  }
+
+  /** D-552: the remote ended or reset a stream before it answered the guest's ClientHello: send the hello once more on a new stream. */
+  #tlsReplay(c) {
+    if (c.tls !== T_TURN || c.bytesOut || c.helloReplayed || !c.hello || !c.helloBytes || c.guestFin || c.via !== this.relay) return false
+    c.helloReplayed = true
+    c.toRelay.unshift(...c.hello)
+    c.toRelayBytes += c.helloBytes
+    c.hello = []
+    c.helloBytes = 0
+    this.stats.tlsReplays = (this.stats.tlsReplays || 0) + 1
+    this.#dialAgain(c, 'replay the ClientHello')
+    return true
+  }
+
+  #redialed(c, code, credit, detail) {
+    c.redialing = false
+    if (code !== E.OK) return this.#close(c, `redial: ${E_NAMES[code] || code}${detail ? ` (${detail})` : ''}`, false)
+    c.dialAt = this.now()
+    c.relayCredit = credit
+    this.#flushToRelay(c)
+    if (this.#rcvWnd(c) > c.lastWndSent) {
+      c.needAck = true
+      this.acks.add(c)
+    }
+  }
+
   onRelayAbort(id, code, reason) {
     const c = this.byId.get(id)
     if (!c) return
+    if (c.redialing) return this.#redialed(c, code || E.GONE, 0, reason)
     if (c.phase === P_CONNECTING) return this.onConnected(id, code || E.GONE, 0, reason)
+    if (this.#tlsReplay(c)) return
     this.#event({ ev: 'abort', to: `${u32ToIp(c.rip)}:${c.rport}`, why: E_NAMES[code] || code, reason })
     this.#close(c, `relay: ${E_NAMES[code] || code} ${reason || ''}`.trim(), false)
   }
@@ -765,6 +905,12 @@ export class NetStack {
     this.byId.delete(c.id)
     this.wantsSend.delete(c)
     this.acks.delete(c)
+    if (c.tls === T_TURN) this.#tlsDone(c)
+    else if (c.tls === T_WAIT) {
+      c.tls = T_DONE
+      const i = this.tlsWait.indexOf(c)
+      if (i >= 0) this.tlsWait.splice(i, 1)
+    }
   }
 
   /** After a batch of input: one ACK per connection that needs one. */
@@ -782,6 +928,12 @@ export class NetStack {
   tick() {
     const t = this.now()
     for (const c of [...this.conns.values()]) {
+      if (c.redialing && t - c.redialAt > CONNECT_TIMEOUT_MS) {
+        this.relay.abort(c.id)
+        this.#redialed(c, E.TIMEOUT, 0, 'no answer from the relay')
+        continue
+      }
+      if (c.tls === T_TURN && t - c.tlsAt > TLS_TURN_MS) this.#tlsDone(c) // a slow handshake goes on without its turn
       if (c.phase === P_CONNECTING) {
         if (t - c.openedAt > CONNECT_TIMEOUT_MS) {
           c.via.abort(c.id)

package/src/registry/load-tar.js

@@ -11,6 +11,7 @@
 // copy is the layer handed to the converter Worker); a Blob is read one entry at a time, so the whole tar is
 // never in memory at once.
 
+import { blobBytes } from '../blob.js'
 import { createConverter } from './converter.js'
 import { RegistryError, sha256 } from './hub.js'
 import { CONVERTER } from './pull.js'
@@ -126,7 +127,7 @@ function source(input) {
   if (input instanceof Uint8Array) return { size: input.length, read: async (off, len) => input.subarray(off, off + len) }
   if (input instanceof ArrayBuffer) return source(new Uint8Array(input))
   if (typeof Blob !== 'undefined' && input instanceof Blob) {
-    return { size: input.size, read: async (off, len) => new Uint8Array(await input.slice(off, off + len).arrayBuffer()) }
+    return { size: input.size, read: (off, len) => blobBytes(input.slice(off, off + len)) }
   }
   throw new TypeError('loadImageTar: the tar as a Uint8Array, ArrayBuffer or Blob')
 }