@fails-components/webtransport-transport-http3-quiche 1.1.4 → 1.2.0

package/CMakeLists.txt

@@ -27,6 +27,7 @@ ENDIF(WIN32)
 
 set(ABSL_PROPAGATE_CXX_STD ON)
 # include abseil
+set(ABSL_MSVC_STATIC_RUNTIME ON)
 add_subdirectory(third_party/abseil-cpp EXCLUDE_FROM_ALL)
 
 
@@ -82,12 +83,10 @@ platform/quiche_platform_impl/quiche_event_loop_impl.h
 platform/quiche_platform_impl/quiche_bug_tracker_impl.h
 platform/quiche_platform_impl/quiche_googleurl_impl.h
 platform/quiche_platform_impl/quiche_iovec_impl.h
-platform/quiche_platform_impl/quiche_mutex_impl.h
 platform/quiche_platform_impl/quiche_stack_trace_impl.h
 platform/quiche_platform_impl/quiche_stream_buffer_allocator_impl.h
 platform/quiche_platform_impl/quiche_time_utils_impl.h
 platform/quiche_platform_impl/quiche_udp_socket_platform_impl.h
-platform/quiche_platform_impl/quiche_prefetch_impl.h
 platform/quiche_platform_impl/quiche_server_stats_impl.h
 platform/quiche_platform_impl/quiche_mem_slice_impl.h
 platform/quiche_platform_impl/quiche_flag_utils_impl.h
@@ -159,9 +158,6 @@ third_party/quiche/quiche/common/platform/api/quiche_hostname_utils.h
 third_party/quiche/quiche/common/platform/api/quiche_iovec.h
 third_party/quiche/quiche/common/platform/api/quiche_logging.h
 third_party/quiche/quiche/common/platform/api/quiche_mem_slice.h
-third_party/quiche/quiche/common/platform/api/quiche_mutex.cc
-third_party/quiche/quiche/common/platform/api/quiche_mutex.h
-third_party/quiche/quiche/common/platform/api/quiche_prefetch.h
 third_party/quiche/quiche/common/platform/api/quiche_reference_counted.h
 third_party/quiche/quiche/common/platform/api/quiche_time_utils.h
 third_party/quiche/quiche/common/platform/api/quiche_url_utils.h
@@ -170,11 +166,9 @@ third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_co
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flag_utils_impl.h
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.cc
-third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_prefetch_impl.h
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.cc
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_logging_impl.h
-third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.cc
-third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h
+third_party/quiche/quiche/common/platform/api/quiche_mem_slice.cc
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_stack_trace_impl.cc
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_stack_trace_impl.h
 third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_iovec_impl.h
@@ -201,11 +195,15 @@ third_party/quiche/quiche/common/quiche_random.cc
 third_party/quiche/quiche/common/quiche_random.h
 third_party/quiche/quiche/common/quiche_simple_arena.cc
 third_party/quiche/quiche/common/quiche_simple_arena.h
+third_party/quiche/quiche/common/quiche_socket_address.cc
+third_party/quiche/quiche/common/quiche_socket_address.h
 third_party/quiche/quiche/common/quiche_text_utils.cc
 third_party/quiche/quiche/common/quiche_text_utils.h
 third_party/quiche/quiche/common/simple_buffer_allocator.cc
 third_party/quiche/quiche/common/structured_headers.h
 third_party/quiche/quiche/common/structured_headers.cc
+third_party/quiche/quiche/common/vectorized_io_utils.h
+third_party/quiche/quiche/common/vectorized_io_utils.cc
 third_party/quiche/quiche/http2/adapter/data_source.h
 third_party/quiche/quiche/http2/adapter/event_forwarder.cc
 third_party/quiche/quiche/http2/adapter/event_forwarder.h
@@ -228,8 +226,12 @@ third_party/quiche/quiche/http2/adapter/oghttp2_util.cc
 third_party/quiche/quiche/http2/adapter/oghttp2_util.h
 third_party/quiche/quiche/http2/adapter/window_manager.cc
 third_party/quiche/quiche/http2/adapter/window_manager.h
+third_party/quiche/quiche/http2/core/http2_constants.cc
+third_party/quiche/quiche/http2/core/http2_constants.h
 third_party/quiche/quiche/http2/core/http2_frame_decoder_adapter.cc
 third_party/quiche/quiche/http2/core/http2_frame_decoder_adapter.h
+third_party/quiche/quiche/http2/core/http2_structures.cc
+third_party/quiche/quiche/http2/core/http2_structures.h
 third_party/quiche/quiche/http2/core/http2_trace_logging.cc
 third_party/quiche/quiche/http2/core/http2_trace_logging.h
 third_party/quiche/quiche/http2/core/priority_write_scheduler.h
