@fails-components/webtransport 0.1.5 → 0.1.7

package/src/http3client.h

@@ -180,7 +180,6 @@ namespace quic
         // Group 2.
         bool response_headers_complete() const;
         const spdy::Http2HeaderBlock *response_headers() const;
-        const spdy::Http2HeaderBlock *preliminary_headers() const;
         int64_t response_size() const;
         size_t bytes_read() const;
         size_t bytes_written() const;
@@ -218,7 +217,7 @@ namespace quic
         // QuicSpdyClientBase::Reponselistener
         void OnCompleteResponse(
             QuicStreamId id, const spdy::Http2HeaderBlock &response_headers,
-            const std::string &response_body);
+            const absl::string_view &response_body);
 
         // From QuicClientPushPromiseIndex::Delegate
         bool CheckVary(const spdy::Http2HeaderBlock &client_request,
@@ -321,8 +320,7 @@ namespace quic
             PerStreamState(QuicRstStreamErrorCode stream_error, bool response_complete,
                            bool response_headers_complete,
                            const spdy::Http2HeaderBlock &response_headers,
-                           const spdy::Http2HeaderBlock &preliminary_headers,
-                           const std::string &response,
+                           const absl::string_view response,
                            const spdy::Http2HeaderBlock &response_trailers,
                            uint64_t bytes_read, uint64_t bytes_written,
                            int64_t response_body_size);
@@ -332,7 +330,6 @@ namespace quic
             bool response_complete;
             bool response_headers_complete;
             spdy::Http2HeaderBlock response_headers;
-            spdy::Http2HeaderBlock preliminary_headers;
             std::string response;
             spdy::Http2HeaderBlock response_trailers;
             uint64_t bytes_read;
@@ -398,7 +395,6 @@ namespace quic
 
         bool response_complete_;
         bool response_headers_complete_;
-        mutable spdy::Http2HeaderBlock preliminary_headers_;
         mutable spdy::Http2HeaderBlock response_headers_;
 
         // Parsed response trailers (if present), copied from the stream in OnClose.

package/src/http3clientsession.cc

@@ -37,9 +37,11 @@ Http3ClientSession::Http3ClientSession(
 
 std::unique_ptr<QuicSpdyClientStream>
 Http3ClientSession::CreateClientStream() {
-  return std::make_unique<Http3ClientStream>(
+  auto stream =  std::make_unique<Http3ClientStream>(
       GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL,
       drop_response_body_);
+  stream->set_on_interim_headers(on_interim_headers_);
+  return stream;
 }
 
 bool Http3ClientSession::ShouldNegotiateWebTransport() {

package/src/http3clientsession.h

@@ -11,6 +11,9 @@
 #ifndef HTTP3_CLIENT_SESSION_H
 #define HTTP3_CLIENT_SESSION_H
 
+#include <functional>
+#include <utility>
+
 #include "quiche/quic/core/http/quic_spdy_client_session.h"
 #include "src/http3clientstream.h"
 
@@ -37,7 +40,13 @@ class Http3ClientSession : public QuicSpdyClientSession {
   bool ShouldNegotiateWebTransport() override;
   HttpDatagramSupport LocalHttpDatagramSupport() override;
 
+  void set_on_interim_headers(
+      std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers) {
+    on_interim_headers_ = std::move(on_interim_headers);
+  }
+
  private:
+  std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers_;
   const bool drop_response_body_;
   const bool enable_web_transport_;
 };

package/src/http3clientstream.cc

@@ -9,6 +9,7 @@
 // found in the LICENSE file.
 
 #include "src/http3clientstream.h"
+#include "quiche/common/platform/api/quiche_logging.h"
 
 namespace quic {
 
@@ -32,4 +33,20 @@ void Http3ClientStream::OnBodyAvailable() {
   }
 }
 
+bool Http3ClientStream::ParseAndValidateStatusCode() {
+  const size_t num_previous_interim_headers = preliminary_headers().size();
+  if (!QuicSpdyClientStream::ParseAndValidateStatusCode()) {
+    return false;
+  }
+  // The base ParseAndValidateStatusCode() may have added a preliminary header.
+  if (preliminary_headers().size() > num_previous_interim_headers) {
+    QUICHE_DCHECK_EQ(preliminary_headers().size(),
+                     num_previous_interim_headers + 1);
+    if (on_interim_headers_) {
+      on_interim_headers_(preliminary_headers().back());
+    }
+  }
+  return true;
+}
+
 }  // namespace quic

package/src/http3clientstream.h

@@ -23,7 +23,17 @@ class Http3ClientStream : public QuicSpdyClientStream {
         drop_response_body_(drop_response_body) {}
   void OnBodyAvailable() override;
 
+  void set_on_interim_headers(
+      std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers) {
+    on_interim_headers_ = std::move(on_interim_headers);
+  }
+
+ protected:
+  bool ParseAndValidateStatusCode() override;
+
+
  private:
+  std::function<void(const spdy::Http2HeaderBlock&)> on_interim_headers_;
   const bool drop_response_body_;
 };
 

package/src/http3eventloop.cc

@@ -17,19 +17,16 @@
 #include "quiche/common/platform/api/quiche_reference_counted.h"
 #include "quiche/quic/core/quic_default_clock.h"
 #include "quiche/quic/bindings/quic_libevent.h"
+#include "quiche/common/platform/api/quiche_command_line_flags.h"
+
+#include "absl/log/initialize.h"
+#include "absl/strings/string_view.h"
 
 using namespace Napi;
 
 namespace quic
 {
 
-#ifdef WIN32
-
-  bool initSockets();
-  bool destroySockets();
-
-#endif
-
   // hack since the header is faulty
   QUICHE_NO_EXPORT QuicEventLoopFactory *GetDefaultEventLoop();
 
@@ -40,9 +37,6 @@ namespace quic
   Http3EventLoop::~Http3EventLoop()
   {
     printf("Destructor eventloop\n");
-#ifdef WIN32
-    destroySockets();
-#endif
   }
 
   void Http3EventLoop::Init(Napi::Env env, Napi::Object exports)
@@ -61,7 +55,6 @@ namespace quic
     Http3ClientJS::InitExports(env, exports);
     Http3WTSessionJS::InitExports(env, exports, constr);
     Http3WTStreamJS::InitExports(env, exports, constr);
-    Napi::ObjectReference *exportref = new Napi::ObjectReference();
 
     env.SetInstanceData<Http3Constructors>(constr);
   }
@@ -116,7 +109,7 @@ namespace quic
 
   void Http3EventLoop::informAboutStream(bool incom, bool bidir, Http3WTSession *sessionobj, Http3WTStream *stream)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     if (incom)
     {
       if (bidir)
@@ -147,7 +140,7 @@ namespace quic
 
   void Http3EventLoop::informStreamRecvSignal(Http3WTStream *streamobj, WebTransportStreamError error_code, NetworkTask task)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamRecvSignal;
     report.streamobj = streamobj;
     report.wtscode = error_code;
@@ -158,7 +151,7 @@ namespace quic
 
   void Http3EventLoop::informAboutStreamRead(Http3WTStream *streamobj, std::string *data, bool fin)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamRead;
     report.streamobj = streamobj;
     report.para = data;
@@ -169,7 +162,7 @@ namespace quic
 
   void Http3EventLoop::informAboutStreamWrite(Http3WTStream *streamobj, Napi::ObjectReference *bufferhandle, bool success)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamWrite;
     report.streamobj = streamobj;
     report.bufferhandle = bufferhandle;
@@ -180,7 +173,7 @@ namespace quic
 
   void Http3EventLoop::informAboutStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamNetworkFinish;
     report.streamobj = streamobj;
     report.nettask = task;
@@ -190,7 +183,7 @@ namespace quic
 
   void Http3EventLoop::informAboutStreamReset(Http3WTStream *streamobj)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::StreamReset;
     report.streamobj = streamobj;
     if (progress_)
@@ -199,7 +192,7 @@ namespace quic
 
   void Http3EventLoop::informDatagramReceived(Http3WTSession *sessionobj, absl::string_view datagram)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::DatagramReceived;
     report.sessionobj = sessionobj;
     report.para = new std::string(datagram);
@@ -207,28 +200,19 @@ namespace quic
       progress_->Send(&report, 1);
   }
 
-  void Http3EventLoop::informDatagramSend(Http3WTSession *sessionobj)
+  void Http3EventLoop::informDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::DatagramSend;
     report.sessionobj = sessionobj;
-    if (progress_)
-      progress_->Send(&report, 1);
-  }
-
-  void Http3EventLoop::informDatagramBufferFree(Napi::ObjectReference *bufferhandle)
-  {
-    struct Http3ProgressReport report;
-    report.type = Http3ProgressReport::DatagramBufferFree;
     report.bufferhandle = bufferhandle;
-
     if (progress_)
       progress_->Send(&report, 1);
   }
 
   void Http3EventLoop::informUnref(LifetimeHelper *obj)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::Unref;
     report.obj = obj;
 
@@ -238,7 +222,7 @@ namespace quic
 
   void Http3EventLoop::informAboutClientConnected(Http3Client *client, bool success)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::ClientConnected;
     report.clientobj = client;
     report.success = success;
@@ -248,7 +232,7 @@ namespace quic
 
   void Http3EventLoop::informClientWebtransportSupport(Http3Client *client)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::ClientWebTransportSupport;
     report.clientobj = client;
     if (progress_)
@@ -257,7 +241,7 @@ namespace quic
 
   void Http3EventLoop::informAboutNewSessionRequest(Http3Server *server, WebTransportSession *session, spdy::Http2HeaderBlock *reqheadcopy, WebTransportRespPromisePtr promise)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::NewSessionRequest;
     report.webtsession = session;
     report.serverobj = server;
@@ -269,7 +253,7 @@ namespace quic
 
   void Http3EventLoop::informAboutNewSession(Http3Server *server, Http3WTSession *session, absl::string_view path, Napi::Reference<Napi::Value> *header)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::NewSession;
     report.serverobj = server;
     report.session = session;
@@ -281,7 +265,7 @@ namespace quic
 
   void Http3EventLoop::informNewClientSession(Http3Client *client, Http3WTSession *session)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::NewClientSession;
     report.clientobj = client;
     report.session = session;
@@ -292,7 +276,7 @@ namespace quic
   void Http3EventLoop::informSessionClosed(Http3WTSession *sessionobj, WebTransportSessionError error_code,
                                            absl::string_view error_message)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::SessionClosed;
     report.sessionobj = sessionobj;
     report.para = new std::string(error_message);
@@ -303,7 +287,7 @@ namespace quic
 
   void Http3EventLoop::informSessionReady(Http3WTSession *sessionobj)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::SessionReady;
     report.sessionobj = sessionobj;
     if (progress_)
@@ -312,7 +296,7 @@ namespace quic
 
   void Http3EventLoop::informServerStatus(Http3Server *serverobj, NetworkStatus status, ServerStatusDetails *details)
   {
-    struct Http3ProgressReport report;
+    Http3ProgressReport report;
     report.type = Http3ProgressReport::ServerStatus;
     report.serverobj = serverobj;
     report.status = status;
@@ -534,12 +518,6 @@ namespace quic
     cbstream_.Call({retObj});
   }
 
-  void Http3EventLoop::processDatagramBufferFree(Napi::ObjectReference *bufferhandle)
-  {
-    bufferhandle->Unref(); // release the outgoing buffer
-    delete bufferhandle;   // free the handle object
-  }
-
   void Http3EventLoop::processDatagramReceived(Http3WTSession *sessionobj, std::string *datagram)
   {
     if (!checkQw())
@@ -565,8 +543,10 @@ namespace quic
     cbsession_.Call({retObj});
   }
 
-  void Http3EventLoop::processDatagramSend(Http3WTSession *sessionobj)
+  void Http3EventLoop::processDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle)
   {
+     bufferhandle->Unref(); // release the outgoing buffer
+    delete bufferhandle;   // free the handle object
     if (!checkQw())
       return;
     HandleScope scope(qw_->Env());
@@ -867,12 +847,7 @@ namespace quic
       break;
       case Http3ProgressReport::DatagramSend:
       {
-        processDatagramSend(cur.sessionobj);
-      }
-      break;
-      case Http3ProgressReport::DatagramBufferFree:
-      {
-        processDatagramBufferFree(cur.bufferhandle);
+        processDatagramSend(cur.sessionobj, cur.bufferhandle);
       }
       break;
       case Http3ProgressReport::Unref:
@@ -891,10 +866,8 @@ namespace quic
         progress_(nullptr),
         quic_event_loop_(GetDefaultEventLoop()->Create(QuicDefaultClock::Get()))
   {
-#ifdef WIN32
-    initSockets();
-#endif
-
+    std::vector<std::string> quiche_cmd_line;
+    quiche_cmd_line.push_back(std::string("webtransport.node"));
     if (!info[0].IsUndefined() /*|| info[1].IsFunction()*/)
     {
       Napi::Object lobj = info[0].ToObject();
@@ -945,12 +918,26 @@ namespace quic
         Napi::Error::New(Env(), "No session callback").ThrowAsJavaScriptException();
         return;
       }
+      quiche_cmd_line.push_back(std::string("-v"));
+      if (lobj.Has("quicheLogVerbose") && lobj.Get("quicheLogVerbose").IsFunction())
+      {
+         Napi::Value verboseValue = (lobj).Get("quicheLogVerbose");
+         quiche_cmd_line.push_back(verboseValue.ToString().Utf8Value());
+      } else {
+         quiche_cmd_line.push_back(std::string("-1"));
+      }
     }
     else
     {
       Napi::Error::New(Env(), "Callback not passed to Http3EventLoop internal").ThrowAsJavaScriptException();
       return;
     }
+    std::vector<const char*> quiche_cmd_line_char;
+    for (auto cur= quiche_cmd_line.begin(); cur != quiche_cmd_line.end(); cur++) {
+      quiche_cmd_line_char.push_back((*cur).c_str());
+    } 
+
+    quiche::QuicheParseCommandLineFlags("No use instruction.", quiche_cmd_line.size(), &(*quiche_cmd_line_char.begin()));
   }
 
   void Http3EventLoop::startEventLoop(const Napi::CallbackInfo &info)

package/src/http3eventloop.h

@@ -93,7 +93,6 @@ namespace quic
             StreamNetworkFinish,
             DatagramReceived,
             DatagramSend,
-            DatagramBufferFree,
             Unref
         } type;
         union
