@fails-components/webtransport 0.1.5 → 0.2.0

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

package/src/http3serversession.h

@@ -26,7 +26,7 @@
 #include "quiche/quic/core/http/quic_spdy_session.h"
 #include "quiche/quic/core/quic_crypto_server_stream_base.h"
 #include "quiche/quic/core/quic_packets.h"
-//#include "quic/tools/quic_backend_response.h"
+// #include "quic/tools/quic_backend_response.h"
 #include "src/http3serverbackend.h"
 #include "src/http3serverstream.h" // todo
 
@@ -36,25 +36,6 @@ namespace quic
   class Http3ServerSession : public QuicServerSessionBase
   {
   public:
-    // A PromisedStreamInfo is an element of the queue to store promised
-    // stream which hasn't been created yet. It keeps a mapping between promised
-    // stream id with its priority and the headers sent out in PUSH_PROMISE.
-    struct PromisedStreamInfo
-    {
-    public:
-      PromisedStreamInfo(spdy::Http2HeaderBlock request_headers,
-                         QuicStreamId stream_id,
-                         const QuicStreamPriority &priority)
-          : request_headers(std::move(request_headers)),
-            stream_id(stream_id),
-            priority(priority),
-            is_cancelled(false) {}
-      spdy::Http2HeaderBlock request_headers;
-      QuicStreamId stream_id;
-      QuicStreamPriority priority;
-      bool is_cancelled;
-    };
-
     // Takes ownership of |connection|.
     Http3ServerSession(const QuicConfig &config,
                        const ParsedQuicVersionVector &supported_versions,
@@ -72,20 +53,12 @@ namespace quic
     // Override base class to detact client sending data on server push stream.
     void OnStreamFrame(const QuicStreamFrame &frame) override;
 
-    void OnCanCreateNewOutgoingStream(bool unidirectional) override;
-
-
   protected:
     // QuicSession methods:
     QuicSpdyStream *CreateIncomingStream(QuicStreamId id) override;
     QuicSpdyStream *CreateIncomingStream(PendingStream *pending) override;
     QuicSpdyStream *CreateOutgoingBidirectionalStream() override;
     Http3ServerStream *CreateOutgoingUnidirectionalStream() override;
-    // Override to return true for locally preserved server push stream.
-    void HandleFrameOnNonexistentOutgoingStream(QuicStreamId stream_id) override;
-    // Override to handle reseting locally preserved streams.
-    void HandleRstOnValidNonexistentStream(
-        const QuicRstStreamFrame &frame) override;
 
     // QuicServerSessionBaseMethod:
     std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
@@ -97,12 +70,14 @@ namespace quic
       return http3_server_backend_;
     }
 
-    void MaybeInitializeHttp3UnidirectionalStreams() override;
-
-    bool ShouldNegotiateWebTransport() override
+    WebTransportHttp3VersionSet LocallySupportedWebTransportVersions()
+        const override
     {
-      return http3_server_backend_->SupportsWebTransport();
+      return http3_server_backend_->SupportsWebTransport()
+                 ? kDefaultSupportedWebTransportVersions
+                 : WebTransportHttp3VersionSet();
     }
+
     HttpDatagramSupport LocalHttpDatagramSupport() override
     {
       if (ShouldNegotiateWebTransport())
@@ -112,51 +87,6 @@ namespace quic
       return QuicServerSessionBase::LocalHttpDatagramSupport();
     }
 
-  private:
-    /*friend class test::QuicSimpleServerSessionPeer;
-
-    // Create a server push headers block by copying request's headers block.
-    // But replace or add these pseudo-headers as they are specific to each
-    // request:
-    // :authority, :path, :method, :scheme, referer.
-    // Copying the rest headers ensures they are the same as the original
-    // request, especially cookies.
-    spdy::Http2HeaderBlock SynthesizePushRequestHeaders(
-        std::string request_url,
-        QuicBackendResponse::ServerPushInfo resource,
-        const spdy::Http2HeaderBlock& original_request_headers);
-
-    // Send PUSH_PROMISE frame on headers stream.
-    void SendPushPromise(QuicStreamId original_stream_id,
-                         QuicStreamId promised_stream_id,
-                         spdy::Http2HeaderBlock headers);
-
-    // Fetch response from cache for request headers enqueued into
-    // promised_headers_and_streams_ and send them on dedicated stream until
-    // reaches max_open_stream_ limit.
-    // Called when return value of GetNumOpenOutgoingStreams() changes:
-    //    CloseStreamInner();
-    //    StreamDraining();
-    // Note that updateFlowControlOnFinalReceivedByteOffset() won't change the
-    // return value becasue all push streams are impossible to become locally
-    // closed. Since a locally preserved stream becomes remotely closed after
-    // HandlePromisedPushRequests() starts to process it, and if it is reset
-    // locally afterwards, it will be immediately become closed and never get into
-    // locally_closed_stream_highest_offset_. So all the streams in this map
-    // are not outgoing streams.*/
-    void HandlePromisedPushRequests();
-
-    // Keep track of the highest stream id which has been sent in PUSH_PROMISE.
-    QuicStreamId highest_promised_stream_id_;
-
-    // Promised streams which hasn't been created yet because of max_open_stream_
-    // limit. New element is added to the end of the queue.
-    // Since outgoing stream is created in sequence, stream_id of each element in
-    // the queue also increases by 2 from previous one's. The front element's
-    // stream_id is always next_outgoing_stream_id_, and the last one is always
-    // highest_promised_stream_id_.
-    quiche::QuicheCircularDeque<PromisedStreamInfo> promised_streams_;
-
     Http3ServerBackend *http3_server_backend_; // Not owned.
   };
 

