imap_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/imap_mock_server.h"
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <string>
#include <string_view>
 
namespace proto_fuzzer {
 
namespace {

bool AsciiEqualsIgnoreCase(std::string_view value, std::string_view expected_lowercase) {
  if (value.size() != expected_lowercase.size()) {
    return false;
  }
  for (std::size_t index = 0; index < value.size(); ++index) {
    unsigned char actual = static_cast<unsigned char>(value[index]);
    if (actual >= 'A' && actual <= 'Z') {
      actual = static_cast<unsigned char>(actual - 'A' + 'a');
    }
    if (actual != static_cast<unsigned char>(expected_lowercase[index])) {
      return false;
    }
  }
  return true;
}
 
}  // namespace

ImapMockServer::ImapMockServer() = default;

ImapMockServer::~ImapMockServer() = default;

void ImapMockServer::ResetProtocolState() {
  current_tag_.clear();
  authentication_continuation_active_ = false;
}

bool ImapMockServer::StatusLineNeedsTag(std::string_view line) {
  const std::size_t space = line.find_first_of(" \r\n");
  const std::string_view keyword = line.substr(0, space);
  if (keyword.empty()) {
    return false;
  }
  if (!AsciiEqualsIgnoreCase(keyword, "ok") && !AsciiEqualsIgnoreCase(keyword, "no") &&
      !AsciiEqualsIgnoreCase(keyword, "bad") && !AsciiEqualsIgnoreCase(keyword, "preauth")) {
    return false;
  }
  return space != std::string_view::npos;
}

bool ImapMockServer::ResponseHasContinuation(std::string_view response) {
  std::size_t position = 0;
  while (position < response.size()) {
    const std::size_t newline = response.find('\n', position);
    const std::size_t line_end = newline == std::string_view::npos ? response.size() : newline + 1;
    const std::string_view line = response.substr(position, line_end - position);
    if (!line.empty() && line.front() == '+') {
      return true;
    }
 
    const std::size_t literal = LiteralSize(line);
    const std::size_t available = response.size() - line_end;
    position = line_end + std::min(literal, available);
  }
  return false;
}

bool ImapMockServer::ResponseHasTaggedCompletion(std::string_view response) const {
  std::size_t position = 0;
  while (position < response.size()) {
    const std::size_t newline = response.find('\n', position);
    const std::size_t line_end = newline == std::string_view::npos ? response.size() : newline + 1;
    const std::string_view line = response.substr(position, line_end - position);
    const bool tag_relative = StatusLineNeedsTag(line);
    const bool has_current_tag = !current_tag_.empty() && line.size() > current_tag_.size() &&
                                 line.compare(0, current_tag_.size(), current_tag_) == 0 &&
                                 line[current_tag_.size()] == ' ' &&
                                 StatusLineNeedsTag(line.substr(current_tag_.size() + 1));
    if (tag_relative || has_current_tag) {
      return true;
    }
 
    const std::size_t literal = LiteralSize(line);
    const std::size_t available = response.size() - line_end;
    position = line_end + std::min(literal, available);
  }
  return false;
}

std::size_t ImapMockServer::LiteralSize(std::string_view line) {
  while (!line.empty() && (line.back() == '\r' || line.back() == '\n')) {
    line.remove_suffix(1);
  }
  if (line.empty() || line.back() != '}') {
    return 0;
  }
  const std::size_t open = line.rfind('{');
  if (open == std::string_view::npos || open + 2 > line.size()) {
    return 0;
  }
 
  std::size_t position = open + 1;
  std::size_t value = 0;
  bool digits = false;
  while (position < line.size() && line[position] >= '0' && line[position] <= '9') {
    const std::size_t digit = static_cast<std::size_t>(line[position] - '0');
    if (value > (std::numeric_limits<std::size_t>::max() - digit) / 10) {
      return 0;
    }
    value = value * 10 + digit;
    digits = true;
    ++position;
  }
  if (!digits) {
    return 0;
  }
  if (position < line.size() && line[position] == '+') {
    ++position;
  }
  return position + 1 == line.size() ? value : 0;
}

std::size_t ImapMockServer::AppendLiteralSize(std::string_view command) {
  while (!command.empty() && (command.back() == '\r' || command.back() == '\n')) {
    command.remove_suffix(1);
  }
  if (command.empty() || command.back() != '}') {
    return std::numeric_limits<std::size_t>::max();
  }
  const std::size_t open = command.rfind('{');
  if (open == std::string_view::npos) {
    return std::numeric_limits<std::size_t>::max();
  }
 
  std::size_t position = open + 1;
  std::size_t value = 0;
  bool digits = false;
  while (position < command.size() && command[position] >= '0' && command[position] <= '9') {
    const std::size_t digit = static_cast<std::size_t>(command[position] - '0');
    if (value > (std::numeric_limits<std::size_t>::max() - digit) / 10) {
      return std::numeric_limits<std::size_t>::max();
    }
    value = value * 10 + digit;
    digits = true;
    ++position;
  }
  if (!digits) {
    return std::numeric_limits<std::size_t>::max();
  }
  if (position < command.size() && command[position] == '+') {
    ++position;
  }
  return position + 1 == command.size() ? value : std::numeric_limits<std::size_t>::max();
}

std::string ImapMockServer::RewriteReply(std::string_view response) const {
  std::string output;
  output.reserve(response.size() + 16);
 
  std::size_t position = 0;
  while (position < response.size()) {
    const std::size_t newline = response.find('\n', position);
    const std::size_t line_end = newline == std::string_view::npos ? response.size() : newline + 1;
    const std::string_view line = response.substr(position, line_end - position);
 
    if (!current_tag_.empty() && StatusLineNeedsTag(line)) {
      output.append(current_tag_);
      output.push_back(' ');
    }
    output.append(line);
 
    const std::size_t literal = LiteralSize(line);
    if (literal == 0) {
      position = line_end;
      continue;
    }
 
    const std::size_t body_start = line_end;
    const std::size_t available = response.size() - body_start;
    const std::size_t body_size = std::min(literal, available);
    output.append(response.substr(body_start, body_size));
    position = body_start + body_size;
  }
  return output;
}

std::string ImapMockServer::NextCommandTag() const {
  std::size_t digits_start = current_tag_.size();
  while (digits_start > 0 && current_tag_[digits_start - 1] >= '0' && current_tag_[digits_start - 1] <= '9') {
    --digits_start;
  }
  if (digits_start == current_tag_.size() || digits_start == 0) {
    return std::string();
  }
 
  std::uint64_t number = 0;
  for (std::size_t index = digits_start; index < current_tag_.size(); ++index) {
    number = number * 10 + static_cast<std::uint64_t>(current_tag_[index] - '0');
    if (number > 999999) {
      return std::string();
    }
  }
  ++number;
 
  std::string digits = std::to_string(number);
  const std::size_t width = current_tag_.size() - digits_start;
  if (digits.size() < width) {
    digits.insert(0, width - digits.size(), '0');
  }
  return current_tag_.substr(0, digits_start) + digits;
}

void ImapMockServer::HandleLine(std::string_view command) {
  if (scenario() == nullptr) {
    return;
  }
 
  const bool authentication_payload = authentication_continuation_active_;
  if (!authentication_payload) {
    current_tag_ = std::string(FirstToken(command));
  }
 
  const std::string* response = NextControlReply();
  if (response == nullptr) {
    return;
  }
 
  const bool continuation = ResponseHasContinuation(*response);
  const bool tagged_completion = ResponseHasTaggedCompletion(*response);
  (void)WriteControlBytes(RewriteReply(*response));
 
  if (authentication_payload) {
    if (tagged_completion) {
      authentication_continuation_active_ = false;
    }
    return;
  }
 
  const std::string_view verb = SecondToken(command);
  if (continuation && TokenEquals(verb, "AUTHENTICATE")) {
    authentication_continuation_active_ = !tagged_completion;
    return;
  }
 
  if (!continuation || !TokenEquals(verb, "APPEND")) {
    return;
  }
 
  const std::size_t literal = AppendLiteralSize(command);
  if (literal == std::numeric_limits<std::size_t>::max()) {
    // Curl always announces the literal size here. Without one, leave the
    // transfer to the bounded idle budget and final half-close instead of
    // guessing where an arbitrary body ends.
    return;
  }
 
  BeginLiteralBody(literal);
 
  const std::string* final_response = NextControlReply();
  if (final_response != nullptr) {
    (void)WriteControlBytes(RewriteReply(*final_response));
  }
}

void ImapMockServer::QueueShutdownReply() {
  const std::string next_tag = NextCommandTag();
  if (!next_tag.empty()) {
    (void)WriteControlBytes(next_tag + std::string(kShutdownTail));
  } else {
    (void)WriteControlBytes("* BYE imap mock closing\r\n");
  }
}

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