pingpong_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_PINGPONG_MOCK_SERVER_H_
#define PROTO_FUZZER_PINGPONG_MOCK_SERVER_H_
 
#include <curl/curl.h>
 
#include <cstddef>
#include <memory>
#include <string>
#include <string_view>
 
#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;

class PingpongMockServer : public MockServerBase, public IncomingDataObserver {
 public:
  ~PingpongMockServer() override;
 
  PingpongMockServer(const PingpongMockServer&) = delete;
  PingpongMockServer& operator=(const PingpongMockServer&) = delete;
 
  // Bounded record of complete command lines sent by curl.
  const std::string& control_transcript() const;
 
  // Bounded record of the body most recently drained by a body phase. Peers
  // without an upload direction keep this empty.
  const std::string& uploaded_data() const;
 
  // Number of opt-in multi-poll probes issued while the most recent transfer
  // was active and its control socket had been handed to curl.
  std::size_t active_pollset_probe_count() const;
 
  // Number of opt-in probes where curl requested writable readiness while
  // the peer held an incomplete control command. A positive count exposes a
  // pending protocol send rather than a transient writable state.
  std::size_t writable_pollset_probe_count() const;
 
 protected:
  explicit PingpongMockServer(MultiDrivePolicy drive_policy = MultiDrivePolicy::kPerform);
 
  // Create the transport that carries the exchange. Overridden by TLS peers.
  virtual std::unique_ptr<MockConnection> CreateConnection();

  virtual void HandleLine(std::string_view line) = 0;
 
  // Body phase control. Only valid while HandleLine() is running; the parser
  // consumes the body before processing further command lines.
 
  // Consume bytes through the first occurrence of `terminator`, capturing the
  // body and the terminator itself. Used by SMTP's "\r\n.\r\n" end-of-body.
  void BeginMarkerBody(std::string_view terminator);
 
  // Consume exactly `length` bytes, capturing them, followed by a CRLF line
  // terminator that is not captured. Used by IMAP's {N} literal uploads.
  void BeginLiteralBody(std::size_t length);
 
  // Consume exactly `length` bytes, capturing them, with no trailing
  // terminator. Used by protocols such as RTSP whose announced entity body is
  // followed immediately by the next request or by the peer's close.
  void BeginExactBody(std::size_t length);
 
  // Drain all subsequent carrier bytes without command parsing or capture.
  // Plaintext upgrade peers use this after accepting STARTTLS because the
  // following TLS handshake is intentionally opaque to the line parser.
  void BeginOpaqueDrain();

  virtual void HandleBodyComplete() {}

  virtual void QueueShutdownReply() {}

  virtual void ResetProtocolState() {}
 
  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;
 
  void HandleDetachedMulti(CurlMultiPtr multi) override;
 
  void ObserveIncomingData(const unsigned char* data, std::size_t size) override;

  const curl::fuzzer::proto::Scenario* scenario() const { return scenario_; }
 
  // Return the next command-aligned reply, or nullptr once the bounded script
  // is exhausted. Empty entries still advance the cursor.
  const std::string* NextControlReply();
 
  // Queue one reply fragment, returning false only when the transport write
  // failed. An empty fragment is a successful no-op.
  bool WriteControlBytes(std::string_view bytes);
 
  // Write the next scripted reply. Returns false when none remains.
  bool WriteNextReply();
 
  // Half-close the peer's write side after a protocol-level transport
  // upgrade response. The existing socket remains readable so the bounded
  // driver can drain client handshake bytes without parsing them as commands.
  void ShutdownControlWrite();
 
  // First and second whitespace-delimited tokens of a command line, without
  // interpreting any protocol-specific arguments.
  static std::string_view FirstToken(std::string_view line);
  static std::string_view SecondToken(std::string_view line);
 
  // Compare an ASCII protocol token to an uppercase literal, ignoring case.
  static bool TokenEquals(std::string_view token, std::string_view expected_uppercase);
 
 private:
  enum class BodyMode {
    kCommand,  
    kMarker,   
    kLiteral,  
    kExact,    
    kOpaque,   
  };
 
  // Observability must not grow with a future curl loop; these caps exceed the
  // normalized upload and command budgets without affecting draining.
  static constexpr std::size_t kMaxCapturedControlBytes = 64 * 1024;
  static constexpr std::size_t kMaxCapturedUploadBytes = 2 * scenario_limits::kMaxUploadBytes;
 
  void ResetForScenario(const curl::fuzzer::proto::Scenario& scenario);
 
  static void ApplyScriptBackpressure(MockConnection* connection, const curl::fuzzer::proto::Connection& script);
 
  bool ServiceControlConnection();
 
  void FinishConnections();
 
  // Retain a bounded prefix for assertions without affecting parser progress.
  static void CapturePrefix(std::string_view source, std::size_t limit, std::string* destination);

  const curl::fuzzer::proto::Scenario* scenario_;
  std::size_t control_reply_count_;
  std::size_t next_control_reply_;
  std::string pending_control_bytes_;
  std::string control_transcript_;
  std::string uploaded_data_;
  std::size_t active_pollset_probe_count_;
  std::size_t writable_pollset_probe_count_;
  std::string body_marker_;
  std::size_t body_length_remaining_;
  std::size_t body_terminator_remaining_;
  BodyMode body_mode_;
  curl_socket_t control_socket_;
  bool control_opened_;
};
 
}  // namespace proto_fuzzer
 
#endif  // PROTO_FUZZER_PINGPONG_MOCK_SERVER_H_