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

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;
 
@@ -157,12 +158,12 @@ namespace quic
 
         // Sends a request containing |headers| and |body| and returns the number of
         // bytes sent (the size of the serialized request headers and body).
-        void SendMessageAsync(const spdy::Http2HeaderBlock &headers,
+        void SendMessageAsync(const quiche::HttpHeaderBlock &headers,
                               absl::string_view body);
         // Sends a request containing |headers| and |body| with the fin bit set to
         // |fin| and returns the number of bytes sent (the size of the serialized
         // request headers and body).
-        void SendMessageAsync(const spdy::Http2HeaderBlock &headers,
+        void SendMessageAsync(const quiche::HttpHeaderBlock &headers,
                               absl::string_view body, bool fin);
 
         void SendConnectivityProbing();
@@ -193,13 +194,13 @@ namespace quic
         // is received. 2) returns state of the oldest active stream which have
         // received partial response (if any).
         // Group 1.
-        const spdy::Http2HeaderBlock &response_trailers() const;
+        const quiche::HttpHeaderBlock &response_trailers() const;
         bool response_complete() const;
         int64_t response_body_size() const;
         const std::string &response_body() const;
         // Group 2.
         bool response_headers_complete() const;
-        const spdy::Http2HeaderBlock *response_headers() const;
+        const quiche::HttpHeaderBlock *response_headers() const;
         int64_t response_size() const;
         size_t bytes_read() const;
         size_t bytes_written() const;
@@ -214,7 +215,7 @@ namespace quic
 
         // QuicSpdyClientBase::Reponselistener
         void OnCompleteResponse(
-            QuicStreamId id, const spdy::Http2HeaderBlock &response_headers,
+            QuicStreamId id, const quiche::HttpHeaderBlock &response_headers,
             const absl::string_view &response_body);
 
         // Returns nullptr if the maximum number of streams have already been created.
@@ -226,7 +227,7 @@ namespace quic
         // stores the request in case it needs to be resent.  If |headers| is
         // null, only the body will be sent on the stream.
         void GetOrCreateStreamAndSendRequest(
-            const spdy::Http2HeaderBlock *headers, absl::string_view body, bool fin);
+            const quiche::HttpHeaderBlock *headers, absl::string_view body, bool fin);
 
         QuicRstStreamErrorCode stream_error() { return stream_error_; }
         QuicErrorCode connection_error() const;
@@ -263,7 +264,7 @@ namespace quic
         // request. If |uri| is a relative URL, the QuicServerId will be
         // use to specify the authority.
         bool PopulateHeaderBlockFromUrl(const std::string &uri,
-                                        spdy::Http2HeaderBlock *headers);
+                                        quiche::HttpHeaderBlock *headers);
 
         QuicSpdyClientStream *latest_created_stream()
         {
@@ -291,7 +292,7 @@ namespace quic
         {
         public:
             Http3ClientDataToResend(
-                std::unique_ptr<spdy::Http2HeaderBlock> headers, absl::string_view body,
+                std::unique_ptr<quiche::HttpHeaderBlock> headers, absl::string_view body,
                 bool fin, Http3Client *client);
 
             ~Http3ClientDataToResend();
@@ -299,7 +300,7 @@ namespace quic
             void Resend();
 
         protected:
-            std::unique_ptr<spdy::Http2HeaderBlock> headers_;
+            std::unique_ptr<quiche::HttpHeaderBlock> headers_;
             absl::string_view body_;
             bool fin_;
             Http3Client *client_;
@@ -311,9 +312,9 @@ namespace quic
             PerStreamState(const PerStreamState &other);
             PerStreamState(QuicRstStreamErrorCode stream_error, bool response_complete,
                            bool response_headers_complete,
-                           const spdy::Http2HeaderBlock &response_headers,
+                           const quiche::HttpHeaderBlock &response_headers,
                            const absl::string_view response,
-                           const spdy::Http2HeaderBlock &response_trailers,
+                           const quiche::HttpHeaderBlock &response_trailers,
                            uint64_t bytes_read, uint64_t bytes_written,
                            int64_t response_body_size);
             ~PerStreamState();
@@ -321,9 +322,9 @@ namespace quic
             QuicRstStreamErrorCode stream_error;
             bool response_complete;
             bool response_headers_complete;
-            spdy::Http2HeaderBlock response_headers;
+            quiche::HttpHeaderBlock response_headers;
             std::string response;
-            spdy::Http2HeaderBlock response_trailers;
+            quiche::HttpHeaderBlock response_trailers;
             uint64_t bytes_read;
             uint64_t bytes_written;
             int64_t response_body_size;
@@ -381,10 +382,10 @@ namespace quic
 
         bool response_complete_;
         bool response_headers_complete_;
-        mutable spdy::Http2HeaderBlock response_headers_;
+        mutable quiche::HttpHeaderBlock response_headers_;
 
         // Parsed response trailers (if present), copied from the stream in OnClose.
-        spdy::Http2HeaderBlock response_trailers_;
+        quiche::HttpHeaderBlock response_trailers_;
 
         QuicStreamPriority priority_;
         std::string response_;
@@ -504,7 +505,7 @@ namespace quic
         // preliminary 100 Continue HTTP/2 headers from most recent response, if any.
         std::string preliminary_response_headers_;
         // HTTP/2 headers from most recent response.
-        spdy::Http2HeaderBlock latest_response_header_block_;
+        quiche::HttpHeaderBlock latest_response_header_block_;
         // Body of most recent response.
         std::string latest_response_body_;
         // HTTP/2 trailers from most recent response.
@@ -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/http3clientsession.h

@@ -47,13 +47,13 @@ namespace quic
     }
 
     void set_on_interim_headers(
-        std::function<void(const spdy::Http2HeaderBlock &)> on_interim_headers)
+        std::function<void(const quiche::HttpHeaderBlock &)> on_interim_headers)
     {
       on_interim_headers_ = std::move(on_interim_headers);
     }
 
   private:
