quic: fix no onstream handler crash quic

Signed-off-by: Efe Karasakal <hi@efe.dev>
PR-URL: #64158
Reviewed-By: Tim Perry <pimterry@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Stephen Belanger <admin@stephenbelanger.com>

Author: efekrskl

src/quic/application.cc

@@ -761,6 +761,12 @@ class DefaultApplication final : public Session::Application {
 // during the onstream callback (via MakeCallback re-entrancy).
 returnfalse;
  }
+
+// The stream was created, but was immediately destroyed because there's
+// no onstream handler.
+if (stream->is_destroyed()) [[unlikely]] {
+returntrue;
+ }
  } else {
  stream = BaseObjectPtr<Stream>(Stream::From(stream_user_data));
 if (!stream) {

src/quic/session.cc

@@ -860,11 +860,11 @@ struct Session::Impl final : public MemoryRetainer {
  }
  }
 
- endpoint->RemoveSession(config_.scid, remote_address_);
-
 auto& binding = BindingData::Get(env());
 if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
 if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
+
+ endpoint->RemoveSession(config_.scid, remote_address_);
  }
 
 voidMemoryInfo(MemoryTracker* tracker) constoverride {

src/quic/streams.cc

@@ -1325,6 +1325,10 @@ bool Stream::is_pending() const {
 returnstate()->pending;
 }
 
+boolStream::is_destroyed() const {
+returnstats()->destroyed_at != 0;
+}
+
 stream_id Stream::id() const {
 returnstate()->id;
 }

src/quic/streams.h

@@ -267,6 +267,9 @@ class Stream final : public AsyncWrap,
 // to be created.
 boolis_pending() const;
 
+// True if the stream is already destroyed.
+boolis_destroyed() const;
+
 // True if we've completely sent all outbound data for this stream.
 // Importantly, this does not necessarily mean that we are completely
 // done with the outbound data. We may still be waiting on outbound

test/parallel/test-quic-stream-uni-no-onstream.mjs

@@ -0,0 +1,47 @@
+// Flags: --experimental-quic --no-warnings
+// Test: client-initiated unidirectional stream with no onstream
+// The client creates a uni stream with no onstream.
+// Verify that this causes no crash.
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+const{ readKey }=fixtures;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ createPrivateKey }=awaitimport('node:crypto');
+const{ listen, connect }=awaitimport('../common/quic.mjs');
+
+constserverKey=createPrivateKey(readKey('agent1-key.pem'));
+constserverCert=readKey('agent1-cert.pem');
+
+constdone=Promise.withResolvers();
+
+constserverEndpoint=awaitlisten(mustCall(async(session)=>{
+awaitsession.opened;
+done.resolve();
+}),{
+sni: {'*': {keys: [serverKey],certs: [serverCert]}},
+alpn: ['repro'],
+});
+
+constclientSession=awaitconnect(serverEndpoint.address,{
+servername: 'localhost',
+alpn: 'repro',
+ca: serverCert,
+});
+
+awaitclientSession.opened;
+
+awaitclientSession.createUnidirectionalStream({
+body: 'something something darkside',
+});
+
+awaitdone.promise;
+
+awaitclientSession.close();
+
+awaitserverEndpoint.close();

src/quic/application.cc

@@ -761,6 +761,12 @@ class DefaultApplication final : public Session::Application {
 // during the onstream callback (via MakeCallback re-entrancy).
 returnfalse;
  }
