EXT-1620: Use getaddrinfo instead of c-ares in DnsResolver (#27689) (#28175)

robdrynkin · web-flow · commit d7c895a79300 · 2025-11-03T17:41:32.000+01:00
diff --git a/ydb/core/driver_lib/run/kikimr_services_initializers.cpp b/ydb/core/driver_lib/run/kikimr_services_initializers.cpp
@@ -557,6 +557,14 @@ void TBasicServicesInitializer::InitializeServices(NActors::TActorSystemSetup* s
         resolverOptions.MonCounters = GetServiceCounters(counters, "utils")->GetSubgroup("subsystem", "dns_resolver");
         resolverOptions.ForceTcp = nsConfig.GetForceTcp();
         resolverOptions.KeepSocket = nsConfig.GetKeepSocket();
+        switch (nsConfig.GetDnsResolverType()) {
+            case NKikimrConfig::TStaticNameserviceConfig::ARES:
+                resolverOptions.Type = NDnsResolver::EDnsResolverType::Ares;
+                break;
+            case NKikimrConfig::TStaticNameserviceConfig::LIBC:
+                resolverOptions.Type = NDnsResolver::EDnsResolverType::Libc;
+                break;
+        }
         IActor *resolver = NDnsResolver::CreateOnDemandDnsResolver(resolverOptions);
 
         setup->LocalServices.emplace_back(
diff --git a/ydb/core/protos/config.proto b/ydb/core/protos/config.proto
@@ -148,6 +148,11 @@ message TStaticNameserviceConfig {
         NS_EXTERNAL = 3;    // may be paired with external discovery
     }
 
+    enum EDnsResolverType {
+        ARES = 0;
+        LIBC = 1;
+    }
+
     message TEndpoint {
         optional string Name = 1;
         optional string Address = 2;
@@ -177,6 +182,7 @@ message TStaticNameserviceConfig {
     optional ENameserviceType Type = 5;
     optional bool KeepSocket = 6 [default = true];
     optional bool ForceTcp = 7 [default = false];
+    optional EDnsResolverType DnsResolverType = 8 [default = ARES];
 }
 
 message TDynamicNameserviceConfig {
diff --git a/ydb/library/actors/dnsresolver/dnsresolver.cpp b/ydb/library/actors/dnsresolver/dnsresolver.cpp
@@ -130,13 +130,13 @@ namespace NDnsResolver {
         std::atomic<size_t> Activations{ 0 };
     };
 
-    class TSimpleDnsResolver
-        : public TActor<TSimpleDnsResolver>
+    class TAresDnsResolver
+        : public TActor<TAresDnsResolver>
         , private TAresLibraryInitBase
         , private TCallbackQueueBase
     {
     public:
-        TSimpleDnsResolver(TSimpleDnsResolverOptions options) noexcept
+        TAresDnsResolver(TSimpleDnsResolverOptions options) noexcept
             : TActor(&TThis::StateWork)
             , Options(std::move(options))
             , WorkerThread(&TThis::WorkerThreadStart, this)
@@ -146,7 +146,7 @@ namespace NDnsResolver {
             WorkerThread.Start();
         }
 
-        ~TSimpleDnsResolver() noexcept override {
+        ~TAresDnsResolver() noexcept override {
             if (!Stopped) {
                 PushCallback([this] {
                     // Mark as stopped first
@@ -384,7 +384,7 @@ namespace NDnsResolver {
 
     private:
         static void* WorkerThreadStart(void* arg) noexcept {
-            static_cast<TSimpleDnsResolver*>(arg)->WorkerThreadLoop();
+            static_cast<TAresDnsResolver*>(arg)->WorkerThreadLoop();
             return nullptr;
         }
 
@@ -483,9 +483,159 @@ namespace NDnsResolver {
         bool Stopped = false;
     };
 
+
+#if not defined(_win32_)
+    class TLibcDnsResolver
+        : public TActor<TLibcDnsResolver>
+        , private TCallbackQueueBase
+    {
+    public:
+    TLibcDnsResolver(TSimpleDnsResolverOptions options) noexcept
+            : TActor(&TThis::StateWork)
+            , WorkerThread(&TThis::WorkerThreadStart, this)
+            , Options(options)
+        {
+            WorkerThread.Start();
+        }
+
+        ~TLibcDnsResolver() noexcept override {
+            if (!Stopped) {
+                PushCallback([this] {
+                    Stopped = true;
+                });
+
+                WorkerThread.Join();
+            }
+        }
+
+        static constexpr EActivityType ActorActivityType() {
+            return EActivityType::DNS_RESOLVER;
+        }
+
+    private:
+        STRICT_STFUNC(StateWork, {
+            hFunc(TEvents::TEvPoison, Handle);
+            hFunc(TEvDns::TEvGetHostByName, Handle);
+            hFunc(TEvDns::TEvGetAddr, Handle);
+        })
+
+        void Handle(TEvents::TEvPoison::TPtr&) {
+            Y_ABORT_UNLESS(!Stopped);
+
+            PushCallback([this] {
+                // Mark as stopped last
+                Stopped = true;
+            });
+
+            WorkerThread.Join();
+            PassAway();
+        }
+
+    private:
+        std::unique_ptr<TEvDns::TEvGetHostByNameResult> GetHostByName(TString name, int family) {
+            auto result = std::make_unique<TEvDns::TEvGetHostByNameResult>();
+
+            struct addrinfo hints, *res;
+            memset(&hints, 0, sizeof(hints));
+            hints.ai_family = family;
+            hints.ai_socktype = Options.ForceTcp ? SOCK_STREAM : SOCK_DGRAM;
+
+            result->Status = getaddrinfo(name.c_str(), nullptr, &hints, &res);
+            if (result->Status != 0) {
+                result->ErrorText = gai_strerror(result->Status);
+                return result;
+            }
+            Y_DEFER { freeaddrinfo(res); };
+
+            for (auto *node = res; node; node = node->ai_next) {
+                switch (node->ai_family) {
+                    case AF_INET: {
+                        result->AddrsV4.emplace_back(((sockaddr_in*)node->ai_addr)->sin_addr);
+                        break;
+                    }
+                    case AF_INET6: {
+                        result->AddrsV6.emplace_back(((sockaddr_in6*)node->ai_addr)->sin6_addr);
+                        break;
+                    }
+                    default:
+                        Y_ABORT("unknown address family in getaddrinfo callback");
+                }
+            }
+
+            return result;
+        }
+
+        std::unique_ptr<TEvDns::TEvGetAddrResult> GetAddr(TString name, int family) {
+            auto result = std::make_unique<TEvDns::TEvGetAddrResult>();
+            auto res = GetHostByName(name, family);
+
+            result->Status = res->Status;
+            result->ErrorText = res->ErrorText;
+            if (res->AddrsV4.empty() && res->AddrsV6.empty()) {
+                result->Status = EAI_NODATA;
+                result->ErrorText = gai_strerror(result->Status);
+                return result;
+            }
+            if (res->AddrsV4.size() > 0) {
+                result->Addr = res->AddrsV4[0];
+            }
+            if (res->AddrsV6.size() > 0) {
+                result->Addr = res->AddrsV6[0];
+            }
+            return result;
+
+        }
+
+    private:
+        void Handle(TEvDns::TEvGetHostByName::TPtr& ev) {
+            auto* msg = ev->Get();
+            PushCallback([this, as = TActivationContext::ActorSystem(), name = std::move(msg->Name), family = msg->Family, sender = ev->Sender, cookie = ev->Cookie] () mutable {
+                auto result = GetHostByName(name, family);
+                as->Send(new IEventHandle(sender, SelfId(), result.release(), 0, cookie));
+            });
+        }
+
+        void Handle(TEvDns::TEvGetAddr::TPtr& ev) {
+            auto* msg = ev->Get();
+            PushCallback([this, as = TActivationContext::ActorSystem(), name = std::move(msg->Name), family = msg->Family, sender = ev->Sender, cookie = ev->Cookie] () mutable {
+                auto result = GetAddr(name, family);
+                as->Send(new IEventHandle(sender, SelfId(), result.release(), 0, cookie));
+            });
+        }
+
+    private:
+        static void* WorkerThreadStart(void* arg) noexcept {
+            static_cast<TLibcDnsResolver*>(arg)->WorkerThreadLoop();
+            return nullptr;
+        }
+
+        void WorkerThreadLoop() noexcept {
+            TThread::SetCurrentThreadName("DnsResolver");
+            while (!Stopped) {
+                RunCallbacks();
+            }
+        }
+    private:
+        TThread WorkerThread;
+        bool Stopped = false;
+        TSimpleDnsResolverOptions Options;
+    };
+
+    IActor* CreateSimpleDnsResolver(TSimpleDnsResolverOptions options) {
+        switch (options.Type) {
+            case EDnsResolverType::Ares:
+                return new TAresDnsResolver(std::move(options));
+            case EDnsResolverType::Libc:
+                return new TLibcDnsResolver(std::move(options));
+            default:
+                Y_ABORT_UNLESS(false, "Invalid dns resolver type: %" PRIu32, options.Type);
+        }
+    }
+#else
     IActor* CreateSimpleDnsResolver(TSimpleDnsResolverOptions options) {
-        return new TSimpleDnsResolver(std::move(options));
+        return new TAresDnsResolver(std::move(options));
     }
+#endif
 
 } // namespace NDnsResolver
 } // namespace NActors
diff --git a/ydb/library/actors/dnsresolver/dnsresolver.h b/ydb/library/actors/dnsresolver/dnsresolver.h
@@ -82,7 +82,14 @@ namespace NDnsResolver {
         };
     };
 
+    enum class EDnsResolverType {
+        Ares,
+        Libc,
+    };
+
     struct TSimpleDnsResolverOptions {
+        // Type of dns resolver to use
+        EDnsResolverType Type = EDnsResolverType::Ares;
         // Initial per-server timeout, grows exponentially with each retry
         TDuration Timeout = TDuration::Seconds(1);
         // Number of attempts per-server
diff --git a/ydb/library/actors/dnsresolver/dnsresolver_ut.cpp b/ydb/library/actors/dnsresolver/dnsresolver_ut.cpp
@@ -29,42 +29,51 @@ Y_UNIT_TEST_SUITE(DnsResolver) {
     };
 
     Y_UNIT_TEST(ResolveLocalHost) {
-        TTestActorRuntimeBase runtime;
-        runtime.Initialize();
-        auto sender = runtime.AllocateEdgeActor();
-        auto resolver = runtime.Register(CreateSimpleDnsResolver());
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("localhost", AF_UNSPEC)),
-                0, true);
-        auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
-        UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
-        size_t addrs = ev->Get()->AddrsV4.size() + ev->Get()->AddrsV6.size();
-        UNIT_ASSERT_C(addrs > 0, "Got " << addrs << " addresses");
+        for (auto type : { EDnsResolverType::Ares, EDnsResolverType::Libc }) {
+            TSimpleDnsResolverOptions options { .Type = type };
+            TTestActorRuntimeBase runtime;
+            runtime.Initialize();
+            auto sender = runtime.AllocateEdgeActor();
+            auto resolver = runtime.Register(CreateSimpleDnsResolver(options));
+            runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("localhost", AF_UNSPEC)),
+                    0, true);
+            auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
+            UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
+            size_t addrs = ev->Get()->AddrsV4.size() + ev->Get()->AddrsV6.size();
+            UNIT_ASSERT_C(addrs > 0, "Got " << addrs << " addresses");
+        }
     }
 
     Y_UNIT_TEST(ResolveYandexRu) {
-        TTestActorRuntimeBase runtime;
-        runtime.Initialize();
-        auto sender = runtime.AllocateEdgeActor();
-        auto resolver = runtime.Register(CreateSimpleDnsResolver());
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("yandex.ru", AF_UNSPEC)),
-                0, true);
-        auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
-        UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
-        size_t addrs = ev->Get()->AddrsV4.size() + ev->Get()->AddrsV6.size();
-        UNIT_ASSERT_C(addrs > 0, "Got " << addrs << " addresses");
+        for (auto type : { EDnsResolverType::Ares, EDnsResolverType::Libc }) {
+            TSimpleDnsResolverOptions options { .Type = type }; 
+            TTestActorRuntimeBase runtime;
+            runtime.Initialize();
+            auto sender = runtime.AllocateEdgeActor();
+            auto resolver = runtime.Register(CreateSimpleDnsResolver(options));
+            runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetHostByName("yandex.ru", AF_UNSPEC)),
+                    0, true);
+            auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetHostByNameResult>(sender);
+            UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
+            size_t addrs = ev->Get()->AddrsV4.size() + ev->Get()->AddrsV6.size();
+            UNIT_ASSERT_C(addrs > 0, "Got " << addrs << " addresses");
+        }
     }
 
     Y_UNIT_TEST(GetAddrYandexRu) {
-        TTestActorRuntimeBase runtime;
-        runtime.Initialize();
-        auto sender = runtime.AllocateEdgeActor();
-        auto resolver = runtime.Register(CreateSimpleDnsResolver());
+        for (auto type : { EDnsResolverType::Ares, EDnsResolverType::Libc }) {
+            TSimpleDnsResolverOptions options { .Type = type };
+            TTestActorRuntimeBase runtime;
+            runtime.Initialize();
+            auto sender = runtime.AllocateEdgeActor();
+            auto resolver = runtime.Register(CreateSimpleDnsResolver(options));
 
-        runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetAddr("yandex.ru", AF_UNSPEC)),
-                0, true);
-        auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetAddrResult>(sender);
-        UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
-        UNIT_ASSERT_C(ev->Get()->IsV4() || ev->Get()->IsV6(), "Expect v4 or v6 address");
+            runtime.Send(new IEventHandle(resolver, sender, new TEvDns::TEvGetAddr("yandex.ru", AF_UNSPEC)),
+                    0, true);
+            auto ev = runtime.GrabEdgeEventRethrow<TEvDns::TEvGetAddrResult>(sender);
+            UNIT_ASSERT_VALUES_EQUAL_C(ev->Get()->Status, 0, ev->Get()->ErrorText);
+            UNIT_ASSERT_C(ev->Get()->IsV4() || ev->Get()->IsV6(), "Expect v4 or v6 address");
+        }
     }
 
     Y_UNIT_TEST(ResolveTimeout) {
