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_MOCK_SERVER_H_
#define PROTO_FUZZER_MOCK_SERVER_H_
 
#include <curl/curl.h>
 
#include <array>
#include <cstddef>
#include <memory>
#include <string>
#include <vector>
 
#include "curl_fuzzer.pb.h"
#include "proto_fuzzer/incoming_data_observer.h"
#include "proto_fuzzer/mock_server_base.h"
#include "proto_fuzzer/scenario_limits.h"
 
namespace proto_fuzzer {
 
class MockConnection {
 public:
  MockConnection();
  virtual ~MockConnection();
 
  MockConnection(const MockConnection&) = delete;
  MockConnection& operator=(const MockConnection&) = delete;
 
  virtual bool ok() const;
  curl_socket_t take_client_fd();
  int server_fd() const;
 
  std::size_t client_send_buffer_size() const;
 
  bool EnsureClientSendBufferSize(std::size_t minimum);
 
  bool FillClientSendBuffer();
 
  virtual bool WriteAll(const unsigned char* data, std::size_t size);
  virtual std::size_t DrainIncoming();
  void SetIncomingDataObserver(IncomingDataObserver* observer);
  void ReadAvailable(std::string* out);
  virtual void ShutdownWrite();
 
  void ApplyBackpressure(int recv_buf_bytes, std::size_t drain_limit);
 
 protected:
  explicit MockConnection(int adopted_server_fd);
 
  void NotifyIncomingData(const unsigned char* data, std::size_t size);
 
 private:
  int server_fd_;
  int client_fd_;
  std::size_t drain_limit_;
  IncomingDataObserver* incoming_data_observer_;
};

class MockServer : public MockServerBase {
 public:
  explicit MockServer(MultiDrivePolicy drive_policy = MultiDrivePolicy::kPerform);
  ~MockServer() override;
 
  void SetScripts(const curl::fuzzer::proto::Scenario& scenario);
 
  void SetKeepConnectionsOpen(bool keep_open);
 
  CURLcode DriveEasyScenario(CURL* easy, const curl::fuzzer::proto::Scenario& scenario,
                             bool use_events = false) override;
 
  ConnectOnlyRunStats DriveConnectOnlyScenario(CURL* easy, const curl::fuzzer::proto::Scenario& scenario) override;
 
  bool DeliverNextChunk();
  bool has_more_chunks() const;
 
  bool ServiceConnections();
 
  std::size_t opened_connection_count() const;
 
 protected:
  virtual std::unique_ptr<MockConnection> CreateConnection();
 
  void ResetConnections();
 
  virtual void ObserveActiveTransfer(CURL* easy);
 
  // Whether this peer can service repeated zero-timeout public polls.
  virtual bool SupportsRepeatedPollsetProbe() const;
 
  curl_socket_t HandleOpenSocket(curlsocktype purpose = CURLSOCKTYPE_IPCXN,
                                 struct curl_sockaddr* address = nullptr) override;
  void RunLoop(CURLM* multi, CURL* easy, const curl::fuzzer::proto::Scenario& scenario) override;
 
 private:
  struct ConnectionScript {
    const curl::fuzzer::proto::Connection* connection = nullptr;
    std::size_t raw_chunk_count = 0;
    std::size_t frame_chunk_count = 0;
    std::size_t next_chunk = 0;

    std::size_t chunk_count() const { return raw_chunk_count + frame_chunk_count; }
  };
 
  std::size_t DrainIncomingConnections();
 
  void RunSocketActionLoop(CURLM* multi, CURL* easy);
 
  std::array<ConnectionScript, scenario_limits::kMaxConnections> scripts_;
  std::size_t script_count_;
  std::size_t next_script_;
  ConnectionScript* active_script_;

  bool preload_all_chunks_;

  bool keep_connections_open_;

  std::vector<std::unique_ptr<MockConnection>> previous_connections_;
};
 
}  // namespace proto_fuzzer
 
#endif  // PROTO_FUZZER_MOCK_SERVER_H_