-    std::function<void(const spdy::Http2HeaderBlock &)> on_interim_headers_;
+    std::function<void(const quiche::HttpHeaderBlock &)> on_interim_headers_;
     const bool drop_response_body_;
     const bool enable_web_transport_;
     absl::flat_hash_map<QuicStreamId, webtransport::SessionVisitor *> svisitors_;

package/src/http3clientstream.h

@@ -24,7 +24,7 @@ class Http3ClientStream : public QuicSpdyClientStream {
   void OnBodyAvailable() override;
 
   void set_on_interim_headers(
-      std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers) {
+      std::function<void(const quiche::HttpHeaderBlock&)> on_interim_headers) {
     on_interim_headers_ = std::move(on_interim_headers);
   }
 
@@ -33,7 +33,7 @@ class Http3ClientStream : public QuicSpdyClientStream {
 
 
  private:
-  std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers_;
+  std::function<void(const quiche::HttpHeaderBlock&)> on_interim_headers_;
   const bool drop_response_body_;
 };
 

package/src/http3server.cc

@@ -426,7 +426,7 @@ namespace quic
         .Call(objVal, {retObj});
   }
 
-  void Http3ServerJS::processNewSessionRequest(WebTransportSession *session, const spdy::Http2HeaderBlock &reqhead, WebTransportRespPromisePtr promise)
+  void Http3ServerJS::processNewSessionRequest(WebTransportSession *session, const quiche::HttpHeaderBlock &reqhead, WebTransportRespPromisePtr promise)
   {
     Napi::HandleScope scope(Env());
 
@@ -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/http3server.h

@@ -85,7 +85,7 @@ namespace quic
         }
 
         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);
+        void processNewSessionRequest(WebTransportSession *session, const quiche::HttpHeaderBlock &reqheadcopy, WebTransportRespPromisePtr promise);
 
     protected:
         std::unique_ptr<Http3Server> server_;

package/src/http3serverbackend.cc

@@ -25,7 +25,7 @@
 #include "quiche/common/platform/api/quiche_file_utils.h"
 #include "quiche/common/quiche_text_utils.h"
 