@@ -343,10 +345,6 @@ third_party/quiche/quiche/http2/hpack/varint/hpack_varint_decoder.cc
 third_party/quiche/quiche/http2/hpack/varint/hpack_varint_decoder.h
 third_party/quiche/quiche/http2/hpack/varint/hpack_varint_encoder.cc
 third_party/quiche/quiche/http2/hpack/varint/hpack_varint_encoder.h
-third_party/quiche/quiche/http2/http2_constants.cc
-third_party/quiche/quiche/http2/http2_constants.h
-third_party/quiche/quiche/http2/http2_structures.cc
-third_party/quiche/quiche/http2/http2_structures.h
 #third_party/quiche/quiche/http2/platform/api/http2_macros.h
 #third_party/quiche/quiche/quic/bindings/quic_libevent.h
 #third_party/quiche/quiche/quic/bindings/quic_libevent.cc
@@ -504,6 +502,8 @@ third_party/quiche/quiche/quic/core/frames/quic_goaway_frame.cc
 third_party/quiche/quiche/quic/core/frames/quic_goaway_frame.h
 third_party/quiche/quiche/quic/core/frames/quic_handshake_done_frame.cc
 third_party/quiche/quiche/quic/core/frames/quic_handshake_done_frame.h
+third_party/quiche/quiche/quic/core/frames/quic_immediate_ack_frame.cc
+third_party/quiche/quiche/quic/core/frames/quic_immediate_ack_frame.h
 third_party/quiche/quiche/quic/core/frames/quic_inlined_frame.h
 third_party/quiche/quiche/quic/core/frames/quic_max_streams_frame.cc
 third_party/quiche/quiche/quic/core/frames/quic_max_streams_frame.h
@@ -596,8 +596,6 @@ third_party/quiche/quiche/quic/core/packet_number_indexed_queue.h
 third_party/quiche/quiche/quic/core/proto/cached_network_parameters_proto.h
 third_party/quiche/quiche/quic/core/proto/crypto_server_config_proto.h
 third_party/quiche/quiche/quic/core/proto/source_address_token_proto.h
-third_party/quiche/quiche/quic/core/qpack/qpack_blocking_manager.cc
-third_party/quiche/quiche/quic/core/qpack/qpack_blocking_manager.h
 third_party/quiche/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.cc
 third_party/quiche/quiche/quic/core/qpack/qpack_decoded_headers_accumulator.h
 third_party/quiche/quiche/quic/core/qpack/qpack_decoder.cc
@@ -634,6 +632,8 @@ third_party/quiche/quiche/quic/core/qpack/qpack_static_table.cc
 third_party/quiche/quiche/quic/core/qpack/qpack_static_table.h
 third_party/quiche/quiche/quic/core/qpack/qpack_stream_receiver.h
 third_party/quiche/quiche/quic/core/qpack/qpack_stream_sender_delegate.h
+third_party/quiche/quiche/quic/core/qpack/new_qpack_blocking_manager.h
+third_party/quiche/quiche/quic/core/qpack/new_qpack_blocking_manager.cc
 third_party/quiche/quiche/quic/core/qpack/value_splitting_header_list.cc
 third_party/quiche/quiche/quic/core/qpack/value_splitting_header_list.h
 third_party/quiche/quiche/quic/core/quic_ack_listener_interface.cc
@@ -807,12 +807,14 @@ third_party/quiche/quiche/quic/platform/api/quic_logging.h
 #third_party/quiche/quiche/quic/platform/api/quic_mem_slice_storage.cc
 #third_party/quiche/quiche/quic/platform/api/quic_mem_slice_storage.h
 third_party/quiche/quiche/quic/platform/api/quic_server_stats.h
-third_party/quiche/quiche/quic/platform/api/quic_socket_address.cc
-third_party/quiche/quiche/quic/platform/api/quic_socket_address.h
 third_party/quiche/quiche/quic/platform/api/quic_stack_trace.h
 third_party/quiche/quiche/quic/platform/api/quic_thread.h
 third_party/quiche/quiche/quic/tools/quic_simple_crypto_server_stream_helper.cc
 third_party/quiche/quiche/quic/tools/quic_simple_crypto_server_stream_helper.h
