@amritk/nish-x86_64-linux 0.27.2 → 0.29.0

package/std/net/http1-client.ts

@@ -10,7 +10,10 @@
  * with nothing allocated. A chunked body is written with `http1Chunk` and
  * `http1LastChunk` from `nish/net/http1`. The writer refuses anything that
  * would let a caller's string end a line early or frame the body itself — the
- * request-splitting and request-smuggling shapes.
+ * request-splitting and request-smuggling shapes. `http1UpgradeRequestHead`
+ * is the one way to ask the server to switch protocols: it writes `Upgrade`
+ * and `Connection: Upgrade` itself, and every other writer refuses a
+ * `Connection` that lists `upgrade`.
  *
  * **The parser** is a push-pull machine, like the server's. A caller tells it
  * what it asked (`expect`), `feed`s whatever slice the socket gave it, cut
@@ -34,10 +37,11 @@
  * final one follows), `HTTP1_HEAD` (the final response's status line and
  * header section are in), `HTTP1_BODY` (some body bytes, de-chunked),
  * `HTTP1_END` (the response is complete; with `keepAlive()` the next one
- * follows), `HTTP1_UPGRADE` (a CONNECT was answered with 2xx and the
- * connection is a tunnel now: `tunnelBytes()` answers what was fed past the
- * head), `HTTP1_CLOSED` (the connection is done: the server closed it
- * between responses, or the last response was not kept alive) and
+ * follows), `HTTP1_UPGRADE` (a CONNECT was answered with 2xx, or a request
+ * that `expectUpgrade` named was answered with 101, and the connection is a
+ * tunnel now: `tunnelBytes()` answers what was fed past the head),
+ * `HTTP1_CLOSED` (the connection is done: the server closed it between
+ * responses, or the last response was not kept alive) and
  * `HTTP1_ERROR`. The last three repeat on every later call. Only complete
  * lines are acted on, body bytes are counted, never guessed, and every
  * refusal is decided by the same byte wherever the input was cut, so the
@@ -55,7 +59,7 @@
  * **What it refuses**, each with its own code in `error`: a malformed status
  * line, an HTTP major version other than 1, a bare LF, a malformed field line
  * (an obs-fold, whitespace before the colon, a control byte in a value), a 101
- * (this client never asks to switch protocols), `Transfer-Encoding` together
+ * to a request that did not ask to switch protocols, `Transfer-Encoding` together
  * with `Content-Length`, a transfer coding other than one `chunked` or one in
  * an HTTP/1.0 response, a `Content-Length` that is not a decimal or whose
  * repeats disagree, a malformed chunk, a status line, header section, field
@@ -112,7 +116,7 @@ export const HTTP1_E_VERSION: i32 = 2
 export const HTTP1_E_BARE_LF: i32 = 3
 /** `error`: a malformed field line: an obs-fold, a bad name, whitespace before the colon, a control byte. */
 export const HTTP1_E_FIELD: i32 = 4
-/** `error`: a 101, which this client never asks for. */
+/** `error`: a 101 to a request that did not ask to switch protocols (see `expectUpgrade`). */
 export const HTTP1_E_SWITCH: i32 = 5
 /** `error`: both `Transfer-Encoding` and `Content-Length` (RFC 9112 §6.1). */
 export const HTTP1_E_FRAMING: i32 = 6