package/src/http3serverstream.cc

@@ -149,27 +149,6 @@ namespace quic
     SendResponse();
   }
 
-  void Http3ServerStream::PushResponse(
-      Http2HeaderBlock push_request_headers)
-  {
-    if (QuicUtils::IsClientInitiatedStreamId(session()->transport_version(),
-                                             id()))
-    {
-      QUIC_BUG(quic_bug_10962_2)
-          << "Client initiated stream shouldn't be used as promised stream.";
-      return;
-    }
-    // Change the stream state to emulate a client request.
-    request_headers_ = std::move(push_request_headers);
-    content_length_ = 0;
-    QUIC_DVLOG(1) << "Stream " << id()
-                  << " ready to receive server push response.";
-    QUICHE_DCHECK(reading_stopped());
-
-    // Directly send response based on the emulated request_headers_.
-    SendResponse();
-  }
-
   void Http3ServerStream::SendResponse()
   {
     if (request_headers_.empty())
@@ -250,19 +229,7 @@ namespace quic
     // http3_server_backend_->FetchResponseFromBackend(request_headers_, body_,
     //                                                       this);
   }
-  /*
-  QuicConnectionId Http3ServerStream::connection_id() const {
-    return spdy_session()->connection_id();
-  }
 
-  QuicStreamId Http3ServerStream::stream_id() const {
-    return id();
-  }
-
-  std::string Http3ServerStream::peer_host() const {
-    return spdy_session()->peer_address().host().ToString();
-  }
-  */
   void Http3ServerStream::OnResponseBackendComplete(
       const Http3BackendResponse *response)
   {
@@ -330,22 +297,6 @@ namespace quic
       return;
     }
 
