@fails-components/webtransport-transport-http3-quiche 1.0.11 → 1.1.0

package/CMakeLists.txt

@@ -539,6 +539,8 @@ third_party/quiche/quiche/quic/core/http/quic_spdy_stream.cc
 third_party/quiche/quiche/quic/core/http/quic_spdy_stream.h
 third_party/quiche/quiche/quic/core/http/quic_spdy_stream_body_manager.cc
 third_party/quiche/quiche/quic/core/http/quic_spdy_stream_body_manager.h
+third_party/quiche/quiche/quic/core/http/metadata_decoder.cc
+third_party/quiche/quiche/quic/core/http/metadata_decoder.h
 third_party/quiche/quiche/quic/core/http/spdy_utils.cc
 third_party/quiche/quiche/quic/core/http/spdy_utils.h
 third_party/quiche/quiche/quic/core/http/web_transport_http3.cc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fails-components/webtransport-transport-http3-quiche",
-  "version": "1.0.11",
+  "version": "1.1.0",
   "description": "A component to add webtransport support (server and client) to node.js, transport using libquiche",
   "exports": {
     ".": {

package/src/http3server.cc

@@ -91,8 +91,8 @@ namespace quic
   Http3ServerJS::Http3ServerJS(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Http3ServerJS>(info)
   {
     std::string secret;
-    std::string cert;
-    std::string privkey;
+    std::vector<std::string> cert;
+    std::vector<std::string> privkey;
 
     QuicConfig sconfig;
     if (!info[0].IsUndefined())
@@ -113,7 +113,16 @@ namespace quic
         if (lobj.Has("cert") && !(lobj).Get("cert").IsEmpty())
         {
           Napi::Value certValue = (lobj).Get("cert");
-          cert = certValue.ToString().Utf8Value();
+          if (!certValue.IsArray()) {
+            cert.push_back(certValue.ToString().Utf8Value());
+          } else {
+            Napi::Array  certArray = certValue.As<Napi::Array>();
+            if (certArray.Length() < 1) Napi::Error::New(Env(), "No cert in array for Http3Server").ThrowAsJavaScriptException();
+            for (uint32_t i = 0; i < certArray.Length(); i++) {
+              Napi::Value curval = certArray.Get(i);
+              cert.push_back(curval.ToString().Utf8Value()); 
+            }
+          }
         }
         else
         {
@@ -123,13 +132,23 @@ namespace quic
         if (lobj.Has("privKey") && !(lobj).Get("privKey").IsEmpty())
         {
           Napi::Value keyValue = (lobj).Get("privKey");
-          privkey = keyValue.ToString().Utf8Value();
+          if (!keyValue.IsArray()) {
+            privkey.push_back(keyValue.ToString().Utf8Value());
+          } else {
+            Napi::Array  keyArray = keyValue.As<Napi::Array>();
+            if (keyArray.Length() < 1) Napi::Error::New(Env(), "No key in array for Http3Server").ThrowAsJavaScriptException();
+            for (uint32_t i = 0; i < keyArray.Length(); i++) {
+              Napi::Value curval = keyArray.Get(i);
+              privkey.push_back(curval.ToString().Utf8Value()); 
+            }
+          }
         }
         else
         {
           Napi::Error::New(Env(), "No privKey set for Http3Server").ThrowAsJavaScriptException();
           return;
         }
+        if (privkey.size() != cert.size()) Napi::Error::New(Env(), "Key and cert array length for Http3Server do not match").ThrowAsJavaScriptException();
         if (lobj.Has("maxConnections") && !(lobj).Get("maxConnections").IsEmpty())
         {
           Napi::Value maxconnValue = (lobj).Get("maxConnections");
@@ -176,10 +195,10 @@ namespace quic
       }
       // Callback *callback, int port, std::unique_ptr<ProofSource> proof_source,  const char *secret
 
-      std::stringstream certstream(cert, std::ios_base::in);
+      std::stringstream certstream(cert[0], std::ios_base::in);
       quiche::QuicheReferenceCountedPointer<ProofSource::Chain> chain(new ProofSource::Chain(CertificateView::LoadPemFromStream(&certstream)));
 
-      std::stringstream privkeystream(privkey, std::ios_base::in);
+      std::stringstream privkeystream(privkey[0], std::ios_base::in);
 
       auto certprivkey = CertificatePrivateKey::LoadPemFromStream(&privkeystream);
       if (certprivkey == nullptr)
@@ -194,6 +213,25 @@ namespace quic
         Napi::Error::New(Env(), "LoadPemFromStream cert failed for Http3Server").ThrowAsJavaScriptException();
         return;
       }
+      // add additional certs to proof source
+      for (size_t i = 1; i < cert.size(); i++)
+      {
+        std::stringstream addcertstream(cert[0], std::ios_base::in);
+        quiche::QuicheReferenceCountedPointer<ProofSource::Chain> addchain(new ProofSource::Chain(CertificateView::LoadPemFromStream(&addcertstream)));
+        std::stringstream addprivkeystream(privkey[0], std::ios_base::in);
+        auto addcertprivkey = CertificatePrivateKey::LoadPemFromStream(&privkeystream);
+        if (addcertprivkey == nullptr)
+        {
+          Napi::Error::New(Env(), "LoadPemFromStream addprivKey  failed for Http3Server").ThrowAsJavaScriptException();
+          return;
+        }
+
+        if (!proofsource->AddCertificateChain(addchain, std::move(*addcertprivkey)))
+        {
+          Napi::Error::New(Env(), "AddCertificateChain failed for Http3Server").ThrowAsJavaScriptException();
+          return;
+        }
+      }
 
       server_ = std::make_unique<Http3Server>(this, std::move(proofsource), secret.c_str(), sconfig);
 
@@ -207,7 +245,7 @@ namespace quic
   }
 
   Http3ServerJS::~Http3ServerJS()
-  {  
+  {
   }
 
   void Http3ServerJS::destroy(const Napi::CallbackInfo &info)
@@ -357,7 +395,7 @@ namespace quic
     }
   }*/
 
-  void Http3ServerJS::processNewSession(Http3WTSession *session, const std::string &path, Napi::Reference<Napi::Value> *header)
+  void Http3ServerJS::processNewSession(Http3WTSession *session, const std::string &path, Napi::Reference<Napi::Value> *header, Napi::Reference<Napi::Value> *userData)
   {
     Napi::HandleScope scope(Env());
 
@@ -378,12 +416,17 @@ namespace quic
       retObj.Set("header", header->Value());
       header->Unref();
     }
+    if (userData)
+    {
+      retObj.Set("userData", userData->Value());
+      userData->Unref();
+    }
     objVal.Get("onHttpWTSessionVisitor")
         .As<Napi::Function>()
         .Call(objVal, {retObj});
   }
 
-  void Http3ServerJS::processNewSessionRequest(WebTransportSession *session, const spdy::Http2HeaderBlock &reqhead, WebTransportRespPromisePtr *promise)
+  void Http3ServerJS::processNewSessionRequest(WebTransportSession *session, const spdy::Http2HeaderBlock &reqhead, WebTransportRespPromisePtr promise)
   {
     Napi::HandleScope scope(Env());
 
@@ -401,10 +444,11 @@ namespace quic
     }
     retObj.Set("header", headObj);
     // delete reqheadcopy; // we own it and must free it!
-
+    
+    WebTransportRespPromisePtr *prompointer = new WebTransportRespPromisePtr(promise);
     // promise
     Napi::External<WebTransportRespPromisePtr> promObj =
-        Napi::External<WebTransportRespPromisePtr>::New(Env(), promise,
+        Napi::External<WebTransportRespPromisePtr>::New(Env(), prompointer,
                                                         [](Napi::Env /*env*/, WebTransportRespPromisePtr *ref)
                                                         {
                                                           delete ref; // we own it and must delete it
@@ -419,6 +463,7 @@ namespace quic
                                                    // does it outlife everything?
                                                  });
     retObj.Set("session", wtsObj);
+    retObj.Set("protocol", "http3:libquiche");
 
     objVal.Get("onSessionRequest")
         .As<Napi::Function>()
@@ -465,7 +510,7 @@ namespace quic
           path = pathValue.ToString().Utf8Value();
         }
         else
-          return Napi::Error::New(Env(), "No status code passed for finishSessionRequest").ThrowAsJavaScriptException();
+          return Napi::Error::New(Env(), "No path passed for finishSessionRequest").ThrowAsJavaScriptException();
         WebTransportSession *session = nullptr;
         if (lobj.Has("session") && !(lobj).Get("session").IsEmpty())
         {
@@ -487,6 +532,7 @@ namespace quic
 
           Http3ServerBackend::WebTransportRespPromisePtr *prom = promise.Data();
           Napi::Reference<Napi::Value> *headerValue = nullptr;
+          Napi::Reference<Napi::Value> *userDataValue = nullptr;
           if (status == 200)
           {
 
@@ -498,7 +544,14 @@ namespace quic
               headerValue = new Napi::Reference<Napi::Value>(Env(), ref);
             }
             else
-              return Napi::Error::New(Env(), "No status code passed for finishSessionRequest").ThrowAsJavaScriptException();
+              return Napi::Error::New(Env(), "No header passed for finishSessionRequest").ThrowAsJavaScriptException();
+            if (lobj.Has("userData") && !(lobj).Get("userData").IsEmpty())
+            {
+              napi_ref ref;
+              napi_status status = napi_create_reference(Env(), lobj.Get("userData"), 1, &ref);
+              NAPI_THROW_IF_FAILED(Env(), status, Reference<Napi::Value>());
+              userDataValue = new Napi::Reference<Napi::Value>(Env(), ref);
+            }
           }
           if (status != 200)
           {
@@ -514,7 +567,7 @@ namespace quic
             wtsession->init(session);
             response->visitor =
                 std::make_unique<Http3WTSession::Visitor>(wtsession);
-            processNewSession(static_cast<Http3WTSession *>(wtsession), path, headerValue);
+            processNewSession(static_cast<Http3WTSession *>(wtsession), path, headerValue, userDataValue);
             (*prom)->resolve(std::move(response));
           }
         }

