http,http2: coalesce chunked end() and cache status lines

Send headers, the last chunk, and the chunked terminator in a single
write() when res.end() is used with Transfer-Encoding: chunked.

Reuse prebuilt HTTP/1.1 status lines for default reason phrases, skip
toLowerCase() on common outgoing header names, and hoist HTTP/2 header
serialization off the per-call closure.

Signed-off-by: Yagiz Nizipli <yagiz@nizipli.com>

Author: anonrig

lib/_http_incoming.js

@@ -503,11 +503,12 @@ IncomingMessage.prototype._hasBodyHeaders = function _hasBodyHeaders() {
     const len = name.length;
     if (len === 14) {
       if (name === 'Content-Length' || name === 'content-length' ||
-          name.toLowerCase() === 'content-length') {
+          name === 'CONTENT-LENGTH' || name.toLowerCase() === 'content-length') {
         return true;
       }
     } else if (len === 17) {
       if (name === 'Transfer-Encoding' || name === 'transfer-encoding' ||
+          name === 'TRANSFER-ENCODING' ||
           name.toLowerCase() === 'transfer-encoding') {
         return true;
       }

lib/_http_outgoing.js

@@ -94,21 +94,22 @@ const kFlushError = Symbol('kFlushError');
 const kHighWaterMark = Symbol('kHighWaterMark');
 const kRejectNonStandardBodyWrites = Symbol('kRejectNonStandardBodyWrites');
 const kLenientHeaderValidation = Symbol('kLenientHeaderValidation');
+const kChunkedEndSent = Symbol('kChunkedEndSent');
 const kMaxHeaderBodyCoalesce = 16 * 1024;
 
 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) {
-  return s.length === 6 && s.toLowerCase() === 'cookie';
+  return s.length === 6 &&
+    (s === 'Cookie' || s === 'cookie' || s.toLowerCase() === 'cookie');
 }
 
 function isContentDispositionField(s) {
-  return s.length === 19 && s.toLowerCase() === 'content-disposition';
+  return s.length === 19 &&
+    (s === 'Content-Disposition' || s === 'content-disposition' ||
+     s.toLowerCase() === 'content-disposition');
 }
 
 function OutgoingMessage(options) {
@@ -637,24 +638,80 @@ function storeHeader(self, state, key, value, validate, lenient) {
   matchHeader(self, state, key, value);
 }
 
+function matchConnection(self, state, value) {
+  state.connection = true;
+  self._removedConnection = false;
+  if (RE_CONN_CLOSE.test(value))
+    self._last = true;
+  else
+    self.shouldKeepAlive = true;
+}
+
+function matchTransferEncoding(self, state, value) {
+  state.te = true;
+  self._removedTE = false;
+  if (RE_TE_CHUNKED.test(value))
+    self.chunkedEncoding = true;
+}
+
 function matchHeader(self, state, field, value) {
-  if (field.length < 4 || field.length > 17)
+  const len = field.length;
+  if (len < 4 || len > 17)
     return;
-  field = field.toLowerCase();
-  switch (field) {
+
+  // Avoid toLowerCase() for the usual Title-Case / lowercase spellings.
+  switch (len) {
+    case 4:
+      if (field === 'Date' || field === 'date') {
+        state.date = true;
+        return;
+      }
+      break;
+    case 6:
+      if (field === 'Expect' || field === 'expect') {
+        state.expect = true;
+        return;
+      }
+      break;
+    case 7:
+      if (field === 'Trailer' || field === 'trailer') {
+        state.trailer = true;
+        return;
+      }
+      break;
+    case 10:
+      if (field === 'Connection' || field === 'connection') {
+        matchConnection(self, state, value);
+        return;
+      }
+      if (field === 'Keep-Alive' || field === 'keep-alive') {
+        self._defaultKeepAlive = false;
+        return;
+      }
+      break;
+    case 14:
+      if (field === 'Content-Length' || field === 'content-length') {
+        state.contLen = true;
+        self._contentLength = +value;
+        self._removedContLen = false;
+        return;
+      }
+      break;
+    case 17:
+      if (field === 'Transfer-Encoding' || field === 'transfer-encoding') {
+        matchTransferEncoding(self, state, value);
+        return;
+      }
+      break;
+  }
+
+  const lower = field.toLowerCase();
+  switch (lower) {
     case 'connection':
-      state.connection = true;
-      self._removedConnection = false;
-      if (RE_CONN_CLOSE.test(value))
-        self._last = true;
-      else
-        self.shouldKeepAlive = true;
+      matchConnection(self, state, value);
       break;
     case 'transfer-encoding':
-      state.te = true;
-      self._removedTE = false;
-      if (RE_TE_CHUNKED.test(value))
-        self.chunkedEncoding = true;
+      matchTransferEncoding(self, state, value);
       break;
     case 'content-length':
       state.contLen = true;
@@ -664,7 +721,7 @@ function matchHeader(self, state, field, value) {
     case 'date':
     case 'expect':
     case 'trailer':
-      state[field] = true;
+      state[lower] = true;
       break;
     case 'keep-alive':
       self._defaultKeepAlive = false;
@@ -917,6 +974,37 @@ ObjectDefineProperty(OutgoingMessage.prototype, 'writableNeedDrain', {
 });
 
 const crlf_buf = Buffer.from('\r\n');
+
+// One write() for headers + last chunk + terminator. Used by end(chunk)
+// when Transfer-Encoding is chunked and headers have not been flushed.
+function trySendCombinedChunkedEnd(msg, chunk, encoding, len, callback) {
+  if (msg._headerSent || msg._header === null || msg[kChunkedLength] !== 0)
+    return undefined;
+
+  const suffix = '\r\n0\r\n' + msg._trailer + '\r\n';
+  const hex = len.toString(16);
+
+  if (typeof chunk === 'string' &&
+      (encoding === 'utf8' || encoding === 'latin1' || !encoding)) {
+    msg[kChunkedEndSent] = true;
+    return msg._send(hex + '\r\n' + chunk + suffix, encoding, callback);
+  }
+
+  if (isUint8Array(chunk) && chunk.byteLength <= kMaxHeaderBodyCoalesce) {
+    const prefix = msg._header + hex + '\r\n';
+    const total = prefix.length + chunk.byteLength + suffix.length;
+    const combined = Buffer.allocUnsafe(total);
+    combined.write(prefix, 0, prefix.length, 'latin1');
+    combined.set(chunk, prefix.length);
+    combined.write(suffix, prefix.length + chunk.byteLength, suffix.length, 'latin1');
+    msg._headerSent = true;
+    msg[kChunkedEndSent] = true;
+    return msg._writeRaw(combined, undefined, callback, total);
+  }
+
+  return undefined;
+}
+
 OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {
   if (typeof encoding === 'function') {
     callback = encoding;
@@ -962,8 +1050,14 @@ function strictContentLength(msg) {
 }
 
 function write_(msg, chunk, encoding, callback, fromEnd) {
-  if (typeof callback !== 'function')
+  let endCallback;
+  if (fromEnd && typeof callback === 'function') {
+    // end() owns the finish callback unless the chunked fast path sends it.
+    endCallback = callback;
+    callback = nop;
+  } else if (typeof callback !== 'function') {
     callback = nop;
+  }
 
   if (chunk === null) {
     throw new ERR_STREAM_NULL_VALUES();
@@ -1030,6 +1124,12 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
   let ret;
   if (msg.chunkedEncoding && chunk.length !== 0) {
     len ??= typeof chunk === 'string' ? Buffer.byteLength(chunk, encoding) : chunk.byteLength;
+    if (fromEnd && !msg.strictContentLength) {
+      const combined = trySendCombinedChunkedEnd(
+        msg, chunk, encoding, len, endCallback ?? nop);
+      if (combined !== undefined)
+        return combined;
+    }
     if (msg[kCorked] && msg._headerSent) {
       msg[kChunkedBuffer].push(chunk, encoding, callback);
       msg[kChunkedLength] += len;
@@ -1170,7 +1270,7 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
       this[kSocket].cork();
     }
 
-    write_(this, chunk, encoding, null, true);
+    write_(this, chunk, encoding, onFinish.bind(undefined, this), true);
   } else if (this.finished) {
     if (typeof callback === 'function') {
       queueEndCallback(this, callback);
@@ -1192,14 +1292,18 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
     throw new ERR_HTTP_CONTENT_LENGTH_MISMATCH(this[kBytesWritten], this._contentLength);
   }
 
-  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);
+  if (this[kChunkedEndSent]) {
+    // Headers, last chunk, and terminator were already flushed together.
   } else {
-    process.nextTick(finish);
+    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 {
+      process.nextTick(finish);
+    }
   }
 
   if (this[kSocket]) {

lib/_http_server.js

@@ -190,6 +190,15 @@ const STATUS_CODES = {
   511: 'Network Authentication Required', // RFC 6585 6
 };
 
+const STATUS_LINES = { __proto__: null };
+{
+  const codes = ObjectKeys(STATUS_CODES);
+  for (let i = 0; i < codes.length; i++) {
+    const code = codes[i];
+    STATUS_LINES[code] = `HTTP/1.1 ${code} ${STATUS_CODES[code]}\r\n`;
+  }
+}
+
 const kOnExecute = HTTPParser.kOnExecute | 0;
 const kOnTimeout = HTTPParser.kOnTimeout | 0;
 
@@ -331,7 +340,8 @@ ServerResponse.prototype.writeInformation = function writeInformation(
   }
 
   const statusMessage = STATUS_CODES[statusCode] || 'unknown';
-  let head = `HTTP/1.1 ${statusCode} ${statusMessage}\r\n`;
+  let head = STATUS_LINES[statusCode] ||
+    `HTTP/1.1 ${statusCode} ${statusMessage}\r\n`;
 
   const lenient = this._isLenientHeaderValidation();
   if (headers !== undefined && headers !== null) {
@@ -427,12 +437,13 @@ function writeHead(statusCode, reason, obj) {
   }
 
 
+  const defaultStatusMessage = STATUS_CODES[statusCode] || 'unknown';
   if (typeof reason === 'string') {
     // writeHead(statusCode, reasonPhrase[, headers])
     this.statusMessage = reason;
   } else {
     // writeHead(statusCode[, headers])
-    this.statusMessage ||= STATUS_CODES[statusCode] || 'unknown';
+    this.statusMessage ||= defaultStatusMessage;
     obj ??= reason;
   }
   this.statusCode = statusCode;
@@ -475,10 +486,16 @@ function writeHead(statusCode, reason, obj) {
     headers = obj;
   }
 
-  if (checkInvalidHeaderChar(this.statusMessage))
-    throw new ERR_INVALID_CHAR('statusMessage');
-
-  const statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r\n`;
+  let statusLine;
+  if (this.statusMessage === defaultStatusMessage) {
+    // Default reason phrases are already valid; reuse the prebuilt status line.
+    statusLine = STATUS_LINES[statusCode] ||
+      `HTTP/1.1 ${statusCode} ${this.statusMessage}\r\n`;
+  } else {
+    if (checkInvalidHeaderChar(this.statusMessage))
+      throw new ERR_INVALID_CHAR('statusMessage');
+    statusLine = `HTTP/1.1 ${statusCode} ${this.statusMessage}\r\n`;
+  }
 
   if (statusCode === 204 || statusCode === 304 ||
       (statusCode >= 100 && statusCode <= 199)) {

lib/internal/http2/core.js

@@ -2858,7 +2858,15 @@ function prepareResponseHeadersArray(headers, options) {
   let isDateSet = false;
 
   for (let i = 0; i < headers.length; i += 2) {
-    const header = headers[i].toLowerCase();
+    let header = headers[i];
+    const headerLen = header.length;
+    for (let j = 0; j < headerLen; j++) {
+      const c = header.charCodeAt(j);
+      if (c >= 65 && c <= 90) {
+        header = header.toLowerCase();
+        break;
+      }
+    }
     const value = headers[i + 1];
 
     if (header === HTTP2_HEADER_STATUS) {