+third_party/quiche/quiche/web_transport/web_transport_headers.cc
+third_party/quiche/quiche/web_transport/web_transport_headers.h
+third_party/quiche/quiche/web_transport/web_transport_priority_scheduler.cc
+third_party/quiche/quiche/web_transport/web_transport_priority_scheduler.h
 )
 
 IF(APPLE OR WIN32)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport-transport-http3-quiche",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "A component to add webtransport support (server and client) to node.js, transport using libquiche",
   "exports": {
     ".": {
@@ -50,13 +50,13 @@
     "@types/node": "^18.15.3",
     "eslint": "^9.3.0",
     "eslint-config-prettier": "^9.1.0",
-    "eslint-config-standard": "^16.0.2",
-    "eslint-plugin-import": "^2.25.2",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-promise": "^4.3.1",
-    "eslint-plugin-standard": "^4.1.0",
+    "eslint-plugin-promise": "^7.2.1",
     "prettier": "^3.2.5",
+    "prettier-linter-helpers": "^1.0.0",
+    "synckit": "^0.11.4",
     "typescript": "^4.8.4"
   },
   "binary": {

package/src/http3backendresponse.h

@@ -14,7 +14,7 @@
 #include <memory>
 
 #include "absl/strings/string_view.h"
-#include "quiche/spdy/core/spdy_protocol.h"
+#include "quiche/http2/core/spdy_protocol.h"
 
 namespace quic
 {

package/src/http3client.cc

@@ -162,7 +162,8 @@ namespace quic
                              std::unique_ptr<ProofVerifier> proof_verifier,
                              std::unique_ptr<SessionCache> session_cache,
                              std::unique_ptr<QuicConnectionHelperInterface> helper,
-                             QuicConfig config) :
+                             QuicConfig config,
+                             const std::vector<std::string>& protocols) :
           initialized_(false),
           store_response_(false),
           latest_response_code_(-1),
@@ -188,7 +189,8 @@ namespace quic
           num_attempts_connect_(0),
           webtransport_server_support_inform_(false),
           connection_debug_visitor_(nullptr),
-          priority_(HttpStreamPriority())
+          priority_(HttpStreamPriority()),
+          protocols_(protocols)
     {
        
     }
@@ -622,7 +624,16 @@ namespace quic
         headers[":path"] = path;
         headers[":method"] = "CONNECT";
         headers[":protocol"] = "webtransport";
-
+        if (protocols_.size() > 0) { // not very efficient
+            std::string protocols = "";
+            for (size_t i=0; i < protocols_.size(); i++) {
+                protocols += protocols_[i];
+                if (i!= protocols_.size()-1) {
+                    protocols += ',';
+                }
+            }
+            headers["wt-available-protocols"] = protocols;
+        }
         SendMessageAsync(headers, "", /*fin=*/false);
     }
 
@@ -1141,6 +1152,7 @@ namespace quic
     {
         bool allowPooling = false;
         std::vector<WebTransportHash> serverCertificateHashes;
+        std::vector<std::string> protocols;
         std::string privkey;
         QuicConfig cconfig;
         auto env = info.Env();
@@ -1240,6 +1252,26 @@ namespace quic
                     cconfig.SetInitialMaxStreamDataBytesIncomingBidirectionalToSend(streamFlowControlWindowSizeLimitWindow);
                     cconfig.SetInitialMaxStreamDataBytesUnidirectionalToSend(streamFlowControlWindowSizeLimitWindow);
                 }
+                if (lobj.Has("protocols") && !(lobj).Get("protocols").IsEmpty()) {
+                    Napi::Value protocolValue = (lobj).Get("protocols");
+                    if (protocolValue.IsArray())
+                    {
+                        Napi::Array protocolArray = protocolValue.As<Napi::Array>();
+                        unsigned int length = protocolArray.Length();
+
+                        for (unsigned int i = 0; i < length; i++)
+                        {
+                            Napi::Value protocolValue = protocolArray.Get(i);
+                            Napi::String protocolString = protocolValue.ToString();
+                            protocols.push_back(protocolString.Utf8Value());
+                        }
+                    }
+                    else
+                    {
+                        Napi::Error::New(env, "protocols is not an array").ThrowAsJavaScriptException();
+                        return;
+                    }
+                }
             }
         }
 
@@ -1271,7 +1303,7 @@ namespace quic
 
         std::unique_ptr<Http3SessionCache> cache;
 
-        client_ = std::make_unique<Http3Client>(this, std::move(verifier), std::move(cache), std::move(helper), cconfig);
+        client_ = std::make_unique<Http3Client>(this, std::move(verifier), std::move(cache), std::move(helper), cconfig, protocols);
         client_->SetUserAgentID("fails-components/webtransport");
 
         Ref(); // do not garbage collect