+
+// The stream was created, but was immediately destroyed because there's
+// no onstream handler.
+if (stream->is_destroyed()) [[unlikely]] {
+returntrue;
+ }
  } else {
  stream = BaseObjectPtr<Stream>(Stream::From(stream_user_data));
 if (!stream) {

src/quic/session.cc

@@ -860,11 +860,11 @@ struct Session::Impl final : public MemoryRetainer {
  }
  }
 
- endpoint->RemoveSession(config_.scid, remote_address_);
-
 auto& binding = BindingData::Get(env());
 if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
 if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
+
+ endpoint->RemoveSession(config_.scid, remote_address_);
  }
 
 voidMemoryInfo(MemoryTracker* tracker) constoverride {

src/quic/streams.cc

@@ -1325,6 +1325,10 @@ bool Stream::is_pending() const {
 returnstate()->pending;
 }
 
+boolStream::is_destroyed() const {
+returnstats()->destroyed_at != 0;
+}
+
 stream_id Stream::id() const {
 returnstate()->id;
 }

src/quic/streams.h

@@ -267,6 +267,9 @@ class Stream final : public AsyncWrap,
 // to be created.
 boolis_pending() const;
 
+// True if the stream is already destroyed.
+boolis_destroyed() const;
+
 // True if we've completely sent all outbound data for this stream.
 // Importantly, this does not necessarily mean that we are completely
 // done with the outbound data. We may still be waiting on outbound

test/parallel/test-quic-stream-uni-no-onstream.mjs

@@ -0,0 +1,47 @@
+// Flags: --experimental-quic --no-warnings
+// Test: client-initiated unidirectional stream with no onstream
+// The client creates a uni stream with no onstream.
+// Verify that this causes no crash.
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+const{ readKey }=fixtures;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ createPrivateKey }=awaitimport('node:crypto');
+const{ listen, connect }=awaitimport('../common/quic.mjs');
+
+constserverKey=createPrivateKey(readKey('agent1-key.pem'));
+constserverCert=readKey('agent1-cert.pem');
+
+constdone=Promise.withResolvers();
+
+constserverEndpoint=awaitlisten(mustCall(async(session)=>{
+awaitsession.opened;
+done.resolve();
+}),{
+sni: {'*': {keys: [serverKey],certs: [serverCert]}},
+alpn: ['repro'],
+});
+
+constclientSession=awaitconnect(serverEndpoint.address,{
+servername: 'localhost',
+alpn: 'repro',
+ca: serverCert,
+});
+
+awaitclientSession.opened;
+
+awaitclientSession.createUnidirectionalStream({
+body: 'something something darkside',
+});
+
+awaitdone.promise;
+
+awaitclientSession.close();
+
+awaitserverEndpoint.close();

src/quic/application.cc

@@ -761,6 +761,12 @@ class DefaultApplication final : public Session::Application {
 // during the onstream callback (via MakeCallback re-entrancy).
 returnfalse;
  }
+
+// The stream was created, but was immediately destroyed because there's
+// no onstream handler.
+if (stream->is_destroyed()) [[unlikely]] {
+returntrue;
+ }
  } else {
  stream = BaseObjectPtr<Stream>(Stream::From(stream_user_data));
 if (!stream) {

src/quic/session.cc

@@ -860,11 +860,11 @@ struct Session::Impl final : public MemoryRetainer {
  }
  }
 
- endpoint->RemoveSession(config_.scid, remote_address_);
-
 auto& binding = BindingData::Get(env());
 if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
 if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
+
+ endpoint->RemoveSession(config_.scid, remote_address_);
  }
 
 voidMemoryInfo(MemoryTracker* tracker) constoverride {

src/quic/streams.cc

@@ -1325,6 +1325,10 @@ bool Stream::is_pending() const {
 returnstate()->pending;
 }
 
+boolStream::is_destroyed() const {
+returnstats()->destroyed_at != 0;
+}
+
 stream_id Stream::id() const {
 returnstate()->id;
 }

src/quic/streams.h

@@ -267,6 +267,9 @@ class Stream final : public AsyncWrap,
 // to be created.
 boolis_pending() const;
 
+// True if the stream is already destroyed.
+boolis_destroyed() const;
+
 // True if we've completely sent all outbound data for this stream.
 // Importantly, this does not necessarily mean that we are completely
 // done with the outbound data. We may still be waiting on outbound

test/parallel/test-quic-stream-uni-no-onstream.mjs

@@ -0,0 +1,47 @@
+// Flags: --experimental-quic --no-warnings
+// Test: client-initiated unidirectional stream with no onstream
+// The client creates a uni stream with no onstream.
+// Verify that this causes no crash.
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+const{ readKey }=fixtures;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ createPrivateKey }=awaitimport('node:crypto');
+const{ listen, connect }=awaitimport('../common/quic.mjs');
+
+constserverKey=createPrivateKey(readKey('agent1-key.pem'));
+constserverCert=readKey('agent1-cert.pem');
+
+constdone=Promise.withResolvers();
+
+constserverEndpoint=awaitlisten(mustCall(async(session)=>{
+awaitsession.opened;
+done.resolve();
+}),{
+sni: {'*': {keys: [serverKey],certs: [serverCert]}},
+alpn: ['repro'],
+});
+
+constclientSession=awaitconnect(serverEndpoint.address,{
+servername: 'localhost',
+alpn: 'repro',
+ca: serverCert,
+});
+
+awaitclientSession.opened;
+
+awaitclientSession.createUnidirectionalStream({
+body: 'something something darkside',
+});
+
+awaitdone.promise;
+
+awaitclientSession.close();
+
+awaitserverEndpoint.close();

