Line data    Source code

       1             : #include "source/common/network/dns_resolver/dns_factory_util.h"
       2             : 
       3             : namespace Envoy {
       4             : namespace Network {
       5             : 
       6             : // Create a default c-ares DNS resolver typed config.
       7             : void makeDefaultCaresDnsResolverConfig(
       8           0 :     envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
       9           0 :   envoy::extensions::network::dns_resolver::cares::v3::CaresDnsResolverConfig cares;
      10           0 :   typed_dns_resolver_config.mutable_typed_config()->PackFrom(cares);
      11           0 :   typed_dns_resolver_config.set_name(std::string(CaresDnsResolver));
      12           0 : }
      13             : 
      14             : // Create a default apple DNS resolver typed config.
      15             : void makeDefaultAppleDnsResolverConfig(
      16           0 :     envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
      17           0 :   envoy::extensions::network::dns_resolver::apple::v3::AppleDnsResolverConfig apple;
      18           0 :   typed_dns_resolver_config.mutable_typed_config()->PackFrom(apple);
      19           0 :   typed_dns_resolver_config.set_name(std::string(AppleDnsResolver));
      20           0 : }
      21             : 
      22             : // Create a default DNS resolver typed config based on build system and configuration.
      23             : void makeDefaultDnsResolverConfig(
      24           0 :     envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
      25             :   // If use apple API for DNS lookups, create an AppleDnsResolverConfig typed config.
      26           0 :   if (tryUseAppleApiForDnsLookups(typed_dns_resolver_config)) {
      27           0 :     return;
      28           0 :   }
      29             :   // Otherwise, create a CaresDnsResolverConfig typed config.
      30           0 :   makeDefaultCaresDnsResolverConfig(typed_dns_resolver_config);
      31           0 : }
      32             : 
      33             : bool tryUseAppleApiForDnsLookups(
      34           5 :     envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
      35           5 :   if (Config::Utility::getAndCheckFactoryByName<Network::DnsResolverFactory>(
      36           5 :           std::string(AppleDnsResolver), true) != nullptr) {
      37           0 :     makeDefaultAppleDnsResolverConfig(typed_dns_resolver_config);
      38           0 :     ENVOY_LOG_MISC(debug, "create Apple DNS resolver type: {} in MacOS.",
      39           0 :                    typed_dns_resolver_config.name());
      40           0 :     return true;
      41           0 :   }
      42             : #ifdef __APPLE__
      43             :   ENVOY_LOG_MISC(warn, "Unable to create Apple DNS resolver type: {} in MacOS.",
      44             :                  typed_dns_resolver_config.name());
      45             : #endif
      46           5 :   return false;
      47           5 : }
      48             : 
      49             : // Overloading the template function for DnsFilterConfig type, which doesn't need to copy anything.
      50             : void handleLegacyDnsResolverData(
      51             :     const envoy::extensions::filters::udp::dns_filter::v3::DnsFilterConfig::ClientContextConfig&,
      52           0 :     envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
      53           0 :   makeDefaultCaresDnsResolverConfig(typed_dns_resolver_config);
      54           0 : }
      55             : 
      56             : // Overloading the template function for Cluster config type, which need to copy
      57             : // both use_tcp_for_dns_lookups and dns_resolvers.
      58             : void handleLegacyDnsResolverData(
      59             :     const envoy::config::cluster::v3::Cluster& config,
      60           0 :     envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
      61           0 :   envoy::extensions::network::dns_resolver::cares::v3::CaresDnsResolverConfig cares;
      62           0 :   cares.mutable_dns_resolver_options()->set_use_tcp_for_dns_lookups(
      63           0 :       config.use_tcp_for_dns_lookups());
      64           0 :   if (!config.dns_resolvers().empty()) {
      65           0 :     cares.mutable_resolvers()->MergeFrom(config.dns_resolvers());
      66           0 :   }
      67           0 :   typed_dns_resolver_config.mutable_typed_config()->PackFrom(cares);
      68           0 :   typed_dns_resolver_config.set_name(std::string(CaresDnsResolver));
      69           0 : }
      70             : 
      71             : // Create the DNS resolver factory from the typed config. This is the underline
      72             : // function which performs the registry lookup based on typed config.
      73             : Network::DnsResolverFactory& createDnsResolverFactoryFromTypedConfig(
      74           5 :     const envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
      75           5 :   ENVOY_LOG_MISC(debug, "create DNS resolver type: {}", typed_dns_resolver_config.name());
      76           5 :   return DnsResolverFactory::createFactory(typed_dns_resolver_config);
      77           5 : }
      78             : 
      79             : // Create the default DNS resolver factory. apple for MacOS or c-ares for all others.
      80             : // The default registry lookup will always succeed, thus no exception throwing.
      81             : // This function can be called in main or worker threads.
      82             : Network::DnsResolverFactory& createDefaultDnsResolverFactory(
      83           0 :     envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
      84           0 :   Network::makeDefaultDnsResolverConfig(typed_dns_resolver_config);
      85           0 :   return createDnsResolverFactoryFromTypedConfig(typed_dns_resolver_config);
      86           0 : }
      87             : 
      88             : Network::DnsResolverFactory& DnsResolverFactory::createFactory(
      89           5 :     const envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config) {
      90           5 :   auto& factory =
      91           5 :       Config::Utility::getAndCheckFactory<Network::DnsResolverFactory>(typed_dns_resolver_config);
      92           5 :   factory.initialize();
      93           5 :   return factory;
      94           5 : }
      95             : 
      96          69 : void DnsResolverFactory::terminateFactories() {
      97          69 :   auto& factories = Registry::FactoryRegistry<Network::DnsResolverFactory>::factories();
      98          69 :   std::for_each(factories.begin(), factories.end(),
      99          71 :                 [](auto& factory_it) { factory_it.second->terminate(); });
     100          69 : }
     101             : 
     102             : } // namespace Network
     103             : } // namespace Envoy