@fails-components/webtransport 0.1.3 → 0.1.7

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

@@ -36,24 +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,
@@ -72,8 +54,6 @@ 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:
@@ -81,11 +61,6 @@ namespace quic
     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,7 +72,6 @@ namespace quic
       return http3_server_backend_;
     }
 
-    void MaybeInitializeHttp3UnidirectionalStreams() override;
 
     bool ShouldNegotiateWebTransport() override
     {
@@ -111,52 +85,7 @@ 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,6 @@ namespace quic
         {
             session_ = session;
             eventloop_ = eventloop;
-            allocator_ = std::make_unique<DatagramAllocator>(eventloop);
         }
 
         class Visitor : public WebTransportVisitor
@@ -62,7 +61,7 @@ namespace quic
 
             ~Visitor();
 
-            void OnSessionReady(const spdy::Http2HeaderBlock &) override;
+            void OnSessionReady() override;
 
             void OnSessionClosed(WebTransportSessionError error_code,
                                  const std::string &error_message) override;
@@ -226,49 +225,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;

package/src/http3wtstreamvisitor.cc

@@ -87,10 +87,10 @@ namespace quic
         // 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);
+        WebTransportStream::ReadResult result = stream_->Read(absl::Span<char>(&(*data)[0], readable));
         data->resize(result.bytes_read);
         QUIC_DVLOG(1) << "Attempted reading on WebTransport bidirectional stream "
-                       << ", bytes read: " << result.bytes_read;
+                      << ", bytes read: " << result.bytes_read;
         eventloop_->informAboutStreamRead(this, data, result.fin);
     }
 

package/test/bidirectional-streams.spec.js

@@ -43,6 +43,7 @@ describe('bidirectional streams', function () {
     url = `https://${address.host}:${address.port}`
   })
 
+  // @ts-ignore
   afterEach(async () => {
     if (client != null) {
       client.close()

package/test/datagrams.spec.js

@@ -39,6 +39,7 @@ describe('datagrams', function () {
     url = `https://${address.host}:${address.port}`
   })
 
+  // @ts-ignore
   afterEach(async () => {
     if (client != null) {
       client.close()

package/test/unidirectional-streams.spec.js

@@ -39,6 +39,7 @@ describe('unidirectional streams', function () {
     url = `https://${address.host}:${address.port}`
   })
 
+  // @ts-ignore
   afterEach(async () => {
     if (client != null) {
       client.close()

package/platform/net/quiche/common/platform/impl/quiche_flags_impl.h

@@ -1,12 +0,0 @@
-// taken from chromium platfom impl
-
-// Copyright 2020 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 NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_
-#define NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_
-
-#include "third_party/quiche/quiche/common/platform/default/quiche_platform_impl/quiche_flags_impl.h"
-
-#endif  // NET_QUICHE_COMMON_PLATFORM_IMPL_QUICHE_FLAGS_IMPL_H_

package/platform/poll.h

@@ -1,2 +0,0 @@
-// fakes poll.h
-#warning Fake poll.h is included to allow compilation on windows, upstream should solve this

package/platform/quiche/quic/core/io/quic_poll_event_loop.h

@@ -1,8 +0,0 @@
-// fake include file to fix problem in upstream
-#warning fake quic_poll_event_loop.h included
-
-#include "quiche/quic/bindings/quic_libevent.h"
-namespace quic
-{
-    typedef QuicLibeventEventLoopFactory QuicPollEventLoopFactory;
-}

package/platform/quiche_platform_impl/quic_testvalue_impl.h

@@ -1,19 +0,0 @@
-// from envoy so LICENSE.envoy applies
-#ifndef QUIC_TESTVALUE_IMPL_H
-#define QUIC_TESTVALUE_IMPL_H
-
-// NOLINT(namespace-envoy)
-
-// This file is part of the QUICHE platform implementation, and is not to be
-// consumed or referenced directly by other Envoy code. It serves purely as a
-// porting layer for QUICHE.
-
-#include "absl/strings/string_view.h"
-
-namespace quic {
-
-// NOLINTNEXTLINE(readability-identifier-naming)
-template <class T> void AdjustTestValueImpl(absl::string_view /*label*/, T* /*var*/) {}
-
-} // namespace quic
-#endif