ftp_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_FTP_MOCK_SERVER_H_
#define PROTO_FUZZER_FTP_MOCK_SERVER_H_
 
#include <curl/curl.h>
 
#include <array>
#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 FtpMockServer : public MockServerBase, public IncomingDataObserver {
 public:
  FtpMockServer();
 
  ~FtpMockServer() override;
 
  void ObserveState() override;
 
  const std::string& control_transcript() const;
 
  const std::string& uploaded_data() const;
 
  std::size_t opened_data_connection_count() const;
 
  std::size_t active_pollset_probe_count() const;
 
 protected:
  // Create one transport for the control or a passive data connection.
  // Implicit-TLS subclasses override this factory while retaining the FTP
  // command parser and data-channel bookkeeping.
  virtual std::unique_ptr<MockConnection> CreateConnection();
 
  // Report whether PORT/EPRT listeners can be created on the real loopback
  // stack. TLS peers whose data channels only exist as wrapped socketpairs
  // return false so curl's active-mode socket request fails boundedly instead
  // of leaving an unusable plaintext listener.
  virtual bool SupportsActiveMode() const;
 
  // Release every server-owned transport and active descriptor. Derived
  // classes call this before destroying a transport object that their
  // connections borrow.
  void ReleaseConnections();
 
  void ObserveIncomingData(const unsigned char* data, std::size_t size) override;
 
  curl_socket_t HandleOpenSocket(curlsocktype purpose = CURLSOCKTYPE_IPCXN,
                                 struct curl_sockaddr* address = nullptr) override;
 
  SocketSetupDisposition GetSocketSetupDisposition(curl_socket_t curlfd, curlsocktype purpose) const override;
 
  void RunLoop(CURLM* multi, CURL* easy, const curl::fuzzer::proto::Scenario& scenario) override;
 
 private:
  enum class TransferDirection {
    kNone,
    kDownload,
    kUpload,
  };

  struct DataChannel : public IncomingDataObserver {
    const curl::fuzzer::proto::Connection* script = nullptr;
    std::unique_ptr<MockConnection> connection;
    int active_fd = -1;
    bool transfer_started = false;
    bool upload = false;
    std::string incoming_data;
 
    void ObserveIncomingData(const unsigned char* data, std::size_t size) override;
  };
 
  void ResetForScenario(const curl::fuzzer::proto::Scenario& scenario);
 
  static void ApplyScriptBackpressure(MockConnection* connection, const curl::fuzzer::proto::Connection& script);
 
  bool ServiceControlConnection();
 
  bool ServiceDataConnections();
 
  void HandleControlCommand(std::string_view command);
 
  void StartNextTransfer(TransferDirection direction);
 
  void PreloadDownload(DataChannel* channel);
 
  bool UsesActiveMode() const;
 
  curl_socket_t OpenActiveListener(struct curl_sockaddr* address);
 
  void ConnectActiveDataChannel();
 
  void CloseActiveDescriptors();
 
  static bool WriteActiveBytes(int fd, const unsigned char* data, std::size_t size);
 
  static bool ReadActiveBytes(int fd, std::string* output);
 
  void QueueTransferCompletion();
 
  const std::string* NextControlReply();
 
  bool WriteControlBytes(std::string_view bytes);
 
  static std::string_view CommandVerb(std::string_view command);
 
  static bool VerbEquals(std::string_view verb, std::string_view expected_uppercase);
 
  static TransferDirection DirectionForVerb(std::string_view verb);
 
  bool IsConfiguredCustomDownload(std::string_view verb) const;
 
  static int FirstReplyCode(std::string_view response);
 
  static bool TailNeedsOnlyNewline(std::string_view response);
 
  static void CapturePrefix(std::string_view source, std::size_t limit, std::string* destination);
 
  void FinishConnections(bool completed);

  static constexpr std::size_t kMaxDataChannels = scenario_limits::kMaxConnections - 1;

  static constexpr std::size_t kMaxCapturedControlBytes = 64 * 1024;
  static constexpr std::size_t kMaxCapturedUploadBytes = 2 * scenario_limits::kMaxUploadBytes;

  const curl::fuzzer::proto::Scenario* scenario_;
  std::unique_ptr<MockConnection> control_connection_;
  std::array<DataChannel, kMaxDataChannels> data_channels_;
  std::size_t next_data_script_;
  int active_listener_fd_;
  curl_socket_t active_listener_client_fd_;
  std::size_t pending_active_channel_;
  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_;
  bool control_opened_;
};
 
}  // namespace proto_fuzzer
 
#endif  // PROTO_FUZZER_FTP_MOCK_SERVER_H_