@amritk/nish-x86_64-linux 0.20.0 → 0.22.1

package/std/net/http1.ts

@@ -80,6 +80,7 @@
  *
  * Written from RFC 9112 and RFC 9110, not ported from another implementation.
  */
+import { copyBytes } from "nish/bytes"
 
 /** `next()`: the input so far holds no further event; feed more. */
 export const HTTP1_NEED_MORE: i32 = 0
@@ -234,11 +235,15 @@ export class Http1Parser {
     this.maxHeaderBytes = http1Clamp(maxHeaderBytes)
     this.maxHeaders = http1Clamp(maxHeaders)
     this.maxBody = http1Clamp(maxBody)
-    this.buf = new Array<u8>(1024)
+    // The input and the head are made by the first byte fed and the first
+    // head kept, at HTTP1_FIRST_INPUT and HTTP1_FIRST_HEAD bytes: a parser
+    // that is built and never fed (a pool's spare slot) costs neither, and a
+    // caller that lends them out between requests puts empty ones here.
+    this.buf = []
     this.body = this.buf
     this.names = []
     this.values = []
-    this.head = new Array<u8>(256)
+    this.head = []
     this.spans = new Array<i32>(64)
     this.tally = new Http1ListTally()
     this.restart()
@@ -261,19 +266,9 @@ export class Http1Parser {
     http1Reserve(this, len)
     const buf: u8[] = this.buf
     const at: i32 = this.end
-    // A whole array is one `set`, a memmove; a window is copied byte by byte,
-    // because `set` takes no window of its source.
-    if (off === 0 && len === size) {
-      buf.set(data, at)
-      this.end = at + len
-      return
-    }
-    for (let k: i32 = 0; k < len; k += 1) {
-      const to: i32 = at + k
-      if (to >= 0 && to < toI32(buf.length)) {
-        buf[to] = data[off + k]
-      }
-    }
+    // One move: http1Reserve made room for `len` bytes at `at`, and the
+    // window was checked above.
+    copyBytes(buf, at, data, off, len)
     this.end = at + len
   }
 
@@ -359,6 +354,16 @@ export class Http1Parser {
     return http1HeadIs(this.head, spans[4 * found + 2], spans[4 * found + 3], protocol, true)
   }
 
+  /**
+   * Whether the parser waits for a request line with nothing fed and unread,
+   * so its input and head buffers hold nothing it needs: a caller may lend
+   * them out and leave empty arrays in `buf`, `body` and `head`, which the
+   * next feed and head make or the caller puts back first.
+   */
+  resting(): boolean {
+    return this.state === HTTP1_S_REQUEST_LINE && this.end === this.start
+  }
+
   /** How many bytes were fed and not consumed yet: what a caller bounds its reads by. */
   buffered(): i32 {
     return this.end - this.start
@@ -410,6 +415,11 @@ export class Http1Parser {
   }
 }
 
+/** The input buffer a parser makes on its first feed, the smallest it grows from. */
+export const HTTP1_FIRST_INPUT: i32 = 1024
+/** The head buffer a parser makes for its first head. */
+export const HTTP1_FIRST_HEAD: i32 = 256
+
 /** Makes room for `len` more bytes at `p.end`, moving the live bytes down first. */
 const http1Reserve = (p: Http1Parser, len: i32): void => {
   const old: u8[] = p.buf
@@ -418,7 +428,7 @@ const http1Reserve = (p: Http1Parser, len: i32): void => {
     return
   }
   const live: i32 = p.end - p.start
-  let size: i32 = capacity
+  let size: i32 = capacity < HTTP1_FIRST_INPUT ? HTTP1_FIRST_INPUT : capacity
   while (size - live < len) {
     if (size > 1073741823) {
       panic("Http1Parser: more than 2^31 - 1 bytes buffered")
@@ -429,8 +439,9 @@ const http1Reserve = (p: Http1Parser, len: i32): void => {
   // the live bytes move to the front, and every index into them moves too.
   const buf: u8[] = size === capacity ? old : new Array<u8>(size)
   const from: i32 = p.start
-  for (let k: i32 = 0; k < live && k < toI32(buf.length); k += 1) {
-    buf[k] = old[from + k]
+  if (live > 0) {
+    // One move, overlapping when the buffer is the same one.
+    copyBytes(buf, 0, old, from, live)
   }
   p.buf = buf
   p.lineStart -= from
@@ -601,6 +612,9 @@ const http1HeadAppend = (p: Http1Parser, from: i32, to: i32): i32 => {
   const at: i32 = p.headLength
   let size: i32 = toI32(p.head.length)
   if (n > size - at) {
+    if (size < HTTP1_FIRST_HEAD) {
+      size = HTTP1_FIRST_HEAD
+    }
     while (size - at < n) {
       if (size > 1073741823) {
         panic("Http1Parser: a head of more than 2^31 - 1 bytes")
@@ -616,9 +630,14 @@ const http1HeadAppend = (p: Http1Parser, from: i32, to: i32): i32 => {
   }
   const head: u8[] = p.head
   const buf: u8[] = p.buf
-  for (let k: i32 = 0; k < n && at + k < toI32(head.length) && from + k < toI32(buf.length); k += 1) {
-    if (from + k >= 0) {
-      head[at + k] = buf[from + k]
+  if (n > 0 && from >= 0 && from <= toI32(buf.length) - n && at <= toI32(head.length) - n) {
+    // The line lies in `buf` and the head was grown to hold it: one move.
+    copyBytes(head, at, buf, from, n)
+  } else {
+    for (let k: i32 = 0; k < n && at + k < toI32(head.length) && from + k < toI32(buf.length); k += 1) {
+      if (from + k >= 0) {
+        head[at + k] = buf[from + k]
+      }
     }
   }
   p.headLength = at + n

package/std/net/http3-server.ts

@@ -41,6 +41,14 @@
  * **Sending.** `flush` writes each touched slot's datagrams with
  * `quicListenerTakeFlight`, a paced flight at a time in one `udpSendTo` with
  * GSO where the platform has it and one datagram at a time where it does not.
+ * Each flight goes with the ECN codepoint its connection marked it with
+ * (`QuicFlight.ecn`, RFC 9000 §13.4), so the peer's ACK_ECN counts are
+ * validated and a CE mark shrinks the window. Where the platform sends no
+ * ECN (Darwin, whose `udpSendTo` answers -95 to a marked send), the first
+ * marked send goes again unmarked and no slot marks after it. A -95 is also
+ * what a platform without segmentation offload answers, so a refused GSO
+ * send goes again one datagram at a time, still marked, and only a -95 to
+ * one of those turns marking off.
  * The pacer counts the microseconds `clock` gives it, so on a path whose
  * round trip is under a millisecond it neither waits for the next
  * millisecond to earn credit nor holds a slot back for a whole one; without
@@ -122,8 +130,8 @@ export const H3_SERVER_ANSWER_INTERVAL: i64 = 100
 /** The address form `nish:net` reads and writes. */
 const H3_SERVER_ADDRESS: i32 = 18
 
-/** What `udpSendTo` answers where the platform has no segmentation offload. */
-const H3_SERVER_NO_GSO: i32 = -95
+/** What `udpSendTo` answers where the platform has no segmentation offload, or sends no ECN. */
+const H3_SERVER_UNSUPPORTED: i32 = -95
 
 /** The largest datagram read: a GRO receive of up to 64 KB. */
 const H3_SERVER_RECEIVE_SIZE: i32 = 65536
@@ -484,6 +492,8 @@ export class Http3Server {
   refused: i32 = 0
   limited: i32 = 0
   sendErrors: i32 = 0
+  /** Whether the platform sends ECN marks: true until a marked send answers -95, and every slot's `ecnMarking` with it. */
+  ecn: boolean = true
   /**
    * The stream buffers every slot's connection borrows from, made by the
    * constructor for the stream table `quicConfig` gives every slot: `null`
@@ -578,6 +588,7 @@ export class Http3Server {
   build(): void {
     crypto.getRandomValues(this.entropy)
     const quic = new QuicConnection(this.quicConfig, this.entropy)
+    quic.ecnMarking = this.ecn
     this.quics.push(quic)
     const pools: QuicStreamPools | null = this.streamPools
     if (pools !== null && pools.data.size === quic.streams.bufferSize && quic.streams.slots.length > 0) {
@@ -751,7 +762,7 @@ export class Http3Server {
     if (this.listener.handleWindow(buf, at, len, address, now, answer) !== QUIC_LISTEN_ACCEPT) {
       const reply: i32 = toI32(answer.reply.length)
       if (reply > 0) {
-        this.send(answer.reply, H3_SERVER_ZERO, reply, address, H3_SERVER_ZERO)
+        this.send(answer.reply, H3_SERVER_ZERO, reply, address, H3_SERVER_ZERO, H3_SERVER_ZERO)
       }
       return
     }
@@ -904,21 +915,40 @@ export class Http3Server {
     }
   }
 
-  /** Sends `buf[at .. at + len)` to `to`, cut into `segment`-byte datagrams when it is above 0; answers whether it went. */
-  send(buf: u8[], at: i32, len: i32, to: u8[], segment: i32): boolean {
-    const sent: i32 = udpSendTo(this.fd, buf, at, len, to, segment, H3_SERVER_ZERO)
+  /**
+   * Sends `buf[at .. at + len)` to `to` with the ECN codepoint `ecn`, cut
+   * into `segment`-byte datagrams when it is above 0; answers whether it went.
+   */
+  send(buf: u8[], at: i32, len: i32, to: u8[], segment: i32, ecn: i32): boolean {
+    const sent: i32 = udpSendTo(this.fd, buf, at, len, to, segment, ecn)
     if (sent >= 0) {
       return true
     }
-    if (sent !== H3_SERVER_NO_GSO || segment <= 0) {
+    if (sent !== H3_SERVER_UNSUPPORTED || (segment <= 0 && ecn === 0)) {
       this.sendErrors = h3Count(this.sendErrors)
       return false
     }
-    // No segmentation offload here: one datagram at a time.
+    // -95: no segmentation offload, or no ECN, or both. One datagram at a
+    // time, still marked: a -95 to a datagram with no segment is the mark's.
+    let mark: i32 = ecn
+    if (segment <= 0) {
+      this.unmark()
+      mark = H3_SERVER_ZERO
+    }
+    const step: i32 = segment > 0 ? segment : len
     let p: i32 = at
     while (p < at + len) {
-      const n: i32 = at + len - p < segment ? at + len - p : segment
-      if (udpSendTo(this.fd, buf, p, n, to, H3_SERVER_ZERO, H3_SERVER_ZERO) < 0) {
+      const n: i32 = at + len - p < step ? at + len - p : step
+      let one: i32 = udpSendTo(this.fd, buf, p, n, to, H3_SERVER_ZERO, mark)
+      if (one === H3_SERVER_UNSUPPORTED && mark !== 0) {
+        // No ECN here: this datagram and the rest go unmarked and no slot
+        // marks again. The packets just counted as marked fail their
+        // connection's validation.
+        this.unmark()
+        mark = H3_SERVER_ZERO
+        one = udpSendTo(this.fd, buf, p, n, to, H3_SERVER_ZERO, mark)
+      }
+      if (one < 0) {
         this.sendErrors = h3Count(this.sendErrors)
         return false
       }
@@ -927,6 +957,14 @@ export class Http3Server {
     return true
   }
 
+  /** The platform sends no ECN: no slot's connection marks from now on. */
+  unmark(): void {
+    this.ecn = false
+    for (let slot: i32 = 0; slot < toI32(this.quics.length); slot++) {
+      this.quics[slot].ecnMarking = false
+    }
+  }
+
   /**
    * Sends what every touched slot has, as far as its pacer lets it, closes a
    * slot whose HTTP/3 side is done after GOAWAY, frees a slot whose
@@ -972,7 +1010,7 @@ export class Http3Server {
         break
       }
       const segment: i32 = this.flight.count > 1 ? this.flight.segment : H3_SERVER_ZERO
-      if (!this.send(this.tx, H3_SERVER_ZERO, n, to, segment)) {
+      if (!this.send(this.tx, H3_SERVER_ZERO, n, to, segment, this.flight.ecn)) {
         break
       }
       retried = false
@@ -981,7 +1019,7 @@ export class Http3Server {
       // The CONNECTION_CLOSE goes whatever the pacer says: nothing follows it.
       const n: i32 = quic.takeDatagramInto(this.tx, H3_SERVER_ZERO, now)
       if (n > 0) {
-        this.send(this.tx, H3_SERVER_ZERO, n, to, H3_SERVER_ZERO)
+        this.send(this.tx, H3_SERVER_ZERO, n, to, H3_SERVER_ZERO, quic.datagramEcn)
       }
       this.release(slot)
       return