From a4d910c644fa88716058cb83bdc0ecb9df530f69 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Mon, 8 Jan 2018 12:18:22 -0800
Subject: [PATCH] http2: remember sent headers

Add sentHeaders, sentTrailers, and sentInfoHeaders properties
on `Http2Stream`.

Backport-PR-URL: https://github.com/nodejs/node/pull/20456
PR-URL: https://github.com/nodejs/node/pull/18045
Fixes: https://github.com/nodejs/node/issues/16619
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 doc/api/http2.md                         | 28 ++++++++++++++
 lib/internal/http2/core.js               | 24 ++++++++++++
 test/parallel/test-http2-sent-headers.js | 47 ++++++++++++++++++++++++
 3 files changed, 99 insertions(+)
 create mode 100644 test/parallel/test-http2-sent-headers.js

diff --git a/doc/api/http2.md b/doc/api/http2.md
index e92baddf3cc695..f92aec7288d0e7 100644
--- a/doc/api/http2.md
+++ b/doc/api/http2.md
@@ -989,6 +989,34 @@ destroyed after either receiving an `RST_STREAM` frame from the connected peer,
 calling `http2stream.close()`, or `http2stream.destroy()`. Will be
 `undefined` if the `Http2Stream` has not been closed.
 
+#### http2stream.sentHeaders
+<!-- YAML
+added: REPLACEME
+-->
+
+* Value: {[Headers Object][]}
+
+An object containing the outbound headers sent for this `Http2Stream`.
+
+#### http2stream.sentInfoHeaders
+<!-- YAML
+added: REPLACEME
+-->
+
+* Value: {[Headers Object][]\[\]}
+
+An array of objects containing the outbound informational (additional) headers
+sent for this `Http2Stream`.
+
+#### http2stream.sentTrailers
+<!-- YAML
+added: REPLACEME
+-->
+
+* Value: {[Headers Object][]}
+
+An object containing the outbound trailers sent for this this `HttpStream`.
+
 #### http2stream.session
 <!-- YAML
 added: v8.4.0
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index 204aa2bdbc3069..3e68ed4a59f750 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -74,6 +74,7 @@ const kEncrypted = Symbol('encrypted');
 const kHandle = Symbol('handle');
 const kID = Symbol('id');
 const kInit = Symbol('init');
+const kInfoHeaders = Symbol('sent-info-headers');
 const kMaybeDestroy = Symbol('maybe-destroy');
 const kLocalSettings = Symbol('local-settings');
 const kOptions = Symbol('options');
@@ -82,6 +83,8 @@ const kProceed = Symbol('proceed');
 const kProtocol = Symbol('protocol');
 const kProxySocket = Symbol('proxy-socket');
 const kRemoteSettings = Symbol('remote-settings');
+const kSentHeaders = Symbol('sent-headers');
+const kSentTrailers = Symbol('sent-trailers');
 const kServer = Symbol('server');
 const kSession = Symbol('session');
 const kState = Symbol('state');
@@ -256,6 +259,7 @@ function onStreamTrailers() {
     stream.destroy(headersList);
     return [];
   }
+  stream[kSentTrailers] = trailers;
   return headersList;
 }
 
@@ -1344,6 +1348,7 @@ class ClientHttp2Session extends Http2Session {
       throw headersList;
 
     const stream = new ClientHttp2Stream(this, undefined, undefined, {});
+    stream[kSentHeaders] = headers;
 
     // Close the writable side of the stream if options.endStream is set.
     if (options.endStream)
@@ -1507,6 +1512,18 @@ class Http2Stream extends Duplex {
     return `Http2Stream ${util.format(obj)}`;
   }
 
+  get sentHeaders() {
+    return this[kSentHeaders];
+  }
+
+  get sentTrailers() {
+    return this[kSentTrailers];
+  }
+
+  get sentInfoHeaders() {
+    return this[kInfoHeaders];
+  }
+
   get pending() {
     return this[kID] === undefined;
   }
@@ -1846,6 +1863,7 @@ function processRespondWithFD(self, fd, headers, offset = 0, length = -1,
   state.flags |= STREAM_FLAGS_HEADERS_SENT;
 
   const headersList = mapToHeaders(headers, assertValidPseudoHeaderResponse);
+  self[kSentHeaders] = headers;
   if (!Array.isArray(headersList)) {
     self.destroy(headersList);
     return;
@@ -2076,6 +2094,7 @@ class ServerHttp2Stream extends Http2Stream {
 
     const id = ret.id();
     const stream = new ServerHttp2Stream(session, ret, id, options, headers);
+    stream[kSentHeaders] = headers;
 
     if (options.endStream)
       stream.end();
@@ -2135,6 +2154,7 @@ class ServerHttp2Stream extends Http2Stream {
     const headersList = mapToHeaders(headers, assertValidPseudoHeaderResponse);
     if (!Array.isArray(headersList))
       throw headersList;
+    this[kSentHeaders] = headers;
 
     state.flags |= STREAM_FLAGS_HEADERS_SENT;
 
@@ -2320,6 +2340,10 @@ class ServerHttp2Stream extends Http2Stream {
     const headersList = mapToHeaders(headers, assertValidPseudoHeaderResponse);
     if (!Array.isArray(headersList))
       throw headersList;
+    if (!this[kInfoHeaders])
+      this[kInfoHeaders] = [headers];
+    else
+      this[kInfoHeaders].push(headers);
 
     const ret = this[kHandle].info(headersList);
     if (ret < 0)
diff --git a/test/parallel/test-http2-sent-headers.js b/test/parallel/test-http2-sent-headers.js
new file mode 100644
index 00000000000000..bffa4d71c6d5f3
--- /dev/null
+++ b/test/parallel/test-http2-sent-headers.js
@@ -0,0 +1,47 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+const assert = require('assert');
+const h2 = require('http2');
+
+const server = h2.createServer();
+
+server.on('stream', common.mustCall((stream) => {
+  stream.additionalHeaders({ ':status': 102 });
+  assert.strictEqual(stream.sentInfoHeaders[0][':status'], 102);
+
+  stream.respond({ abc: 'xyz' }, {
+    getTrailers(headers) {
+      headers.xyz = 'abc';
+    }
+  });
+  assert.strictEqual(stream.sentHeaders.abc, 'xyz');
+  assert.strictEqual(stream.sentHeaders[':status'], 200);
+  assert.notStrictEqual(stream.sentHeaders.date, undefined);
+  stream.end();
+  stream.on('close', () => {
+    assert.strictEqual(stream.sentTrailers.xyz, 'abc');
+  });
+}));
+
+server.listen(0, common.mustCall(() => {
+  const client = h2.connect(`http://localhost:${server.address().port}`);
+  const req = client.request();
+
+  req.on('headers', common.mustCall((headers) => {
+    assert.strictEqual(headers[':status'], 102);
+  }));
+
+  assert.strictEqual(req.sentHeaders[':method'], 'GET');
+  assert.strictEqual(req.sentHeaders[':authority'],
+                     `localhost:${server.address().port}`);
+  assert.strictEqual(req.sentHeaders[':scheme'], 'http');
+  assert.strictEqual(req.sentHeaders[':path'], '/');
+  req.resume();
+  req.on('close', () => {
+    server.close();
+    client.close();
+  });
+}));