@amritk/nish-x86_64-linux 0.17.0 → 0.20.0

package/std/net/http3.ts

@@ -86,9 +86,11 @@
  * **No server push.** It never sends PUSH_PROMISE; a client's MAX_PUSH_ID is
  * allowed, checked and ignored.
  *
- * **Caps are start-up numbers**, all in `Http3Config`, and every buffer is
- * made by the constructor: the stream state for every QUIC stream slot, the
- * field section, the body chunk and the control frame. A field section's
+ * **Caps are start-up numbers**, all in `Http3Config`. The stream state for
+ * every QUIC stream slot and the control frame are made by the constructor;
+ * the body chunk and the field section are borrowed, around one read, from
+ * pools that a server's connections share (`share`) and that a standalone
+ * connection keeps one buffer each of. A field section's
  * names and values are copied into arrays the connection keeps, which grow to
  * the largest section seen and are then reused, so a warm connection
  * allocates nothing per request (`docs/security/http3.md`, H3-2). A peer's
@@ -121,6 +123,13 @@
  * Private helpers share the importing program's flat symbol namespace
  * (`docs/wp26-stdlib.md` §3e), which is why each one carries the module's name.
  *
+ * **The Date.** A response carries the `date` in `conn.date`, 29 bytes of
+ * IMF-fixdate, right after `:status`, unless the program's fields hold their
+ * own; trailers carry none. It counts against the peer's
+ * SETTINGS_MAX_FIELD_SECTION_SIZE. A bare connection has no clock, so `date`
+ * starts empty and nothing is sent; `Http3Server` fills it from its
+ * `HttpDate` (RFC 9110 §6.6.1).
+ *
  * Written from RFC 9114 and RFC 9204, not ported from another implementation.
  */
 import {
@@ -191,8 +200,9 @@ import {
   h3VarintLength,
 } from "nish/net/http3-frame"
 import { QUIC_STATE_CONNECTED, QuicConnection } from "nish/net/quic"
-import { QUIC_STREAM_END, QUIC_STREAM_ERR_RESET, QuicStream } from "nish/net/quic-stream"
+import { QUIC_STREAM_END, QUIC_STREAM_ERR_RESET, QuicStream, quicStreamGrowFree } from "nish/net/quic-stream"
 import { quicVarintPut } from "nish/net/quic-packet"
+import { BufferPool } from "nish/net/buffer-pool"
 
 /** The ALPN protocol identifier of HTTP/3 (RFC 9114 §3.1). */
 export const H3_ALPN: string = "h3"
@@ -344,6 +354,21 @@ const http3CheckCap = (what: string, value: i32, low: i32, high: i32): void => {
   }
 }
 