@@ -1380,10 +1412,10 @@ namespace quic
 
     void Http3ClientJS::processClientWebtransportSupport()
     {
+        Http3Client *obj = getObj();
         Napi::HandleScope scope(Env());
         Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
         Napi::Object retObj = Napi::Object::New(Env());
-
         objVal.Get("onClientWebTransportSupport")
             .As<Napi::Function>()
             .Call(objVal, {retObj});

package/src/http3client.h

@@ -121,7 +121,8 @@ namespace quic
             std::unique_ptr<ProofVerifier> proof_verifier,
             std::unique_ptr<SessionCache> session_cache,
             std::unique_ptr<QuicConnectionHelperInterface> helper,
-            QuicConfig config);
+            QuicConfig config,
+            const std::vector<std::string>& protocols);
 
         ~Http3Client() override;
 
@@ -528,6 +529,7 @@ namespace quic
         bool connectionrecheck_;
 
         std::queue<std::function<void(QuicSpdyClientStream *)>> finish_stream_open_;
+        std::vector<std::string> protocols_;
     };
 
 } // namespace quic

package/src/http3clientsession.cc

@@ -34,7 +34,7 @@ namespace quic
       bool drop_response_body,
       bool enable_web_transport)
       : QuicSpdyClientSession(config, supported_versions, connection, server_id,
-                              crypto_config),
+                              crypto_config, QuicPriorityType::kWebTransport),
         drop_response_body_(drop_response_body),
         enable_web_transport_(enable_web_transport) {}
 

package/src/http3server.cc

@@ -494,6 +494,7 @@ namespace quic
       int status = -1;
       std::string path = "";
       Napi::Object lobj = info[0].ToObject();
+      std::string selectedProtocol = "";
       if (!lobj.IsEmpty())
       {
         if (lobj.Has("status") && !(lobj).Get("status").IsEmpty())
@@ -552,6 +553,11 @@ namespace quic
               NAPI_THROW_IF_FAILED(Env(), status, Reference<Napi::Value>());
               userDataValue = new Napi::Reference<Napi::Value>(Env(), ref);
             }
+            if (lobj.Has("selectedProtocol") && !(lobj).Get("selectedProtocol").IsUndefined())
+            {
+              Napi::Value selectedProtocolValue = (lobj).Get("selectedProtocol");
+              selectedProtocol = selectedProtocolValue.ToString().Utf8Value();
+            }
           }
           if (status != 200)
           {
@@ -563,6 +569,9 @@ namespace quic
           {
             std::unique_ptr<Http3ServerBackend::WebTransportResponse> response = std::make_unique<Http3ServerBackend::WebTransportResponse>();
             response->response_headers[":status"] = std::to_string(status);
+            if (selectedProtocol != "") {
+              response->response_headers["wt-protocol"] = selectedProtocol;
+            }
             Http3WTSession *wtsession = new Http3WTSession();
             wtsession->init(session);
             response->visitor =

package/src/http3serversession.cc

@@ -33,7 +33,10 @@ namespace quic
       QuicCompressedCertsCache *compressed_certs_cache,
       Http3ServerBackend *http3_server_backend)
       : QuicServerSessionBase(config, supported_versions, connection, visitor,
-                              helper, crypto_config, compressed_certs_cache),
+                              helper, crypto_config, compressed_certs_cache,
+                              http3_server_backend->SupportsWebTransport()
+                                 ? QuicPriorityType::kWebTransport
+                                 : QuicPriorityType::kHttp),
         http3_server_backend_(http3_server_backend)
   {
     QUICHE_DCHECK(http3_server_backend_);

package/src/http3serverstream.cc

@@ -25,7 +25,7 @@
 #include "quiche/quic/platform/api/quic_flags.h"
 #include "quiche/quic/platform/api/quic_logging.h"
 #include "src/http3serversession.h"
-#include "quiche/spdy/core/spdy_protocol.h"
+#include "quiche/http2/core/spdy_protocol.h"
 
 using quiche::HttpHeaderBlock;
 

package/src/http3wtsessionvisitor.cc

@@ -45,7 +45,7 @@ namespace quic
                 << stream->GetStreamId();
             stream->SetVisitor(
                 std::make_unique<Http3WTStream::Visitor>(wtstream));
-            session_->getJS()->processStream(true, true, static_cast<Http3WTStream *>(wtstream));
+            session_->getJS()->processStream(true, true, 0/*sendOrder*/, 0 /*sendGroup*/, static_cast<Http3WTStream *>(wtstream));
             stream->visitor()->OnCanRead();
         }
     }
@@ -67,7 +67,7 @@ namespace quic
                 << "Http3WTSession received a unidirectional stream";
             stream->SetVisitor(
                 std::make_unique<Http3WTStream::Visitor>(wtstream));
-            session_->getJS()->processStream(true, false, static_cast<Http3WTStream *>(wtstream));
+            session_->getJS()->processStream(true, false, 0/*sendOrder*/, 0 /*sendGroup*/, static_cast<Http3WTStream *>(wtstream));
             stream->visitor()->OnCanRead();
         }
     }