package/src/http3server.h

@@ -84,8 +84,8 @@ namespace quic
             exports.Set("Http3WebTransportServer", tplsrv);
         }
 
-        void processNewSession(Http3WTSession *session, const std::string &path, Napi::Reference<Napi::Value> *header);
-        void processNewSessionRequest(WebTransportSession *session, const spdy::Http2HeaderBlock &reqheadcopy, WebTransportRespPromisePtr *promise);
+        void processNewSession(Http3WTSession *session, const std::string &path, Napi::Reference<Napi::Value> *header, Napi::Reference<Napi::Value> *userData);
+        void processNewSessionRequest(WebTransportSession *session, const spdy::Http2HeaderBlock &reqheadcopy, WebTransportRespPromisePtr promise);
 
     protected:
         std::unique_ptr<Http3Server> server_;

package/src/http3serverbackend.cc

@@ -67,27 +67,28 @@ namespace quic
     }
     std::string path(path_it->second);
 
+    if (jshandlerequesthandler_)
+    {
+      // first step pass header block along, due to thread safety, we need to copy
+      // not necessary anymore
+
+      // second step inform the js side
+      server_->getJS()->processNewSessionRequest(session, request_headers, promise);
+      return promise;
+    } 
+    
     if (paths_.find(path) != paths_.end())