+/** Whether one of `names` is `date` in any ASCII case (RFC 9110 §5.1). */
+const http3NamesHoldDate = (names: u8[][]): boolean => {
+  // An ASCII letter's case is its 0x20 bit, and every octet of `date` is a letter.
+  const bit: i32 = 32
+  for (const name of names) {
+    if (toI32(name.length) === 4) {
+      const d: boolean = (toI32(name[0]) | bit) === 100 && (toI32(name[1]) | bit) === 97
+      if (d && (toI32(name[2]) | bit) === 116 && (toI32(name[3]) | bit) === 101) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
 /** Empties `bytes`, keeping its storage for the next fill. */
 const http3Empty = (bytes: u8[]): void => {
   while (toI32(bytes.length) > 0) {
@@ -381,10 +406,20 @@ export class Http3Connection {
   /** The client's SETTINGS. */
   peer: Http3Settings
   header: Http3FrameHeader
-  /** H3_DATA's bytes, and where a payload being skipped is read to. */
+  /**
+   * H3_DATA's bytes, and where a payload being skipped is read to: a
+   * `bodyChunk`-byte buffer borrowed from `dataPool` for the read that needs
+   * it and held while an H3_DATA window is live, else `none`.
+   */
   data: u8[]
-  /** A HEADERS payload read whole, for the decoder. */
+  /** A HEADERS payload read whole, for the decoder: a buffer borrowed from `sectionPool` around one read and decode, else `none`. */
   section: u8[]
+  /** The empty array `data` and `section` are while they hold nothing borrowed. */
+  none: u8[]
+  /** Where `data` is borrowed from: the connection's own pool until `share` hands it its server's. */
+  dataPool: BufferPool
+  /** Where `section` is borrowed from, likewise. */
+  sectionPool: BufferPool
   /** A control frame's payload, read whole. */
   control: u8[]
   /** Frame headers, SETTINGS and GOAWAY on their way out. */
@@ -400,6 +435,15 @@ export class Http3Connection {
   valueList: u8[][]
   statusName: u8[]
   statusValue: u8[]
+  /**
+   * The `date` every response carries (RFC 9110 §6.6.1), as the 29 bytes of
+   * an IMF-fixdate, or empty for none. A bare connection has no clock, so it
+   * starts empty; `Http3Server` points it at its `HttpDate`'s bytes, which
+   * that rewrites in place once a second.
+   */
+  date: u8[]
+  /** The bytes of `date`, the field's name, made once. */
+  dateName: u8[]
   /** The SETTINGS this side sends. */
   settingIds: i64[]
   settingValues: i64[]
@@ -460,6 +504,8 @@ export class Http3Connection {
   dataLength: i32 = 0
   /** How much of `control` is filled. */
   controlFill: i32 = 0
+  /** How far into the borrowed `data` reads have written: what its give-back zeroes. */
+  dataUsed: i32 = 0
   state: i32 = 0
   /** Requests open: taken and not yet finished both ways. */
   live: i32 = 0
@@ -523,8 +569,13 @@ export class Http3Connection {
     this.fields = new HttpFields()
     this.peer = new Http3Settings()
     this.header = new Http3FrameHeader()
-    this.data = new Array<u8>(config.bodyChunk)
-    this.section = new Array<u8>(config.maxFieldSectionSize)
+    this.none = []
+    this.data = this.none
+    this.section = this.none
+    this.dataPool = new BufferPool("Http3Connection.data", config.bodyChunk, 1)
+    this.sectionPool = new BufferPool("Http3Connection.section", config.maxFieldSectionSize, 1)
+    quicStreamGrowFree(this.dataPool.free, 1, this.none)
+    quicStreamGrowFree(this.sectionPool.free, 1, this.none)
     this.control = new Array<u8>(H3_CONTROL_FRAME_MAX)
     this.scratch = new Array<u8>(64)
     this.zeros = new Array<u8>(256)
@@ -539,6 +590,8 @@ export class Http3Connection {
     this.valueList = []
     this.statusName = httpFieldBytes(":status")
     this.statusValue = [48, 48, 48]
+    this.date = []
+    this.dateName = httpFieldBytes("date")
     this.settingIds = [
       H3_SETTINGS_QPACK_MAX_TABLE_CAPACITY,
       H3_SETTINGS_QPACK_BLOCKED_STREAMS,
@@ -580,9 +633,11 @@ export class Http3Connection {
   /**
    * Puts the connection back as the constructor left it, for the QUIC
    * connection's next peer (call it after `quic.reset`): no stream known,
-   * QPACK's state and the client's SETTINGS forgotten. It allocates nothing.
+   * QPACK's state and the client's SETTINGS forgotten, and any buffer
+   * still borrowed given back. It allocates nothing.
    */
   restart(): void {
+    this.giveBack()
     this.slotId.fill(H3_NONE)
     this.flags.fill(H3_ZERO)
     this.headLen.fill(H3_ZERO)
@@ -713,6 +768,89 @@ export class Http3Connection {
    * connection takes, until it answers H3_NEED_MORE or H3_ERROR.
    */
   next(): i32 {
+    // The last H3_DATA window ends here. A body read chunk by chunk keeps the
+    // one buffer; any other event, H3_NEED_MORE among them, gives it back.
+    const event: i32 = this.nextEvent()
+    if (event !== H3_DATA) {
+      this.giveData()
+    }
+    return event
+  }
+
+  /**
+   * Lends this connection its server's pools in place of its own, giving
+   * back to the old pools whatever it holds. Panics unless their buffers are
+   * `bodyChunk` and `maxFieldSectionSize` bytes long, as this connection's
+   * reads need.
+   */
+  share(data: BufferPool, section: BufferPool): void {
+    if (data.size !== this.config.bodyChunk || section.size !== this.config.maxFieldSectionSize) {
+      panic(
+        `Http3Connection: pools of ${data.size} and ${section.size} bytes shared with a connection of bodyChunk ${this.config.bodyChunk} and maxFieldSectionSize ${this.config.maxFieldSectionSize}`
+      )
+    }
+    this.giveBack()
+    this.dataPool = data
+    this.sectionPool = section
+  }
+
+  /** Releases the QUIC connection (`QuicConnection.release`) and gives back every pooled buffer this connection holds. */
+  release(): void {
+    this.quic.release()
+    this.giveBack()
+  }
+
+  /** Gives back `data` and `section` if either is borrowed: the connection holds no pooled buffer after it. */
+  giveBack(): void {
+    this.giveData()
+    this.giveSection(H3_ZERO)
+  }
+
+  /** `data`, borrowed from `dataPool` first if it is not already. */
+  borrowData(): u8[] {
+    if (this.data.length === 0) {
+      this.data = this.dataPool.take()
+      this.dataUsed = 0
+    }
+    return this.data
+  }
+
+  /** Gives `data` back to `dataPool`, zeroed as far as reads wrote, if it is borrowed. */
+  giveData(): void {
+    if (this.data.length > 0) {
+      this.dataPool.give(this.data, this.dataUsed)
+      this.data = this.none
+      this.dataUsed = 0
+    }
+  }
+
+  /** Reads up to `want` bytes of stream `id` into the start of `data`, borrowed for it: `streamRead`'s answer. */
+  readData(id: i64, want: i32): i32 {
+    const n: i32 = this.quic.streamRead(id, this.borrowData(), H3_ZERO, want)
+    if (n > this.dataUsed) {
+      this.dataUsed = n
+    }
+    return n
+  }
+
+  /** `section`, borrowed from `sectionPool`. */
+  borrowSection(): u8[] {
+    if (this.section.length === 0) {
+      this.section = this.sectionPool.take()
+    }
+    return this.section
+  }
+
+  /** Gives `section` back to `sectionPool`, zeroed over `[0, used)`, if it is borrowed. */
+  giveSection(used: i32): void {
+    if (this.section.length > 0) {
+      this.sectionPool.give(this.section, used)
+      this.section = this.none
+    }
+  }
+
+  /** `next`'s work: everything but the lending of `data` around it. */
+  nextEvent(): i32 {
     if (this.state === H3_STATE_FAILED) {
       return H3_ERROR
     }
@@ -924,7 +1062,7 @@ export class Http3Connection {
       } else if (phase === H3_PHASE_CONTROL) {
         return this.controlStep(k, id)
       } else if (phase === H3_PHASE_ENCODER || phase === H3_PHASE_DECODER) {
-        const n: i32 = this.quic.streamRead(id, this.data, H3_ZERO, toI32(this.data.length))
+        const n: i32 = this.readData(id, this.config.bodyChunk)
         if (n === 0) {
           return H3_NEED_MORE
         }
@@ -1027,10 +1165,12 @@ export class Http3Connection {
         this.controlFill = 0
       }
       if (this.frameLeft[k] > 0) {
-        const into: u8[] = this.frameType[k] === H3_SKIP_TYPE ? this.data : this.control
-        const at: i32 = this.frameType[k] === H3_SKIP_TYPE ? H3_ZERO : this.controlFill
-        const want: i32 = toI32(http3Min(this.frameLeft[k], toI64(toI32(into.length) - at)))
-        const n: i32 = this.quic.streamRead(id, into, at, want)
+        const skip: boolean = this.frameType[k] === H3_SKIP_TYPE
+        const room: i32 = skip ? this.config.bodyChunk : toI32(this.control.length) - this.controlFill
+        const want: i32 = toI32(http3Min(this.frameLeft[k], toI64(room)))
+        const n: i32 = skip
+          ? this.readData(id, want)
+          : this.quic.streamRead(id, this.control, this.controlFill, want)
         if (n === 0) {
           return H3_NEED_MORE
         }
@@ -1118,9 +1258,9 @@ export class Http3Connection {
 
   /** Reads stream `id` into `data` until nothing more is there; answers 0, or the `QUIC_STREAM_*` that ended it. */
   drop(id: i64): i32 {
-    let n: i32 = this.quic.streamRead(id, this.data, H3_ZERO, toI32(this.data.length))
+    let n: i32 = this.readData(id, this.config.bodyChunk)
     while (n > 0) {
-      n = this.quic.streamRead(id, this.data, H3_ZERO, toI32(this.data.length))
+      n = this.readData(id, this.config.bodyChunk)
     }
     return n
   }
@@ -1189,7 +1329,7 @@ export class Http3Connection {
     if (phase === H3_PHASE_WT) {
       if ((this.flags[k] & H3_FLAG_RECV_DONE) === 0) {
         const resetCode: i64 = stream.resetCode
-        const n: i32 = this.quic.streamRead(id, this.data, H3_ZERO, toI32(this.data.length))
+        const n: i32 = this.readData(id, this.config.bodyChunk)
         if (n > 0) {
           this.stream = id
           this.dataStart = 0
@@ -1421,24 +1561,28 @@ export class Http3Connection {
           return this.writable(k, id)
         }
         const length: i32 = toI32(this.frameLeft[k])
-        const n: i32 = this.quic.streamRead(id, this.section, H3_ZERO, length)
+        const n: i32 = this.quic.streamRead(id, this.borrowSection(), H3_ZERO, length)
         if (n < 0) {
+          this.giveSection(H3_ZERO)
           return this.ended(k, id, n, stream.resetCode)
         }
         if (n !== length) {
+          this.giveSection(n)
           return this.writable(k, id)
         }
         this.frameLeft[k] = -1
+        // `fieldSection` copies what it keeps into `fields`: the section is not read after it.
         const event: i32 = this.fieldSection(k, id, length)
+        this.giveSection(length)
         if (event !== H3_NEED_MORE) {
           return event
         }
         continue
       }
       // DATA, a payload being skipped, or an unknown frame's.
-      const want: i32 = toI32(http3Min(this.frameLeft[k], toI64(toI32(this.data.length))))
+      const want: i32 = toI32(http3Min(this.frameLeft[k], toI64(this.config.bodyChunk)))
       const resetCode: i64 = stream.resetCode
-      const n: i32 = this.quic.streamRead(id, this.data, H3_ZERO, want)
+      const n: i32 = this.readData(id, want)
       if (n === 0) {
         return this.writable(k, id)
       }
@@ -1711,13 +1855,19 @@ export class Http3Connection {
   /**
    * A request whose field section is past `maxFieldSectionSize`: answered
    * with a 431 and its stream asked to stop with H3_NO_ERROR (§4.2.2,
-   * §4.1.2). The program never sees it.
+   * §4.1.2). The program never sees it. A peer whose own
+   * SETTINGS_MAX_FIELD_SECTION_SIZE has room for a bare 431 but not for one
+   * with the date gets it without the date rather than a reset.
    */
   answerTooLarge(k: i32, id: i64): i32 {
     this.tooLarge = h3Count(this.tooLarge)
     const empty: u8[][] = this.nameList
     http3EmptyList(empty)
-    if (this.writeHead(k, id, H3_STATUS_TOO_LARGE, empty, empty, true) !== 0) {
+    let r: i32 = this.writeHead(k, id, H3_STATUS_TOO_LARGE, empty, empty, true, true)
+    if (r === H3_TOO_LARGE) {
+      r = this.writeHead(k, id, H3_STATUS_TOO_LARGE, empty, empty, true, false)
+    }
+    if (r !== 0) {
       this.abandon(k, id, H3_EXCESSIVE_LOAD)
     }
     this.quic.streamStopSending(id, H3_NO_ERROR)
@@ -1833,11 +1983,14 @@ export class Http3Connection {
   }
 
   /**
-   * Encodes `:status` (unless it is 0, for trailers) and `names`/`values` into a HEADERS
-   * frame and writes it whole to stream `id`, with the FIN when `fin`.
-   * Answers 0, H3_AGAIN, or H3_TOO_LARGE.
+   * Encodes `:status` (unless it is 0, for trailers), the server's `date`
+   * for a final status when `dated` unless `names` holds one, and
+   * `names`/`values` into a HEADERS frame and writes it whole to stream `id`,
+   * with the FIN when `fin`. The date counts against the peer's
+   * SETTINGS_MAX_FIELD_SECTION_SIZE as any field does. Answers 0, H3_AGAIN,
+   * or H3_TOO_LARGE.
    */
-  writeHead(k: i32, id: i64, status: i32, names: u8[][], values: u8[][], fin: boolean): i32 {
+  writeHead(k: i32, id: i64, status: i32, names: u8[][], values: u8[][], fin: boolean, dated: boolean): i32 {
     const out: u8[] = this.encoded
     http3Empty(out)
     this.encoder.beginSection(out)
@@ -1862,6 +2015,12 @@ export class Http3Connection {
       )
       size = toI64(nameLength + valueLength + QPACK_FIELD_OVERHEAD)
     }
+    if (dated && status >= 200 && toI32(this.date.length) > 0 && !http3NamesHoldDate(names)) {
+      const nl: i32 = toI32(this.dateName.length)
+      const vl: i32 = toI32(this.date.length)
+      this.encoder.encodeField(out, this.dateName, H3_ZERO, nl, this.date, H3_ZERO, vl, false, true)
+      size = size + toI64(nl + vl + QPACK_FIELD_OVERHEAD)
+    }
     const n: i32 = toI32(names.length)
     for (let j: i32 = 0; j < n && j < toI32(names.length) && j < toI32(values.length); j++) {
       const name: u8[] = names[j]
@@ -1922,7 +2081,7 @@ export class Http3Connection {
     ) {
       return H3_INVALID
     }
-    return this.writeHead(k, id, status, names, values, endStream)
+    return this.writeHead(k, id, status, names, values, endStream, true)
   }
 
   /**
@@ -1942,7 +2101,7 @@ export class Http3Connection {
     ) {
       return H3_INVALID
     }
-    return this.writeHead(k, id, H3_ZERO, names, values, true)
+    return this.writeHead(k, id, H3_ZERO, names, values, true, false)
   }
 
   /**