import { BufReader, BufWriter } from "../io/bufio.ts";import { TextProtoReader } from "../textproto/mod.ts";import { assert } from "../testing/asserts.ts";import { encoder } from "../encoding/utf8.ts";import { ServerRequest, Response } from "./server.ts";import { STATUS_TEXT } from "./http_status.ts";
export function emptyReader(): Deno.Reader { return { read(_: Uint8Array): Promise<number | Deno.EOF> { return Promise.resolve(Deno.EOF); }, };}
export function bodyReader(contentLength: number, r: BufReader): Deno.Reader { let totalRead = 0; let finished = false; async function read(buf: Uint8Array): Promise<number | Deno.EOF> { if (finished) return Deno.EOF; let result: number | Deno.EOF; const remaining = contentLength - totalRead; if (remaining >= buf.byteLength) { result = await r.read(buf); } else { const readBuf = buf.subarray(0, remaining); result = await r.read(readBuf); } if (result !== Deno.EOF) { totalRead += result; } finished = totalRead === contentLength; return result; } return { read };}
export function chunkedBodyReader(h: Headers, r: BufReader): Deno.Reader { const tp = new TextProtoReader(r); let finished = false; const chunks: Array<{ offset: number; data: Uint8Array; }> = []; async function read(buf: Uint8Array): Promise<number | Deno.EOF> { if (finished) return Deno.EOF; const [chunk] = chunks; if (chunk) { const chunkRemaining = chunk.data.byteLength - chunk.offset; const readLength = Math.min(chunkRemaining, buf.byteLength); for (let i = 0; i < readLength; i++) { buf[i] = chunk.data[chunk.offset + i]; } chunk.offset += readLength; if (chunk.offset === chunk.data.byteLength) { chunks.shift(); if ((await tp.readLine()) === Deno.EOF) { throw new Deno.errors.UnexpectedEof(); } } return readLength; } const line = await tp.readLine(); if (line === Deno.EOF) throw new Deno.errors.UnexpectedEof(); const [chunkSizeString] = line.split(";"); const chunkSize = parseInt(chunkSizeString, 16); if (Number.isNaN(chunkSize) || chunkSize < 0) { throw new Error("Invalid chunk size"); } if (chunkSize > 0) { if (chunkSize > buf.byteLength) { let eof = await r.readFull(buf); if (eof === Deno.EOF) { throw new Deno.errors.UnexpectedEof(); } const restChunk = new Uint8Array(chunkSize - buf.byteLength); eof = await r.readFull(restChunk); if (eof === Deno.EOF) { throw new Deno.errors.UnexpectedEof(); } else { chunks.push({ offset: 0, data: restChunk, }); } return buf.byteLength; } else { const bufToFill = buf.subarray(0, chunkSize); const eof = await r.readFull(bufToFill); if (eof === Deno.EOF) { throw new Deno.errors.UnexpectedEof(); } if ((await tp.readLine()) === Deno.EOF) { throw new Deno.errors.UnexpectedEof(); } return chunkSize; } } else { assert(chunkSize === 0); if ((await r.readLine()) === Deno.EOF) { throw new Deno.errors.UnexpectedEof(); } await readTrailers(h, r); finished = true; return Deno.EOF; } } return { read };}
const kProhibitedTrailerHeaders = [ "transfer-encoding", "content-length", "trailer",];
export async function readTrailers( headers: Headers, r: BufReader): Promise<void> { const keys = parseTrailer(headers.get("trailer")); if (!keys) return; const tp = new TextProtoReader(r); const result = await tp.readMIMEHeader(); assert(result != Deno.EOF, "trailer must be set"); for (const [k, v] of result) { if (!keys.has(k)) { throw new Error("Undeclared trailer field"); } keys.delete(k); headers.append(k, v); } assert(keys.size === 0, "Missing trailers"); headers.delete("trailer");}
function parseTrailer(field: string | null): Set<string> | undefined { if (field == null) { return undefined; } const keys = field.split(",").map((v) => v.trim()); if (keys.length === 0) { throw new Error("Empty trailer"); } for (const invalid of kProhibitedTrailerHeaders) { if (keys.includes(invalid)) { throw new Error(`Prohibited field for trailer`); } } return new Set(keys);}
export async function writeChunkedBody( w: Deno.Writer, r: Deno.Reader): Promise<void> { const writer = BufWriter.create(w); for await (const chunk of Deno.toAsyncIterator(r)) { if (chunk.byteLength <= 0) continue; const start = encoder.encode(`${chunk.byteLength.toString(16)}\r\n`); const end = encoder.encode("\r\n"); await writer.write(start); await writer.write(chunk); await writer.write(end); }
const endChunk = encoder.encode("0\r\n\r\n"); await writer.write(endChunk);}
export async function writeTrailers( w: Deno.Writer, headers: Headers, trailers: Headers): Promise<void> { const trailer = headers.get("trailer"); if (trailer === null) { throw new Error('response headers must have "trailer" header field'); } const transferEncoding = headers.get("transfer-encoding"); if (transferEncoding === null || !transferEncoding.match(/^chunked/)) { throw new Error( `trailer headers is only allowed for "transfer-encoding: chunked": got "${transferEncoding}"` ); } const writer = BufWriter.create(w); const trailerHeaderFields = trailer .split(",") .map((s) => s.trim().toLowerCase()); for (const f of trailerHeaderFields) { assert( !kProhibitedTrailerHeaders.includes(f), `"${f}" is prohibited for trailer header` ); } for (const [key, value] of trailers) { assert( trailerHeaderFields.includes(key), `Not trailer header field: ${key}` ); await writer.write(encoder.encode(`${key}: ${value}\r\n`)); } await writer.write(encoder.encode("\r\n")); await writer.flush();}
export function setContentLength(r: Response): void { if (!r.headers) { r.headers = new Headers(); }
if (r.body) { if (!r.headers.has("content-length")) { if (r.body instanceof Uint8Array) { const bodyLength = r.body.byteLength; r.headers.set("content-length", bodyLength.toString()); } else { r.headers.set("transfer-encoding", "chunked"); } } }}
export async function writeResponse( w: Deno.Writer, r: Response): Promise<void> { const protoMajor = 1; const protoMinor = 1; const statusCode = r.status || 200; const statusText = STATUS_TEXT.get(statusCode); const writer = BufWriter.create(w); if (!statusText) { throw new Deno.errors.InvalidData("Bad status code"); } if (!r.body) { r.body = new Uint8Array(); } if (typeof r.body === "string") { r.body = encoder.encode(r.body); }
let out = `HTTP/${protoMajor}.${protoMinor} ${statusCode} ${statusText}\r\n`;
setContentLength(r); assert(r.headers != null); const headers = r.headers;
for (const [key, value] of headers) { out += `${key}: ${value}\r\n`; } out += "\r\n";
const header = encoder.encode(out); const n = await writer.write(header); assert(n === header.byteLength);
if (r.body instanceof Uint8Array) { const n = await writer.write(r.body); assert(n === r.body.byteLength); } else if (headers.has("content-length")) { const contentLength = headers.get("content-length"); assert(contentLength != null); const bodyLength = parseInt(contentLength); const n = await Deno.copy(writer, r.body); assert(n === bodyLength); } else { await writeChunkedBody(writer, r.body); } if (r.trailers) { const t = await r.trailers(); await writeTrailers(writer, headers, t); } await writer.flush();}
export function parseHTTPVersion(vers: string): [number, number] { switch (vers) { case "HTTP/1.1": return [1, 1];
case "HTTP/1.0": return [1, 0];
default: { const Big = 1000000; const digitReg = /^\d+$/;
if (!vers.startsWith("HTTP/")) { break; }
const dot = vers.indexOf("."); if (dot < 0) { break; }
const majorStr = vers.substring(vers.indexOf("/") + 1, dot); const major = parseInt(majorStr); if ( !digitReg.test(majorStr) || isNaN(major) || major < 0 || major > Big ) { break; }
const minorStr = vers.substring(dot + 1); const minor = parseInt(minorStr); if ( !digitReg.test(minorStr) || isNaN(minor) || minor < 0 || minor > Big ) { break; }
return [major, minor]; } }
throw new Error(`malformed HTTP version ${vers}`);}
export async function readRequest( conn: Deno.Conn, bufr: BufReader): Promise<ServerRequest | Deno.EOF> { const tp = new TextProtoReader(bufr); const firstLine = await tp.readLine(); if (firstLine === Deno.EOF) return Deno.EOF; const headers = await tp.readMIMEHeader(); if (headers === Deno.EOF) throw new Deno.errors.UnexpectedEof();
const req = new ServerRequest(); req.conn = conn; req.r = bufr; [req.method, req.url, req.proto] = firstLine.split(" ", 3); [req.protoMinor, req.protoMajor] = parseHTTPVersion(req.proto); req.headers = headers; fixLength(req); return req;}
function fixLength(req: ServerRequest): void { const contentLength = req.headers.get("Content-Length"); if (contentLength) { const arrClen = contentLength.split(","); if (arrClen.length > 1) { const distinct = [...new Set(arrClen.map((e): string => e.trim()))]; if (distinct.length > 1) { throw Error("cannot contain multiple Content-Length headers"); } else { req.headers.set("Content-Length", distinct[0]); } } const c = req.headers.get("Content-Length"); if (req.method === "HEAD" && c && c !== "0") { throw Error("http: method cannot contain a Content-Length"); } if (c && req.headers.has("transfer-encoding")) { throw new Error( "http: Transfer-Encoding and Content-Length cannot be send together" ); } }}