-    { // to do handle our web transport paths
+    { // to do handle our web transport paths, if no handler is present
       std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
       Http3WTSession *wtsession = new Http3WTSession();
       wtsession->init(session);
       response->response_headers[":status"] = "200";
       response->visitor =
           std::make_unique<Http3WTSession::Visitor>(wtsession);
-      server_->getJS()->processNewSession(static_cast<Http3WTSession *>(wtsession), path, nullptr);
+      server_->getJS()->processNewSession(static_cast<Http3WTSession *>(wtsession), path, nullptr, nullptr);
       promise->resolve(std::move(response));
       return promise;
     }
-    else if (jshandlerequesthandler_)
-    {
-      // first step pass header block along, due to thread safety, we need to copy
-      // not necessary anymore
-
-      // second step inform the js side
-      server_->getJS()->processNewSessionRequest(session, request_headers, &promise);
-      return promise;
-    }
 
     std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
     response->response_headers[":status"] = "404";

package/src/napialarmfactory.h

@@ -134,10 +134,17 @@ namespace quic
         alarmref_.Unref();
         timerset_ = false;
       }
+      auto val =  Napi::Value::From(alarmjs_->Env(), timedelay);
+      // Workaround for problem on windows plattform
+      if (val.ToNumber().DoubleValue() != timedelay) { 
+        // printf("val %lg %lg\n", val.ToNumber().DoubleValue(), timedelay);
+        val =  Napi::Value::From(alarmjs_->Env(), timedelay);
+        // printf("val2 %lg %lg\n", val.ToNumber().DoubleValue(), timedelay);
+      }
 
       Napi::Value timeoutobj = NapiAlarmJS::FAILSsetTimeoutAlarm_.Call({
           alarmjs_->Value().As<Napi::Object>(),
-          Napi::Value::From(alarmjs_->Env(), timedelay),
+          val,
       });
       alarmref_ = Napi::Reference<Napi::Object>::New(timeoutobj.As<Napi::Object>(), 1);
       timerset_ = true;