http1 encode trailers in chunk encoding

source/common/http/http1/codec_impl.cc

@@ -32,7 +32,8 @@ const StringUtil::CaseUnorderedSet& caseUnorderdSetContainingUpgradeAndHttp2Sett
 } // namespace
 
 const std::string StreamEncoderImpl::CRLF = "\r\n";
-const std::string StreamEncoderImpl::LAST_CHUNK = "0\r\n\r\n";
+// Last chunk as defined here https://tools.ietf.org/html/rfc7230#section-4.1
+const std::string StreamEncoderImpl::LAST_CHUNK = "0\r\n";
 
 StreamEncoderImpl::StreamEncoderImpl(ConnectionImpl& connection) : connection_(connection) {
   if (connection_.connection().aboveHighWatermark()) {
@@ -171,7 +172,30 @@ void StreamEncoderImpl::encodeData(Buffer::Instance& data, bool end_stream) {
   }
 }
 
-void StreamEncoderImpl::encodeTrailers(const HeaderMap&) { endEncode(); }
+void StreamEncoderImpl::encodeTrailers(const HeaderMap& trailers) {
+  if (chunk_encoding_) {
+    // Finalize the body
+    connection_.buffer().add(LAST_CHUNK);
+
+    // Trailers only matter if it is a chunk transfer encoding
+    // https://tools.ietf.org/html/rfc7230#section-4.4
+    trailers.iterate(
+        [](const HeaderEntry& header, void* context) -> HeaderMap::Iterate {
+          Buffer::WatermarkBuffer* buffer = static_cast<Buffer::WatermarkBuffer*>(context);
+          buffer->add(header.key().getStringView());
+          buffer->add(":");
+          buffer->add(header.value().getStringView());
+          buffer->add(CRLF);
+          return HeaderMap::Iterate::Continue;
+        },
+        &connection_.buffer());
+
+    connection_.buffer().add(CRLF);
+  }
+
+  connection_.flushOutput();
+  connection_.onEncodeComplete();
+}
 
 void StreamEncoderImpl::encodeMetadata(const MetadataMapVector&) {
   connection_.stats().metadata_not_supported_error_.inc();
@@ -180,6 +204,7 @@ void StreamEncoderImpl::encodeMetadata(const MetadataMapVector&) {
 void StreamEncoderImpl::endEncode() {
   if (chunk_encoding_) {
     connection_.buffer().add(LAST_CHUNK);
+    connection_.buffer().add(CRLF);
   }
 
   connection_.flushOutput();

test/common/http/http1/codec_impl_test.cc

@@ -652,8 +652,13 @@ TEST_F(Http1ServerConnectionImplTest, ChunkedResponse) {
   response_encoder->encodeHeaders(headers, false);
 
   Buffer::OwnedImpl data("Hello World");
-  response_encoder->encodeData(data, true);
-  EXPECT_EQ("HTTP/1.1 200 OK\r\ntransfer-encoding: chunked\r\n\r\nb\r\nHello World\r\n0\r\n\r\n",
+  response_encoder->encodeData(data, false);
+
+  TestHeaderMapImpl trailers{{"foo", "bar"}, {"foo", "baz"}};
+  response_encoder->encodeTrailers(trailers);
+
+  EXPECT_EQ("HTTP/1.1 200 OK\r\ntransfer-encoding: chunked\r\n\r\nb\r\nHello "
+            "World\r\n0\r\nfoo:bar\r\nfoo:baz\r\n\r\n",
             output);
 }
 

test/integration/integration_test.cc

@@ -283,6 +283,39 @@ TEST_P(IntegrationTest, HittingGrpcFilterLimitBufferingHeaders) {
               HeaderValueOf(Headers::get().GrpcStatus, "2")); // Unknown gRPC error
 }
 
+TEST_P(IntegrationTest, TrailersWithHttp1AndHttp2) {
+  setUpstreamProtocol(FakeHttpConnection::Type::HTTP2);
+  Http::TestHeaderMapImpl response_trailers{{"response1", "trailer1"}, {"response2", "trailer2"}};
+
+  initialize();
+  codec_client_ = makeHttpConnection(lookupPort("http"));
+  auto encoder_decoder =
+      codec_client_->startRequest(Http::TestHeaderMapImpl{{":method", "POST"},
+                                                          {":path", "/test/long/url"},
+                                                          {":scheme", "http"},
+                                                          {":authority", "host"},
+                                                          {"TE", "trailers"},
+                                                          {"Accept", "*/*"}});
+  request_encoder_ = &encoder_decoder.first;
+  codec_client_->sendData(*request_encoder_, 0, true);
+
+  auto response = std::move(encoder_decoder.second);
+
+  waitForNextUpstreamRequest();
+  upstream_request_->encodeHeaders(default_response_headers_, false);
+  upstream_request_->encodeData(5, false);
+  upstream_request_->encodeTrailers(response_trailers);
+  response->waitForEndStream();
+
+  ASSERT_TRUE(upstream_request_->complete());
+  ASSERT_TRUE(response->complete());
+
+  EXPECT_EQ(5, response->body().size());
+  EXPECT_EQ("aaaaa", response->body());
+  EXPECT_EQ("200", response->headers().Status()->value().getStringView());
+  EXPECT_THAT(*response->trailers(), HeaderMapEqualRef(&response_trailers));
+}
+
 TEST_P(IntegrationTest, BadFirstline) {
   initialize();
   std::string response;