@@ -216,8 +215,7 @@ namespace quic
         void informAboutStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task);
 
         void informDatagramReceived(Http3WTSession *sessionobj, absl::string_view datagram);
-        void informDatagramBufferFree(Napi::ObjectReference *bufferhandle);
-        void informDatagramSend(Http3WTSession *sessionobj);
+        void informDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle);
 
         void informUnref(LifetimeHelper *obj);
 
@@ -282,8 +280,7 @@ namespace quic
         void processStreamNetworkFinish(Http3WTStream *streamobj, NetworkTask task);
 
         void processDatagramReceived(Http3WTSession *sessionobj, std::string *datagram);
-        void processDatagramSend(Http3WTSession *sessionobj);
-        void processDatagramBufferFree(Napi::ObjectReference *bufferhandle);
+        void processDatagramSend(Http3WTSession *sessionobj, Napi::ObjectReference *bufferhandle);
 
         bool shutDownEventLoopInt();
 

package/src/http3serversession.cc

@@ -34,14 +34,12 @@ namespace quic
       Http3ServerBackend *http3_server_backend)
       : QuicServerSessionBase(config, supported_versions, connection, visitor,
                               helper, crypto_config, compressed_certs_cache),
-        highest_promised_stream_id_(
-            QuicUtils::GetInvalidStreamId(connection->transport_version())),
         http3_server_backend_(http3_server_backend)
   {
     QUICHE_DCHECK(http3_server_backend_);
   }
 