@@ -104,22 +104,30 @@ namespace quic
             getJS()->processDatagramStats(session_->GetDatagramStats());
     }
 
+    size_t Http3WTSession::getMaxDatagramSizeInt()
+    {
+        if (!session_) return 0;
+        return session_->GetMaxDatagramSize();
+    }
+
     void Http3WTSession::TrySendingBidirectionalStreams()
     {
         if (!session_)
             return;
-        while (ordBidiStreams > 0 &&
+        while (!ordBidiStreams.empty() &&
                session_->CanOpenNextOutgoingBidirectionalStream())
         {
             QUIC_DVLOG(1)
                 << "Http3WTSessionVisitor opens a bidirectional stream";
             WebTransportStream *stream = session_->OpenOutgoingBidirectionalStream();
+            webtransport::StreamPriority prio = ordBidiStreams.front();
+            stream->SetPriority(prio);
             Http3WTStream *wtstream = new Http3WTStream(stream);
             stream->SetVisitor(
                 std::make_unique<Http3WTStream::Visitor>(wtstream));
-            getJS()->processStream(false, true, static_cast<Http3WTStream *>(wtstream));
+            getJS()->processStream(false, true, prio.send_order, prio.send_group_id, static_cast<Http3WTStream *>(wtstream));
             stream->visitor()->OnCanWrite();
-            ordBidiStreams--;
+            ordBidiStreams.pop();
         }
     }
 
@@ -127,7 +135,7 @@ namespace quic
     {
         if (!session_->session_) return;
 
-        session_->getJS()->processSessionReady();
+        session_->getJS()->processSessionReady(session_->session_->GetNegotiatedSubprotocol());
 
         if (session_->session_->CanOpenNextOutgoingBidirectionalStream())
         {
@@ -144,37 +152,43 @@ namespace quic
         if (!session_)
             return;
         // move to some where else?
-        while (ordUnidiStreams > 0 &&
+        while (!ordUnidiStreams.empty() &&
                session_->CanOpenNextOutgoingUnidirectionalStream())
         {
             QUIC_DVLOG(1)
                 << "Http3WTSessionVisitor opened a unidirectional stream";
             WebTransportStream *stream = session_->OpenOutgoingUnidirectionalStream();
+            webtransport::StreamPriority prio = ordUnidiStreams.front();
+            stream->SetPriority(prio);
             Http3WTStream *wtstream = new Http3WTStream(stream);
             stream->SetVisitor(
                 std::make_unique<Http3WTStream::Visitor>(wtstream));
 
-            getJS()->processStream(false, false, static_cast<Http3WTStream *>(wtstream));
+            getJS()->processStream(false, false, prio.send_order, prio.send_group_id, static_cast<Http3WTStream *>(wtstream));
             stream->visitor()->OnCanWrite();
-            ordUnidiStreams--;
+            ordUnidiStreams.pop();
         }
     }
 
-    void Http3WTSession::writeDatagramInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle)
+    webtransport::DatagramStatus Http3WTSession::writeDatagramInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle)
     {
         // printf("Datagram write %d %x %x\n", getpid(), this, session_ );
         if (!session_)
         {
             // printf("Datagram session gone %d %x %x\n", getpid(), this, session_);
-            getJS()->processDatagramSend(bufferhandle);
-            return;
+            bufferhandle->Unref(); // release the outgoing buffer
+            delete bufferhandle;   // free the handle object
+            webtransport::DatagramStatus status(webtransport::DatagramStatusCode::kInternalError, "Session not present");
+            return status;
         }
-        auto status = session_->SendOrQueueDatagram(absl::string_view(buffer, len));
+        webtransport::DatagramStatus status = session_->SendOrQueueDatagram(absl::string_view(buffer, len));
         // printf("Datagram status %d %d %s %x %x\n", getpid(), status.code, status.error_message.c_str(), this, session_);
-        getJS()->processDatagramSend(bufferhandle);
+        bufferhandle->Unref(); // release the outgoing buffer
+        delete bufferhandle;   // free the handle object
+        return status;
     }
 
-    void Http3WTSessionJS::processStream(bool incom, bool bidi, Http3WTStream *stream)
+    void Http3WTSessionJS::processStream(bool incom, bool bidi, uint64_t sendOrder, uint64_t sendGroupId, Http3WTStream *stream)
     {
         Napi::HandleScope scope(Env());
         Http3Constructors *constr = Env().GetInstanceData<Http3Constructors>();
@@ -192,6 +206,8 @@ namespace quic
         retObj.Set("stream", strobj);
         retObj.Set("incoming", incom);
         retObj.Set("bidirectional", bidi);
+        retObj.Set("sendOrder", sendOrder);
+        retObj.Set("sendGroupId", sendGroupId);
 
         objVal.Get("onStream").As<Napi::Function>().Call(objVal, {retObj});
     }
@@ -263,13 +279,16 @@ namespace quic
         objVal.Get("onDatagramSend").As<Napi::Function>().Call(objVal, {retObj});
     }
 
