@fails-components/webtransport 0.3.1 → 1.0.1

package/src/http3serverbackend.cc

@@ -1,105 +0,0 @@
-// modifications
-// Copyright (c) 2022 Marten Richter or other contributers (see commit). All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// original copyright, see LICENSE.chromium
-// Copyright (c) 2012 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.
-
-#include "src/http3serverbackend.h"
-#include "src/http3wtsessionvisitor.h"
-#include "src/http3server.h"
-#include "src/http3eventloop.h"
-
-#include <utility>
-
-#include "absl/strings/match.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-#include "quiche/quic/core/http/spdy_utils.h"
-#include "quiche/quic/platform/api/quic_bug_tracker.h"
-#include "quiche/quic/platform/api/quic_logging.h"
-//#include "quic/tools/web_transport_test_visitors.h"
-#include "quiche/common/platform/api/quiche_file_utils.h"
-#include "quiche/common/quiche_text_utils.h"
-
-using spdy::Http2HeaderBlock;
-
-namespace quic
-{
-
-  /*
-  void QuicMemoryCacheBackend::GenerateDynamicResponses() {
-    QuicWriterMutexLock lock(&response_mutex_);
-    // Add a generate bytes response.
-    spdy::Http2HeaderBlock response_headers;
-    response_headers[":status"] = "200";
-    generate_bytes_response_ = std::make_unique<QuicBackendResponse>();
-    generate_bytes_response_->set_headers(std::move(response_headers));
-    generate_bytes_response_->set_response_type(
-        QuicBackendResponse::GENERATE_BYTES);
-  }
-  */
-
-  Http3ServerBackend::WebTransportRespPromisePtr
-  Http3ServerBackend::ProcessWebTransportRequest(
-      const spdy::Http2HeaderBlock &request_headers,
-      WebTransportSession *session)
-  {
-    WebTransportRespPromisePtr promise = std::make_shared<WebTransportRespPromise>();
-    if (!SupportsWebTransport())
-    {
-      std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
-      response->response_headers[":status"] = "400";
-      promise->resolve(std::move(response));
-      return promise;
-    }
-
-    auto path_it = request_headers.find(":path");
-    if (path_it == request_headers.end())
-    {
-      std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
-      response->response_headers[":status"] = "400";
-      promise->resolve(std::move(response));
-      return promise;
-    }
-    std::string path(path_it->second);
-
-    if (paths_.find(path) != paths_.end())
-    { // to do handle our web transport paths
-      std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
-      Http3WTSession *wtsession = new Http3WTSession();
-      wtsession->init(session, eventloop_);
-      response->response_headers[":status"] = "200";
-      response->visitor =
-          std::make_unique<Http3WTSession::Visitor>(wtsession);
-      eventloop_->informAboutNewSession(server_, static_cast<Http3WTSession *>(wtsession), path, 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
-      spdy::Http2HeaderBlock *reqheadcopy = new Http2HeaderBlock(request_headers.Clone());
-
-      // second step inform the js side
-      eventloop_->informAboutNewSessionRequest(server_, session, reqheadcopy, promise);
-      return promise;
-    }
-
-    std::unique_ptr<WebTransportResponse> response = std::make_unique<WebTransportResponse>();
-    response->response_headers[":status"] = "404";
-    promise->resolve(std::move(response));
-    return promise;
-  }
-
-  Http3ServerBackend::~Http3ServerBackend()
-  {
-    {
-    }
-  }
-
-} // namespace quic

package/src/http3serverbackend.h

@@ -1,98 +0,0 @@
-// modifications
-// Copyright (c) 2022 Marten Richter or other contributers (see commit). All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// original copyright, see LICENSE.chromium
-// Copyright (c) 2012 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 QUICHE_QUIC_TOOLS_QUIC_SIMPLE_SERVER_BACKEND_H_
-#define QUICHE_QUIC_TOOLS_QUIC_SIMPLE_SERVER_BACKEND_H_
-
-#include <memory>
-
-#include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/core/web_transport_interface.h"
-#include "quiche/spdy/core/http2_header_block.h"
-
-namespace quic
-{
-
-  class Http3Server;
-  class Http3EventLoop;
-
-  template <typename T>
-  class JSlikePromise
-  {
-  public:
-    void finally(std::function<void(T *)> func)
-    {
-      T *res = result.get();
-      if (res != nullptr)
-        func(res);
-      else
-        finallys.push_back(func);
-    }
-
-    void resolve(std::unique_ptr<T> res)
-    {
-      if (result.get() != nullptr)
-        return; // throw std::runtime_error("Promise already settled");
-      result = std::move(res);
-      for (auto finally : finallys)
-      {
-        finally(result.get());
-      }
-      finallys.clear();
-    }
-
-  protected:
-    std::unique_ptr<T> result;
-    std::list<std::function<void(T *)>> finallys;
-  };
-
-  // This interface implements the functionality to fetch a response
-  // from the backend (such as cache, http-proxy etc) to serve
-  // requests received by a Quic Server
-  // no, here only webtransport stuff remained, I do not want to serve http3
-  class Http3ServerBackend
-  {
-  public:
-    struct WebTransportResponse
-    {
-      spdy::Http2HeaderBlock response_headers;
-      std::unique_ptr<WebTransportVisitor> visitor;
-    };
-
-    using WebTransportRespPromise = JSlikePromise<WebTransportResponse>;
-    using WebTransportRespPromisePtr = std::shared_ptr<WebTransportRespPromise>;
-
-    Http3ServerBackend(Http3EventLoop *eventloop) : eventloop_(eventloop),
-                                                    server_(nullptr), jshandlerequesthandler_(false) {}
-
-    ~Http3ServerBackend();
-
-    void setServer(Http3Server *server) { server_ = server; }
-    void setJSHandler(bool on) { jshandlerequesthandler_ = on; }
-
-    WebTransportRespPromisePtr ProcessWebTransportRequest(
-        const spdy::Http2HeaderBlock & /*request_headers*/,
-        WebTransportSession * /*session*/);
-    bool SupportsWebTransport() { return true; }
-    bool UsesDatagramContexts() { return true; }
-    bool SupportsExtendedConnect() { return true; }
-
-    void addPath(std::string path) { paths_.insert(path); }
-
-  protected:
-    Http3Server *server_;       // unowned
-    Http3EventLoop *eventloop_; // unowned
-    bool jshandlerequesthandler_;
-    std::set<std::string> paths_;
-  };
-
-} // namespace quic
-
-#endif // QUICHE_QUIC_TOOLS_QUIC_SIMPLE_SERVER_BACKEND_H_

package/src/http3serversession.cc

@@ -1,123 +0,0 @@
-// modifications
-// Copyright (c) 2022 Marten Richter or other contributers (see commit). All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// original copyright, see LICENSE.chromium
-// Copyright (c) 2012 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.
-
-#include "src/http3serversession.h"
-
-#include <utility>
-
-#include "absl/memory/memory.h"
-#include "quiche/quic/core/http/quic_server_initiated_spdy_stream.h"
-#include "quiche/quic/core/http/quic_spdy_session.h"
-#include "quiche/quic/core/quic_connection.h"
-#include "quiche/quic/core/quic_types.h"
-#include "quiche/quic/core/quic_utils.h"
-#include "quiche/quic/platform/api/quic_flags.h"
-#include "quiche/quic/platform/api/quic_logging.h"
-#include "src/http3serverstream.h"
-
-namespace quic
-{
-
-  Http3ServerSession::Http3ServerSession(
-      const QuicConfig &config, const ParsedQuicVersionVector &supported_versions,
-      QuicConnection *connection, QuicSession::Visitor *visitor,
-      QuicCryptoServerStreamBase::Helper *helper,
-      const QuicCryptoServerConfig *crypto_config,
-      QuicCompressedCertsCache *compressed_certs_cache,
-      Http3ServerBackend *http3_server_backend)
-      : QuicServerSessionBase(config, supported_versions, connection, visitor,
-                              helper, crypto_config, compressed_certs_cache),
-        http3_server_backend_(http3_server_backend)
-  {
-    QUICHE_DCHECK(http3_server_backend_);
-  }
-
-  Http3ServerSession::~Http3ServerSession() {  DeleteConnection(); }
-
-  std::unique_ptr<QuicCryptoServerStreamBase>
-  Http3ServerSession::CreateQuicCryptoServerStream(
-      const QuicCryptoServerConfig *crypto_config,
-      QuicCompressedCertsCache *compressed_certs_cache)
-  {
-    return CreateCryptoServerStream(crypto_config, compressed_certs_cache, this,
-                                    stream_helper());
-  }
-
-  void Http3ServerSession::OnStreamFrame(const QuicStreamFrame &frame)
-  {
-    if (!IsIncomingStream(frame.stream_id) && !WillNegotiateWebTransport())
-    {
-      QUIC_LOG(WARNING) << "Client shouldn't send data on server push stream";
-      connection()->CloseConnection(
-          QUIC_INVALID_STREAM_ID, "Client sent data on server push stream",
-          ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-      return;
-    }
-    QuicSpdySession::OnStreamFrame(frame);
-  }
-
-  QuicSpdyStream *Http3ServerSession::CreateIncomingStream(QuicStreamId id)
-  {
-    if (!ShouldCreateIncomingStream(id))
-    {
-      return nullptr;
-    }
-
-    QuicSpdyStream *stream = new Http3ServerStream(
-        id, this, BIDIRECTIONAL, http3_server_backend_);
-    ActivateStream(absl::WrapUnique(stream));
-    return stream;
-  }
-
-  QuicSpdyStream *Http3ServerSession::CreateIncomingStream(
-      PendingStream *pending)
-  {
-    QuicSpdyStream *stream =
-        new Http3ServerStream(pending, this, http3_server_backend_);
-    ActivateStream(absl::WrapUnique(stream));
-    return stream;
-  }
-
-  QuicSpdyStream *Http3ServerSession::CreateOutgoingBidirectionalStream()
-  {
-    if (!WillNegotiateWebTransport())
-    {
-      QUIC_BUG(Http3ServerSession CreateOutgoingBidirectionalStream without
-                   WebTransport support)
-          << "Http3ServerSession::CreateOutgoingBidirectionalStream called "
-             "in a session without WebTransport support.";
-      return nullptr;
-    }
-    if (!ShouldCreateOutgoingBidirectionalStream())
-    {
-      return nullptr;
-    }
-
-    QuicServerInitiatedSpdyStream *stream = new QuicServerInitiatedSpdyStream(
-        GetNextOutgoingBidirectionalStreamId(), this, BIDIRECTIONAL);
-    ActivateStream(absl::WrapUnique(stream));
-    return stream;
-  }
-
-  Http3ServerStream *
-  Http3ServerSession::CreateOutgoingUnidirectionalStream()
-  {
-    if (!ShouldCreateOutgoingUnidirectionalStream())
-    {
-      return nullptr;
-    }
-
-    Http3ServerStream *stream = new Http3ServerStream(
-        GetNextOutgoingUnidirectionalStreamId(), this, WRITE_UNIDIRECTIONAL,
-        http3_server_backend_);
-    ActivateStream(absl::WrapUnique(stream));
-    return stream;
-  }
-} // namespace quic

package/src/http3serversession.h

@@ -1,95 +0,0 @@
-// modifications
-// Copyright (c) 2022 Marten Richter or other contributers (see commit). All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// original copyright, see LICENSE.chromium
-// Copyright (c) 2012 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.
-
-// A toy server specific QuicSession subclass.
-
-#ifndef HTTP3_SERVER_SESSION_H
-#define HTTP3_SERVER_SESSION_H
-
-#include <stdint.h>
-
-#include <list>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "quiche/quic/core/http/quic_server_session_base.h"
-#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 "src/http3serverbackend.h"
-#include "src/http3serverstream.h" // todo
-
-namespace quic
-{
-
-  class Http3ServerSession : public QuicServerSessionBase
-  {
-  public:
-    // Takes ownership of |connection|.
-    Http3ServerSession(const QuicConfig &config,
-                       const ParsedQuicVersionVector &supported_versions,
-                       QuicConnection *connection,
-                       QuicSession::Visitor *visitor,
-                       QuicCryptoServerStreamBase::Helper *helper,
-                       const QuicCryptoServerConfig *crypto_config,
-                       QuicCompressedCertsCache *compressed_certs_cache,
-                       Http3ServerBackend *http3_server_backend);
-    Http3ServerSession(const Http3ServerSession &) = delete;
-    Http3ServerSession &operator=(const Http3ServerSession &) = delete;
-
-    ~Http3ServerSession() override;
-
-    // Override base class to detact client sending data on server push stream.
-    void OnStreamFrame(const QuicStreamFrame &frame) override;
-
-  protected:
-    // QuicSession methods:
-    QuicSpdyStream *CreateIncomingStream(QuicStreamId id) override;
-    QuicSpdyStream *CreateIncomingStream(PendingStream *pending) override;
-    QuicSpdyStream *CreateOutgoingBidirectionalStream() override;
-    Http3ServerStream *CreateOutgoingUnidirectionalStream() override;
-
-    // QuicServerSessionBaseMethod:
-    std::unique_ptr<QuicCryptoServerStreamBase> CreateQuicCryptoServerStream(
-        const QuicCryptoServerConfig *crypto_config,
-        QuicCompressedCertsCache *compressed_certs_cache) override;
-
-    Http3ServerBackend *server_backend()
-    {
-      return http3_server_backend_;
-    }
-
-    WebTransportHttp3VersionSet LocallySupportedWebTransportVersions()
-        const override
-    {
-      return http3_server_backend_->SupportsWebTransport()
-                 ? kDefaultSupportedWebTransportVersions
-                 : WebTransportHttp3VersionSet();
-    }
-
-    HttpDatagramSupport LocalHttpDatagramSupport() override
-    {
-      if (ShouldNegotiateWebTransport())
-      {
-        return HttpDatagramSupport::kRfcAndDraft04;
-      }
-      return QuicServerSessionBase::LocalHttpDatagramSupport();
-    }
-
-    Http3ServerBackend *http3_server_backend_; // Not owned.
-  };
-
-} // namespace quic
-
-#endif // QUICHE_QUIC_TOOLS_QUIC_SIMPLE_SERVER_SESSION_H_