123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
// Copyright 2018-2024 the oak authors. All rights reserved. MIT license.
/** The ability to parse a request body into {@linkcode FormData} when not * supported natively by the runtime. * * @module */
import { concat, createHttpError, Status, timingSafeEqual } from "./deps.ts";import { toParamRegExp, unquote } from "./headers.ts";import { skipLWSPChar, stripEol } from "./util.ts";import { getFilename } from "./content_disposition.ts";
import "./util.ts";
type Part = [  key: string,  value: string | Blob,  fileName: string | undefined,];
const BOUNDARY_PARAM_RE = toParamRegExp("boundary", "i");const NAME_PARAM_RE = toParamRegExp("name", "i");
const LF = 0x0a;const CR = 0x0d;const COLON = 0x3a;const HTAB = 0x09;const SPACE = 0x20;
const encoder = new TextEncoder();const decoder = new TextDecoder();
function indexOfCRLF(u8: Uint8Array): number {  let start = 0;  while (true) {    const idx = u8.indexOf(CR, start);    if (idx < 0) {      return idx;    }    if (u8.at(idx + 1) === LF) {      return idx + 1;    }    start = idx + 1;  }}
function isEqual(a: Uint8Array, b: Uint8Array): boolean {  return timingSafeEqual(skipLWSPChar(a), b);}
class MultipartStream extends TransformStream<Uint8Array, Part> {  #buffer = new Uint8Array(0);  #boundaryFinal: Uint8Array;  #boundaryPart: Uint8Array;  #current?: { headers?: Headers };  #finalized = false;  #pos = 0;
  constructor(contentType: string) {    const matches = contentType.match(BOUNDARY_PARAM_RE);    if (!matches) {      throw createHttpError(        Status.BadRequest,        `Content type "${contentType}" does not contain a valid boundary.`,      );    }    super({      transform: (chunk, controller) => {        this.#transform(chunk, controller);      },      flush: (controller) => {        if (!this.#finalized) {          controller.error(            createHttpError(              Status.BadRequest,              `Body terminated without being finalized.`,            ),          );        }      },    });
    let [, boundary] = matches;    boundary = unquote(boundary);    this.#boundaryPart = encoder.encode(`--${boundary}`);    this.#boundaryFinal = encoder.encode(`--${boundary}--`);  }
  #readLine(strip = true): Uint8Array | null {    let slice: Uint8Array | null = null;
    const i = indexOfCRLF(this.#buffer.subarray(this.#pos));    if (i >= 0) {      slice = this.#buffer.subarray(this.#pos, this.#pos + i + 1);      this.#pos += i + 1;      if (slice.byteLength && strip) {        return stripEol(slice);      }      return slice;    }    return null;  }
  #readHeaders(): Headers | null {    const currentPos = this.#pos;    const headers = new Headers();    let line = this.#readLine();    while (line) {      let i = line.indexOf(COLON);      if (i < 0) {        return headers;      }      const key = decoder.decode(line.subarray(0, i)).trim();      i++;      while (i < line.byteLength && (line[i] === SPACE || line[i] === HTAB)) {        i++;      }      const value = decoder.decode(line.subarray(i)).trim();      headers.set(key, encodeURIComponent(value));      line = this.#readLine();    }    // if we have a partial part that breaks across chunks, we won't have the    // right read position and so need to reset the pos and return a `null`.    this.#pos = currentPos;    return null;  }
  *#readParts(): IterableIterator<Part | null> {    while (true) {      const headers = this.#current?.headers ?? this.#readHeaders();      if (!headers) {        break;      }      const contentDisposition = decodeURIComponent(        headers.get("content-disposition") ?? "",      );      if (!contentDisposition) {        throw createHttpError(          Status.BadRequest,          'Form data part missing "content-disposition" header.',        );      }      if (!contentDisposition.match(/^form-data;/i)) {        throw createHttpError(          Status.BadRequest,          `Invalid "content-disposition" header: "${contentDisposition}"`,        );      }      const matches = NAME_PARAM_RE.exec(contentDisposition);      if (!matches) {        throw createHttpError(          Status.BadRequest,          "Unable to determine name of form body part.",        );      }      this.#current = { headers };      let [, key] = matches;      key = unquote(key);      const rawContentType = headers.get("content-type");      if (rawContentType) {        const contentType = decodeURIComponent(rawContentType);        const fileName = getFilename(contentDisposition);        const arrays: Uint8Array[] = [];        const pos = this.#pos;        while (true) {          const line = this.#readLine(false);          if (!line) {            // abnormal termination of part, therefore we will reset pos and            // return            this.#pos = pos;            return null;          }          const stripped = stripEol(line);          if (            isEqual(stripped, this.#boundaryPart) ||            isEqual(stripped, this.#boundaryFinal)          ) {            this.#current = {};            arrays[arrays.length - 1] = stripEol(arrays[arrays.length - 1]);            yield [key, new Blob(arrays, { type: contentType }), fileName];            this.#truncate();            if (isEqual(stripped, this.#boundaryFinal)) {              this.#finalized = true;              return null;            }            break;          }          arrays.push(line);        }      } else {        const lines: string[] = [];        const pos = this.#pos;        while (true) {          const line = this.#readLine();          if (!line) {            this.#pos = pos;            return null;          }          if (            isEqual(line, this.#boundaryPart) ||            isEqual(line, this.#boundaryFinal)          ) {            this.#current = {};            yield [key, lines.join("\n"), undefined];            this.#truncate();            if (isEqual(line, this.#boundaryFinal)) {              this.#finalized = true;              return null;            }            break;          }          lines.push(decoder.decode(line));        }      }    }    return null;  }
  #readToBoundary(): "part" | "final" | null {    let line: Uint8Array | null;    while ((line = this.#readLine())) {      if (isEqual(line, this.#boundaryPart)) {        return "part";      }      if (isEqual(line, this.#boundaryFinal)) {        return "final";      }    }    return null;  }
  #transform(    chunk: Uint8Array,    controller: TransformStreamDefaultController<Part>,  ) {    this.#buffer = concat([this.#buffer, chunk]);    if (!this.#current) {      const boundary = this.#readToBoundary();      if (!boundary) {        return;      }      if (boundary === "final") {        this.#finalized = true;        controller.terminate();        return;      }    }    try {      for (const part of this.#readParts()) {        if (!part) {          break;        }        controller.enqueue(part);      }      if (this.#finalized) {        controller.terminate();      }    } catch (err) {      controller.error(err);    }  }
  #truncate() {    this.#buffer = this.#buffer.slice(this.#pos);    this.#pos = 0;  }}
/** Take a content type and the body of a request and parse it as * {@linkcode FormData}. * * This is used in run-times where there isn't native support for this * feature. */export async function parse(  contentType: string,  body: ReadableStream<Uint8Array>,): Promise<FormData> {  const formData = new FormData();  if (body) {    const stream = body      .pipeThrough(new MultipartStream(contentType));    for await (const [key, value, fileName] of stream) {      if (fileName) {        formData.append(key, value, fileName);      } else {        formData.append(key, value);      }    }  }  return formData;}