summaryrefslogtreecommitdiff
path: root/ext/node/polyfills/_http_outgoing.ts
diff options
context:
space:
mode:
Diffstat (limited to 'ext/node/polyfills/_http_outgoing.ts')
-rw-r--r--ext/node/polyfills/_http_outgoing.ts1444
1 files changed, 556 insertions, 888 deletions
diff --git a/ext/node/polyfills/_http_outgoing.ts b/ext/node/polyfills/_http_outgoing.ts
index 7382be19c..b859d99ca 100644
--- a/ext/node/polyfills/_http_outgoing.ts
+++ b/ext/node/polyfills/_http_outgoing.ts
@@ -10,13 +10,14 @@ import type { Socket } from "ext:deno_node/net.ts";
import {
kNeedDrain,
kOutHeaders,
- utcDate,
+ // utcDate,
} from "ext:deno_node/internal/http.ts";
+import { notImplemented } from "ext:deno_node/_utils.ts";
import { Buffer } from "ext:deno_node/buffer.ts";
import {
_checkInvalidHeaderChar as checkInvalidHeaderChar,
_checkIsHttpToken as checkIsHttpToken,
- chunkExpression as RE_TE_CHUNKED,
+ // chunkExpression as RE_TE_CHUNKED,
} from "ext:deno_node/_http_common.ts";
import {
defaultTriggerAsyncIdScope,
@@ -27,21 +28,22 @@ const { async_id_symbol } = symbols;
import {
ERR_HTTP_HEADERS_SENT,
ERR_HTTP_INVALID_HEADER_VALUE,
- ERR_HTTP_TRAILER_INVALID,
- ERR_INVALID_ARG_TYPE,
- ERR_INVALID_ARG_VALUE,
+ // ERR_HTTP_TRAILER_INVALID,
+ // ERR_INVALID_ARG_TYPE,
+ // ERR_INVALID_ARG_VALUE,
ERR_INVALID_CHAR,
ERR_INVALID_HTTP_TOKEN,
ERR_METHOD_NOT_IMPLEMENTED,
- ERR_STREAM_ALREADY_FINISHED,
+ // ERR_STREAM_ALREADY_FINISHED,
ERR_STREAM_CANNOT_PIPE,
- ERR_STREAM_DESTROYED,
- ERR_STREAM_NULL_VALUES,
- ERR_STREAM_WRITE_AFTER_END,
+ // ERR_STREAM_DESTROYED,
+ // ERR_STREAM_NULL_VALUES,
+ // ERR_STREAM_WRITE_AFTER_END,
hideStackFrames,
} from "ext:deno_node/internal/errors.ts";
import { validateString } from "ext:deno_node/internal/validators.mjs";
-import { isUint8Array } from "ext:deno_node/internal/util/types.ts";
+// import { isUint8Array } from "ext:deno_node/internal/util/types.ts";
+// import { kStreamBaseField } from "ext:deno_node/internal_binding/stream_wrap.ts";
import { debuglog } from "ext:deno_node/internal/util/debuglog.ts";
let debug = debuglog("http", (fn) => {
@@ -54,98 +56,539 @@ const kCorked = Symbol("corked");
const nop = () => {};
-const RE_CONN_CLOSE = /(?:^|\W)close(?:$|\W)/i;
-
-// isCookieField performs a case-insensitive comparison of a provided string
-// against the word "cookie." As of V8 6.6 this is faster than handrolling or
-// using a case-insensitive RegExp.
-function isCookieField(s: string) {
- return s.length === 6 && s.toLowerCase() === "cookie";
-}
-
-// deno-lint-ignore no-explicit-any
-export function OutgoingMessage(this: any) {
- Stream.call(this);
-
- // Queue that holds all currently pending data, until the response will be
- // assigned to the socket (until it will its turn in the HTTP pipeline).
- this.outputData = [];
-
- // `outputSize` is an approximate measure of how much data is queued on this
- // response. `_onPendingData` will be invoked to update similar global
- // per-connection counter. That counter will be used to pause/unpause the
- // TCP socket and HTTP Parser and thus handle the backpressure.
- this.outputSize = 0;
-
- this.writable = true;
- this.destroyed = false;
-
- this._last = false;
- this.chunkedEncoding = false;
- this.shouldKeepAlive = true;
- this.maxRequestsOnConnectionReached = false;
- this._defaultKeepAlive = true;
- this.useChunkedEncodingByDefault = true;
- this.sendDate = false;
- this._removedConnection = false;
- this._removedContLen = false;
- this._removedTE = false;
-
- this._contentLength = null;
- this._hasBody = true;
- this._trailer = "";
- this[kNeedDrain] = false;
-
- this.finished = false;
- this._headerSent = false;
- this[kCorked] = 0;
- this._closed = false;
-
- this.socket = null;
- this._header = null;
- this[kOutHeaders] = null;
-
- this._keepAliveTimeout = 0;
-
- this._onPendingData = nop;
-}
-Object.setPrototypeOf(OutgoingMessage.prototype, Stream.prototype);
-Object.setPrototypeOf(OutgoingMessage, Stream);
+export class OutgoingMessage extends Stream {
+ // deno-lint-ignore no-explicit-any
+ outputData: any[];
+ outputSize: number;
+ writable: boolean;
+ destroyed: boolean;
+
+ _last: boolean;
+ chunkedEncoding: boolean;
+ shouldKeepAlive: boolean;
+ maxRequestsOnConnectionReached: boolean;
+ _defaultKeepAlive: boolean;
+ useChunkedEncodingByDefault: boolean;
+ sendDate: boolean;
+ _removedConnection: boolean;
+ _removedContLen: boolean;
+ _removedTE: boolean;
+
+ _contentLength: number | null;
+ _hasBody: boolean;
+ _trailer: string;
+ [kNeedDrain]: boolean;
+
+ finished: boolean;
+ _headerSent: boolean;
+ [kCorked]: number;
+ _closed: boolean;
+
+ // TODO(crowlKats): use it
+ socket: null;
+ // TODO(crowlKats): use it
+ _header: null;
+ [kOutHeaders]: null | Record<string, [string, string]>;
+
+ _keepAliveTimeout: number;
+ _onPendingData: () => void;
+
+ constructor() {
+ super();
+
+ // Queue that holds all currently pending data, until the response will be
+ // assigned to the socket (until it will its turn in the HTTP pipeline).
+ this.outputData = [];
+
+ // `outputSize` is an approximate measure of how much data is queued on this
+ // response. `_onPendingData` will be invoked to update similar global
+ // per-connection counter. That counter will be used to pause/unpause the
+ // TCP socket and HTTP Parser and thus handle the backpressure.
+ this.outputSize = 0;
+
+ this.writable = true;
+ this.destroyed = false;
+
+ this._last = false;
+ this.chunkedEncoding = false;
+ this.shouldKeepAlive = true;
+ this.maxRequestsOnConnectionReached = false;
+ this._defaultKeepAlive = true;
+ this.useChunkedEncodingByDefault = true;
+ this.sendDate = false;
+ this._removedConnection = false;
+ this._removedContLen = false;
+ this._removedTE = false;
+
+ this._contentLength = null;
+ this._hasBody = true;
+ this._trailer = "";
+ this[kNeedDrain] = false;
+
+ this.finished = false;
+ this._headerSent = false;
+ this[kCorked] = 0;
+ this._closed = false;
+
+ this.socket = null;
+ this._header = null;
+ this[kOutHeaders] = null;
+
+ this._keepAliveTimeout = 0;
+
+ this._onPendingData = nop;
+
+ this.stream = new ReadableStream({
+ start: (controller) => {
+ this.controller = controller;
+ },
+ });
+ }
-Object.defineProperty(OutgoingMessage.prototype, "writableFinished", {
- get() {
+ get writableFinished() {
return (
this.finished &&
this.outputSize === 0 &&
(!this.socket || this.socket.writableLength === 0)
);
- },
-});
+ }
-Object.defineProperty(OutgoingMessage.prototype, "writableObjectMode", {
- get() {
+ get writableObjectMode() {
return false;
- },
-});
+ }
-Object.defineProperty(OutgoingMessage.prototype, "writableLength", {
- get() {
+ get writableLength() {
return this.outputSize + (this.socket ? this.socket.writableLength : 0);
- },
-});
+ }
-Object.defineProperty(OutgoingMessage.prototype, "writableHighWaterMark", {
- get() {
+ get writableHighWaterMark() {
return this.socket ? this.socket.writableHighWaterMark : HIGH_WATER_MARK;
- },
-});
+ }
-Object.defineProperty(OutgoingMessage.prototype, "writableCorked", {
- get() {
+ get writableCorked() {
const corked = this.socket ? this.socket.writableCorked : 0;
return corked + this[kCorked];
- },
-});
+ }
+
+ get connection() {
+ return this.socket;
+ }
+
+ set connection(val) {
+ this.socket = val;
+ }
+
+ get writableEnded() {
+ return this.finished;
+ }
+
+ get writableNeedDrain() {
+ return !this.destroyed && !this.finished && this[kNeedDrain];
+ }
+
+ cork() {
+ if (this.socket) {
+ this.socket.cork();
+ } else {
+ this[kCorked]++;
+ }
+ }
+
+ uncork() {
+ if (this.socket) {
+ this.socket.uncork();
+ } else if (this[kCorked]) {
+ this[kCorked]--;
+ }
+ }
+
+ setTimeout(msecs: number, callback?: (...args: unknown[]) => void) {
+ if (callback) {
+ this.on("timeout", callback);
+ }
+
+ if (!this.socket) {
+ // deno-lint-ignore no-explicit-any
+ this.once("socket", function socketSetTimeoutOnConnect(socket: any) {
+ socket.setTimeout(msecs);
+ });
+ } else {
+ this.socket.setTimeout(msecs);
+ }
+ return this;
+ }
+
+ // It's possible that the socket will be destroyed, and removed from
+ // any messages, before ever calling this. In that case, just skip
+ // it, since something else is destroying this connection anyway.
+ destroy(error: unknown) {
+ if (this.destroyed) {
+ return this;
+ }
+ this.destroyed = true;
+
+ if (this.socket) {
+ this.socket.destroy(error);
+ } else {
+ // deno-lint-ignore no-explicit-any
+ this.once("socket", function socketDestroyOnConnect(socket: any) {
+ socket.destroy(error);
+ });
+ }
+
+ return this;
+ }
+
+ setHeader(name: string, value: string) {
+ if (this._header) {
+ throw new ERR_HTTP_HEADERS_SENT("set");
+ }
+ validateHeaderName(name);
+ validateHeaderValue(name, value);
+
+ let headers = this[kOutHeaders];
+ if (headers === null) {
+ this[kOutHeaders] = headers = Object.create(null);
+ }
+
+ headers[name.toLowerCase()] = [name, value];
+ return this;
+ }
+
+ appendHeader(name, value) {
+ if (this._header) {
+ throw new ERR_HTTP_HEADERS_SENT("append");
+ }
+ validateHeaderName(name);
+ validateHeaderValue(name, value);
+
+ const field = name.toLowerCase();
+ const headers = this[kOutHeaders];
+ if (headers === null || !headers[field]) {
+ return this.setHeader(name, value);
+ }
+
+ // Prepare the field for appending, if required
+ if (!Array.isArray(headers[field][1])) {
+ headers[field][1] = [headers[field][1]];
+ }
+
+ const existingValues = headers[field][1];
+ if (Array.isArray(value)) {
+ for (let i = 0, length = value.length; i < length; i++) {
+ existingValues.push(value[i]);
+ }
+ } else {
+ existingValues.push(value);
+ }
+
+ return this;
+ }
+
+ // Returns a shallow copy of the current outgoing headers.
+ getHeaders() {
+ const headers = this[kOutHeaders];
+ const ret = Object.create(null);
+ if (headers) {
+ const keys = Object.keys(headers);
+ // Retain for(;;) loop for performance reasons
+ // Refs: https://github.com/nodejs/node/pull/30958
+ for (let i = 0; i < keys.length; ++i) {
+ const key = keys[i];
+ const val = headers[key][1];
+ ret[key] = val;
+ }
+ }
+ return ret;
+ }
+
+ hasHeader(name: string) {
+ validateString(name, "name");
+ return this[kOutHeaders] !== null &&
+ !!this[kOutHeaders][name.toLowerCase()];
+ }
+
+ removeHeader(name: string) {
+ validateString(name, "name");
+
+ if (this._header) {
+ throw new ERR_HTTP_HEADERS_SENT("remove");
+ }
+
+ const key = name.toLowerCase();
+
+ switch (key) {
+ case "connection":
+ this._removedConnection = true;
+ break;
+ case "content-length":
+ this._removedContLen = true;
+ break;
+ case "transfer-encoding":
+ this._removedTE = true;
+ break;
+ case "date":
+ this.sendDate = false;
+ break;
+ }
+
+ if (this[kOutHeaders] !== null) {
+ delete this[kOutHeaders][key];
+ }
+ }
+
+ getHeader(name: string) {
+ validateString(name, "name");
+
+ const headers = this[kOutHeaders];
+ if (headers === null) {
+ return;
+ }
+
+ const entry = headers[name.toLowerCase()];
+ return entry && entry[1];
+ }
+
+ // Returns an array of the names of the current outgoing headers.
+ getHeaderNames() {
+ return this[kOutHeaders] !== null ? Object.keys(this[kOutHeaders]) : [];
+ }
+
+ // Returns an array of the names of the current outgoing raw headers.
+ getRawHeaderNames() {
+ const headersMap = this[kOutHeaders];
+ if (headersMap === null) return [];
+
+ const values = Object.values(headersMap);
+ const headers = Array(values.length);
+ // Retain for(;;) loop for performance reasons
+ // Refs: https://github.com/nodejs/node/pull/30958
+ for (let i = 0, l = values.length; i < l; i++) {
+ // deno-lint-ignore no-explicit-any
+ headers[i] = (values as any)[i][0];
+ }
+
+ return headers;
+ }
+
+ controller: ReadableStreamDefaultController;
+ write(
+ chunk: string | Uint8Array | Buffer,
+ encoding: string | null,
+ // TODO(crowlKats): use callback
+ _callback: () => void,
+ ): boolean {
+ if (typeof chunk === "string") {
+ chunk = Buffer.from(chunk, encoding);
+ }
+ if (chunk instanceof Buffer) {
+ chunk = new Uint8Array(chunk.buffer);
+ }
+
+ this.controller.enqueue(chunk);
+
+ return false;
+ }
+
+ // deno-lint-ignore no-explicit-any
+ addTrailers(_headers: any) {
+ // TODO(crowlKats): finish it
+ notImplemented("OutgoingMessage.addTrailers");
+ }
+
+ // deno-lint-ignore no-explicit-any
+ end(chunk: any, encoding: any, _callback: any) {
+ if (typeof chunk === "function") {
+ callback = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === "function") {
+ callback = encoding;
+ encoding = null;
+ }
+ // TODO(crowlKats): finish
+
+ return this;
+ }
+
+ flushHeaders() {
+ if (!this._header) {
+ this._implicitHeader();
+ }
+
+ // Force-flush the headers.
+ this._send("");
+ }
+
+ pipe() {
+ // OutgoingMessage should be write-only. Piping from it is disabled.
+ this.emit("error", new ERR_STREAM_CANNOT_PIPE());
+ }
+
+ _implicitHeader() {
+ throw new ERR_METHOD_NOT_IMPLEMENTED("_implicitHeader()");
+ }
+
+ _finish() {
+ assert(this.socket);
+ this.emit("prefinish");
+ }
+
+ // This logic is probably a bit confusing. Let me explain a bit:
+ //
+ // In both HTTP servers and clients it is possible to queue up several
+ // outgoing messages. This is easiest to imagine in the case of a client.
+ // Take the following situation:
+ //
+ // req1 = client.request('GET', '/');
+ // req2 = client.request('POST', '/');
+ //
+ // When the user does
+ //
+ // req2.write('hello world\n');
+ //
+ // it's possible that the first request has not been completely flushed to
+ // the socket yet. Thus the outgoing messages need to be prepared to queue
+ // up data internally before sending it on further to the socket's queue.
+ //
+ // This function, outgoingFlush(), is called by both the Server and Client
+ // to attempt to flush any pending messages out to the socket.
+ _flush() {
+ const socket = this.socket;
+
+ if (socket && socket.writable) {
+ // There might be remaining data in this.output; write it out
+ const ret = this._flushOutput(socket);
+
+ if (this.finished) {
+ // This is a queue to the server or client to bring in the next this.
+ this._finish();
+ } else if (ret && this[kNeedDrain]) {
+ this[kNeedDrain] = false;
+ this.emit("drain");
+ }
+ }
+ }
+
+ _flushOutput(socket: Socket) {
+ while (this[kCorked]) {
+ this[kCorked]--;
+ socket.cork();
+ }
+
+ const outputLength = this.outputData.length;
+ if (outputLength <= 0) {
+ return undefined;
+ }
+
+ const outputData = this.outputData;
+ socket.cork();
+ let ret;
+ // Retain for(;;) loop for performance reasons
+ // Refs: https://github.com/nodejs/node/pull/30958
+ for (let i = 0; i < outputLength; i++) {
+ const { data, encoding, callback } = outputData[i];
+ ret = socket.write(data, encoding, callback);
+ }
+ socket.uncork();
+
+ this.outputData = [];
+ this._onPendingData(-this.outputSize);
+ this.outputSize = 0;
+
+ return ret;
+ }
+
+ // This abstract either writing directly to the socket or buffering it.
+ // deno-lint-ignore no-explicit-any
+ _send(data: any, encoding?: string | null, callback?: () => void) {
+ // This is a shameful hack to get the headers and first body chunk onto
+ // the same packet. Future versions of Node are going to take care of
+ // this at a lower level and in a more general way.
+ if (!this._headerSent && this._header !== null) {
+ // `this._header` can be null if OutgoingMessage is used without a proper Socket
+ // See: /test/parallel/test-http-outgoing-message-inheritance.js
+ if (
+ typeof data === "string" &&
+ (encoding === "utf8" || encoding === "latin1" || !encoding)
+ ) {
+ data = this._header + data;
+ } else {
+ const header = this._header;
+ this.outputData.unshift({
+ data: header,
+ encoding: "latin1",
+ callback: null,
+ });
+ this.outputSize += header.length;
+ this._onPendingData(header.length);
+ }
+ this._headerSent = true;
+ }
+ return this._writeRaw(data, encoding, callback);
+ }
+
+ _writeRaw(
+ // deno-lint-ignore no-explicit-any
+ this: any,
+ // deno-lint-ignore no-explicit-any
+ data: any,
+ encoding?: string | null,
+ callback?: () => void,
+ ) {
+ const conn = this.socket;
+ if (conn && conn.destroyed) {
+ // The socket was destroyed. If we're still trying to write to it,
+ // then we haven't gotten the 'close' event yet.
+ return false;
+ }
+
+ if (typeof encoding === "function") {
+ callback = encoding;
+ encoding = null;
+ }
+
+ if (conn && conn._httpMessage === this && conn.writable) {
+ // There might be pending data in the this.output buffer.
+ if (this.outputData.length) {
+ this._flushOutput(conn);
+ }
+ // Directly write to socket.
+ return conn.write(data, encoding, callback);
+ }
+ // Buffer, as long as we're not destroyed.
+ this.outputData.push({ data, encoding, callback });
+ this.outputSize += data.length;
+ this._onPendingData(data.length);
+ return this.outputSize < HIGH_WATER_MARK;
+ }
+
+ _renderHeaders() {
+ if (this._header) {
+ throw new ERR_HTTP_HEADERS_SENT("render");
+ }
+
+ const headersMap = this[kOutHeaders];
+ // deno-lint-ignore no-explicit-any
+ const headers: any = {};
+
+ if (headersMap !== null) {
+ const keys = Object.keys(headersMap);
+ // Retain for(;;) loop for performance reasons
+ // Refs: https://github.com/nodejs/node/pull/30958
+ for (let i = 0, l = keys.length; i < l; i++) {
+ const key = keys[i];
+ headers[headersMap[key][0]] = headersMap[key][1];
+ }
+ }
+ return headers;
+ }
+
+ // deno-lint-ignore no-explicit-any
+ [EE.captureRejectionSymbol](err: any, _event: any) {
+ this.destroy(err);
+ }
+}
Object.defineProperty(OutgoingMessage.prototype, "_headers", {
get: deprecate(
@@ -177,15 +620,6 @@ Object.defineProperty(OutgoingMessage.prototype, "_headers", {
),
});
-Object.defineProperty(OutgoingMessage.prototype, "connection", {
- get: function () {
- return this.socket;
- },
- set: function (val) {
- this.socket = val;
- },
-});
-
Object.defineProperty(OutgoingMessage.prototype, "_headerNames", {
get: deprecate(
// deno-lint-ignore no-explicit-any
@@ -232,373 +666,6 @@ Object.defineProperty(OutgoingMessage.prototype, "_headerNames", {
),
});
-OutgoingMessage.prototype._renderHeaders = function _renderHeaders() {
- if (this._header) {
- throw new ERR_HTTP_HEADERS_SENT("render");
- }
-
- const headersMap = this[kOutHeaders];
- // deno-lint-ignore no-explicit-any
- const headers: any = {};
-
- if (headersMap !== null) {
- const keys = Object.keys(headersMap);
- // Retain for(;;) loop for performance reasons
- // Refs: https://github.com/nodejs/node/pull/30958
- for (let i = 0, l = keys.length; i < l; i++) {
- const key = keys[i];
- headers[headersMap[key][0]] = headersMap[key][1];
- }
- }
- return headers;
-};
-
-OutgoingMessage.prototype.cork = function () {
- if (this.socket) {
- this.socket.cork();
- } else {
- this[kCorked]++;
- }
-};
-
-OutgoingMessage.prototype.uncork = function () {
- if (this.socket) {
- this.socket.uncork();
- } else if (this[kCorked]) {
- this[kCorked]--;
- }
-};
-
-OutgoingMessage.prototype.setTimeout = function setTimeout(
- msecs: number,
- callback?: (...args: unknown[]) => void,
-) {
- if (callback) {
- this.on("timeout", callback);
- }
-
- if (!this.socket) {
- // deno-lint-ignore no-explicit-any
- this.once("socket", function socketSetTimeoutOnConnect(socket: any) {
- socket.setTimeout(msecs);
- });
- } else {
- this.socket.setTimeout(msecs);
- }
- return this;
-};
-
-// It's possible that the socket will be destroyed, and removed from
-// any messages, before ever calling this. In that case, just skip
-// it, since something else is destroying this connection anyway.
-OutgoingMessage.prototype.destroy = function destroy(error: unknown) {
- if (this.destroyed) {
- return this;
- }
- this.destroyed = true;
-
- if (this.socket) {
- this.socket.destroy(error);
- } else {
- // deno-lint-ignore no-explicit-any
- this.once("socket", function socketDestroyOnConnect(socket: any) {
- socket.destroy(error);
- });
- }
-
- return this;
-};
-
-// This abstract either writing directly to the socket or buffering it.
-OutgoingMessage.prototype._send = function _send(
- // deno-lint-ignore no-explicit-any
- data: any,
- encoding: string | null,
- callback: () => void,
-) {
- // This is a shameful hack to get the headers and first body chunk onto
- // the same packet. Future versions of Node are going to take care of
- // this at a lower level and in a more general way.
- if (!this._headerSent) {
- if (
- typeof data === "string" &&
- (encoding === "utf8" || encoding === "latin1" || !encoding)
- ) {
- data = this._header + data;
- } else {
- const header = this._header;
- this.outputData.unshift({
- data: header,
- encoding: "latin1",
- callback: null,
- });
- this.outputSize += header.length;
- this._onPendingData(header.length);
- }
- this._headerSent = true;
- }
- return this._writeRaw(data, encoding, callback);
-};
-
-OutgoingMessage.prototype._writeRaw = _writeRaw;
-function _writeRaw(
- // deno-lint-ignore no-explicit-any
- this: any,
- // deno-lint-ignore no-explicit-any
- data: any,
- encoding: string | null,
- callback: () => void,
-) {
- const conn = this.socket;
- if (conn && conn.destroyed) {
- // The socket was destroyed. If we're still trying to write to it,
- // then we haven't gotten the 'close' event yet.
- return false;
- }
-
- if (typeof encoding === "function") {
- callback = encoding;
- encoding = null;
- }
-
- if (conn && conn._httpMessage === this && conn.writable) {
- // There might be pending data in the this.output buffer.
- if (this.outputData.length) {
- this._flushOutput(conn);
- }
- // Directly write to socket.
- return conn.write(data, encoding, callback);
- }
- // Buffer, as long as we're not destroyed.
- this.outputData.push({ data, encoding, callback });
- this.outputSize += data.length;
- this._onPendingData(data.length);
- return this.outputSize < HIGH_WATER_MARK;
-}
-
-OutgoingMessage.prototype._storeHeader = _storeHeader;
-// deno-lint-ignore no-explicit-any
-function _storeHeader(this: any, firstLine: any, headers: any) {
- // firstLine in the case of request is: 'GET /index.html HTTP/1.1\r\n'
- // in the case of response it is: 'HTTP/1.1 200 OK\r\n'
- const state = {
- connection: false,
- contLen: false,
- te: false,
- date: false,
- expect: false,
- trailer: false,
- header: firstLine,
- };
-
- if (headers) {
- if (headers === this[kOutHeaders]) {
- for (const key in headers) {
- if (Object.hasOwn(headers, key)) {
- const entry = headers[key];
- processHeader(this, state, entry[0], entry[1], false);
- }
- }
- } else if (Array.isArray(headers)) {
- if (headers.length && Array.isArray(headers[0])) {
- for (let i = 0; i < headers.length; i++) {
- const entry = headers[i];
- processHeader(this, state, entry[0], entry[1], true);
- }
- } else {
- if (headers.length % 2 !== 0) {
- throw new ERR_INVALID_ARG_VALUE("headers", headers);
- }
-
- for (let n = 0; n < headers.length; n += 2) {
- processHeader(this, state, headers[n + 0], headers[n + 1], true);
- }
- }
- } else {
- for (const key in headers) {
- if (Object.hasOwn(headers, key)) {
- processHeader(this, state, key, headers[key], true);
- }
- }
- }
- }
-
- let { header } = state;
-
- // Date header
- if (this.sendDate && !state.date) {
- header += "Date: " + utcDate() + "\r\n";
- }
-
- // Force the connection to close when the response is a 204 No Content or
- // a 304 Not Modified and the user has set a "Transfer-Encoding: chunked"
- // header.
- //
- // RFC 2616 mandates that 204 and 304 responses MUST NOT have a body but
- // node.js used to send out a zero chunk anyway to accommodate clients
- // that don't have special handling for those responses.
- //
- // It was pointed out that this might confuse reverse proxies to the point
- // of creating security liabilities, so suppress the zero chunk and force
- // the connection to close.
- if (
- this.chunkedEncoding && (this.statusCode === 204 ||
- this.statusCode === 304)
- ) {
- debug(
- this.statusCode + " response should not use chunked encoding," +
- " closing connection.",
- );
- this.chunkedEncoding = false;
- this.shouldKeepAlive = false;
- }
-
- // keep-alive logic
- if (this._removedConnection) {
- this._last = true;
- this.shouldKeepAlive = false;
- } else if (!state.connection) {
- const shouldSendKeepAlive = this.shouldKeepAlive &&
- (state.contLen || this.useChunkedEncodingByDefault || this.agent);
- if (shouldSendKeepAlive && this.maxRequestsOnConnectionReached) {
- header += "Connection: close\r\n";
- } else if (shouldSendKeepAlive) {
- header += "Connection: keep-alive\r\n";
- if (this._keepAliveTimeout && this._defaultKeepAlive) {
- const timeoutSeconds = Math.floor(this._keepAliveTimeout / 1000);
- header += `Keep-Alive: timeout=${timeoutSeconds}\r\n`;
- }
- } else {
- this._last = true;
- header += "Connection: close\r\n";
- }
- }
-
- if (!state.contLen && !state.te) {
- if (!this._hasBody) {
- // Make sure we don't end the 0\r\n\r\n at the end of the message.
- this.chunkedEncoding = false;
- } else if (!this.useChunkedEncodingByDefault) {
- this._last = true;
- } else if (
- !state.trailer &&
- !this._removedContLen &&
- typeof this._contentLength === "number"
- ) {
- header += "Content-Length: " + this._contentLength + "\r\n";
- } else if (!this._removedTE) {
- header += "Transfer-Encoding: chunked\r\n";
- this.chunkedEncoding = true;
- } else {
- // We should only be able to get here if both Content-Length and
- // Transfer-Encoding are removed by the user.
- // See: test/parallel/test-http-remove-header-stays-removed.js
- debug("Both Content-Length and Transfer-Encoding are removed");
- }
- }
-
- // Test non-chunked message does not have trailer header set,
- // message will be terminated by the first empty line after the
- // header fields, regardless of the header fields present in the
- // message, and thus cannot contain a message body or 'trailers'.
- if (this.chunkedEncoding !== true && state.trailer) {
- throw new ERR_HTTP_TRAILER_INVALID();
- }
-
- this._header = header + "\r\n";
- this._headerSent = false;
-
- // Wait until the first body chunk, or close(), is sent to flush,
- // UNLESS we're sending Expect: 100-continue.
- if (state.expect) this._send("");
-}
-
-function processHeader(
- // deno-lint-ignore no-explicit-any
- self: any,
- // deno-lint-ignore no-explicit-any
- state: any,
- // deno-lint-ignore no-explicit-any
- key: any,
- // deno-lint-ignore no-explicit-any
- value: any,
- // deno-lint-ignore no-explicit-any
- validate: any,
-) {
- if (validate) {
- validateHeaderName(key);
- }
- if (Array.isArray(value)) {
- if (value.length < 2 || !isCookieField(key)) {
- // Retain for(;;) loop for performance reasons
- // Refs: https://github.com/nodejs/node/pull/30958
- for (let i = 0; i < value.length; i++) {
- storeHeader(self, state, key, value[i], validate);
- }
- return;
- }
- value = value.join("; ");
- }
- storeHeader(self, state, key, value, validate);
-}
-
-function storeHeader(
- // deno-lint-ignore no-explicit-any
- self: any,
- // deno-lint-ignore no-explicit-any
- state: any,
- // deno-lint-ignore no-explicit-any
- key: any,
- // deno-lint-ignore no-explicit-any
- value: any,
- // deno-lint-ignore no-explicit-any
- validate: any,
-) {
- if (validate) {
- validateHeaderValue(key, value);
- }
- state.header += key + ": " + value + "\r\n";
- matchHeader(self, state, key, value);
-}
-
-// deno-lint-ignore no-explicit-any
-function matchHeader(self: any, state: any, field: string, value: any) {
- if (field.length < 4 || field.length > 17) {
- return;
- }
- field = field.toLowerCase();
- switch (field) {
- case "connection":
- state.connection = true;
- self._removedConnection = false;
- if (RE_CONN_CLOSE.test(value)) {
- self._last = true;
- } else {
- self.shouldKeepAlive = true;
- }
- break;
- case "transfer-encoding":
- state.te = true;
- self._removedTE = false;
- if (RE_TE_CHUNKED.test(value)) {
- self.chunkedEncoding = true;
- }
- break;
- case "content-length":
- state.contLen = true;
- self._removedContLen = false;
- break;
- case "date":
- case "expect":
- case "trailer":
- state[field] = true;
- break;
- case "keep-alive":
- self._defaultKeepAlive = false;
- break;
- }
-}
-
export const validateHeaderName = hideStackFrames((name) => {
if (typeof name !== "string" || !name || !checkIsHttpToken(name)) {
throw new ERR_INVALID_HTTP_TOKEN("Header name", name);
@@ -615,114 +682,19 @@ export const validateHeaderValue = hideStackFrames((name, value) => {
}
});
-OutgoingMessage.prototype.setHeader = function setHeader(
- name: string,
- value: string,
-) {
- if (this._header) {
- throw new ERR_HTTP_HEADERS_SENT("set");
- }
- validateHeaderName(name);
- validateHeaderValue(name, value);
-
- let headers = this[kOutHeaders];
- if (headers === null) {
- this[kOutHeaders] = headers = Object.create(null);
- }
-
- headers[name.toLowerCase()] = [name, value];
- return this;
-};
-
-OutgoingMessage.prototype.getHeader = function getHeader(name: string) {
- validateString(name, "name");
-
- const headers = this[kOutHeaders];
- if (headers === null) {
- return;
- }
-
- const entry = headers[name.toLowerCase()];
- return entry && entry[1];
-};
-
-// Returns an array of the names of the current outgoing headers.
-OutgoingMessage.prototype.getHeaderNames = function getHeaderNames() {
- return this[kOutHeaders] !== null ? Object.keys(this[kOutHeaders]) : [];
-};
-
-// Returns an array of the names of the current outgoing raw headers.
-OutgoingMessage.prototype.getRawHeaderNames = function getRawHeaderNames() {
- const headersMap = this[kOutHeaders];
- if (headersMap === null) return [];
-
- const values = Object.values(headersMap);
- const headers = Array(values.length);
- // Retain for(;;) loop for performance reasons
- // Refs: https://github.com/nodejs/node/pull/30958
- for (let i = 0, l = values.length; i < l; i++) {
- // deno-lint-ignore no-explicit-any
- headers[i] = (values as any)[i][0];
+export function parseUniqueHeadersOption(headers) {
+ if (!Array.isArray(headers)) {
+ return null;
}
- return headers;
-};
-
-// Returns a shallow copy of the current outgoing headers.
-OutgoingMessage.prototype.getHeaders = function getHeaders() {
- const headers = this[kOutHeaders];
- const ret = Object.create(null);
- if (headers) {
- const keys = Object.keys(headers);
- // Retain for(;;) loop for performance reasons
- // Refs: https://github.com/nodejs/node/pull/30958
- for (let i = 0; i < keys.length; ++i) {
- const key = keys[i];
- const val = headers[key][1];
- ret[key] = val;
- }
+ const unique = new Set();
+ const l = headers.length;
+ for (let i = 0; i < l; i++) {
+ unique.add(headers[i].toLowerCasee());
}
- return ret;
-};
-OutgoingMessage.prototype.hasHeader = function hasHeader(name: string) {
- validateString(name, "name");
- return this[kOutHeaders] !== null &&
- !!this[kOutHeaders][name.toLowerCase()];
-};
-
-OutgoingMessage.prototype.removeHeader = function removeHeader(name: string) {
- validateString(name, "name");
-
- if (this._header) {
- throw new ERR_HTTP_HEADERS_SENT("remove");
- }
-
- const key = name.toLowerCase();
-
- switch (key) {
- case "connection":
- this._removedConnection = true;
- break;
- case "content-length":
- this._removedContLen = true;
- break;
- case "transfer-encoding":
- this._removedTE = true;
- break;
- case "date":
- this.sendDate = false;
- break;
- }
-
- if (this[kOutHeaders] !== null) {
- delete this[kOutHeaders][key];
- }
-};
-
-OutgoingMessage.prototype._implicitHeader = function _implicitHeader() {
- throw new ERR_METHOD_NOT_IMPLEMENTED("_implicitHeader()");
-};
+ return unique;
+}
Object.defineProperty(OutgoingMessage.prototype, "headersSent", {
configurable: true,
@@ -732,40 +704,13 @@ Object.defineProperty(OutgoingMessage.prototype, "headersSent", {
},
});
-Object.defineProperty(OutgoingMessage.prototype, "writableEnded", {
- get: function () {
- return this.finished;
- },
-});
-
-Object.defineProperty(OutgoingMessage.prototype, "writableNeedDrain", {
- get: function () {
- return !this.destroyed && !this.finished && this[kNeedDrain];
- },
-});
-
+// TODO(bartlomieju): use it
// deno-lint-ignore camelcase
-const crlf_buf = Buffer.from("\r\n");
-OutgoingMessage.prototype.write = function write(
- // deno-lint-ignore no-explicit-any
- chunk: any,
- encoding: string | null,
- callback: () => void,
-) {
- if (typeof encoding === "function") {
- callback = encoding;
- encoding = null;
- }
-
- const ret = write_(this, chunk, encoding, callback, false);
- if (!ret) {
- this[kNeedDrain] = true;
- }
- return ret;
-};
+const _crlf_buf = Buffer.from("\r\n");
+// TODO(bartlomieju): use it
// deno-lint-ignore no-explicit-any
-function onError(msg: any, err: any, callback: any) {
+function _onError(msg: any, err: any, callback: any) {
const triggerAsyncId = msg.socket ? msg.socket[async_id_symbol] : undefined;
defaultTriggerAsyncIdScope(
triggerAsyncId,
@@ -786,314 +731,37 @@ function emitErrorNt(msg: any, err: any, callback: any) {
}
}
-function write_(
+// TODO(bartlomieju): use it
+function _write_(
// deno-lint-ignore no-explicit-any
- msg: any,
+ _msg: any,
// deno-lint-ignore no-explicit-any
- chunk: any,
- encoding: string | null,
+ _chunk: any,
+ _encoding: string | null,
// deno-lint-ignore no-explicit-any
- callback: any,
+ _callback: any,
// deno-lint-ignore no-explicit-any
- fromEnd: any,
+ _fromEnd: any,
) {
- if (typeof callback !== "function") {
- callback = nop;
- }
-
- let len;
- if (chunk === null) {
- throw new ERR_STREAM_NULL_VALUES();
- } else if (typeof chunk === "string") {
- len = Buffer.byteLength(chunk, encoding);
- } else if (isUint8Array(chunk)) {
- len = chunk.length;
- } else {
- throw new ERR_INVALID_ARG_TYPE(
- "chunk",
- ["string", "Buffer", "Uint8Array"],
- chunk,
- );
- }
-
- let err;
- if (msg.finished) {
- err = new ERR_STREAM_WRITE_AFTER_END();
- } else if (msg.destroyed) {
- err = new ERR_STREAM_DESTROYED("write");
- }
-
- if (err) {
- if (!msg.destroyed) {
- onError(msg, err, callback);
- } else {
- // deno-lint-ignore no-explicit-any
- (globalThis as any).process.nextTick(callback, err);
- }
- return false;
- }
-
- if (!msg._header) {
- if (fromEnd) {
- msg._contentLength = len;
- }
- msg._implicitHeader();
- }
-
- if (!msg._hasBody) {
- debug(
- "This type of response MUST NOT have a body. " +
- "Ignoring write() calls.",
- );
- // deno-lint-ignore no-explicit-any
- (globalThis as any).process.nextTick(callback);
- return true;
- }
-
- if (!fromEnd && msg.socket && !msg.socket.writableCorked) {
- msg.socket.cork();
- // deno-lint-ignore no-explicit-any
- (globalThis as any).process.nextTick(connectionCorkNT, msg.socket);
- }
-
- let ret;
- if (msg.chunkedEncoding && chunk.length !== 0) {
- msg._send(len.toString(16), "latin1", null);
- msg._send(crlf_buf, null, null);
- msg._send(chunk, encoding, null);
- ret = msg._send(crlf_buf, null, callback);
- } else {
- ret = msg._send(chunk, encoding, callback);
- }
-
- debug("write ret = " + ret);
- return ret;
+ // TODO(crowlKats): finish
}
+// TODO(bartlomieju): use it
// deno-lint-ignore no-explicit-any
-function connectionCorkNT(conn: any) {
+function _connectionCorkNT(conn: any) {
conn.uncork();
}
+// TODO(bartlomieju): use it
// deno-lint-ignore no-explicit-any
-OutgoingMessage.prototype.addTrailers = function addTrailers(headers: any) {
- this._trailer = "";
- const keys = Object.keys(headers);
- const isArray = Array.isArray(headers);
- // Retain for(;;) loop for performance reasons
- // Refs: https://github.com/nodejs/node/pull/30958
- for (let i = 0, l = keys.length; i < l; i++) {
- let field, value;
- const key = keys[i];
- if (isArray) {
- // deno-lint-ignore no-explicit-any
- field = headers[key as any][0];
- // deno-lint-ignore no-explicit-any
- value = headers[key as any][1];
- } else {
- field = key;
- value = headers[key];
- }
- if (typeof field !== "string" || !field || !checkIsHttpToken(field)) {
- throw new ERR_INVALID_HTTP_TOKEN("Trailer name", field);
- }
- if (checkInvalidHeaderChar(value)) {
- debug('Trailer "%s" contains invalid characters', field);
- throw new ERR_INVALID_CHAR("trailer content", field);
- }
- this._trailer += field + ": " + value + "\r\n";
- }
-};
-
-// deno-lint-ignore no-explicit-any
-function onFinish(outmsg: any) {
+function _onFinish(outmsg: any) {
if (outmsg && outmsg.socket && outmsg.socket._hadError) return;
outmsg.emit("finish");
}
-OutgoingMessage.prototype.end = function end(
- // deno-lint-ignore no-explicit-any
- chunk: any,
- // deno-lint-ignore no-explicit-any
- encoding: any,
- // deno-lint-ignore no-explicit-any
- callback: any,
-) {
- if (typeof chunk === "function") {
- callback = chunk;
- chunk = null;
- encoding = null;
- } else if (typeof encoding === "function") {
- callback = encoding;
- encoding = null;
- }
-
- if (chunk) {
- if (this.finished) {
- onError(
- this,
- new ERR_STREAM_WRITE_AFTER_END(),
- typeof callback !== "function" ? nop : callback,
- );
- return this;
- }
-
- if (this.socket) {
- this.socket.cork();
- }
-
- write_(this, chunk, encoding, null, true);
- } else if (this.finished) {
- if (typeof callback === "function") {
- if (!this.writableFinished) {
- this.on("finish", callback);
- } else {
- callback(new ERR_STREAM_ALREADY_FINISHED("end"));
- }
- }
- return this;
- } else if (!this._header) {
- if (this.socket) {
- this.socket.cork();
- }
-
- this._contentLength = 0;
- this._implicitHeader();
- }
-
- if (typeof callback === "function") {
- this.once("finish", callback);
- }
-
- const finish = onFinish.bind(undefined, this);
-
- if (this._hasBody && this.chunkedEncoding) {
- this._send("0\r\n" + this._trailer + "\r\n", "latin1", finish);
- } else if (!this._headerSent || this.writableLength || chunk) {
- this._send("", "latin1", finish);
- } else {
- // deno-lint-ignore no-explicit-any
- (globalThis as any).process.nextTick(finish);
- }
-
- if (this.socket) {
- // Fully uncork connection on end().
- this.socket._writableState.corked = 1;
- this.socket.uncork();
- }
- this[kCorked] = 0;
-
- this.finished = true;
-
- // There is the first message on the outgoing queue, and we've sent
- // everything to the socket.
- debug("outgoing message end.");
- if (
- this.outputData.length === 0 &&
- this.socket &&
- this.socket._httpMessage === this
- ) {
- this._finish();
- }
-
- return this;
-};
-
-OutgoingMessage.prototype._finish = function _finish() {
- assert(this.socket);
- this.emit("prefinish");
-};
-
-// This logic is probably a bit confusing. Let me explain a bit:
-//
-// In both HTTP servers and clients it is possible to queue up several
-// outgoing messages. This is easiest to imagine in the case of a client.
-// Take the following situation:
-//
-// req1 = client.request('GET', '/');
-// req2 = client.request('POST', '/');
-//
-// When the user does
-//
-// req2.write('hello world\n');
-//
-// it's possible that the first request has not been completely flushed to
-// the socket yet. Thus the outgoing messages need to be prepared to queue
-// up data internally before sending it on further to the socket's queue.
-//
-// This function, outgoingFlush(), is called by both the Server and Client
-// to attempt to flush any pending messages out to the socket.
-OutgoingMessage.prototype._flush = function _flush() {
- const socket = this.socket;
-
- if (socket && socket.writable) {
- // There might be remaining data in this.output; write it out
- const ret = this._flushOutput(socket);
-
- if (this.finished) {
- // This is a queue to the server or client to bring in the next this.
- this._finish();
- } else if (ret && this[kNeedDrain]) {
- this[kNeedDrain] = false;
- this.emit("drain");
- }
- }
-};
-
-OutgoingMessage.prototype._flushOutput = function _flushOutput(socket: Socket) {
- while (this[kCorked]) {
- this[kCorked]--;
- socket.cork();
- }
-
- const outputLength = this.outputData.length;
- if (outputLength <= 0) {
- return undefined;
- }
-
- const outputData = this.outputData;
- socket.cork();
- let ret;
- // Retain for(;;) loop for performance reasons
- // Refs: https://github.com/nodejs/node/pull/30958
- for (let i = 0; i < outputLength; i++) {
- const { data, encoding, callback } = outputData[i];
- ret = socket.write(data, encoding, callback);
- }
- socket.uncork();
-
- this.outputData = [];
- this._onPendingData(-this.outputSize);
- this.outputSize = 0;
-
- return ret;
-};
-
-OutgoingMessage.prototype.flushHeaders = function flushHeaders() {
- if (!this._header) {
- this._implicitHeader();
- }
-
- // Force-flush the headers.
- this._send("");
-};
-
-OutgoingMessage.prototype.pipe = function pipe() {
- // OutgoingMessage should be write-only. Piping from it is disabled.
- this.emit("error", new ERR_STREAM_CANNOT_PIPE());
-};
-
-OutgoingMessage.prototype[EE.captureRejectionSymbol] = function (
- // deno-lint-ignore no-explicit-any
- err: any,
- // deno-lint-ignore no-explicit-any
- _event: any,
-) {
- this.destroy(err);
-};
-
export default {
validateHeaderName,
validateHeaderValue,
+ parseUniqueHeadersOption,
OutgoingMessage,
};
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 13:17:45 +0000