dict_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/dict_mock_server.h"
 
#include <cstdlib>
#include <string>
#include <string_view>
 
#include "proto_fuzzer/mock_server.h"
#include "proto_fuzzer/scenario_limits.h"
 
namespace proto_fuzzer {
 
namespace {
 
// curl builds and sends the complete DICT request synchronously before the
// outer peer loop can drain it. RFC 2229 escaping can double every retained
// path byte; fixed command/version text fits comfortably in the remaining
// headroom. Rejecting a surprising platform socket configuration is safer
// than entering curl's blocking POLLOUT wait without an operation deadline.
constexpr std::size_t kMinClientSendBufferBytes = 64 * 1024;
constexpr std::size_t kMaxBufferedClientBytes = 2 * scenario_limits::kMaxDictHostPathBytes + 4 * 1024;
static_assert(kMaxBufferedClientBytes < kMinClientSendBufferBytes,
              "DICT mutation cap exceeds the verified client send buffer");

class ScopedEnvironmentOverride {
 public:
  ScopedEnvironmentOverride(const char* name, const char* value) : name_(name) {
    const char* previous = std::getenv(name);
    if (previous != nullptr) {
      had_previous_ = true;
      previous_ = previous;
    }
    active_ = setenv(name, value, 1) == 0;
  }
 
  ~ScopedEnvironmentOverride() {
    if (!active_) {
      return;
    }
    if (had_previous_) {
      (void)setenv(name_.c_str(), previous_.c_str(), 1);
    } else {
      (void)unsetenv(name_.c_str());
    }
  }
 
  ScopedEnvironmentOverride(const ScopedEnvironmentOverride&) = delete;
  ScopedEnvironmentOverride& operator=(const ScopedEnvironmentOverride&) = delete;
 
 private:
  std::string name_;
  std::string previous_;
  bool had_previous_ = false;
  bool active_ = false;
};
 
}  // namespace

DictMockServer::DictMockServer() : reply_sent_(false), write_closed_(false) {}

DictMockServer::~DictMockServer() = default;

void DictMockServer::Install(CURL* easy) {
  MockServerBase::Install(easy);
  (void)curl_easy_setopt(easy, CURLOPT_TIMEOUT_MS, 0L);
}

std::unique_ptr<MockConnection> DictMockServer::CreateConnection() {
  std::unique_ptr<MockConnection> connection = PingpongMockServer::CreateConnection();
  if (connection == nullptr || !connection->ok() ||
      !connection->EnsureClientSendBufferSize(kMinClientSendBufferBytes)) {
    return nullptr;
  }
  return connection;
}

void DictMockServer::RunLoop(CURLM* multi, CURL* easy, const curl::fuzzer::proto::Scenario& scenario) {
  ScopedEnvironmentOverride partial_writes("CURL_DBG_SOCK_WPARTIAL", "50");
  PingpongMockServer::RunLoop(multi, easy, scenario);
}

void DictMockServer::ResetProtocolState() {
  reply_sent_ = false;
  write_closed_ = false;
}

void DictMockServer::FinishResponse() {
  if (write_closed_) {
    return;
  }
  write_closed_ = true;
  if (connection_ != nullptr) {
    connection_->ShutdownWrite();
  }
}

void DictMockServer::HandleLine(std::string_view line) {
  const std::string_view verb = FirstToken(line);
  if (verb.empty()) {
    return;
  }
 
  if (TokenEquals(verb, "CLIENT")) {
    return;
  }
 
  if (reply_sent_ || TokenEquals(verb, "QUIT")) {
    if (!reply_sent_) {
      (void)WriteNextReply();
      reply_sent_ = true;
    }
    FinishResponse();
    return;
  }
 
  // The first lookup command consumes the scripted body. A script without a
  // reply still closes the response so curl cannot wait for a body forever.
  (void)WriteNextReply();
  reply_sent_ = true;
  FinishResponse();
}

void DictMockServer::ObserveState() {
#if defined(PROTO_FUZZER_OBSERVE_STATE)
  PingpongMockServer::ObserveState();
  const volatile std::size_t dict_observation[] = {control_transcript().size(), uploaded_data().size()};
  (void)dict_observation;
#endif
}
 
}  // namespace proto_fuzzer