src/quic/application.cc

@@ -761,6 +761,12 @@ class DefaultApplication final : public Session::Application {
 // during the onstream callback (via MakeCallback re-entrancy).
 returnfalse;
  }
+
+// The stream was created, but was immediately destroyed because there's
+// no onstream handler.
+if (stream->is_destroyed()) [[unlikely]] {
+returntrue;
+ }
  } else {
  stream = BaseObjectPtr<Stream>(Stream::From(stream_user_data));
 if (!stream) {

src/quic/session.cc

@@ -860,11 +860,11 @@ struct Session::Impl final : public MemoryRetainer {
  }
  }
 
- endpoint->RemoveSession(config_.scid, remote_address_);
-
 auto& binding = BindingData::Get(env());
 if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
 if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
+
+ endpoint->RemoveSession(config_.scid, remote_address_);
  }
 
 voidMemoryInfo(MemoryTracker* tracker) constoverride {

src/quic/streams.cc

@@ -1325,6 +1325,10 @@ bool Stream::is_pending() const {
 returnstate()->pending;
 }
 
+boolStream::is_destroyed() const {
+returnstats()->destroyed_at != 0;
+}
+
 stream_id Stream::id() const {
 returnstate()->id;
 }

src/quic/streams.h

@@ -267,6 +267,9 @@ class Stream final : public AsyncWrap,
 // to be created.
 boolis_pending() const;
 
+// True if the stream is already destroyed.
+boolis_destroyed() const;
+
 // True if we've completely sent all outbound data for this stream.
 // Importantly, this does not necessarily mean that we are completely
 // done with the outbound data. We may still be waiting on outbound

test/parallel/test-quic-stream-uni-no-onstream.mjs

@@ -0,0 +1,47 @@
+// Flags: --experimental-quic --no-warnings
+// Test: client-initiated unidirectional stream with no onstream
+// The client creates a uni stream with no onstream.
+// Verify that this causes no crash.
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+const{ readKey }=fixtures;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ createPrivateKey }=awaitimport('node:crypto');
+const{ listen, connect }=awaitimport('../common/quic.mjs');
+
+constserverKey=createPrivateKey(readKey('agent1-key.pem'));
+constserverCert=readKey('agent1-cert.pem');
+
+constdone=Promise.withResolvers();
+
+constserverEndpoint=awaitlisten(mustCall(async(session)=>{
+awaitsession.opened;
+done.resolve();
+}),{
+sni: {'*': {keys: [serverKey],certs: [serverCert]}},
+alpn: ['repro'],
+});
+
+constclientSession=awaitconnect(serverEndpoint.address,{
+servername: 'localhost',
+alpn: 'repro',
+ca: serverCert,
+});
+
+awaitclientSession.opened;
+
+awaitclientSession.createUnidirectionalStream({
+body: 'something something darkside',
+});
+
+awaitdone.promise;
+
+awaitclientSession.close();
+
+awaitserverEndpoint.close();

src/quic/application.cc

