http_transport_mock_server.cc

Go to the documentation of this file.

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

 
#include "proto_fuzzer/http_transport_mock_server.h"
 
#include <curl/curl.h>
 
#include <algorithm>
#include <cstddef>
#include <memory>
 
namespace proto_fuzzer {
 
namespace {
 
constexpr char kProxyUrl[] = "http://127.0.0.1:8080";
constexpr char kAbstractUnixSocket[] = "curl-fuzzer-http-origin";
constexpr char kHaproxyClientIp[] = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
 
}  // namespace

HttpTransportMockServer::HttpTransportMockServer(curl::fuzzer::proto::HttpTransportMode mode, bool haproxy_protocol)
    : mode_(mode), haproxy_protocol_(haproxy_protocol && mode == curl::fuzzer::proto::HTTP_TRANSPORT_CONNECT_PROXY) {}

void HttpTransportMockServer::Install(CURL* easy) {
  MockServer::Install(easy);
  client_transcript_.clear();
 
  switch (mode_) {
    case curl::fuzzer::proto::HTTP_TRANSPORT_FORWARD_PROXY:
    case curl::fuzzer::proto::HTTP_TRANSPORT_CONNECT_PROXY:
      // The baseline CONNECT_TO entry belongs to direct origins. A numeric
      // proxy avoids DNS, while OPENSOCKETFUNCTION replaces its socket with
      // the in-process peer before any network I/O can occur.
      (void)curl_easy_setopt(easy, CURLOPT_CONNECT_TO, nullptr);
      (void)curl_easy_setopt(easy, CURLOPT_PROXY, kProxyUrl);
      (void)curl_easy_setopt(easy, CURLOPT_PROXYTYPE, static_cast<long>(CURLPROXY_HTTP));
      (void)curl_easy_setopt(easy, CURLOPT_NOPROXY, "");
      (void)curl_easy_setopt(easy, CURLOPT_HTTPPROXYTUNNEL,
                             mode_ == curl::fuzzer::proto::HTTP_TRANSPORT_CONNECT_PROXY ? 1L : 0L);
      // The dedicated HAProxy pressure seed uses its bounded request headers
      // to fill the CONNECT socket before curl inserts the HAProxy filter.
      // Other proxy scenarios retain libcurl's safer separate-header default.
      (void)curl_easy_setopt(easy, CURLOPT_HEADEROPT, haproxy_protocol_ ? CURLHEADER_UNIFIED : CURLHEADER_SEPARATE);
      (void)curl_easy_setopt(easy, CURLOPT_HAPROXY_CLIENT_IP, haproxy_protocol_ ? kHaproxyClientIp : nullptr);
      (void)curl_easy_setopt(easy, CURLOPT_HAPROXYPROTOCOL, haproxy_protocol_ ? 1L : 0L);
      break;
 
    case curl::fuzzer::proto::HTTP_TRANSPORT_UNIX_SOCKET:
      // Abstract namespace sockets create no filesystem entry. The callback
      // still substitutes a preconnected socketpair, but curl constructs its
      // production Unix peer, resolver result, and socket filter first.
      (void)curl_easy_setopt(easy, CURLOPT_CONNECT_TO, nullptr);
      (void)curl_easy_setopt(easy, CURLOPT_ABSTRACT_UNIX_SOCKET, kAbstractUnixSocket);
      break;
 
    case curl::fuzzer::proto::HTTP_TRANSPORT_DIRECT:
    default:
      break;
  }
}

const std::string& HttpTransportMockServer::client_transcript() const { return client_transcript_; }

std::unique_ptr<MockConnection> HttpTransportMockServer::CreateConnection() {
  auto connection = std::make_unique<MockConnection>();
  connection->SetIncomingDataObserver(this);
  return connection;
}

bool HttpTransportMockServer::SupportsRepeatedPollsetProbe() const { return true; }

void HttpTransportMockServer::ObserveIncomingData(const unsigned char* data, std::size_t size) {
  if (data == nullptr || size == 0 || client_transcript_.size() >= kMaxTranscriptBytes) {
    return;
  }
  const std::size_t remaining = kMaxTranscriptBytes - client_transcript_.size();
  client_transcript_.append(reinterpret_cast<const char*>(data), std::min(size, remaining));
}

void HttpTransportMockServer::ObserveState() {
#if defined(PROTO_FUZZER_OBSERVE_STATE)
  MockServer::ObserveState();
  const volatile std::size_t transport_observation = client_transcript().size();
  (void)transport_observation;
#endif
}
 
}  // namespace proto_fuzzer