@@ -290,11 +294,16 @@ const http1ClientRequestNeed = (
   target: string,
   names: string[],
   values: string[],
-  bodyLength: i64
+  bodyLength: i64,
+  upgrade: string
 ): i64 => {
   if (!http1IsToken(method) || !http1ClientTargetOk(method, target)) {
     return toI64(-1)
   }
+  const upgrading: boolean = toI32(upgrade.length) > 0
+  if (upgrading && (!http1IsToken(upgrade) || bodyLength !== toI64(-2))) {
+    return toI64(-1)
+  }
   if (bodyLength < toI64(-2)) {
     return toI64(-1)
   }
@@ -319,7 +328,13 @@ const http1ClientRequestNeed = (
     ) {
       return toI64(-1)
     }
-    if (http1SameWord(name, 0, nameLength, "connection") && http1ClientListHas(value, "upgrade")) {
+    if (
+      http1SameWord(name, 0, nameLength, "connection") &&
+      (upgrading || http1ClientListHas(value, "upgrade"))
+    ) {
+      return toI64(-1)
+    }
+    if (upgrading && http1SameWord(name, 0, nameLength, "upgrade")) {
       return toI64(-1)
     }
     if (http1SameWord(name, 0, nameLength, "host")) {
@@ -335,6 +350,10 @@ const http1ClientRequestNeed = (
   } else if (bodyLength === toI64(-1)) {
     need = need + toI64(28)
   }
+  if (upgrading) {
+    // "Upgrade: " value CRLF "Connection: Upgrade" CRLF
+    need = need + toI64(upgrade.length) + toI64(32)
+  }
   return need
 }
 
@@ -364,9 +383,9 @@ const http1ClientPutField = (out: u8[], at: i32, names: string[], values: string
  * early and let the rest be read as a field or a second request); `names` and
  * `values` of different lengths; not exactly one `Host`; a `Content-Length` or
  * `Transfer-Encoding` among the caller's fields, since the framing is decided
- * here; a `Connection` that lists `upgrade`, which the parser refuses the
- * answer to; and a `bodyLength` below -2. Answers `HTTP1_NO_ROOM` when it is
- * well formed but does not fit. Either way `out` is untouched.
+ * here; a `Connection` that lists `upgrade`, which only
+ * `http1UpgradeRequestHead` may write; and a `bodyLength` below -2. Answers
+ * `HTTP1_NO_ROOM` when it is well formed but does not fit. Either way `out` is untouched.
  */
 export const http1WriteRequestHead = (
   out: u8[],
@@ -377,14 +396,14 @@ export const http1WriteRequestHead = (
   values: string[],
   bodyLength: i64
 ): i32 => {
-  const need: i64 = http1ClientRequestNeed(method, target, names, values, bodyLength)
+  const need: i64 = http1ClientRequestNeed(method, target, names, values, bodyLength, "")
   if (need < toI64(0)) {
     return HTTP1_REFUSED
   }
   if (at < 0 || need > toI64(toI32(out.length) - at)) {
     return HTTP1_NO_ROOM
   }
-  return http1ClientPutHead(out, at, method, target, names, values, bodyLength)
+  return http1ClientPutHead(out, at, method, target, names, values, bodyLength, "")
 }
 
 /** Writes a head `http1ClientRequestNeed` accepted into room it counted; answers the end. */
@@ -395,7 +414,8 @@ const http1ClientPutHead = (
   target: string,
   names: string[],
   values: string[],
-  bodyLength: i64
+  bodyLength: i64,
+  upgrade: string
 ): i32 => {
   let end: i32 = http1PutText(out, at, method)
   end = http1PutText(out, end, " ")
@@ -419,6 +439,11 @@ const http1ClientPutHead = (
   } else if (bodyLength === toI64(-1)) {
     end = http1PutText(out, end, "Transfer-Encoding: chunked\r\n")
   }
+  if (toI32(upgrade.length) > 0) {
+    end = http1PutText(out, end, "Upgrade: ")
+    end = http1PutText(out, end, upgrade)
+    end = http1PutText(out, end, "\r\nConnection: Upgrade\r\n")
+  }
   return http1PutText(out, end, "\r\n")
 }
 
@@ -432,13 +457,46 @@ export const http1RequestHead = (
   names: string[],
   values: string[],
   bodyLength: i64
+): u8[] | null => http1ClientHeadArray(method, target, names, values, bodyLength, "")
+
+/**
+ * A request that asks the server to switch the connection to `upgrade` (RFC
+ * 9110 §7.8), such as a WebSocket opening handshake: `http1RequestHead`'s head
+ * with no body, and `Upgrade: <upgrade>` and `Connection: Upgrade` written
+ * after the caller's fields. Answers `null` for everything `http1RequestHead`
+ * refuses, an `upgrade` that is not one token, and an `Upgrade` or
+ * `Connection` among the caller's fields, which would contradict the two this
+ * writes. A response to it is read after `expect(false, false)` and then
+ * `expectUpgrade()`, so that its 101 answers `HTTP1_UPGRADE`.
+ */
+export const http1UpgradeRequestHead = (
+  method: string,
+  target: string,
+  names: string[],
+  values: string[],
+  upgrade: string
 ): u8[] | null => {
-  const need: i64 = http1ClientRequestNeed(method, target, names, values, bodyLength)
+  if (toI32(upgrade.length) === 0) {
+    return null
+  }
+  return http1ClientHeadArray(method, target, names, values, toI64(-2), upgrade)
+}
+
+/** The head `http1ClientRequestNeed` accepts in an array of its own, or `null`. */
+const http1ClientHeadArray = (
+  method: string,
+  target: string,
+  names: string[],
+  values: string[],
+  bodyLength: i64,
+  upgrade: string
+): u8[] | null => {
+  const need: i64 = http1ClientRequestNeed(method, target, names, values, bodyLength, upgrade)
   if (need < toI64(0) || need > toI64(1073741824)) {
     return null
   }
   const out: u8[] = new Array<u8>(toI32(need))
-  http1ClientPutHead(out, 0, method, target, names, values, bodyLength)
+  http1ClientPutHead(out, 0, method, target, names, values, bodyLength, upgrade)
   return out
 }
 
@@ -533,6 +591,8 @@ export class Http1ResponseParser {
   /** What `expect` said of the request this response answers. */
   wasHead: boolean = false
   wasConnect: boolean = false
+  /** Whether `expectUpgrade` said the request asked to switch protocols. */
+  wasUpgrade: boolean = false
   /** Whether `finish()` said the server closed the connection. */
   closed: boolean = false
 
@@ -567,6 +627,24 @@ export class Http1ResponseParser {
     if (this.state === HTTP1_CLIENT_S_STATUS_LINE && this.informational === 0) {
       this.wasHead = methodWasHead
       this.wasConnect = wasConnect
+      this.wasUpgrade = false
+    }
+  }
+
+  /**
+   * Says the request this response answers asked to switch protocols (it was
+   * written by `http1UpgradeRequestHead`), so a 101 is that switch: the parser
+   * answers `HTTP1_HEAD` with its status and fields readable, `HTTP1_END`, and
+   * then `HTTP1_UPGRADE`, and `tunnelBytes()` answers what was fed past the
+   * head. Any other status is read as it would be without it. It is said after
+   * `expect`, which clears it, and like `expect` it takes effect only while the
+   * parser waits for a response's first status line. Without it a 101 is
+   * refused with `HTTP1_E_SWITCH`: a server may not switch a connection whose
+   * client never asked.
+   */
+  expectUpgrade(): void {
+    if (this.state === HTTP1_CLIENT_S_STATUS_LINE && this.informational === 0) {
+      this.wasUpgrade = true
     }
   }
 
@@ -949,7 +1027,13 @@ const http1ClientConnectionHas = (p: Http1ResponseParser, word: string): boolean
 const http1ClientEndOfHead = (p: Http1ResponseParser): i32 => {
   const status: i32 = p.status
   if (status === 101) {
-    return http1ClientFail(p, HTTP1_E_SWITCH, "a 101 Switching Protocols this client never asks for")
+    if (!p.wasUpgrade) {
+      return http1ClientFail(p, HTTP1_E_SWITCH, "a 101 Switching Protocols the request did not ask for")
+    }
+    // RFC 9110 §15.2.2: the connection switches right after the 101's empty
+    // line, so what follows the head is the new protocol's.
+    p.state = HTTP1_CLIENT_S_MESSAGE_END
+    return HTTP1_HEAD
   }
   if (status < 200) {
     if (p.informational >= HTTP1_MAX_INFORMATIONAL) {
@@ -1203,7 +1287,7 @@ const http1ClientNext = (p: Http1ResponseParser): i32 => {
         break
       }
       case HTTP1_CLIENT_S_MESSAGE_END: {
-        if (p.wasConnect && p.status < 300) {
+        if ((p.wasConnect && p.status < 300) || (p.wasUpgrade && p.status === 101)) {
           p.state = HTTP1_CLIENT_S_TUNNEL
         } else if (!p.persistent) {
           p.state = HTTP1_CLIENT_S_CLOSED
@@ -1213,6 +1297,7 @@ const http1ClientNext = (p: Http1ResponseParser): i32 => {
           p.informational = 0
           p.wasHead = false
           p.wasConnect = false
+          p.wasUpgrade = false
         }
         return HTTP1_END
       }

package/std/net/http1-server.ts

@@ -115,12 +115,15 @@
 import { Secret } from "nish:secret"
 import { copyBytes } from "nish/bytes"
 import {
+  HTTP_CODING_GZIP,
   HTTP_CODING_IDENTITY,
+  HTTP_CODING_NONE,
+  HTTP_DEFAULT_MSS,
   HTTP_OFFER_GZIP,
   HttpCompressor,
   httpAcceptEncoding,
 } from "nish/net/http-compress"
-import { netClose, netRead, netWrite, tcpAccept } from "nish:net"
+import { netClose, netMss, netRead, netWrite, tcpAccept } from "nish:net"
 import {
   HTTP1_BODY,
   HTTP1_CHUNKED,
@@ -491,7 +494,11 @@ export class Http1Connection {
    * put another, to share it or to pin its clock.
    */
   date: HttpDate
-  /** The request parser: its head (`methodIs`, `targetIs`, `header`, spans) is the last `H1_REQUEST`'s. */
+  /**
+   * The request parser: its head (`methodIs`, `targetIs`, `header`, spans) is
+   * the current request's from its `H1_REQUEST` until its response is done,
+   * `H1_END` included, however much of a pipelined request is fed behind it.
+   */
   parser: Http1Parser
   /**
    * The frame decoder: made when the slot first switches to WebSocket, so a
@@ -559,6 +566,15 @@ export class Http1Connection {
   inputEnded: boolean = false
   /** A head has begun to arrive and is not read whole yet: `headSince` is its deadline's start. */
   headTimed: boolean = false
+  /**
+   * The TCP maximum segment size the program sets for this connection, for
+   * `respondEncoded` under `HttpCompressor.segmentMode`; 0, the default,
+   * leaves it to the compressor and the socket (`segmentMss`). Each accept
+   * puts it back to 0.
+   */
+  mss: i32 = 0
+  /** The MSS `Http1Server.accept` read from this connection's socket (`netMss`), or 0 when it reports none. */
+  socketMss: i32 = 0
 
   /** A connection under `config`. A cap outside what the connection can work with panics. */
   constructor(config: Http1Config) {
@@ -642,6 +658,8 @@ export class Http1Connection {
     this.inputEnded = false
     this.headTimed = false
     this.headSince = 0
+    this.mss = 0
+    this.socketMss = 0
     this.release()
     this.park()
   }
@@ -1218,9 +1236,23 @@ export class Http1Connection {
    * `Accept-Encoding` with gzip offered (`httpAcceptEncoding`):
    * `HTTP_CODING_GZIP`, `HTTP_CODING_IDENTITY` (also with no such field), or
    * `HTTP_CODING_NONE` when the client refuses identity and does not take
-   * gzip. Allocates nothing.
+   * gzip. Allocates nothing. Read at `H1_REQUEST`, `H1_BODY` or `H1_END`
+   * alike: the head stays the request's until its response is done.
    */
   acceptEncoding(): i32 {
+    return this.acceptEncodingOf(HTTP_OFFER_GZIP)
+  }
+
+  /**
+   * Whether the current request's `Accept-Encoding` refuses the body as it
+   * is (`httpIdentityRefused`); `respondEncoded` then gzips any body it can.
+   */
+  identityRefused(): boolean {
+    return this.acceptEncodingOf(toI32(0)) === HTTP_CODING_NONE
+  }
+
+  /** `httpAcceptEncoding` of the current request's `Accept-Encoding`, with `offered`. */
+  acceptEncodingOf(offered: i32): i32 {
     const parser: Http1Parser = this.parser
     const i: i32 = parser.headerIndex("accept-encoding")
     const spans: i32[] = parser.spans
@@ -1232,7 +1264,23 @@ export class Http1Connection {
     if (start < 0 || start > end || end > toI32(parser.head.length)) {
       return HTTP_CODING_IDENTITY
     }
-    return httpAcceptEncoding(parser.head, start, end, HTTP_OFFER_GZIP)
+    return httpAcceptEncoding(parser.head, start, end, offered)
+  }
+
+  /**
+   * The segment `respondEncoded` counts in under `enc.segmentMode`: this
+   * connection's `mss` when the program set it, else `enc.mss` when the
+   * program set it to other than `HTTP_DEFAULT_MSS`, else the socket's
+   * (`socketMss`), else `HTTP_DEFAULT_MSS`.
+   */
+  segmentMss(enc: HttpCompressor): i32 {
+    if (this.mss > 0) {
+      return this.mss
+    }
+    if (enc.mss > 0 && enc.mss !== HTTP_DEFAULT_MSS) {
+      return enc.mss
+    }
+    return this.socketMss > 0 ? this.socketMss : HTTP_DEFAULT_MSS
   }
 
   /**
@@ -1240,9 +1288,17 @@ export class Http1Connection {
    * call: `respond`, `write` and `end`, the body compressed by `enc` when
    * `coding` (from `acceptEncoding`) is gzip and `enc.compress` takes it,
    * with `Content-Encoding: gzip` and the compressed `Content-Length`, and
-   * otherwise sent as it is; `Vary: Accept-Encoding` either way while
-   * `enc.vary` is set. The program's fields may not name `Content-Encoding`
-   * or, with `enc.vary`, `Vary`. The whole response is written or none of
+   * otherwise sent as it is; `Vary: Accept-Encoding` while `enc.vary` is set
+   * and the choice turned on the request (`HttpCompressor.varies`). Under
+   * `enc.segmentMode` the compressed response goes out only when, head
+   * included, it takes fewer segments of `segmentMss(enc)` bytes than the
+   * body as it is, and a response that fits one segment as it is goes so
+   * without compressing (`enc.oneSegment`); `enc.decision`
+   * says what was chosen. A request that refuses identity (`identityRefused`)
+   * is sent gzip whatever the length, the saving or the segments
+   * (`enc.compressAnyway`).
+   * The program's fields may not name `Content-Encoding` or, with
+   * `enc.vary`, `Vary`. The whole response is written or none of
    * it: `H1_AGAIN` when the output has no room for it yet (`H1_WRITE` says
    * when to try again, compressing again), `H1_INVALID` for a response
    * larger than the output could ever hold or one `respond` refuses,
@@ -1263,14 +1319,7 @@ export class Http1Connection {
     if (!this.answerable()) {
       return H1_CLOSED
     }
-    const packed: i32 = enc.compress(coding, body, off, len)
-    let n: i32 = len
-    if (packed >= 0) {
-      enc.addFields(names, values)
-      n = packed
-    } else {
-      enc.identityFields(names, values)
-    }
+    const required: boolean = coding === HTTP_CODING_GZIP && this.identityRefused()
     // `respond` and the body together, or neither: what `respond` sets is
     // put back when the body does not fit behind the head. `room` first, so
     // that what was sent is already moved out of the way and the `outputEnd`
@@ -1278,18 +1327,56 @@ export class Http1Connection {
     this.room()
     const outputEnd: i32 = this.outputEnd
     const closeAfter: boolean = this.closeAfter
-    const r: i32 = this.respond(status, enc.names, enc.values, n)
-    if (r !== 0) {
-      return r
+    let packed: i32 = -1
+    let n: i32 = len
+    let r: i32 = 0
+    let queued: boolean = false
+    const mss: i32 = this.segmentMss(enc)
+    if (!required && enc.segmentMode && enc.oneSegment(coding, len, mss)) {
+      // A response that fits one segment as it is cannot take fewer
+      // compressed, so it goes as it is with no encoder run, unless its head
+      // pushes it past the segment: then it is taken back and decided below.
+      enc.identityFields(names, values)
+      r = this.respond(status, enc.names, enc.values, len)
+      if (r !== 0) {
+        return r
+      }
+      queued = this.outputEnd - outputEnd + len <= enc.segmentSize(mss)
+      if (!queued) {
+        this.unrespond(outputEnd, closeAfter)
+      }
+    }
+    if (!queued) {
+      packed = required ? enc.compressAnyway(coding, body, off, len) : enc.compress(coding, body, off, len)
+      if (packed >= 0) {
+        enc.addFields(names, values)
+        n = packed
+      } else {
+        enc.identityFields(names, values)
+      }
+      r = this.respond(status, enc.names, enc.values, n)
+      if (r !== 0) {
+        return r
+      }
+    }
+    if (packed >= 0 && enc.segmentMode && !required) {
+      // The head just written, and the one the body as it is would get.
+      const head: i32 = this.outputEnd - outputEnd
+      const plain: i32 = enc.http1IdentityHead(head, packed, len)
+      if (!enc.fewerSegments(plain + len, head + packed, mss)) {
+        this.unrespond(outputEnd, closeAfter)
+        enc.identityFields(names, values)
+        packed = -1
+        n = len
+        r = this.respond(status, enc.names, enc.values, n)
+        if (r !== 0) {
+          return r
+        }
+      }
     }
     if (!this.responseEmpty && n > this.bodyRoom()) {
       const fits: boolean = this.outputEnd - outputEnd + n <= this.config.outputSize - H1_CONTROL_RESERVE
-      this.outputEnd = outputEnd
-      this.closeAfter = closeAfter
-      this.response = H1_R_NONE
-      this.responseFraming = 0
-      this.responseLeft = 0
-      this.responseEmpty = false
+      this.unrespond(outputEnd, closeAfter)
       if (!fits) {
         return H1_INVALID
       }
@@ -1303,6 +1390,16 @@ export class Http1Connection {
     return this.end()
   }
 
+  /** Takes back a head `respond` just queued: `outputEnd` and `closeAfter` as they were before it. */
+  unrespond(outputEnd: i32, closeAfter: boolean): void {
+    this.outputEnd = outputEnd
+    this.closeAfter = closeAfter
+    this.response = H1_R_NONE
+    this.responseFraming = 0
+    this.responseLeft = 0
+    this.responseEmpty = false
+  }
+
   // ---- WebSocket ----------------------------------------------------------------
 
   /**
@@ -1620,6 +1717,12 @@ export class Http1Server {
     this.fds[k] = fd
     this.armed[k] = H1_WANT_READ
     conn.restart()
+    // Once a connection, not a request, so a keep-alive request costs no
+    // syscall: a path whose MSS moves after the handshake is not followed.
+    const mss: i32 = netMss(fd)
+    if (mss > 0) {
+      conn.socketMss = mss
+    }
     conn.lastActive = monotonicNanos()
     return k
   }

package/std/net/http1.ts

@@ -88,7 +88,12 @@ export const HTTP1_NEED_MORE: i32 = 0
 export const HTTP1_HEAD: i32 = 1
 /** `next()`: `bodyLen` body bytes are at `body[bodyOff ..]`, valid until the next `feed`. */
 export const HTTP1_BODY: i32 = 2
-/** `next()`: the request's body is complete. */
+/**
+ * `next()`: the request's body is complete. Its head (method, target,
+ * version, fields, `keepAlive`) still reads as this request's until the next
+ * call to `next()`, so a response written at `HTTP1_END` sees the request it
+ * answers and never the pipelined one behind it.
+ */
 export const HTTP1_END: i32 = 3
 /** `next()`, from now on: the request switched protocols; see `upgradeBytes()`. */
 export const HTTP1_UPGRADE: i32 = 4
@@ -144,7 +149,7 @@ export class Http1Parser {
   // The fields are declared widest first, references before numbers before
   // flags, so the struct carries no padding; the groups say what each is.
 
-  // --- the request: valid from its `HTTP1_HEAD` until the next request's -----
+  // --- the request: valid from its `HTTP1_HEAD` until the `next()` after its `HTTP1_END`
   method: string = ""
   target: string = ""
   /** The field names, in lowercase, in the order they arrived; `values` beside them. */
@@ -218,6 +223,11 @@ export class Http1Parser {
   keepAlive: boolean = false
   /** Whether the request asked to switch protocols (`upgrade` is its value when `keepText`). */
   upgrading: boolean = false
+  /**
+   * Whether a kept-alive request ended and its head is still held for the
+   * response: the next `next()` clears it before it reads a byte more.
+   */
+  headHeld: boolean = false
   /**
    * Whether `method`, `target`, `names`, `values` and `upgrade` are filled as
    * strings. A server that must allocate nothing per request turns it off and
@@ -361,7 +371,7 @@ export class Http1Parser {
    * next feed and head make or the caller puts back first.
    */
   resting(): boolean {
-    return this.state === HTTP1_S_REQUEST_LINE && this.end === this.start
+    return this.state === HTTP1_S_REQUEST_LINE && this.end === this.start && !this.headHeld
   }
 
   /** How many bytes were fed and not consumed yet: what a caller bounds its reads by. */
@@ -485,6 +495,7 @@ const http1StartRequest = (p: Http1Parser): void => {
   p.bodyTotal = 0
   p.sectionBytes = 0
   p.fieldCount = 0
+  p.headHeld = false
 }
 
 /** `http1TakeLine`'s answer when a whole line is ready; never an event. */
@@ -1092,6 +1103,11 @@ const http1Next = (p: Http1Parser): i32 => {
   while (true) {
     switch (p.state) {
       case HTTP1_S_REQUEST_LINE: {
+        // The request that ended was answered while its head was held; the
+        // pipelined bytes behind it are only read once it is cleared.
+        if (p.headHeld) {
+          http1StartRequest(p)
+        }
         // A method too long is a 400, decided before the line's length can
         // call it a long target and answer 414.
         if (http1MethodOverrun(p)) {
@@ -1162,7 +1178,11 @@ const http1Next = (p: Http1Parser): i32 => {
         } else if (!p.keepAlive) {
           p.state = HTTP1_S_CLOSED
         } else {
-          http1StartRequest(p)
+          // The head stays this request's until the next call, which clears
+          // it before reading on: a response written at HTTP1_END reads its
+          // own method, version and fields, and no copy is made.
+          p.state = HTTP1_S_REQUEST_LINE
+          p.headHeld = true
         }
         return HTTP1_END
       }