-    void Http3WTSessionJS::processSessionReady()
+    void Http3WTSessionJS::processSessionReady(std::optional<std::string> protocol)
     {
         Napi::HandleScope scope(Env());
         Napi::Object objVal = Value().Get("jsobj").As<Napi::Object>();
 
         Napi::Object retObj = Napi::Object::New(Env());
 
+        if (protocol.has_value()) {
+            retObj.Set("protocol", protocol.value());
+        }
         objVal.Get("onReady").As<Napi::Function>().Call(objVal, {retObj});
     }
 

package/src/http3wtsessionvisitor.h

@@ -16,6 +16,7 @@
 #include <atomic>
 
 #include <string>
+#include <queue>
 
 #include "src/librarymain.h"
 #include "src/http3wtstreamvisitor.h"
@@ -37,7 +38,7 @@ namespace quic
 
     public:
         Http3WTSession()
-            : ordBidiStreams(0), ordUnidiStreams(0), session_(nullptr), js_(nullptr)
+            : session_(nullptr), js_(nullptr)
         {
         }
 
@@ -83,11 +84,14 @@ namespace quic
         };
 
         bool
-        tryOpenBidiStream(bool waitUntilAvailable)
+        tryOpenBidiStream(bool waitUntilAvailable, uint64_t sendGroupId, uint64_t sendOrder)
         {
             if (session_->CanOpenNextOutgoingBidirectionalStream() 
                 || waitUntilAvailable) {
-                ordBidiStreams++;
+                webtransport::StreamPriority priority;
+                priority.send_group_id = sendGroupId;
+                priority.send_order = sendOrder;
+                ordBidiStreams.push(priority);
                 TrySendingBidirectionalStreams();
                 return true;
             } else {
@@ -95,11 +99,14 @@ namespace quic
             }
         }
 
-        bool tryOpenUnidiStream(bool waitUntilAvailable)
+        bool tryOpenUnidiStream(bool waitUntilAvailable, uint64_t sendGroupId, uint64_t sendOrder)
         {
             if (session_->CanOpenNextOutgoingUnidirectionalStream() 
                 || waitUntilAvailable) {
-                ordUnidiStreams++;
+                webtransport::StreamPriority priority;
+                priority.send_group_id = sendGroupId;
+                priority.send_order = sendOrder;
+                ordUnidiStreams.push(priority);
                 TrySendingUnidirectionalStreams();
                 return true;
             } else {
@@ -130,18 +137,21 @@ namespace quic
 
         void orderDatagramStatsInt();
 
+        size_t getMaxDatagramSizeInt();
+
         void closeInt(int code, std::string &reason)
         {
             if (session_)
                 session_->CloseSession(code, reason);
         }
 
-        void writeDatagramInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle);
+        webtransport::DatagramStatus writeDatagramInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle);
 
         WebTransportSession *session_;
         bool echo_stream_opened_ = false;
-        uint32_t ordBidiStreams;
-        uint32_t ordUnidiStreams;
+
+        std::queue<webtransport::StreamPriority> ordBidiStreams;
+        std::queue<webtransport::StreamPriority> ordUnidiStreams;
     };
 
     class Http3WTSessionJS : public Napi::ObjectWrap<Http3WTSessionJS>
@@ -167,6 +177,8 @@ namespace quic
         Napi::Value orderBidiStream(const Napi::CallbackInfo &info)
         {
             bool waitUntilAvailable = false;
+            uint64_t sendGroupId = 0;
+            uint64_t sendOrder = 0;
             if (!info[0].IsUndefined())
             {
                 Napi::Object lobj = info[0].ToObject();
@@ -177,9 +189,20 @@ namespace quic
                         Napi::Value waitUntilAvailableValue = (lobj).Get("waitUntilAvailable");
                         waitUntilAvailable = waitUntilAvailableValue.As<Napi::Boolean>().Value();
                     }
+                    if (lobj.Has("sendGroup") && !(lobj).Get("sendGroup").IsEmpty()
+                        && !(lobj).Get("sendGroup").IsNull()) {
+                        Napi::Value  sendGroupIdValue = (lobj).Get("sendGroup").ToObject().Get("_sendGroupId");
+                        bool lossless;
+                        sendGroupId = sendGroupIdValue.As<Napi::BigInt>().Uint64Value(&lossless);
+                    }
+                    if (lobj.Has("sendOrder") && !(lobj).Get("sendOrder").IsEmpty()) {
+                        Napi::Value sendOrderValue = (lobj).Get("sendOrder");
+                        bool lossless;
+                        sendOrder = sendOrderValue.As<Napi::BigInt>().Uint64Value(&lossless);
+                    }
                 }
             }