@@ -761,6 +761,12 @@ class DefaultApplication final : public Session::Application {
 // during the onstream callback (via MakeCallback re-entrancy).
 returnfalse;
  }
+
+// The stream was created, but was immediately destroyed because there's
+// no onstream handler.
+if (stream->is_destroyed()) [[unlikely]] {
+returntrue;
+ }
  } else {
  stream = BaseObjectPtr<Stream>(Stream::From(stream_user_data));
 if (!stream) {

src/quic/session.cc

@@ -860,11 +860,11 @@ struct Session::Impl final : public MemoryRetainer {
  }
  }
 
- endpoint->RemoveSession(config_.scid, remote_address_);
-
 auto& binding = BindingData::Get(env());
 if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
 if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
+
+ endpoint->RemoveSession(config_.scid, remote_address_);
  }
 
 voidMemoryInfo(MemoryTracker* tracker) constoverride {

src/quic/streams.cc

@@ -1325,6 +1325,10 @@ bool Stream::is_pending() const {
 returnstate()->pending;
 }
 
+boolStream::is_destroyed() const {
+returnstats()->destroyed_at != 0;
+}
+
 stream_id Stream::id() const {
 returnstate()->id;
 }

src/quic/streams.h

@@ -267,6 +267,9 @@ class Stream final : public AsyncWrap,
 // to be created.
 boolis_pending() const;
 
+// True if the stream is already destroyed.
+boolis_destroyed() const;
+
 // True if we've completely sent all outbound data for this stream.
 // Importantly, this does not necessarily mean that we are completely
 // done with the outbound data. We may still be waiting on outbound

test/parallel/test-quic-stream-uni-no-onstream.mjs

@@ -0,0 +1,47 @@
+// Flags: --experimental-quic --no-warnings
+// Test: client-initiated unidirectional stream with no onstream
+// The client creates a uni stream with no onstream.
+// Verify that this causes no crash.
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+const{ readKey }=fixtures;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ createPrivateKey }=awaitimport('node:crypto');
+const{ listen, connect }=awaitimport('../common/quic.mjs');
+
+constserverKey=createPrivateKey(readKey('agent1-key.pem'));
+constserverCert=readKey('agent1-cert.pem');
+
+constdone=Promise.withResolvers();
+
+constserverEndpoint=awaitlisten(mustCall(async(session)=>{
+awaitsession.opened;
+done.resolve();
+}),{
+sni: {'*': {keys: [serverKey],certs: [serverCert]}},
+alpn: ['repro'],
+});
+
+constclientSession=awaitconnect(serverEndpoint.address,{
+servername: 'localhost',
+alpn: 'repro',
+ca: serverCert,
+});
+
+awaitclientSession.opened;
+
+awaitclientSession.createUnidirectionalStream({
+body: 'something something darkside',
+});
+
+awaitdone.promise;
+
+awaitclientSession.close();
+
+awaitserverEndpoint.close();

src/quic/application.cc

@@ -761,6 +761,12 @@ class DefaultApplication final : public Session::Application {
 // during the onstream callback (via MakeCallback re-entrancy).
 returnfalse;
  }
