mock_server_base.h

Go to the documentation of this file.

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

 
#ifndef PROTO_FUZZER_MOCK_SERVER_BASE_H_
#define PROTO_FUZZER_MOCK_SERVER_BASE_H_
 
#include <curl/curl.h>
 
#include <cstddef>
#include <functional>
#include <memory>
#include <utility>
 
#include "curl_fuzzer.pb.h"
#include "proto_fuzzer/curl_raii.h"
 
namespace proto_fuzzer {
 
class MockConnection;
class MultiSocketDriver;
class ScenarioRequestData;

enum class SocketSetupDisposition {
  kNeedsSetup,
  kAlreadyConnected,
};

struct ConnectOnlyRunStats {
  CURLcode connect_result = CURLE_FAILED_INIT;  
  CURLcode send_result = CURLE_FAILED_INIT;     
  CURLcode recv_result = CURLE_FAILED_INIT;     
  std::size_t sent_bytes = 0;                   
  std::size_t received_bytes = 0;               
};

enum class MultiDrivePolicy {
  kPerform,       
  kSocketAction,  
  kFromApiPlan,   
};

class MockServerBase {
 public:
  virtual ~MockServerBase();
 
  MockServerBase(const MockServerBase&) = delete;
  MockServerBase& operator=(const MockServerBase&) = delete;
 
  virtual void ObserveState();
 
  virtual void Install(CURL* easy);
 
  virtual void ConfigureRequestData(ScenarioRequestData* request_data);
 
  CURLcode DriveScenario(CURL* easy, const curl::fuzzer::proto::Scenario& scenario);
 
  virtual CURLcode DriveEasyScenario(CURL* easy, const curl::fuzzer::proto::Scenario& scenario,
                                     bool use_events = false);
 
  virtual ConnectOnlyRunStats DriveConnectOnlyScenario(CURL* easy, const curl::fuzzer::proto::Scenario& scenario);

  using MultiObserver = std::function<void(CURLM*)>;

  void SetMultiObserver(MultiObserver observer) { multi_observer_ = std::move(observer); }
 
  MockConnection* connection();
 
 protected:
  explicit MockServerBase(MultiDrivePolicy drive_policy = MultiDrivePolicy::kPerform);
 
  virtual void HandleDetachedMulti(CurlMultiPtr multi);

  virtual curl_socket_t HandleOpenSocket(curlsocktype purpose, struct curl_sockaddr* address) = 0;
 
  virtual SocketSetupDisposition GetSocketSetupDisposition(curl_socket_t curlfd, curlsocktype purpose) const;

  virtual void RunLoop(CURLM* multi, CURL* easy, const curl::fuzzer::proto::Scenario& scenario) = 0;
 
  static int WaitOnMultiFdset(CURLM* multi, CURLMcode* rc);
 
  static void ProbeMultiPollset(CURLM* multi);
 
  // Ask curl whether one live socket currently needs writable readiness.
  static bool MultiPollsetWantsWrite(CURLM* multi, curl_socket_t socket);
 
  MultiSocketDriver* multi_socket_driver();
 
  std::size_t additional_handle_cleanup_count() const;
 
  void ResumeResponseIfRequested(CURL* easy);

  static constexpr int kMaxDriveIterations = 512;

  static constexpr int kMaxIdleIterations = 8;

  static constexpr int kMaxTimedIdleIterations = 256;
 
  static bool UsesTimedDrive(const curl::fuzzer::proto::Scenario& scenario);
 
  void ApplyPendingBackpressure();

  std::unique_ptr<MockConnection> connection_;

  int pending_recv_buf_bytes_;
  std::size_t pending_drain_limit_;

  MultiSocketDriver* multi_socket_driver_;

  std::size_t additional_handle_cleanup_count_;

  bool resume_response_;

  MultiObserver multi_observer_;
 
 private:
  MultiDrivePolicy drive_policy_;
 
  friend curl_socket_t MockServerBaseOpenSocketTrampoline(void*, curlsocktype, struct curl_sockaddr*);
  friend int MockServerBaseSockOptTrampoline(void*, curl_socket_t, curlsocktype);
};
 
}  // namespace proto_fuzzer
 
#endif  // PROTO_FUZZER_MOCK_SERVER_BASE_H_