-            if (wtsession_->tryOpenBidiStream(waitUntilAvailable))
+            if (wtsession_->tryOpenBidiStream(waitUntilAvailable, sendGroupId, sendOrder))
             {
                 return Napi::Value::From(Env(), true);
             }
@@ -192,6 +215,8 @@ namespace quic
         Napi::Value orderUnidiStream(const Napi::CallbackInfo &info)
         {
             bool waitUntilAvailable = false;
+            uint64_t sendGroupId = 0;
+            uint64_t sendOrder = 0;
             if (!info[0].IsUndefined())
             {
                 Napi::Object lobj = info[0].ToObject();
@@ -202,9 +227,20 @@ namespace quic
                         Napi::Value waitUntilAvailableValue = (lobj).Get("waitUntilAvailable");
                         waitUntilAvailable = waitUntilAvailableValue.As<Napi::Boolean>().Value();
                     }
+                    if (lobj.Has("sendGroup") && !(lobj).Get("sendGroup").IsEmpty() 
+                        && !(lobj).Get("sendGroup").IsNull()) {
+                        Napi::Value  sendGroupIdValue = (lobj).Get("sendGroup").ToObject().Get("_sendGroupId");
+                        bool lossless;
+                        sendGroupId = sendGroupIdValue.As<Napi::BigInt>().Uint64Value(&lossless);
+                    }
+                    if (lobj.Has("sendOrder") && !(lobj).Get("sendOrder").IsEmpty()) {
+                        Napi::Value sendOrderValue = (lobj).Get("sendOrder");
+                        bool lossless;
+                        sendOrder = sendOrderValue.As<Napi::BigInt>().Uint64Value(&lossless);
+                    }
                 }
             }
-            if (wtsession_->tryOpenUnidiStream(waitUntilAvailable))
+            if (wtsession_->tryOpenUnidiStream(waitUntilAvailable, sendGroupId, sendOrder))
             {
                 return Napi::Value::From(Env(), true);
             }
@@ -214,7 +250,7 @@ namespace quic
             }
         }
 
-        void writeDatagram(const Napi::CallbackInfo &info)
+        Napi::Value writeDatagram(const Napi::CallbackInfo &info)
         {
             if (!info[0].IsUndefined())
             {
@@ -223,8 +259,27 @@ namespace quic
                 *bufferhandle = Napi::Persistent(bufferlocal);
                 char *buffer = bufferlocal.As<Napi::Buffer<char>>().Data();
                 size_t len = bufferlocal.As<Napi::Buffer<char>>().Length();
-                wtsession_->writeDatagramInt(buffer, len, bufferhandle);
+                webtransport::DatagramStatus status = wtsession_->writeDatagramInt(buffer, len, bufferhandle);
+
+                Napi::Object retObj = Napi::Object::New(Env());
+                switch (status.code) {
+                case webtransport::DatagramStatusCode::kBlocked:
+                    retObj.Set("code", "blocked");
+                break;
+                case webtransport::DatagramStatusCode::kInternalError:
+                    retObj.Set("code", "internalError");
+                break;
+                case webtransport::DatagramStatusCode::kSuccess:
+                    retObj.Set("code", "success");
+                break;
+                case webtransport::DatagramStatusCode::kTooBig:
+                    retObj.Set("code", "tooBig");
+                break;
+                };
+                retObj.Set("message", status.error_message);
+                return retObj;
             }
+            return Napi::Object::New(Env());
         }
 
         void notifySessionDraining(const Napi::CallbackInfo &info)
@@ -242,6 +297,11 @@ namespace quic
             wtsession_->orderDatagramStatsInt();
         }
 