+
+// The stream was created, but was immediately destroyed because there's
+// no onstream handler.
+if (stream->is_destroyed()) [[unlikely]] {
+returntrue;
+ }
  } else {
  stream = BaseObjectPtr<Stream>(Stream::From(stream_user_data));
 if (!stream) {

src/quic/session.cc

@@ -860,11 +860,11 @@ struct Session::Impl final : public MemoryRetainer {
  }
  }
 
- endpoint->RemoveSession(config_.scid, remote_address_);
-
 auto& binding = BindingData::Get(env());
 if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
 if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
+
+ endpoint->RemoveSession(config_.scid, remote_address_);
  }
 
 voidMemoryInfo(MemoryTracker* tracker) constoverride {

src/quic/streams.cc

@@ -1325,6 +1325,10 @@ bool Stream::is_pending() const {
 returnstate()->pending;
 }
 
+boolStream::is_destroyed() const {
+returnstats()->destroyed_at != 0;
+}
+
 stream_id Stream::id() const {
 returnstate()->id;
 }

src/quic/streams.h

@@ -267,6 +267,9 @@ class Stream final : public AsyncWrap,
 // to be created.
 boolis_pending() const;
 
+// True if the stream is already destroyed.
+boolis_destroyed() const;
+
 // True if we've completely sent all outbound data for this stream.
 // Importantly, this does not necessarily mean that we are completely
 // done with the outbound data. We may still be waiting on outbound

test/parallel/test-quic-stream-uni-no-onstream.mjs

@@ -0,0 +1,47 @@
+// Flags: --experimental-quic --no-warnings
+// Test: client-initiated unidirectional stream with no onstream
+// The client creates a uni stream with no onstream.
+// Verify that this causes no crash.
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+const{ readKey }=fixtures;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ createPrivateKey }=awaitimport('node:crypto');
+const{ listen, connect }=awaitimport('../common/quic.mjs');
+
+constserverKey=createPrivateKey(readKey('agent1-key.pem'));
+constserverCert=readKey('agent1-cert.pem');
+
+constdone=Promise.withResolvers();
+
+constserverEndpoint=awaitlisten(mustCall(async(session)=>{
+awaitsession.opened;
+done.resolve();
+}),{
+sni: {'*': {keys: [serverKey],certs: [serverCert]}},
+alpn: ['repro'],
+});
+
+constclientSession=awaitconnect(serverEndpoint.address,{
+servername: 'localhost',
+alpn: 'repro',
+ca: serverCert,
+});
+
+awaitclientSession.opened;
+
+awaitclientSession.createUnidirectionalStream({
+body: 'something something darkside',
+});
+
+awaitdone.promise;
+
+awaitclientSession.close();
+
+awaitserverEndpoint.close();

src/quic/application.cc

@@ -761,6 +761,12 @@ class DefaultApplication final : public Session::Application {
 // during the onstream callback (via MakeCallback re-entrancy).
 returnfalse;
  }
+
+// The stream was created, but was immediately destroyed because there's
+// no onstream handler.
+if (stream->is_destroyed()) [[unlikely]] {
+returntrue;
+ }
  } else {
  stream = BaseObjectPtr<Stream>(Stream::From(stream_user_data));
 if (!stream) {

src/quic/session.cc

@@ -860,11 +860,11 @@ struct Session::Impl final : public MemoryRetainer {
  }
  }
 
- endpoint->RemoveSession(config_.scid, remote_address_);
-
 auto& binding = BindingData::Get(env());
 if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
 if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
+
+ endpoint->RemoveSession(config_.scid, remote_address_);
  }
 
 voidMemoryInfo(MemoryTracker* tracker) constoverride {

src/quic/streams.cc

@@ -1325,6 +1325,10 @@ bool Stream::is_pending() const {
 returnstate()->pending;
 }
 
+boolStream::is_destroyed() const {
+returnstats()->destroyed_at != 0;
+}
+
 stream_id Stream::id() const {
 returnstate()->id;
 }

src/quic/streams.h

@@ -267,6 +267,9 @@ class Stream final : public AsyncWrap,
 // to be created.
 boolis_pending() const;
 
+// True if the stream is already destroyed.
+boolis_destroyed() const;
+
 // True if we've completely sent all outbound data for this stream.
 // Importantly, this does not necessarily mean that we are completely
 // done with the outbound data. We may still be waiting on outbound

test/parallel/test-quic-stream-uni-no-onstream.mjs

@@ -0,0 +1,47 @@
+// Flags: --experimental-quic --no-warnings
+// Test: client-initiated unidirectional stream with no onstream
+// The client creates a uni stream with no onstream.
+// Verify that this causes no crash.
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+const{ readKey }=fixtures;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ createPrivateKey }=awaitimport('node:crypto');
+const{ listen, connect }=awaitimport('../common/quic.mjs');
+
+constserverKey=createPrivateKey(readKey('agent1-key.pem'));
+constserverCert=readKey('agent1-cert.pem');
+
+constdone=Promise.withResolvers();
+
+constserverEndpoint=awaitlisten(mustCall(async(session)=>{
+awaitsession.opened;
+done.resolve();
+}),{
+sni: {'*': {keys: [serverKey],certs: [serverCert]}},
+alpn: ['repro'],
+});
+
+constclientSession=awaitconnect(serverEndpoint.address,{
+servername: 'localhost',
+alpn: 'repro',
+ca: serverCert,
+});
+
+awaitclientSession.opened;
+
+awaitclientSession.createUnidirectionalStream({
+body: 'something something darkside',
+});
+
+awaitdone.promise;
+
+awaitclientSession.close();
+
+awaitserverEndpoint.close();

