doh_https_rr_mock_server.h

Go to the documentation of this file.

/*
 * Copyright (C) Max Dymond, <cmeister2@gmail.com>, et al.
 *
 * SPDX-License-Identifier: curl
 */

 
#ifndef PROTO_FUZZER_DOH_HTTPS_RR_MOCK_SERVER_H_
#define PROTO_FUZZER_DOH_HTTPS_RR_MOCK_SERVER_H_
 
#include <curl/curl.h>
 
#include <array>
#include <cstddef>
#include <cstdio>
#include <memory>
#include <string>
 
#include "curl_fuzzer.pb.h"
#include "proto_fuzzer/h2_origin_mock_server.h"
 
namespace proto_fuzzer {
 
class BoundedAnonymousInputFile;

class DohHttpsRrMockServer : public H2OriginMockServer {
 public:
  explicit DohHttpsRrMockServer(const curl::fuzzer::proto::Scenario& scenario);
  ~DohHttpsRrMockServer() override;
 
  DohHttpsRrMockServer(const DohHttpsRrMockServer&) = delete;
  DohHttpsRrMockServer& operator=(const DohHttpsRrMockServer&) = delete;
 
  void Install(CURL* easy) override;
 
  void ConfigureRequestData(ScenarioRequestData* request_data) override;

  std::size_t doh_request_count() const { return doh_request_count_; }

  std::size_t httpsrr_answer_count() const { return httpsrr_answer_count_; }

  const std::string& doh_url() const { return doh_url_; }

  std::size_t doh_tls_handshake_count() const {
    return doh_tls_transport_ == nullptr ? 0 : doh_tls_transport_->completed_handshake_count();
  }

  std::string doh_tls_alpn() const {
    return doh_tls_transport_ == nullptr ? std::string() : doh_tls_transport_->negotiated_alpn();
  }
 
  std::string custom_stderr_contents();
 
  bool tls_path_fixture_ready() const;

  std::size_t internal_ssl_ctx_callback_count() const { return internal_ssl_ctx_callback_count_; }
 
 protected:
  void ObserveActiveTransfer(CURL* easy) override;
 
  void RunLoop(CURLM* multi, CURL* easy, const curl::fuzzer::proto::Scenario& scenario) override;
 
 private:
  static constexpr std::size_t kMaxConnections = 8;
  static constexpr std::size_t kMaxRequestBytes = 4096;
  static constexpr std::size_t kMaxResponseBytes = 4096;
  static constexpr std::size_t kMaxDiagnosticBytes = 4096;

  struct DohConnection final : public IncomingDataObserver {
    bool active() const { return fd >= 0 || tls != nullptr; }
    void ObserveIncomingData(const unsigned char* data, std::size_t size) override;
 
    int fd = -1;
    std::unique_ptr<MockConnection> tls;
    std::string request;
    std::string response;
    std::size_t response_offset = 0;
    std::size_t deferred_write_turns = 0;
    bool writing = false;
    bool request_overflow = false;
  };
 
  virtual bool StartListener();
  void StopListener();
  bool ConfigureHttpsOptions();
  static CURLcode ObserveSslContext(CURL* easy, void* ssl_context, void* user_data);
  bool BeginProxyBypass();
  void EndProxyBypass();
 
  void ServiceDohConnections();
  void AcceptConnections();
  void CloseConnection(DohConnection* connection);
  bool CompleteRequest(DohConnection* connection);
 
  CURL* easy_;
  int listener_;
  std::string doh_url_;

  curl::fuzzer::proto::DohOptionProbeMode option_probe_mode_;

  curl::fuzzer::proto::DohTransportMode transport_mode_;

  std::FILE* diagnostic_stream_;

  std::unique_ptr<BoundedAnonymousInputFile> tls_path_fixture_;

  std::size_t internal_ssl_ctx_callback_count_;

  std::unique_ptr<TlsMockTransport> doh_tls_transport_;
 
  std::array<DohConnection, kMaxConnections> connections_;
  std::size_t doh_request_count_;
  std::size_t httpsrr_answer_count_;

  curl::fuzzer::proto::DohResponseMode response_mode_;

  bool defer_httpsrr_;

  bool setup_ok_;

  bool proxy_bypass_active_;
  bool lower_no_proxy_was_set_;
  bool upper_no_proxy_was_set_;
  std::string saved_no_proxy_lower_;
  std::string saved_no_proxy_upper_;
};
 
}  // namespace proto_fuzzer
 
#endif  // PROTO_FUZZER_DOH_HTTPS_RR_MOCK_SERVER_H_