-    if (QuicUtils::IsServerInitiatedStreamId(session()->transport_version(),
-                                             id()))
-    {
-      // A server initiated stream is only used for a server push response,
-      // and only 200 and 30X response codes are supported for server push.
-      // This behavior mirrors the HTTP/2 implementation.
-      bool is_redirection = response_code / 100 == 3;
-      if (response_code != 200 && !is_redirection)
-      {
-        QUIC_LOG(WARNING) << "Response to server push request " << request_url
-                          << " result in response code " << response_code;
-        Reset(QUIC_STREAM_CANCELLED);
-        return;
-      }
-    }
-
     if (response->response_type() == Http3BackendResponse::INCOMPLETE_RESPONSE)
     {
       QUIC_DVLOG(1)

package/src/http3serverstream.h

@@ -53,11 +53,6 @@ namespace quic
 
     void OnInvalidHeaders() override;
 
-    // Make this stream start from as if it just finished parsing an incoming
-    // request whose headers are equivalent to |push_request_headers|.
-    // Doing so will trigger this toy stream to fetch response and send it back.
-    virtual void PushResponse(spdy::Http2HeaderBlock push_request_headers);
-
     // The response body of error responses.
     static const char *const kErrorResponseBody;
     static const char *const kNotFoundResponseBody;

package/src/http3wtsessionvisitor.cc

@@ -25,7 +25,7 @@ namespace quic
         session_->eventloop_->informSessionClosed(session_, error_code, error_message);
     }
 
-    void Http3WTSession::Visitor::OnSessionReady(const spdy::Http2HeaderBlock &)
+    void Http3WTSession::Visitor::OnSessionReady()
     {
         session_->eventloop_->informSessionReady(session_);
 

package/src/http3wtsessionvisitor.h

@@ -52,7 +52,11 @@ namespace quic
         {
             session_ = session;
             eventloop_ = eventloop;
-            allocator_ = std::make_unique<DatagramAllocator>(eventloop);
+            if (session_) {
+                session_->SetOnDraining([this]() {
+                    eventloop_->informGoawayReceived(this);
+                }); 
+            }
         }
 
         class Visitor : public WebTransportVisitor
@@ -62,7 +66,7 @@ namespace quic
 
             ~Visitor();
 
-            void OnSessionReady(const spdy::Http2HeaderBlock &) override;
+            void OnSessionReady() override;
 
             void OnSessionClosed(WebTransportSessionError error_code,
                                  const std::string &error_message) override;
@@ -219,6 +223,13 @@ namespace quic
             eventloop_->Schedule(task);
         }
 
+        void notifySessionDrainingInt()
+        {
+            std::function<void()> task = [this]()
+            { if (session_) session_->NotifySessionDraining(); };
+            eventloop_->Schedule(task);
+        }
+
         void closeInt(int code, std::string &reason)
         {
             std::function<void()> task = [this, code, reason]()
@@ -226,49 +237,18 @@ namespace quic
             eventloop_->Schedule(task);
         }
 
-        class DatagramAllocator : public quiche::QuicheBufferAllocator
-        {
-        public:
-            DatagramAllocator(Http3EventLoop *eventloop) : eventloop_(eventloop)
-            {
-            }
-
-            char *New(size_t size) { return nullptr; }                   // fake it comes from javascript
-            char *New(size_t size, bool flag_enable) { return nullptr; } // fake it comes from javascript
-
-            void Delete(char *buffer)
-            {
-                eventloop_->informDatagramBufferFree(buffers_[buffer]);
-                buffers_.erase(buffer);
-            }
-
-            void registerBuffer(char *buffer, Napi::ObjectReference *bufferhandle)
-            {
-                buffers_[buffer] = bufferhandle;
-            }
-
-        protected:
-            Http3EventLoop *eventloop_;
-            std::map<char *, Napi::ObjectReference *> buffers_;
-        };
-
         void writeDatagramInt(char *buffer, size_t len, Napi::ObjectReference *bufferhandle)
         {
             if (!session_)
             {
-                eventloop_->informDatagramSend(this);
+                eventloop_->informDatagramSend(this, bufferhandle);
                 return;
             }
-            allocator_->registerBuffer(buffer, bufferhandle);
-            auto ubuffer = quiche::QuicheUniqueBufferPtr(buffer,
-                                                         quiche::QuicheBufferDeleter(allocator_.get()));
-
-            quiche::QuicheMemSlice slice(quiche::QuicheBuffer(std::move(ubuffer), len));
-            session_->SendOrQueueDatagram(std::move(slice));
-            eventloop_->informDatagramSend(this);
+            session_->SendOrQueueDatagram(absl::string_view(buffer, len));
+            eventloop_->informDatagramSend(this, bufferhandle);
         }