src/quic/application.cc

@@ -761,6 +761,12 @@ class DefaultApplication final : public Session::Application {
 // during the onstream callback (via MakeCallback re-entrancy).
 returnfalse;
  }
+
+// The stream was created, but was immediately destroyed because there's
+// no onstream handler.
+if (stream->is_destroyed()) [[unlikely]] {
+returntrue;
+ }
  } else {
  stream = BaseObjectPtr<Stream>(Stream::From(stream_user_data));
 if (!stream) {

src/quic/session.cc

@@ -860,11 +860,11 @@ struct Session::Impl final : public MemoryRetainer {
  }
  }
 
- endpoint->RemoveSession(config_.scid, remote_address_);
-
 auto& binding = BindingData::Get(env());
 if (stats_slot_) GetSessionStatsArena(binding).ReleaseSlot(stats_slot_);
 if (state_slot_) GetSessionStateArena(binding).ReleaseSlot(state_slot_);
+
+ endpoint->RemoveSession(config_.scid, remote_address_);
  }
 
 voidMemoryInfo(MemoryTracker* tracker) constoverride {

src/quic/streams.cc

@@ -1325,6 +1325,10 @@ bool Stream::is_pending() const {
 returnstate()->pending;
 }
 
+boolStream::is_destroyed() const {
+returnstats()->destroyed_at != 0;
+}
+
 stream_id Stream::id() const {
 returnstate()->id;
 }

src/quic/streams.h

@@ -267,6 +267,9 @@ class Stream final : public AsyncWrap,
 // to be created.
 boolis_pending() const;
 
+// True if the stream is already destroyed.
+boolis_destroyed() const;
+
 // True if we've completely sent all outbound data for this stream.
 // Importantly, this does not necessarily mean that we are completely
 // done with the outbound data. We may still be waiting on outbound

test/parallel/test-quic-stream-uni-no-onstream.mjs

@@ -0,0 +1,47 @@
+// Flags: --experimental-quic --no-warnings
+// Test: client-initiated unidirectional stream with no onstream
+// The client creates a uni stream with no onstream.
+// Verify that this causes no crash.
+
+import{hasQuic,skip,mustCall}from'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+
+const{ readKey }=fixtures;
+
+if(!hasQuic){
+skip('QUIC is not enabled');
+}
+
+const{ createPrivateKey }=awaitimport('node:crypto');
+const{ listen, connect }=awaitimport('../common/quic.mjs');
+
+constserverKey=createPrivateKey(readKey('agent1-key.pem'));
+constserverCert=readKey('agent1-cert.pem');
+
+constdone=Promise.withResolvers();
+
+constserverEndpoint=awaitlisten(mustCall(async(session)=>{
+awaitsession.opened;
+done.resolve();
+}),{
+sni: {'*': {keys: [serverKey],certs: [serverCert]}},
+alpn: ['repro'],
+});
+
+constclientSession=awaitconnect(serverEndpoint.address,{
+servername: 'localhost',
+alpn: 'repro',
+ca: serverCert,
+});
+
+awaitclientSession.opened;
+
+awaitclientSession.createUnidirectionalStream({
+body: 'something something darkside',
+});
+
+awaitdone.promise;
+
+awaitclientSession.close();
+
+awaitserverEndpoint.close();