http2: reinject data received before http2 is attached

Reinject the data already received from the TLS
socket when the HTTP2 client is attached with a
delay
Fixes: #35475
PR-URL: #35678
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Alba Mendez <me@alba.sh>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Ricky Zhou <0x19951125@gmail.com>

Author: mmomtchev

lib/internal/http2/core.js

@@ -1037,7 +1037,7 @@ function finishSessionClose(session, error) {
 if(socket&&!socket.destroyed){
 // Always wait for writable side to finish.
 socket.end((err)=>{
-debugSessionObj(session,'finishSessionClose socket end',err);
+debugSessionObj(session,'finishSessionClose socket end',err,error);
 // Due to the way the underlying stream is handled in Http2Session we
 // won't get graceful Readable end from the other side even if it was sent
 // as the stream is already considered closed and will neither be read
@@ -1055,7 +1055,7 @@ function finishSessionClose(session, error) {
 }
 
 functioncloseSession(session,code,error){
-debugSessionObj(session,'start closing/destroying');
+debugSessionObj(session,'start closing/destroying',error);
 
 conststate=session[kState];
 state.flags|=SESSION_FLAGS_DESTROYED;
@@ -3140,6 +3140,17 @@ function connect(authority, options, listener) {
 
 if(typeoflistener==='function')
 session.once('connect',listener);
+
+debug('Http2Session connect',options.createConnection);
+// Socket already has some buffered data - emulate receiving it
+// https://github.com/nodejs/node/issues/35475
+if(typeofoptions.createConnection==='function'){
+letbuf;
+while((buf=socket.read())!==null){
+debug(`Http2Session connect: injecting ${buf.length} already in buffer`);
+session[kHandle].receive(buf);
+}
+}
 returnsession;
 }
 

src/node_http2.cc

@@ -1829,6 +1829,33 @@ void Http2Session::Consume(Local<Object> stream_obj) {
 Debug(this, "i/o stream consumed");
 }
 
+// Allow injecting of data from JS
+// This is used when the socket has already some data received
+// before our listener was attached
+// https://github.com/nodejs/node/issues/35475
+voidHttp2Session::Receive(const FunctionCallbackInfo<Value>& args) {
+ Http2Session* session;
+ASSIGN_OR_RETURN_UNWRAP(&session, args.Holder());
+CHECK(args[0]->IsObject());
+
+ ArrayBufferViewContents<char> buffer(args[0]);
+constchar* data = buffer.data();
+size_t len = buffer.length();
+Debug(session, "Receiving %zu bytes injected from JS", len);
+
+// Copy given buffer
+while (len > 0) {
+uv_buf_t buf = session->OnStreamAlloc(len);
+size_t copy = buf.len > len ? len : buf.len;
+memcpy(buf.base, data, copy);
+ buf.len = copy;
+ session->OnStreamRead(copy, buf);
+
+ data += copy;
+ len -= copy;
+ }
+}
+
 Http2Stream* Http2Stream::New(Http2Session* session,
 int32_t id,
  nghttp2_headers_category category,
@@ -3054,6 +3081,7 @@ void Initialize(Local<Object> target,
  env->SetProtoMethod(session, "altsvc", Http2Session::AltSvc);
  env->SetProtoMethod(session, "ping", Http2Session::Ping);
  env->SetProtoMethod(session, "consume", Http2Session::Consume);
+ env->SetProtoMethod(session, "receive", Http2Session::Receive);
  env->SetProtoMethod(session, "destroy", Http2Session::Destroy);
  env->SetProtoMethod(session, "goaway", Http2Session::Goaway);
  env->SetProtoMethod(session, "settings", Http2Session::Settings);

src/node_http2.h

@@ -694,6 +694,7 @@ class Http2Session : public AsyncWrap,
 // The JavaScript API
 staticvoidNew(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidConsume(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidReceive(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidDestroy(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidSettings(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidRequest(const v8::FunctionCallbackInfo<v8::Value>& args);

test/parallel/test-http2-connect-tls-with-delay.js

@@ -0,0 +1,64 @@
+// Flags: --expose-internals
+'use strict';
+constcommon=require('../common');
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+if(!common.hasMultiLocalhost())
+common.skip('platform-specific test.');
+
+consthttp2=require('http2');
+constassert=require('assert');
+consttls=require('tls');
+constfixtures=require('../common/fixtures');
+
+constserverOptions={
+key: fixtures.readKey('agent1-key.pem'),
+cert: fixtures.readKey('agent1-cert.pem')
+};
+constserver=http2.createSecureServer(serverOptions,(req,res)=>{
+console.log(`Connect from: ${req.connection.remoteAddress}`);
+assert.strictEqual(req.connection.remoteAddress,'127.0.0.2');
+
+req.on('end',common.mustCall(()=>{
+res.writeHead(200,{'Content-Type': 'text/plain'});
+res.end(`You are from: ${req.connection.remoteAddress}`);
+}));
+req.resume();
+});
+
+server.listen(0,'127.0.0.1',common.mustCall(()=>{
+constoptions={
+ALPNProtocols: ['h2'],
+host: '127.0.0.1',
+servername: 'localhost',
+localAddress: '127.0.0.2',
+port: server.address().port,
+rejectUnauthorized: false
+};
+
+console.log('Server ready',server.address().port);
+
+constsocket=tls.connect(options,async()=>{
+
+console.log('TLS Connected!');
+
+setTimeout(()=>{
+
+constclient=http2.connect(
+'https://localhost:'+server.address().port,
+{ ...options,createConnection: ()=>socket}
+);
+constreq=client.request({
+':path': '/'
+});
+req.on('data',()=>req.resume());
+req.on('end',common.mustCall(function(){
+client.close();
+req.close();
+server.close();
+}));
+req.end();
+},1000);
+});
+}));