+
         WebTransportSession *session_;
-        std::unique_ptr<DatagramAllocator> allocator_;
         bool echo_stream_opened_ = false;
         Http3EventLoop *eventloop_;
         uint32_t ordBidiStreams;
@@ -315,6 +295,11 @@ namespace quic
             }
         }
 
+        void notifySessionDraining(const Napi::CallbackInfo &info)
+        {
+            wtsession_->notifySessionDrainingInt();
+        }
+
         void close(const Napi::CallbackInfo &info)
         {
             int code = 0;
@@ -351,6 +336,8 @@ namespace quic
                                                                                                                static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
                                                            InstanceMethod<&Http3WTSessionJS::writeDatagram>("writeDatagram",
                                                                                                             static_cast<napi_property_attributes>(napi_writable | napi_configurable)),
+                                                           InstanceMethod<&Http3WTSessionJS::notifySessionDraining>("notifySessionDraining",
+                                                                                                            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);                                                                                      

package/src/http3wtstreamvisitor.cc

@@ -23,6 +23,9 @@ namespace quic
 
             stream_->chunks_.pop_front();
         }
+
+        stream_->eventloop_->informAboutStreamRead(stream_, 0, false, false);
+
         if (!stream_->stop_sending_received_)
         {
             stream_->eventloop_->informStreamRecvSignal(stream_, 0, NetworkTask::stopSending);
@@ -77,21 +80,45 @@ namespace quic
 
     void Http3WTStream::doCanRead()
     {
+        // if (pause_reading_) return ; // back pressure folks!
+        
         if (pause_reading_)
         {
             can_read_pending_ = true;
             return; // back pressure folks!
         }
         // first figure out if we have readable data
+        if (bufferlen_ >= readbufsize_ || !readbufdata_) {
+            can_read_pending_ = true;
+            return; // no space here
+        }
         size_t readable = stream_->ReadableBytes();
-        // ok create a string obj to hold the data
-        std::string *data = new std::string();
-        data->resize(readable);
-        WebTransportStream::ReadResult result = stream_->Read(&(*data)[0], readable);
-        data->resize(result.bytes_read);
-        QUIC_DVLOG(1) << "Attempted reading on WebTransport bidirectional stream "
-                       << ", bytes read: " << result.bytes_read;
-        eventloop_->informAboutStreamRead(this, data, result.fin);
+        bool read = false;
+        while (readable > 0 && bufferlen_ < readbufsize_)
+        {
+            if (writepos_ >= readpos_) {
+                size_t len = readbufsize_ - writepos_;   
+                WebTransportStream::ReadResult result = 
+                    stream_->Read(absl::Span<char>(((char*) readbufdata_) + writepos_, len));
+                QUIC_DVLOG(1) << "Attempted reading on WebTransport stream "
+                          << ", bytes read: " << result.bytes_read;
+                writepos_ = (writepos_ + result.bytes_read) % readbufsize_;
+                bufferlen_ = bufferlen_ + result.bytes_read;
+                eventloop_->informAboutStreamRead(this, result.bytes_read, 
+                            result.fin, true);
+            } else  { // readpos_ > writepos_
+                size_t len = writepos_ - readpos_;
+                WebTransportStream::ReadResult result = 
+                    stream_->Read(absl::Span<char>(((char*) readbufdata_) + writepos_, len));
+                QUIC_DVLOG(1) << "Attempted reading on WebTransport stream "
+                          << ", bytes read: " << result.bytes_read; 
+                writepos_ = (writepos_ + result.bytes_read) % readbufsize_;
+                bufferlen_ = bufferlen_ + result.bytes_read;
+                eventloop_->informAboutStreamRead(this, result.bytes_read,
+                             result.fin, true);
+            } 
+            readable = stream_->ReadableBytes();
+        }
     }
 
     void Http3WTStream::doCanWrite()