constructor(type, socket) {

this.type = type;

this.socket = socket;

}

OutgoingMessage.call(this, options);

if (req.method === 'HEAD') this._hasBody = false;

this.req = req;

this.sendDate = true;

this._sent100 = false;

this._expect_continue = false;

if (req.httpVersionMajor < 1 || req.httpVersionMinor < 1) {

this.useChunkedEncodingByDefault = RegExpPrototypeExec(chunkExpression,

req.headers.te) !== null;

this.shouldKeepAlive = false;

}

if (hasObserver('http')) {

startPerf(this, kServerResponseStatistics, {

type: 'http',

name: 'HttpRequest',

detail: {

req: {

method: req.method,

url: req.url,

headers: req.headers,

},

},

});

}

if (isTraceHTTPEnabled()) {

this._traceEventId = getNextTraceEventId();

traceBegin(HTTP_SERVER_TRACE_EVENT_NAME, this._traceEventId);

}

if (this[kServerResponseStatistics] && hasObserver('http')) {

stopPerf(this, kServerResponseStatistics, {

detail: {

res: {

statusCode: this.statusCode,

statusMessage: this.statusMessage,

headers: typeof this.getHeaders === 'function' ? this.getHeaders() : {},

},

},

});

}

OutgoingMessage.prototype._finish.call(this);

if (isTraceHTTPEnabled() && typeof this._traceEventId === 'number') {

const data = {

url: this.req?.url,

statusCode: this.statusCode,

};

traceEnd(HTTP_SERVER_TRACE_EVENT_NAME, this._traceEventId, data);

}

// EventEmitter.emit makes a copy of the 'close' listeners array before

// calling the listeners. detachSocket() unregisters onServerResponseClose

// but if detachSocket() is called, directly or indirectly, by a 'close'

// listener, onServerResponseClose is still in that copy of the listeners

// array. That is, in the example below, b still gets called even though

// it's been removed by a:

//

// const EventEmitter = require('events');

// const obj = new EventEmitter();

// obj.on('event', a);

// obj.on('event', b);

// function a() { obj.removeListener('event', b) }

// function b() { throw "BAM!" }

// obj.emit('event'); // throws

//

// Ergo, we need to deal with stale 'close' events and handle the case

// where the ServerResponse object has already been deconstructed.

// Fortunately, that requires only a single if check. :-)

if (this._httpMessage) {

emitCloseNT(this._httpMessage);

}

if (socket._httpMessage) {

throw new ERR_HTTP_SOCKET_ASSIGNED();

}

socket._httpMessage = this;

socket.on('close', onServerResponseClose);

this.socket = socket;

this.emit('socket', socket);

this._flush();

assert(socket._httpMessage === this);

socket.removeListener('close', onServerResponseClose);

socket._httpMessage = null;

this.socket = null;

let head = 'HTTP/1.1 103 Early Hints\r\n';

validateObject(hints, 'hints');

if (hints.link === null || hints.link === undefined) {

return;

}

const link = validateLinkHeaderValue(hints.link);

if (link.length === 0) {

return;

}

head += 'Link: ' + link + '\r\n';

for (const key of ObjectKeys(hints)) {

if (key !== 'link') {

head += key + ': ' + hints[key] + '\r\n';

}

}

head += '\r\n';

this._writeRaw(head, 'ascii', cb);

if (this._header) {

throw new ERR_HTTP_HEADERS_SENT('write');

}

const originalStatusCode = statusCode;

statusCode |= 0;

if (statusCode < 100 || statusCode > 999) {

throw new ERR_HTTP_INVALID_STATUS_CODE(originalStatusCode);

}

if (typeof reason === 'string') {

// writeHead(statusCode, reasonPhrase[, headers])

this.statusMessage = reason;

} else {

// writeHead(statusCode[, headers])

if (!this.statusMessage)

this.statusMessage = STATUS_CODES[statusCode] || 'unknown';

obj ??= reason;

}

this.statusCode = statusCode;

let headers;

