mqtt_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_MQTT_MOCK_SERVER_H_
#define PROTO_FUZZER_MQTT_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 MqttMockServer : public MockServerBase, public IncomingDataObserver {
 public:
  explicit MqttMockServer(curl::fuzzer::proto::MqttProbeMode mode = curl::fuzzer::proto::MQTT_PROBE_DEFAULT);
 
  ~MqttMockServer() override;
 
  void ObserveState() override;
 
  MqttMockServer(const MqttMockServer&) = delete;
  MqttMockServer& operator=(const MqttMockServer&) = delete;
 
  // Bounded raw capture of complete client packets, including their fixed
  // headers. Tests use it to assert CONNECT/CONNECT acknowledgement order
  // without parsing curl's debug output.
  const std::string& packet_transcript() const;
 
  // Bounded topic capture from the first PUBLISH packet.
  const std::string& published_topic() const;
 
  // Bounded payload capture from the first PUBLISH packet.
  const std::string& published_payload() const;
 
  std::size_t packet_count() const;
 
  std::size_t connect_count() const;
 
  std::size_t publish_count() const;
 
  std::size_t subscribe_count() const;
 
  // Number of PUBLISH packets whose fixed-header QoS bits requested QoS 1.
  std::size_t qos1_publish_count() const;
 
  // Number of requested zero-timeout multi-poll probes made while the most
  // recent transfer and MQTT socket were both active.
  std::size_t active_pollset_probe_count() const;
 
 protected:
  virtual std::unique_ptr<MockConnection> CreateConnection();
 
  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 ObserveIncomingData(const unsigned char* data, std::size_t size) override;
 
 private:
  enum class ParseResult {
    kNeedMore,
    kInvalid,
    kComplete,
  };
 
  // Decode a fixed header whose first byte is already present at offset zero.
  // Returns complete, need-more-data, or invalid (>4 length bytes).
  static ParseResult ParseRemainingLength(std::string_view bytes, std::size_t* header_size,
                                          std::size_t* remaining_length);
 
  void ResetForScenario(const curl::fuzzer::proto::Scenario& scenario);
 
  static void ApplyScriptBackpressure(MockConnection* connection, const curl::fuzzer::proto::Connection& script);
 
  bool ServiceClientConnection();
 
  void HandleClientPacket(unsigned char first_byte, std::string_view body);
 
  bool ReleaseNextServerChunk();
 
  bool WriteServerBytes(std::string_view bytes);
 
  static void CapturePrefix(std::string_view source, std::size_t limit, std::string* destination);
 
  void FinishConnections();
 
  void ApplyProbeOptions(CURL* easy) const;

  static constexpr std::size_t kMaxPacketBytes = 64 * 1024;

  static constexpr std::size_t kMaxCapturedPacketBytes = 64 * 1024;
  static constexpr std::size_t kMaxCapturedPayloadBytes = 2 * scenario_limits::kMaxMetadataBytes;

  static constexpr int kMaxPacketsPerService = 16;

  const curl::fuzzer::proto::MqttProbeMode mode_;

  const curl::fuzzer::proto::Scenario* scenario_;
  std::size_t server_chunk_count_;
  std::size_t next_server_chunk_;
  std::size_t packet_count_;
  std::size_t connect_count_;
  std::size_t publish_count_;
  std::size_t subscribe_count_;
  std::size_t qos1_publish_count_;
  std::size_t active_pollset_probe_count_;
  std::string pending_client_bytes_;
  std::string packet_transcript_;
  std::string published_topic_;
  std::string published_payload_;
  bool release_script_chunks_;
  bool protocol_error_;
  bool socket_opened_;
};
 
}  // namespace proto_fuzzer
 
#endif  // PROTO_FUZZER_MQTT_MOCK_SERVER_H_