-  Http3ServerSession::~Http3ServerSession() { DeleteConnection(); }
+  Http3ServerSession::~Http3ServerSession() {  DeleteConnection(); }
 
   std::unique_ptr<QuicCryptoServerStreamBase>
   Http3ServerSession::CreateQuicCryptoServerStream(
@@ -122,137 +120,4 @@ namespace quic
     ActivateStream(absl::WrapUnique(stream));
     return stream;
   }
-
-  void Http3ServerSession::HandleFrameOnNonexistentOutgoingStream(
-      QuicStreamId stream_id)
-  {
-    // If this stream is a promised but not created stream (stream_id within the
-    // range of next_outgoing_stream_id_ and highes_promised_stream_id_),
-    // connection shouldn't be closed.
-    // Otherwise behave in the same way as base class.
-    if (highest_promised_stream_id_ ==
-            QuicUtils::GetInvalidStreamId(transport_version()) ||
-        stream_id > highest_promised_stream_id_)
-    {
-      QuicSession::HandleFrameOnNonexistentOutgoingStream(stream_id);
-    }
-  }
-
-  void Http3ServerSession::HandleRstOnValidNonexistentStream(
-      const QuicRstStreamFrame &frame)
-  {
-    QuicSession::HandleRstOnValidNonexistentStream(frame);
-    if (!IsClosedStream(frame.stream_id))
-    {
-      // If a nonexistent stream is not a closed stream and still valid, it must
-      // be a locally preserved stream. Resetting this kind of stream means
-      // cancelling the promised server push.
-      // Since PromisedStreamInfo are queued in sequence, the corresponding
-      // index for it in promised_streams_ can be calculated.
-      QuicStreamId next_stream_id = next_outgoing_unidirectional_stream_id();
-      if ((!version().HasIetfQuicFrames() ||
-           !QuicUtils::IsBidirectionalStreamId(frame.stream_id, version())) &&
-          frame.stream_id >= next_stream_id)
-      {
-        size_t index = (frame.stream_id - next_stream_id) /
-                       QuicUtils::StreamIdDelta(transport_version());
-        if (index <= promised_streams_.size())
-        {
-          promised_streams_[index].is_cancelled = true;
-        }
-      }
-      control_frame_manager().WriteOrBufferRstStream(
-          frame.stream_id,
-          QuicResetStreamError::FromInternal(QUIC_RST_ACKNOWLEDGEMENT), 0);
-      connection()->OnStreamReset(frame.stream_id, QUIC_RST_ACKNOWLEDGEMENT);
-    }
-  }
-
-  /*
-  spdy::Http2HeaderBlock Http3ServerSession::SynthesizePushRequestHeaders(
-      std::string request_url, QuicBackendResponse::ServerPushInfo resource,
-      const spdy::Http2HeaderBlock& original_request_headers) {
-    QuicUrl push_request_url = resource.request_url;
-
-    spdy::Http2HeaderBlock spdy_headers = original_request_headers.Clone();
-    // :authority could be different from original request.
-    spdy_headers[":authority"] = push_request_url.host();
-    spdy_headers[":path"] = push_request_url.path();
-    // Push request always use GET.
-    spdy_headers[":method"] = "GET";
-    spdy_headers["referer"] = request_url;
-    spdy_headers[":scheme"] = push_request_url.scheme();
-    // It is not possible to push a response to a request that includes a request
-    // body.
-    spdy_headers["content-length"] = "0";
-    // Remove "host" field as push request is a directly generated HTTP2 request
-    // which should use ":authority" instead of "host".
-    spdy_headers.erase("host");
-    return spdy_headers;
-  }*/
-
-  /*
-  void Http3ServerSession::SendPushPromise(QuicStreamId original_stream_id,
-                                                QuicStreamId promised_stream_id,
-                                                spdy::Http2HeaderBlock headers) {
-    QUIC_DLOG(INFO) << "stream " << original_stream_id
-                    << " send PUSH_PROMISE for promised stream "
-                    << promised_stream_id;
-    WritePushPromise(original_stream_id, promised_stream_id, std::move(headers));
-  }*/
-
-  void Http3ServerSession::HandlePromisedPushRequests()
-  {
-    while (!promised_streams_.empty() &&
-           ShouldCreateOutgoingUnidirectionalStream())
-    {
-      PromisedStreamInfo &promised_info = promised_streams_.front();
-      QUICHE_DCHECK_EQ(next_outgoing_unidirectional_stream_id(),
-                       promised_info.stream_id);
-
-      if (promised_info.is_cancelled)
-      {
-        // This stream has been reset by client. Skip this stream id.
-        promised_streams_.pop_front();
-        GetNextOutgoingUnidirectionalStreamId();
-        return;
-      }
-
-      Http3ServerStream *promised_stream =
-          static_cast<Http3ServerStream *>(
-              CreateOutgoingUnidirectionalStream());
-      QUICHE_DCHECK_NE(promised_stream, nullptr);
-      QUICHE_DCHECK_EQ(promised_info.stream_id, promised_stream->id());
-      QUIC_DLOG(INFO) << "created server push stream " << promised_stream->id();
-
-      promised_stream->SetPriority(promised_info.priority);
-
-      spdy::Http2HeaderBlock request_headers(
-          std::move(promised_info.request_headers));
-
-      promised_streams_.pop_front();
-      promised_stream->PushResponse(std::move(request_headers));
-    }
-  }
-
-  void Http3ServerSession::OnCanCreateNewOutgoingStream(
-      bool unidirectional)
-  {
-    QuicSpdySession::OnCanCreateNewOutgoingStream(unidirectional);
-    if (unidirectional)
-    {
-      HandlePromisedPushRequests();
-    }
-  }
-
-  void Http3ServerSession::MaybeInitializeHttp3UnidirectionalStreams()
-  {
-    size_t previous_static_stream_count = num_static_streams();
-    QuicSpdySession::MaybeInitializeHttp3UnidirectionalStreams();
-    size_t current_static_stream_count = num_static_streams();
-    QUICHE_DCHECK_GE(current_static_stream_count, previous_static_stream_count);
-    highest_promised_stream_id_ +=
-        QuicUtils::StreamIdDelta(transport_version()) *
-        (current_static_stream_count - previous_static_stream_count);
-  }
 } // namespace quic