if (this[kOutHeaders]) {

// Slow-case: when progressive API and header fields are passed.

let k;

if (ArrayIsArray(obj)) {

if (obj.length % 2 !== 0) {

throw new ERR_INVALID_ARG_VALUE('headers', obj);

}

for (let n = 0; n < obj.length; n += 2) {

k = obj[n + 0];

if (k) this.setHeader(k, obj[n + 1]);

}

} else if (obj) {

const keys = ObjectKeys(obj);

// Retain for(;;) loop for performance reasons

// Refs: https://github.com/nodejs/node/pull/30958

for (let i = 0; i < keys.length; i++) {

k = keys[i];

if (k) this.setHeader(k, obj[k]);

}

}

// Only progressive api is used

headers = this[kOutHeaders];

} else {

// Only writeHead() called

headers = obj;

}

if (checkInvalidHeaderChar(this.statusMessage))

throw new ERR_INVALID_CHAR('statusMessage');

const statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r\n`;

if (statusCode === 204 || statusCode === 304 ||

(statusCode >= 100 && statusCode <= 199)) {

// RFC 2616, 10.2.5:

// The 204 response MUST NOT include a message-body, and thus is always

// terminated by the first empty line after the header fields.

// RFC 2616, 10.3.5:

// The 304 response MUST NOT contain a message-body, and thus is always

// terminated by the first empty line after the header fields.

// RFC 2616, 10.1 Informational 1xx:

// This class of status code indicates a provisional response,

// consisting only of the Status-Line and optional headers, and is

// terminated by an empty line.

this._hasBody = false;

}

// Don't keep alive connections where the client expects 100 Continue

// but we sent a final status; they may put extra bytes on the wire.

if (this._expect_continue && !this._sent100) {

this.shouldKeepAlive = false;

}

this._storeHeader(statusLine, headers);

return this;

this[kIncomingMessage] = options.IncomingMessage || IncomingMessage;

this[kServerResponse] = options.ServerResponse || ServerResponse;

const maxHeaderSize = options.maxHeaderSize;

if (maxHeaderSize !== undefined)

validateInteger(maxHeaderSize, 'maxHeaderSize', 0);

this.maxHeaderSize = maxHeaderSize;

const insecureHTTPParser = options.insecureHTTPParser;

if (insecureHTTPParser !== undefined)

validateBoolean(insecureHTTPParser, 'options.insecureHTTPParser');

this.insecureHTTPParser = insecureHTTPParser;

const requestTimeout = options.requestTimeout;

if (requestTimeout !== undefined) {

validateInteger(requestTimeout, 'requestTimeout', 0);

this.requestTimeout = requestTimeout;

} else {

this.requestTimeout = 300_000; // 5 minutes

}

const headersTimeout = options.headersTimeout;

if (headersTimeout !== undefined) {

validateInteger(headersTimeout, 'headersTimeout', 0);

this.headersTimeout = headersTimeout;

} else {

this.headersTimeout = MathMin(60_000, this.requestTimeout); // Minimum between 60 seconds or requestTimeout

}

if (this.requestTimeout > 0 && this.headersTimeout > 0 && this.headersTimeout > this.requestTimeout) {

throw new codes.ERR_OUT_OF_RANGE('headersTimeout', '<= requestTimeout', headersTimeout);

}

const keepAliveTimeout = options.keepAliveTimeout;

if (keepAliveTimeout !== undefined) {

validateInteger(keepAliveTimeout, 'keepAliveTimeout', 0);

this.keepAliveTimeout = keepAliveTimeout;

} else {

this.keepAliveTimeout = 5_000; // 5 seconds;

}

const connectionsCheckingInterval = options.connectionsCheckingInterval;

if (connectionsCheckingInterval !== undefined) {

validateInteger(connectionsCheckingInterval, 'connectionsCheckingInterval', 0);

this.connectionsCheckingInterval = connectionsCheckingInterval;

} else {

this.connectionsCheckingInterval = 30_000; // 30 seconds

}

const requireHostHeader = options.requireHostHeader;

if (requireHostHeader !== undefined) {

validateBoolean(requireHostHeader, 'options.requireHostHeader');

this.requireHostHeader = requireHostHeader;

} else {

this.requireHostHeader = true;

}

const joinDuplicateHeaders = options.joinDuplicateHeaders;

if (joinDuplicateHeaders !== undefined) {

validateBoolean(joinDuplicateHeaders, 'options.joinDuplicateHeaders');

}

this.joinDuplicateHeaders = joinDuplicateHeaders;

const rejectNonStandardBodyWrites = options.rejectNonStandardBodyWrites;

if (rejectNonStandardBodyWrites !== undefined) {

validateBoolean(rejectNonStandardBodyWrites, 'options.rejectNonStandardBodyWrites');

this.rejectNonStandardBodyWrites = rejectNonStandardBodyWrites;

} else {

this.rejectNonStandardBodyWrites = false;

}

// Start connection handling

if (!this[kConnections]) {

this[kConnections] = new ConnectionsList();

}

// This checker is started without checking whether any headersTimeout or requestTimeout is non zero

// otherwise it would not be started if such timeouts are modified after createServer.

this[kConnectionsCheckingInterval] =

setInterval(checkConnections.bind(this), this.connectionsCheckingInterval).unref();

if (!(this instanceof Server)) return new Server(options, requestListener);

if (typeof options === 'function') {

requestListener = options;

options = kEmptyObject;

} else if (options == null) {

options = kEmptyObject;

} else {

validateObject(options, 'options');

}

storeHTTPOptions.call(this, options);

net.Server.call(

this,

{ allowHalfOpen: true, noDelay: options.noDelay ?? true,

keepAlive: options.keepAlive,

keepAliveInitialDelay: options.keepAliveInitialDelay,

highWaterMark: options.highWaterMark });

if (requestListener) {

this.on('request', requestListener);

}

// Similar option to this. Too lazy to write my own docs.

// http://www.squid-cache.org/Doc/config/half_closed_clients/

// https://wiki.squid-cache.org/SquidFaq/InnerWorkings#What_is_a_half-closed_filedescriptor.3F

this.httpAllowHalfOpen = false;

this.on('connection', connectionListener);

this.on('listening', setupConnectionsTracking);

this.timeout = 0;

this.maxHeadersCount = null;

this.maxRequestsPerSocket = 0;

this[kUniqueHeaders] = parseUniqueHeadersOption(options.uniqueHeaders);

if (!this[kConnections]) {

return;

}

const connections = this[kConnections].all();

for (let i = 0, l = connections.length; i < l; i++) {

connections[i].socket.destroy();

}

if (!this[kConnections]) {

return;

}

const connections = this[kConnections].idle();

for (let i = 0, l = connections.length; i < l; i++) {

if (connections[i].socket._httpMessage && !connections[i].socket._httpMessage.finished) {

continue;

}

connections[i].socket.destroy();

}

this.timeout = msecs;

if (callback)

this.on('timeout', callback);

return this;

if (this.headersTimeout === 0 && this.requestTimeout === 0) {

return;

}

const expired = this[kConnections].expired(this.headersTimeout, this.requestTimeout);

for (let i = 0; i < expired.length; i++) {

const socket = expired[i].socket;

if (socket) {

onRequestTimeout(socket);

}

}

defaultTriggerAsyncIdScope(

getOrSetAsyncId(socket), connectionListenerInternal, this, socket,

);

debug('SERVER new http connection');

// Ensure that the server property of the socket is correctly set.

// See https://github.com/nodejs/node/issues/13435

socket.server = server;

// If the user has added a listener to the server,

// request, or response, then it's their responsibility.

// otherwise, destroy on timeout by default

if (server.timeout && typeof socket.setTimeout === 'function')

socket.setTimeout(server.timeout);

socket.on('timeout', socketOnTimeout);

const parser = parsers.alloc();

const lenient = server.insecureHTTPParser === undefined ?

isLenient() : server.insecureHTTPParser;

// TODO(addaleax): This doesn't play well with the

// `async_hooks.currentResource()` proposal, see

// https://github.com/nodejs/node/pull/21313

parser.initialize(

HTTPParser.REQUEST,

new HTTPServerAsyncResource('HTTPINCOMINGMESSAGE', socket),

server.maxHeaderSize || 0,

lenient ? kLenientAll : kLenientNone,

server[kConnections],

);

parser.socket = socket;

socket.parser = parser;

// Propagate headers limit from server instance to parser

if (typeof server.maxHeadersCount === 'number') {

parser.maxHeaderPairs = server.maxHeadersCount << 1;

}

const state = {

onData: null,

onEnd: null,

onClose: null,

onDrain: null,

outgoing: [],

incoming: [],

// `outgoingData` is an approximate amount of bytes queued through all

// inactive responses. If more data than the high watermark is queued - we

// need to pause TCP socket/HTTP parser, and wait until the data will be

// sent to the client.

outgoingData: 0,

requestsCount: 0,

keepAliveTimeoutSet: false,

};

state.onData = socketOnData.bind(undefined,

server, socket, parser, state);

state.onEnd = socketOnEnd.bind(undefined,

server, socket, parser, state);

state.onClose = socketOnClose.bind(undefined,

socket, state);

state.onDrain = socketOnDrain.bind(undefined,

socket, state);

socket.on('data', state.onData);

socket.on('error', socketOnError);

socket.on('end', state.onEnd);

socket.on('close', state.onClose);

socket.on('drain', state.onDrain);

parser.onIncoming = parserOnIncoming.bind(undefined,

server, socket, state);

// We are consuming socket, so it won't get any actual data

socket.on('resume', onSocketResume);

socket.on('pause', onSocketPause);

// Overrides to unconsume on `data`, `readable` listeners

socket.on = generateSocketListenerWrapper('on');

socket.addListener = generateSocketListenerWrapper('addListener');

socket.prependListener = generateSocketListenerWrapper('prependListener');

socket.setEncoding = socketSetEncoding;

// We only consume the socket if it has never been consumed before.

if (socket._handle && socket._handle.isStreamBase &&

!socket._handle._consumed) {

parser._consumed = true;

socket._handle._consumed = true;

parser.consume(socket._handle);

}

parser[kOnExecute] =

onParserExecute.bind(undefined,

server, socket, parser, state);

parser[kOnTimeout] =

onParserTimeout.bind(undefined,

server, socket);

socket._paused = false;

const needPause = state.outgoingData > socket.writableHighWaterMark;

// If we previously paused, then start reading again.

if (socket._paused && !needPause) {

socket._paused = false;

if (socket.parser)

socket.parser.resume();

socket.resume();

}

const msg = socket._httpMessage;

if (msg && !msg.finished && msg[kNeedDrain]) {

msg[kNeedDrain] = false;

msg.emit('drain');

}

const req = this.parser && this.parser.incoming;

const reqTimeout = req && !req.complete && req.emit('timeout', this);

const res = this._httpMessage;

const resTimeout = res && res.emit('timeout', this);

const serverTimeout = this.server.emit('timeout', this);

if (!reqTimeout && !resTimeout && !serverTimeout)

this.destroy();

debug('server socket close');

freeParser(socket.parser, null, socket);

abortIncoming(state.incoming);

while (incoming.length) {

const req = incoming.shift();

req.destroy(new ConnResetException('aborted'));

}

// Abort socket._httpMessage ?

const ret = parser.finish();

if (ret instanceof Error) {

debug('parse error');

// socketOnError has additional logic and will call socket.destroy(err).

socketOnError.call(socket, ret);

} else if (!server.httpAllowHalfOpen) {

socket.end();

} else if (state.outgoing.length) {

state.outgoing[state.outgoing.length - 1]._last = true;

} else if (socket._httpMessage) {

socket._httpMessage._last = true;

} else {

socket.end();

}

assert(!socket._paused);

debug('SERVER socketOnData %d', d.length);

const ret = parser.execute(d);

onParserExecuteCommon(server, socket, parser, state, ret, d);

// When underlying `net.Socket` instance is consumed - no

// `data` events are emitted, and thus `socket.setTimeout` fires the

// callback even if the data is constantly flowing into the socket.

// See, https://github.com/nodejs/node/commit/ec2822adaad76b126b5cccdeaa1addf2376c9aa6

socket._unrefTimer();

debug('SERVER socketOnParserExecute %d', ret);

onParserExecuteCommon(server, socket, parser, state, ret, undefined);

const serverTimeout = server.emit('timeout', socket);

if (!serverTimeout)

socket.destroy();

if (warnUnclosedSocket.emitted) {

return;

}

warnUnclosedSocket.emitted = true;

process.emitWarning(

'An error event has already been emitted on the socket. ' +

'Please use the destroy method on the socket while handling ' +

"a 'clientError' event.",

);