-using spdy::Http2HeaderBlock;
+using quiche::HttpHeaderBlock;
 
 namespace quic
 {
@@ -34,7 +34,7 @@ namespace quic
   void QuicMemoryCacheBackend::GenerateDynamicResponses() {
     QuicWriterMutexLock lock(&response_mutex_);
     // Add a generate bytes response.
-    spdy::Http2HeaderBlock response_headers;
+    quiche::HttpHeaderBlock response_headers;
     response_headers[":status"] = "200";
     generate_bytes_response_ = std::make_unique<QuicBackendResponse>();
     generate_bytes_response_->set_headers(std::move(response_headers));
@@ -45,7 +45,7 @@ namespace quic
 
   Http3ServerBackend::WebTransportRespPromisePtr
   Http3ServerBackend::ProcessWebTransportRequest(
-      const spdy::Http2HeaderBlock &request_headers,
+      const quiche::HttpHeaderBlock &request_headers,
       WebTransportSession *session)
   {
     WebTransportRespPromisePtr promise = std::make_shared<WebTransportRespPromise>();

package/src/http3serverbackend.h

@@ -15,7 +15,7 @@
 
 #include "quiche/quic/core/quic_types.h"
 #include "quiche/quic/core/web_transport_interface.h"
-#include "quiche/spdy/core/http2_header_block.h"
+#include "quiche/common/http/http_header_block.h"
 
 namespace quic
 {
@@ -62,7 +62,7 @@ namespace quic
   public:
     struct WebTransportResponse
     {
-      spdy::Http2HeaderBlock response_headers;
+      quiche::HttpHeaderBlock response_headers;
       std::unique_ptr<WebTransportVisitor> visitor;
     };
 
@@ -77,7 +77,7 @@ namespace quic
     void setJSHandler(bool on) { jshandlerequesthandler_ = on; }
 
     WebTransportRespPromisePtr ProcessWebTransportRequest(
-        const spdy::Http2HeaderBlock & /*request_headers*/,
+        const quiche::HttpHeaderBlock & /*request_headers*/,
         WebTransportSession * /*session*/);
     bool SupportsWebTransport() { return true; }
     bool UsesDatagramContexts() { return true; }

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,9 +25,9 @@
 #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 spdy::Http2HeaderBlock;
+using quiche::HttpHeaderBlock;
 
 namespace quic
 {
@@ -279,7 +279,7 @@ namespace quic
     std::string request_url = request_headers_[":authority"].as_string() +
                               request_headers_[":path"].as_string();
     int response_code;
-    const Http2HeaderBlock &response_headers = response->headers();
+    const HttpHeaderBlock &response_headers = response->headers();
     if (!ParseHeaderStatusCode(response_headers, &response_code))
     {
       auto status = response_headers.find(":status");
@@ -317,7 +317,7 @@ namespace quic
         SendNotFoundResponse();
         return;
       }
-      Http2HeaderBlock headers = response->headers().Clone();
+      HttpHeaderBlock headers = response->headers().Clone();
       headers["content-length"] = absl::StrCat(generate_bytes_length_);
 
       WriteHeaders(std::move(headers), false, nullptr);
@@ -356,7 +356,7 @@ namespace quic
   void Http3ServerStream::SendNotFoundResponse()
   {
     QUIC_DVLOG(1) << "Stream " << id() << " sending not found response.";
-    Http2HeaderBlock headers;
+    HttpHeaderBlock headers;
     headers[":status"] = "404";
     headers["content-length"] = absl::StrCat(strlen(kNotFoundResponseBody));
     SendHeadersAndBody(std::move(headers), kNotFoundResponseBody);
@@ -374,7 +374,7 @@ namespace quic
     {
       StopReading();
     }
-    Http2HeaderBlock headers;
+    HttpHeaderBlock headers;
     if (resp_code <= 0)
     {
       headers[":status"] = "500";
@@ -388,7 +388,7 @@ namespace quic
   }
 
   void Http3ServerStream::SendIncompleteResponse(
-      Http2HeaderBlock response_headers,
+      HttpHeaderBlock response_headers,
       absl::string_view body)
   {
     QUIC_DLOG(INFO) << "Stream " << id() << " writing headers (fin = false) : "
@@ -406,17 +406,17 @@ namespace quic
   }
 
   void Http3ServerStream::SendHeadersAndBody(
-      Http2HeaderBlock response_headers,
+      HttpHeaderBlock response_headers,
       absl::string_view body)
   {
     SendHeadersAndBodyAndTrailers(std::move(response_headers), body,
-                                  Http2HeaderBlock());
+                                  HttpHeaderBlock());
   }
 
   void Http3ServerStream::SendHeadersAndBodyAndTrailers(
-      Http2HeaderBlock response_headers,
+      HttpHeaderBlock response_headers,
       absl::string_view body,
-      Http2HeaderBlock response_trailers)
+      HttpHeaderBlock response_trailers)
   {
     // Send the headers, with a FIN if there's nothing else to send.
     bool send_fin = (body.empty() && response_trailers.empty());

package/src/http3serverstream.h

@@ -16,7 +16,7 @@
 #include "quiche/quic/core/quic_packets.h"
 #include "src/http3serverbackend.h"
 #include "src/http3backendresponse.h"
-#include "quiche/spdy/core/spdy_framer.h"
+#include "quiche/http2/core/spdy_framer.h"
 
 namespace quic
 {
@@ -78,16 +78,16 @@ namespace quic
     void SendNotFoundResponse();
 
     // Sends the response header and body, but not the fin.
-    void SendIncompleteResponse(spdy::Http2HeaderBlock response_headers,
+    void SendIncompleteResponse(quiche::HttpHeaderBlock response_headers,
                                 absl::string_view body);
 
-    void SendHeadersAndBody(spdy::Http2HeaderBlock response_headers,
+    void SendHeadersAndBody(quiche::HttpHeaderBlock response_headers,
                             absl::string_view body);
-    void SendHeadersAndBodyAndTrailers(spdy::Http2HeaderBlock response_headers,
+    void SendHeadersAndBodyAndTrailers(quiche::HttpHeaderBlock response_headers,
                                        absl::string_view body,
-                                       spdy::Http2HeaderBlock response_trailers);
+                                       quiche::HttpHeaderBlock response_trailers);
 
-    spdy::Http2HeaderBlock *request_headers() { return &request_headers_; }
+    quiche::HttpHeaderBlock *request_headers() { return &request_headers_; }
 
     const std::string &body() { return body_; }
 
@@ -95,7 +95,7 @@ namespace quic
     void WriteGeneratedBytes();
 
     // The parsed headers received from the client.
-    spdy::Http2HeaderBlock request_headers_;
+    quiche::HttpHeaderBlock request_headers_;
     int64_t content_length_;
     std::string body_;
     // promises not fullfilled from js side or c++ side

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});
     }