+        Napi::Value getMaxDatagramSize(const Napi::CallbackInfo &info) {
+            size_t size = wtsession_->getMaxDatagramSizeInt();
+            return Napi::Value::From(Env(), size);
+        }
+
         void close(const Napi::CallbackInfo &info)
         {
             int code = 0;
@@ -284,6 +344,8 @@ namespace quic
                                                                                                                 static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                                                            InstanceMethod<&Http3WTSessionJS::orderDatagramStats>("orderDatagramStats",
                                                                                                                  static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::getMaxDatagramSize>("getMaxDatagramSize",
+                                                                                                                    static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                                                            InstanceMethod<&Http3WTSessionJS::close>("close",
                                                                                                     static_cast<napi_property_attributes>(napi_writable | napi_configurable))});
             constr->session = Napi::Persistent(tplwt);
@@ -295,13 +357,13 @@ namespace quic
 
         static void freeData(Napi::Env env, void *data, std::string *hint);
 
-        void processStream(bool incom, bool bidi, Http3WTStream *stream);
+        void processStream(bool incom, bool bidi, uint64_t sendOrder, uint64_t sendGroupId, Http3WTStream *stream);
         void processSessionStats(webtransport::SessionStats sessstats);
         void processDatagramStats(webtransport::DatagramStats datastats);
         void processGoawayReceived();
         void processDatagramSend(Napi::ObjectReference *bufferhandle);
         void processDatagramReceived(std::string *datagram);
-        void processSessionReady();
+        void processSessionReady(std::optional<std::string> protocol);
         void processSessionClose(uint32_t errorcode, const std::string &error);
     };
 

package/src/http3wtstreamvisitor.cc

@@ -179,6 +179,16 @@ namespace quic
         }
     }
 
+    void Http3WTStream::updateSendOrderAndGroupInt(uint64_t sendOrder, uint64_t sendGroupId) {
+        if (stream_)
+        {
+            webtransport::StreamPriority prio;
+            prio.send_group_id = sendGroupId;
+            prio.send_order = sendOrder;
+            stream_->SetPriority(prio);
+        }
+    }
+
     
     void  Http3WTStreamJS::signalFinOnly() {
         Napi::HandleScope scope(Env());

package/src/http3wtstreamvisitor.h

@@ -127,6 +127,8 @@ namespace quic
         void stopSendingInt(unsigned int reason);
         void resetStreamInt(unsigned int reason);
 
+        void updateSendOrderAndGroupInt(uint64_t sendOrder, uint64_t sendGroupId);
+
         WebTransportStream *stream() { return stream_; }
 
         struct WChunks
@@ -281,6 +283,30 @@ namespace quic
             wtstream_->resetStreamInt(reason);
         }
 
+        void updateSendOrderAndGroup(const Napi::CallbackInfo &info)
+        {
+            if (!info[0].IsUndefined())
+            {
+                Napi::Object obj = info[0].ToObject();
+                uint64_t sendOrder = 0;
+                uint64_t sendGroupId = 0;
+
+                if (obj.Has("sendOrder") && !(obj).Get("sendOrder").IsEmpty())
+                {
+                    Napi::Value sendOrderValue = (obj).Get("sendOrder");
+                    bool approx;
+                    sendOrder = sendOrderValue.As<Napi::BigInt>().Uint64Value(&approx);
+                }
+                if (obj.Has("sendGroupId") && !(obj).Get("sendGroupId").IsEmpty())
+                {
+                    Napi::Value sendGroupIdValue = (obj).Get("sendGroupId");
+                    bool approx;
+                    sendGroupId = sendGroupIdValue.As<Napi::BigInt>().Uint64Value(&approx);
+                }
+                wtstream_->updateSendOrderAndGroupInt(sendOrder, sendGroupId);
+            }
+        }
+
         static void InitExports(Napi::Env env, Napi::Object exports, Http3Constructors *constr)
         {
             Napi::Function tplwtsv =
@@ -296,7 +322,10 @@ namespace quic
                              InstanceMethod<&Http3WTStreamJS::startReading>("drainReads",
                                                                             static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                              InstanceMethod<&Http3WTStreamJS::stopReading>("stopReading",
-                                                                           static_cast<napi_property_attributes>(napi_writable | napi_configurable))});
+                                                                           static_cast<napi_property_attributes>(napi_writable | napi_configurable)),                                            
+                            InstanceMethod<&Http3WTStreamJS::updateSendOrderAndGroup>("updateSendOrderAndGroup",
+                                                                            static_cast<napi_property_attributes>(napi_writable | napi_configurable)), 
+                                                                        });
             constr->stream = Napi::Persistent(tplwtsv);
             exports.Set("Http3WTStreamVisitor", tplwtsv);
         }

package/platform/quiche_platform_impl/quiche_mutex_impl.h

@@ -1,8 +0,0 @@
-// from envoy so LICENSE.envoy applies
-// use default impl
-#ifndef QUICHE_MUTEX_IMPL
-#define QUICHE_MUTEX_IMPL
-
-#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_mutex_impl.h"
-
-#endif

package/platform/quiche_platform_impl/quiche_prefetch_impl.h

@@ -1,11 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef QUICHE_PREFETCH_IMPL_H_
-#define QUICHE_PREFETCH_IMPL_H_
-
-#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_prefetch_impl.h"
-
-
-#endif