@amritk/nish-x86_64-linux 0.17.0 → 0.20.0

package/std/net/http1.ts

@@ -67,6 +67,9 @@
  * header section with the framing field the body needs, and `http1Chunk` and
  * `http1LastChunk` for a chunked body. It refuses (`null`) anything that would
  * let a caller's string end a line early — the response-splitting shape.
+ * `http1WriteResponseHead` writes the same head into a caller's buffer with
+ * nothing allocated, and adds a `Date` field from the bytes it is given
+ * (`httpDateWrite` in `nish/net/http-fields` makes them) to a final response.
  *
  * Field names are kept in lowercase, the form RFC 9110 §5.1 says they compare
  * in and the form HTTP/2 sends them in. Strings in the language are bytes, so a
@@ -1410,11 +1413,16 @@ const http1PutDecimal = (out: u8[], at: i32, n: i32): i32 => {
  * `http1ResponseHead`'s status line and header section, written into `out`
  * at `at` with nothing allocated: field names and values are octets (as
  * `nish/net/http-fields` holds them), and `connection`, when not empty, is
- * sent as a `Connection` field after the caller's. Answers where the head
- * ends; `HTTP1_REFUSED` for everything `http1ResponseHead` refuses, a
- * `Connection` among the caller's fields when `connection` is given, and a
- * `connection` that is not field text; `HTTP1_NO_ROOM` when it is well formed
- * but does not fit. Either way `out` is untouched.
+ * sent as a `Connection` field after the caller's. `date`, when not empty, is
+ * sent as a `Date` field between the caller's fields and the framing ones
+ * (RFC 9110 §6.6.1), on a final status only, and not when the caller's fields
+ * already hold a `date` in any case: the caller's wins, so a response carries
+ * one. Answers where the head ends; `HTTP1_REFUSED` for everything
+ * `http1ResponseHead` refuses, a `Connection` among the caller's fields when
+ * `connection` is given, a `connection` that is not field text, and a `date`
+ * that is not field text on a final status, the only one it is sent on;
+ * `HTTP1_NO_ROOM` when it is well formed but does not fit, the `Date` line
+ * counted when it is sent. Either way `out` is untouched.
  */
 export const http1WriteResponseHead = (
   out: u8[],
@@ -1424,11 +1432,15 @@ export const http1WriteResponseHead = (
   names: u8[][],
   values: u8[][],
   bodyLength: i32,
-  connection: string
+  connection: string,
+  date: u8[]
 ): i32 => {
   if (status < 100 || status > 599 || !http1IsFieldText(reason) || !http1IsFieldText(connection)) {
     return HTTP1_REFUSED
   }
+  if (status >= 200 && !http1BytesAreFieldText(date)) {
+    return HTTP1_REFUSED
+  }
   if (bodyLength < HTTP1_NO_BODY || ((status < 200 || status === 204) && bodyLength !== HTTP1_NO_BODY)) {
     return HTTP1_REFUSED
   }
@@ -1440,6 +1452,7 @@ export const http1WriteResponseHead = (
   // field, the connection field and the empty line: counted before anything
   // is written, in 64 bits so that no caller's lengths can wrap the sum.
   let need: i64 = toI64(17) + toI64(reason.length)
+  let sendDate: boolean = status >= 200 && toI32(date.length) > 0
   for (let i: i32 = 0; i < count && i < toI32(values.length); i += 1) {
     const name: u8[] = names[i]
     const value: u8[] = values[i]
@@ -1452,8 +1465,15 @@ export const http1WriteResponseHead = (
     if (toI32(connection.length) > 0 && http1BytesAre(name, "connection")) {
       return HTTP1_REFUSED
     }
+    if (http1BytesAre(name, "date")) {
+      sendDate = false
+    }
     need = need + toI64(name.length) + toI64(value.length) + toI64(4)
   }
+  if (sendDate) {
+    // "Date: " value CRLF: 37 bytes for an IMF-fixdate.
+    need = need + toI64(8) + toI64(date.length)
+  }
   if (bodyLength >= 0) {
     need = need + toI64(18 + http1DecimalDigits(bodyLength))
   } else if (bodyLength === HTTP1_CHUNKED) {
@@ -1476,6 +1496,11 @@ export const http1WriteResponseHead = (
     end = http1PutBytes(out, end, values[i])
     end = http1PutText(out, end, "\r\n")
   }
+  if (sendDate) {
+    end = http1PutText(out, end, "Date: ")
+    end = http1PutBytes(out, end, date)
+    end = http1PutText(out, end, "\r\n")
+  }
   if (bodyLength >= 0) {
     end = http1PutText(out, end, "Content-Length: ")
     end = http1PutDecimal(out, end, bodyLength)

package/std/net/http2-tls.ts

@@ -1,7 +1,9 @@
 /**
  * `nish/net/http2-tls` — HTTP/2 over TLS 1.3 on TCP: a pool of
  * `Http2Connection`s, one beside each slot of a `TlsTcpServer`, for a
- * program that owns its readiness loop.
+ * program that owns its readiness loop. Slot 0's connection is built with the
+ * server, so a bad `Http2Config` is refused there; every other slot's is built
+ * on the first accept into it.
  *
  *     const listener = tcpListen("0.0.0.0", 8443, 128);
  *     const server = new Http2TlsServer(tlsConfig, new Http2Config(), listener, 64);
@@ -36,16 +38,35 @@
  * configuration offers `h2` (and may offer `http/1.1` beside it, for a
  * program that serves both and calls `alpn(slot)` itself).
  *
- * **Slots, sized at start-up.** The constructor makes every connection and
- * the TLS pool beside them; `accept` resets the slot's connection, and
- * nothing a connection does after that allocates but a header block's HPACK
- * decoding (`docs/security/http2.md`, H2-1). The caps are the
- * `Http2Config`'s, one for every slot, so a program sets them once.
+ * **Slots, a cap; buffers, borrowed.** The constructor makes the TLS pool
+ * and slot 0's connection, but no other slot's and no frame buffer: a slot's
+ * connection is made by the first `accept` into it and kept, so a pool sized
+ * for its peak costs at start-up only what does not depend on the size, and
+ * holds at most `size` connections once the peak has come. A connection
+ * borrows its input, output and header-block buffers from the
+ * server's `Http2Pools` when it first needs each, and gives each back once it
+ * is empty and when the slot closes, so a free or idle slot holds none. A
+ * slot whose handshake is not done holds one output buffer, its SETTINGS
+ * written and waiting on TLS, until the handshake ends or the slot closes:
+ * one client that stalls its handshake keeps one buffer, as it kept a whole
+ * slot before (`docs/security/tls.md`, TLS-4). Each pool's ceiling is the
+ * slot count, so a borrow never fails. `accept` resets
+ * the slot's connection, and once the pools are warm nothing a connection
+ * does allocates but a header block's HPACK decoding (`docs/security/http2.md`,
+ * H2-1). The caps are the `Http2Config`'s, one for every slot, so a program
+ * sets them once.
+ *
+ * **The Date.** Every final response carries one `date` field (RFC 9110
+ * §6.6.1) from the pool's `HttpDate`, which formats the IMF-fixdate at most
+ * once a second for every slot; a 1xx and trailers carry none, and a program
+ * that sends its own `date` sends that one instead. `server.date.pin(unixMs)`
+ * fixes it, for a test that compares bytes.
  *
  * Written from RFC 9113 §3 and §9.2, not ported from another implementation.
  */
 import { Secret } from "nish:secret"
-import { H2_ERROR, H2_NEED_MORE, Http2Config, Http2Connection } from "nish/net/http2"
+import { HttpDate } from "nish/net/http1-server"
+import { H2_ERROR, H2_NEED_MORE, Http2Config, Http2Connection, Http2Pools } from "nish/net/http2"
 import { TlsServerConfig } from "nish/net/tls"
 import { TLS_RECORD_DONE, TLS_RECORD_STATE_OPEN, TLS_RECORD_WANT_WRITE } from "nish/net/tls/record-server"
 import { TlsTcpServer } from "nish/net/tls-tcp"
@@ -62,22 +83,57 @@ export const H2_ALPN: string = "h2"
  */
 export class Http2TlsServer {
   tls: TlsTcpServer
+  /** The caps every slot's connection is made under. */
+  config: Http2Config
+  /**
+   * The connections made so far, slot `k`'s at `k`: slot 0's, made by the
+   * constructor, and one for each slot accepted into since.
+   */
   connections: Http2Connection[]
+  /**
+   * The `date` every slot's responses carry, formatted once a second for all
+   * of them: each slot's `Http2Connection.date` is its bytes, refreshed by
+   * `connection` and `next`. `date.pin` fixes its clock.
+   */
+  date: HttpDate
+  /** The frame buffers every slot's connection borrows: one of each per slot at most, none made up front. */
+  readonly pools: Http2Pools
 
   /**
    * A pool of `size` slots, at least one, serving HTTP/2 under `config` over
-   * TLS under `tlsConfig` on `listener`. Every slot's buffers are allocated
-   * here.
+   * TLS under `tlsConfig` on `listener`. Only slot 0's connection is made
+   * here, so a config it refuses panics now, with its words; every other
+   * slot's is made by the first `accept` into it and kept. Frame buffers are
+   * borrowed from `pools` as a connection needs them.
    */
   constructor(tlsConfig: TlsServerConfig, config: Http2Config, listener: i32, size: i32) {
     this.tls = new TlsTcpServer(tlsConfig, listener, size)
+    this.config = config
     this.connections = []
-    for (let k: i32 = 0; k < this.tls.size(); k++) {
-      this.connections.push(new Http2Connection(config))
-    }
+    this.date = new HttpDate()
+    // Formatted once now, so no slot ever sends the bytes before a first format.
+    const first: Http2Connection = new Http2Connection(config)
+    first.date = this.date.current()
+    this.connections.push(first)
+    // After slot 0's connection, so a config it refuses panics with its words.
+    this.pools = new Http2Pools("Http2TlsServer", config, this.tls.size())
+    first.pools = this.pools
   }
 
-  /** How many slots the pool has. */
+  /** Makes the next slot's connection, on this pool's buffers and `date`. */
+  build(): void {
+    const conn: Http2Connection = new Http2Connection(this.config)
+    conn.date = this.date.current()
+    conn.pools = this.pools
+    this.connections.push(conn)
+  }
+
+  /** Whether `slot` holds a connection and its HTTP/2 side has been made. */
+  live(slot: i32): boolean {
+    return this.tls.holds(slot) && slot < toI32(this.connections.length)
+  }
+
+  /** How many slots the pool has, made or not. */
   size(): i32 {
     return this.tls.size()
   }
@@ -97,8 +153,12 @@ export class Http2TlsServer {
     return this.tls.fd(slot)
   }
 
-  /** The HTTP/2 connection of `slot`; a slot out of range names the first. */
+  /**
+   * The HTTP/2 connection of `slot`, its `date` brought up to now. A slot
+   * never accepted into, or out of range, names slot 0's, which may be live.
+   */
   connection(slot: i32): Http2Connection {
+    this.date.current()
     const at: i32 = slot >= 0 && slot < toI32(this.connections.length) ? slot : H2_TLS_ZERO
     return this.connections[at]
   }
@@ -111,33 +171,46 @@ export class Http2TlsServer {
   /**
    * Accepts the next waiting connection into a free slot, as
    * `TlsTcpServer.accept` does, and gives it a fresh HTTP/2 connection whose
-   * SETTINGS go out once the handshake is done. Answers the slot, or what
-   * `TlsTcpServer.accept` answers.
+   * SETTINGS go out once the handshake is done: the slot's own, restarted,
+   * or one made now if this is the first accept into it. Answers the slot,
+   * or what `TlsTcpServer.accept` answers.
    */
   accept(serverRandom: u8[], ephemeralPrivate: u8[]): i32 {
     const slot: i32 = this.tls.accept(serverRandom, ephemeralPrivate)
-    if (slot >= 0 && slot < toI32(this.connections.length)) {
-      this.connections[slot].restart()
+    if (slot < 0 || slot >= this.tls.size()) {
+      return slot
+    }
+    // `TlsTcpServer` hands out its lowest slots first, so this makes one
+    // connection, unless a program accepted on `tls` itself.
+    while (toI32(this.connections.length) <= slot) {
+      this.build()
     }
+    this.connections[slot].restart()
     return slot
   }
 
   /** The socket of `slot` is readable: TLS reads it, and what HTTP/2 has to send goes after. Answers the interest. */
   readable(slot: i32): i32 {
     this.tls.readable(slot)
-    return this.flush(slot)
+    const wants: i32 = this.flush(slot)
+    this.rest(slot)
+    return wants
   }
 
   /** The socket of `slot` is writable. Answers the interest. */
   writable(slot: i32): i32 {
     this.tls.writable(slot)
-    return this.flush(slot)
+    const wants: i32 = this.flush(slot)
+    this.rest(slot)
+    return wants
   }
 
   /** Signs `slot`'s CertificateVerify with `key`, as `TlsTcpServer.signP256` does. Answers the interest. */
   signP256(slot: i32, key: Secret<u8[]>): i32 {
     this.tls.signP256(slot, key)
-    return this.flush(slot)
+    const wants: i32 = this.flush(slot)
+    this.rest(slot)
+    return wants
   }
 
   /** Whether `slot`'s handshake is done and chose anything but `h2`. */
@@ -151,9 +224,10 @@ export class Http2TlsServer {
    * slot, or one whose ALPN was not `h2`, answers `H2_ERROR`.
    */
   next(slot: i32): i32 {
-    if (!this.holds(slot) || this.refused(slot)) {
+    if (!this.live(slot) || this.refused(slot)) {
       return H2_ERROR
     }
+    this.date.current()
     const conn: Http2Connection = this.connections[slot]
     // TLS decrypts straight into the connection's input, so a byte is
     // copied once on its way in.
@@ -177,6 +251,7 @@ export class Http2TlsServer {
     // the program's own `flush` after the loop.
     if (event === H2_NEED_MORE || event === H2_ERROR) {
       this.flush(slot)
+      this.rest(slot)
     }
     return event
   }
@@ -188,7 +263,7 @@ export class Http2TlsServer {
    * with the write bit while the connection still holds bytes.
    */
   flush(slot: i32): i32 {
-    if (!this.holds(slot)) {
+    if (!this.live(slot)) {
       return TLS_RECORD_DONE
     }
     if (this.refused(slot)) {
@@ -209,8 +284,21 @@ export class Http2TlsServer {
     return conn.wantsWrite() && (wants & TLS_RECORD_DONE) === 0 ? wants | TLS_RECORD_WANT_WRITE : wants
   }
 
-  /** Ends `slot`'s connection and frees the slot at once, as `TlsTcpServer.close` does. */
+  /**
+   * Ends `slot`'s connection and frees the slot at once, as
+   * `TlsTcpServer.close` does; the connection gives back every buffer it holds.
+   */
   close(slot: i32): void {
+    if (slot >= 0 && slot < toI32(this.connections.length)) {
+      this.connections[slot].drop()
+    }
     this.tls.close(slot)
   }
+
+  /** Gives back the buffers `slot`'s connection holds and has emptied, so an idle slot holds none. */
+  rest(slot: i32): void {
+    if (slot >= 0 && slot < toI32(this.connections.length)) {
+      this.connections[slot].rest()
+    }
+  }
 }