@amritk/nish-x86_64-linux 0.23.1 → 0.25.0

package/std/net/http1-server.ts

@@ -114,6 +114,12 @@
  */
 import { Secret } from "nish:secret"
 import { copyBytes } from "nish/bytes"
+import {
+  HTTP_CODING_IDENTITY,
+  HTTP_OFFER_GZIP,
+  HttpCompressor,
+  httpAcceptEncoding,
+} from "nish/net/http-compress"
 import { netClose, netRead, netWrite, tcpAccept } from "nish:net"
 import {
   HTTP1_BODY,
@@ -1205,6 +1211,98 @@ export class Http1Connection {
     return 0
   }
 
+  // ---- Content coding -----------------------------------------------------------
+
+  /**
+   * The content coding to answer the current request with, read from its
+   * `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.
+   */
+  acceptEncoding(): i32 {
+    const parser: Http1Parser = this.parser
+    const i: i32 = parser.headerIndex("accept-encoding")
+    const spans: i32[] = parser.spans
+    if (i < 0 || 4 * i + 3 >= toI32(spans.length)) {
+      return HTTP_CODING_IDENTITY
+    }
+    const start: i32 = spans[4 * i + 2]
+    const end: i32 = spans[4 * i + 3]
+    if (start < 0 || start > end || end > toI32(parser.head.length)) {
+      return HTTP_CODING_IDENTITY
+    }
+    return httpAcceptEncoding(parser.head, start, end, HTTP_OFFER_GZIP)
+  }
+
+  /**
+   * Answers the current request with all of `body[off .. off + len)` in one
+   * 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
+   * 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,
+   * `H1_CLOSED` with no request to answer; 0 once it is queued. A window
+   * outside `body` panics.
+   */
+  respondEncoded(
+    status: i32,
+    names: u8[][],
+    values: u8[][],
+    body: u8[],
+    off: i32,
+    len: i32,
+    enc: HttpCompressor,
+    coding: i32
+  ): i32 {
+    http1ServerCheckWindow("Http1Connection.respondEncoded", body, off, len)
+    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)
+    }
+    // `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`
+    // put back is one `respond` did not move.
+    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
+    }
+    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
+      if (!fits) {
+        return H1_INVALID
+      }
+      this.writeHeld = true
+      return H1_AGAIN
+    }
+    const w: i32 = packed >= 0 ? this.write(enc.output, toI32(0), n) : this.write(body, off, n)
+    if (w !== n) {
+      panic("Http1Connection.respondEncoded: a body the room was checked for did not fit")
+    }
+    return this.end()
+  }
+
   // ---- WebSocket ----------------------------------------------------------------
 
   /**
@@ -1859,7 +1957,9 @@ export class Http1TlsServer {
   readable(slot: i32): i32 {
     const live: boolean = this.live(slot)
     const now: i64 = monotonicNanos()
-    if (live) {
+    // What a lingering slot drains is not activity, so `idleTimeout` bounds
+    // how long a client that trickles bytes after the close can hold it.
+    if (live && !this.tls.lingering(slot)) {
       this.connections[slot].lastActive = now
     }
     this.tls.readable(slot)

package/std/net/http1.ts

@@ -524,7 +524,7 @@ const http1TakeLine = (p: Http1Parser, limit: i32, overStatus: i32): i32 => {
 }
 
 /** Whether `c` is a tchar of RFC 9110 §5.6.2, the bytes a token is made of. */
-const http1IsTokenByte = (c: i32): boolean =>
+export const http1IsTokenByte = (c: i32): boolean =>
   (c >= 97 && c <= 122) ||
   (c >= 65 && c <= 90) ||
   (c >= 48 && c <= 57) ||
@@ -541,10 +541,10 @@ const http1IsTokenByte = (c: i32): boolean =>
   c === 126
 
 /** Whether `c` may appear in a field value (RFC 9110 §5.5): HTAB, SP, VCHAR or obs-text. */
-const http1IsValueByte = (c: i32): boolean => c === 9 || (c >= 32 && c !== 127)
+export const http1IsValueByte = (c: i32): boolean => c === 9 || (c >= 32 && c !== 127)
 
 /** `buf[from .. to)` as a string, each upper-case ASCII letter lowered when `lower`. */
-const http1Text = (buf: u8[], from: i32, to: i32, lower: boolean): string => {
+export const http1Text = (buf: u8[], from: i32, to: i32, lower: boolean): string => {
   const parts: string[] = []
   for (let k: i32 = from; k >= 0 && k < to && k < toI32(buf.length); k += 1) {
     let c: i32 = toI32(buf[k])
@@ -557,10 +557,10 @@ const http1Text = (buf: u8[], from: i32, to: i32, lower: boolean): string => {
 }
 
 /** Whether `c` is optional whitespace, a space or a tab (OWS, RFC 9110 §5.6.3). */
-const http1IsOws = (c: i32): boolean => c === 32 || c === 9
+export const http1IsOws = (c: i32): boolean => c === 32 || c === 9
 
 /** Whether `text[a .. b)` is `word`, which is lowercase, in any ASCII case. */
-const http1SameWord = (text: string, a: i32, b: i32, word: string): boolean => {
+export const http1SameWord = (text: string, a: i32, b: i32, word: string): boolean => {
   const n: i32 = toI32(word.length)
   if (a < 0 || b - a !== n || b > toI32(text.length)) {
     return false
@@ -989,7 +989,7 @@ const http1ContentLength = (bytes: u8[], from: i32, to: i32, limit: i32): i32 =>
 }
 
 /** The value of the hex digit `c`, or -1. */
-const http1HexValue = (c: i32): i32 => {
+export const http1HexValue = (c: i32): i32 => {
   if (c >= 48 && c <= 57) {
     return c - 48
   }
@@ -1190,7 +1190,7 @@ const http1BytesOf = (text: string): u8[] => {
 }
 
 /** Whether every byte of `text` is a tchar, and there is at least one. */
-const http1IsToken = (text: string): boolean => {
+export const http1IsToken = (text: string): boolean => {
   const n: i32 = toI32(text.length)
   if (n === 0) {
     return false
@@ -1204,7 +1204,7 @@ const http1IsToken = (text: string): boolean => {
 }
 
 /** Whether every byte of `text` may stand in a field value or a reason phrase. */
-const http1IsFieldText = (text: string): boolean => {
+export const http1IsFieldText = (text: string): boolean => {
   const n: i32 = toI32(text.length)
   for (let k: i32 = 0; k < n; k += 1) {
     if (!http1IsValueByte(toI32(text.charCodeAt(k)))) {
@@ -1395,7 +1395,7 @@ const http1DecimalDigits = (n: i32): i32 => {
 }
 
 /** Writes `text` at `out[at ..)`, which the caller has made sure holds it, and answers where it ends. */
-const http1PutText = (out: u8[], at: i32, text: string): i32 => {
+export const http1PutText = (out: u8[], at: i32, text: string): i32 => {
   const n: i32 = toI32(text.length)
   for (let k: i32 = 0; k < n && at + k < toI32(out.length); k += 1) {
     if (at + k >= 0) {