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

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/src/librarymain.cc

@@ -14,6 +14,7 @@
 #include "src/http3wtsessionvisitor.h"
 #include "src/napialarmfactory.h"
 #include "quiche/common/platform/api/quiche_command_line_flags.h"
+#include "quiche/common/platform/api/quiche_flags.h"
 
 #include "absl/log/initialize.h"
 #include "absl/strings/string_view.h"
@@ -58,6 +59,7 @@ namespace quic
     {
       quiche_cmd_line_char.push_back((*cur).c_str());
     }
+    SetQuicheReloadableFlag(quic_deliver_stop_sending_to_zombie_streams, true); // enable patch
     if (!hasSetLogging)
     {
       quiche::QuicheParseCommandLineFlags("No use instruction.", quiche_cmd_line.size(), &(*quiche_cmd_line_char.begin()));

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