dns_test_util.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40284755): Remove this and spanify to fix the errors.
#pragma allow_unsafe_buffers
#endif

#include "net/dns/dns_test_util.h"

#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check.h"
#include "base/containers/span.h"
#include "base/functional/bind.h"
#include "base/location.h"
#include "base/numerics/byte_conversions.h"
#include "base/numerics/safe_conversions.h"
#include "base/ranges/algorithm.h"
#include "base/strings/strcat.h"
#include "base/sys_byteorder.h"
#include "base/task/single_thread_task_runner.h"
#include "base/test/test_timeouts.h"
#include "base/threading/thread_restrictions.h"
#include "base/time/time.h"
#include "base/types/optional_util.h"
#include "net/base/io_buffer.h"
#include "net/base/ip_address.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_errors.h"
#include "net/dns/address_sorter.h"
#include "net/dns/dns_hosts.h"
#include "net/dns/dns_names_util.h"
#include "net/dns/dns_query.h"
#include "net/dns/dns_session.h"
#include "net/dns/mock_host_resolver.h"
#include "net/dns/public/dns_over_https_server_config.h"
#include "net/dns/resolve_context.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/scheme_host_port.h"

namespace net {
namespace {

const uint8_t kMalformedResponseHeader[] = …;

// Create a response containing a valid question (as would normally be validated
// in DnsTransaction) but completely missing a header-declared answer.
DnsResponse CreateMalformedResponse(std::string hostname, uint16_t type) { … }

class MockAddressSorter : public AddressSorter { … };

}  // namespace

DnsConfig CreateValidDnsConfig() { … }

DnsResourceRecord BuildTestDnsRecord(std::string name,
                                     uint16_t type,
                                     std::string rdata,
                                     base::TimeDelta ttl) { … }

DnsResourceRecord BuildTestCnameRecord(std::string name,
                                       std::string_view canonical_name,
                                       base::TimeDelta ttl) { … }

DnsResourceRecord BuildTestAddressRecord(std::string name,
                                         const IPAddress& ip,
                                         base::TimeDelta ttl) { … }

DnsResourceRecord BuildTestTextRecord(std::string name,
                                      std::vector<std::string> text_strings,
                                      base::TimeDelta ttl) { … }

DnsResourceRecord BuildTestHttpsAliasRecord(std::string name,
                                            std::string_view alias_name,
                                            base::TimeDelta ttl) { … }

std::pair<uint16_t, std::string> BuildTestHttpsServiceAlpnParam(
    const std::vector<std::string>& alpns) { … }

std::pair<uint16_t, std::string> BuildTestHttpsServiceEchConfigParam(
    base::span<const uint8_t> ech_config_list) { … }

std::pair<uint16_t, std::string> BuildTestHttpsServiceMandatoryParam(
    std::vector<uint16_t> param_key_list) { … }

std::pair<uint16_t, std::string> BuildTestHttpsServicePortParam(uint16_t port) { … }

DnsResourceRecord BuildTestHttpsServiceRecord(
    std::string name,
    uint16_t priority,
    std::string_view service_name,
    const std::map<uint16_t, std::string>& params,
    base::TimeDelta ttl) { … }

DnsResponse BuildTestDnsResponse(
    std::string name,
    uint16_t type,
    const std::vector<DnsResourceRecord>& answers,
    const std::vector<DnsResourceRecord>& authority,
    const std::vector<DnsResourceRecord>& additional,
    uint8_t rcode) { … }

DnsResponse BuildTestDnsAddressResponse(std::string name,
                                        const IPAddress& ip,
                                        std::string answer_name) { … }

DnsResponse BuildTestDnsAddressResponseWithCname(std::string name,
                                                 const IPAddress& ip,
                                                 std::string cannonname,
                                                 std::string answer_name) { … }

DnsResponse BuildTestDnsTextResponse(
    std::string name,
    std::vector<std::vector<std::string>> text_records,
    std::string answer_name) { … }

DnsResponse BuildTestDnsPointerResponse(std::string name,
                                        std::vector<std::string> pointer_names,
                                        std::string answer_name) { … }

DnsResponse BuildTestDnsServiceResponse(
    std::string name,
    std::vector<TestServiceRecord> service_records,
    std::string answer_name) { … }

MockDnsClientRule::Result::Result(ResultType type,
                                  std::optional<DnsResponse> response,
                                  std::optional<int> net_error)
    : … { … }

MockDnsClientRule::Result::Result(DnsResponse response)
    : … { … }

MockDnsClientRule::Result::Result(Result&&) = default;

MockDnsClientRule::Result& MockDnsClientRule::Result::operator=(Result&&) =
    default;

MockDnsClientRule::Result::~Result() = default;

MockDnsClientRule::MockDnsClientRule(const std::string& prefix,
                                     uint16_t qtype,
                                     bool secure,
                                     Result result,
                                     bool delay,
                                     URLRequestContext* context)
    : … { … }

MockDnsClientRule::MockDnsClientRule(MockDnsClientRule&& rule) = default;

// A DnsTransaction which uses MockDnsClientRuleList to determine the response.
class MockDnsTransactionFactory::MockTransaction final : public DnsTransaction { … };

class MockDnsTransactionFactory::MockDohProbeRunner : public DnsProbeRunner { … };

MockDnsTransactionFactory::MockDnsTransactionFactory(
    MockDnsClientRuleList rules)
    : … { … }

MockDnsTransactionFactory::~MockDnsTransactionFactory() = default;

std::unique_ptr<DnsTransaction> MockDnsTransactionFactory::CreateTransaction(
    std::string hostname,
    uint16_t qtype,
    const NetLogWithSource&,
    bool secure,
    SecureDnsMode secure_dns_mode,
    ResolveContext* resolve_context,
    bool fast_timeout) { … }

std::unique_ptr<DnsProbeRunner> MockDnsTransactionFactory::CreateDohProbeRunner(
    ResolveContext* resolve_context) { … }

void MockDnsTransactionFactory::AddEDNSOption(
    std::unique_ptr<OptRecordRdata::Opt> opt) { … }

SecureDnsMode MockDnsTransactionFactory::GetSecureDnsModeForTest() { … }

void MockDnsTransactionFactory::CompleteDelayedTransactions() { … }

bool MockDnsTransactionFactory::CompleteOneDelayedTransactionOfType(
    DnsQueryType type) { … }

MockDnsClient::MockDnsClient(DnsConfig config, MockDnsClientRuleList rules)
    : … { … }

MockDnsClient::~MockDnsClient() = default;

bool MockDnsClient::CanUseSecureDnsTransactions() const { … }

bool MockDnsClient::CanUseInsecureDnsTransactions() const { … }

bool MockDnsClient::CanQueryAdditionalTypesViaInsecureDns() const { … }

void MockDnsClient::SetInsecureEnabled(bool enabled,
                                       bool additional_types_enabled) { … }

bool MockDnsClient::FallbackFromSecureTransactionPreferred(
    ResolveContext* context) const { … }

bool MockDnsClient::FallbackFromInsecureTransactionPreferred() const { … }

bool MockDnsClient::SetSystemConfig(std::optional<DnsConfig> system_config) { … }

bool MockDnsClient::SetConfigOverrides(DnsConfigOverrides config_overrides) { … }

void MockDnsClient::ReplaceCurrentSession() { … }

DnsSession* MockDnsClient::GetCurrentSession() { … }

const DnsConfig* MockDnsClient::GetEffectiveConfig() const { … }

base::Value::Dict MockDnsClient::GetDnsConfigAsValueForNetLog() const { … }

const DnsHosts* MockDnsClient::GetHosts() const { … }

DnsTransactionFactory* MockDnsClient::GetTransactionFactory() { … }

AddressSorter* MockDnsClient::GetAddressSorter() { … }

void MockDnsClient::IncrementInsecureFallbackFailures() { … }

void MockDnsClient::ClearInsecureFallbackFailures() { … }

std::optional<DnsConfig> MockDnsClient::GetSystemConfigForTesting() const { … }

DnsConfigOverrides MockDnsClient::GetConfigOverridesForTesting() const { … }

void MockDnsClient::SetTransactionFactoryForTesting(
    std::unique_ptr<DnsTransactionFactory> factory) { … }

void MockDnsClient::SetAddressSorterForTesting(
    std::unique_ptr<AddressSorter> address_sorter) { … }

std::optional<std::vector<IPEndPoint>> MockDnsClient::GetPresetAddrs(
    const url::SchemeHostPort& endpoint) const { … }

void MockDnsClient::CompleteDelayedTransactions() { … }

bool MockDnsClient::CompleteOneDelayedTransactionOfType(DnsQueryType type) { … }

void MockDnsClient::SetForceDohServerAvailable(bool available) { … }

std::optional<DnsConfig> MockDnsClient::BuildEffectiveConfig() { … }

scoped_refptr<DnsSession> MockDnsClient::BuildSession() { … }

MockHostResolverProc::MockHostResolverProc()
    : … { … }

MockHostResolverProc::~MockHostResolverProc() = default;

bool MockHostResolverProc::WaitFor(unsigned count) { … }

void MockHostResolverProc::SignalMultiple(unsigned count) { … }

void MockHostResolverProc::SignalAll() { … }

void MockHostResolverProc::AddRule(const std::string& hostname,
                                   AddressFamily family,
                                   const AddressList& result,
                                   HostResolverFlags flags) { … }

void MockHostResolverProc::AddRule(const std::string& hostname,
                                   AddressFamily family,
                                   const std::string& ip_list,
                                   HostResolverFlags flags,
                                   const std::string& canonical_name) { … }

void MockHostResolverProc::AddRuleForAllFamilies(
    const std::string& hostname,
    const std::string& ip_list,
    HostResolverFlags flags,
    const std::string& canonical_name) { … }

int MockHostResolverProc::Resolve(const std::string& hostname,
                                  AddressFamily address_family,
                                  HostResolverFlags host_resolver_flags,
                                  AddressList* addrlist,
                                  int* os_error) { … }

MockHostResolverProc::CaptureList MockHostResolverProc::GetCaptureList() const { … }

void MockHostResolverProc::ClearCaptureList() { … }

bool MockHostResolverProc::HasBlockedRequests() const { … }

}  // namespace net
chromium/net/dns/dns_test_util.cc
