Modify the Resolver (#75)

an-tao · web-flow · commit 65366dddbbfd · 2020-03-07T10:34:50.000+08:00
* Fix a bug in AresResolver;
* Use the getaddrinfo() instead of the gethostbyname();
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -11,7 +11,6 @@ set(TRANTOR_PATCH_VERSION 0)
 set(TRANTOR_VERSION
     ${TRANTOR_MAJOR_VERSION}.${TRANTOR_MINOR_VERSION}.${TRANTOR_PATCH_VERSION})
 
-
 # Offer the user the choice of overriding the installation directories
 set(INSTALL_LIB_DIR lib CACHE PATH "Installation directory for libraries")
 set(INSTALL_INCLUDE_DIR
@@ -86,7 +85,7 @@ find_path(CARES_INCLUDE_DIR ares.h)
 find_library(CARES_LIBRARY NAMES cares)
 if(CARES_INCLUDE_DIR AND CARES_LIBRARY)
   target_include_directories(${PROJECT_NAME} PRIVATE ${CARES_INCLUDE_DIR})
-  target_link_libraries(${PROJECT_NAME} INTERFACE ${CARES_LIBRARY})
+  target_link_libraries(${PROJECT_NAME} PRIVATE ${CARES_LIBRARY})
   set(TRANTOR_SOURCES ${TRANTOR_SOURCES} trantor/net/inner/AresResolver.cc)
 else()
   set(TRANTOR_SOURCES ${TRANTOR_SOURCES} trantor/net/inner/NormalResolver.cc)
diff --git a/trantor/net/inner/AresResolver.cc b/trantor/net/inner/AresResolver.cc
@@ -44,6 +44,17 @@ const char* getSocketType(int type)
 
 }  // namespace
 
+AresResolver::LibraryInitializer::LibraryInitializer()
+{
+    ares_library_init(ARES_LIB_INIT_ALL);
+}
+AresResolver::LibraryInitializer::~LibraryInitializer()
+{
+    ares_library_cleanup();
+}
+
+AresResolver::LibraryInitializer AresResolver::libraryInitializer_;
+
 std::shared_ptr<Resolver> Resolver::newResolver(trantor::EventLoop* loop,
                                                 size_t timeout)
 {
@@ -53,67 +64,49 @@ std::shared_ptr<Resolver> Resolver::newResolver(trantor::EventLoop* loop,
 AresResolver::AresResolver(EventLoop* loop, size_t timeout)
     : loop_(loop), timeout_(timeout)
 {
-    assert(loop_);
-    // static char lookups[] = "b";
-    struct ares_options options;
-    int optmask = ARES_OPT_FLAGS;
-    options.flags = ARES_FLAG_NOCHECKRESP;
-    options.flags |= ARES_FLAG_STAYOPEN;
-    options.flags |= ARES_FLAG_IGNTC;  // UDP only
-    optmask |= ARES_OPT_SOCK_STATE_CB;
-    options.sock_state_cb = &AresResolver::ares_sock_statecallback_;
-    options.sock_state_cb_data = this;
-    optmask |= ARES_OPT_TIMEOUT;
-    options.timeout = 2;
-    // optmask |= ARES_OPT_LOOKUPS;
-    // options.lookups = lookups;
-
-    int status = ares_init_options(&ctx_, &options, optmask);
-    if (status != ARES_SUCCESS)
+    if (!loop)
     {
-        assert(0);
+        loop_ = getLoop();
+    }
+}
+void AresResolver::init()
+{
+    if (!ctx_)
+    {
+        struct ares_options options;
+        int optmask = ARES_OPT_FLAGS;
+        options.flags = ARES_FLAG_NOCHECKRESP;
+        options.flags |= ARES_FLAG_STAYOPEN;
+        options.flags |= ARES_FLAG_IGNTC;  // UDP only
+        optmask |= ARES_OPT_SOCK_STATE_CB;
+        options.sock_state_cb = &AresResolver::ares_sock_statecallback_;
+        options.sock_state_cb_data = this;
+        optmask |= ARES_OPT_TIMEOUT;
+        options.timeout = 2;
+        // optmask |= ARES_OPT_LOOKUPS;
+        // options.lookups = lookups;
+
+        int status = ares_init_options(&ctx_, &options, optmask);
+        if (status != ARES_SUCCESS)
+        {
+            assert(0);
+        }
+        ares_set_socket_callback(ctx_,
+                                 &AresResolver::ares_sock_createcallback_,
+                                 this);
     }
-    ares_set_socket_callback(ctx_,
-                             &AresResolver::ares_sock_createcallback_,
-                             this);
 }
-
 AresResolver::~AresResolver()
 {
-    ares_destroy(ctx_);
+    if (ctx_)
+        ares_destroy(ctx_);
 }
 
 void AresResolver::resolveInLoop(const std::string& hostname,
                                  const Callback& cb)
 {
     loop_->assertInLoopThread();
-    bool cached = false;
-    InetAddress inet;
-    {
-        std::lock_guard<std::mutex> lock(globalMutex());
-        auto iter = globalCache().find(hostname);
-        if (iter != globalCache().end())
-        {
-            auto& cachedAddr = iter->second;
-            if (timeout_ == 0 ||
-                cachedAddr.second.after(timeout_) > trantor::Date::date())
-            {
-                struct sockaddr_in addr;
-                memset(&addr, 0, sizeof addr);
-                addr.sin_family = AF_INET;
-                addr.sin_port = 0;
-                addr.sin_addr = cachedAddr.first;
-                inet = InetAddress(addr);
-                cached = true;
-            }
-        }
-    }
-    if (cached)
-    {
-        cb(inet);
-        return;
-    }
-
+    init();
     QueryData* queryData = new QueryData(this, cb, hostname);
     ares_gethostbyname(ctx_,
                        hostname.c_str(),
@@ -124,9 +117,10 @@ void AresResolver::resolveInLoop(const std::string& hostname,
     struct timeval* tvp = ares_timeout(ctx_, NULL, &tv);
     double timeout = getSeconds(tvp);
     // LOG_DEBUG << "timeout " << timeout << " active " << timerActive_;
-    if (!timerActive_)
+    if (!timerActive_ && timeout >= 0.0)
     {
-        loop_->runAfter(timeout, std::bind(&AresResolver::onTimer, this));
+        loop_->runAfter(timeout,
+                        std::bind(&AresResolver::onTimer, shared_from_this()));
         timerActive_ = true;
     }
     return;
@@ -151,7 +145,8 @@ void AresResolver::onTimer()
     }
     else
     {
-        loop_->runAfter(timeout, std::bind(&AresResolver::onTimer, this));
+        loop_->runAfter(timeout,
+                        std::bind(&AresResolver::onTimer, shared_from_this()));
     }
 }
 
@@ -172,8 +167,9 @@ void AresResolver::onQueryResult(int status,
     InetAddress inet(addr);
     {
         std::lock_guard<std::mutex> lock(globalMutex());
-        globalCache()[hostname].first = addr.sin_addr;
-        globalCache()[hostname].second = trantor::Date::date();
+        auto& addrItem = globalCache()[hostname];
+        addrItem.first = addr.sin_addr;
+        addrItem.second = trantor::Date::date();
     }
     callback(inet);
 }
diff --git a/trantor/net/inner/AresResolver.h b/trantor/net/inner/AresResolver.h
@@ -8,8 +8,10 @@
 #pragma once
 #include <trantor/net/Resolver.h>
 #include <trantor/utils/NonCopyable.h>
+#include <trantor/net/EventLoopThread.h>
 #include <map>
 #include <memory>
+#include <string.h>
 
 extern "C"
 {
@@ -30,6 +32,32 @@ class AresResolver : public Resolver,
     virtual void resolve(const std::string& hostname,
                          const Callback& cb) override
     {
+        bool cached = false;
+        InetAddress inet;
+        {
+            std::lock_guard<std::mutex> lock(globalMutex());
+            auto iter = globalCache().find(hostname);
+            if (iter != globalCache().end())
+            {
+                auto& cachedAddr = iter->second;
+                if (timeout_ == 0 ||
+                    cachedAddr.second.after(timeout_) > trantor::Date::date())
+                {
+                    struct sockaddr_in addr;
+                    memset(&addr, 0, sizeof addr);
+                    addr.sin_family = AF_INET;
+                    addr.sin_port = 0;
+                    addr.sin_addr = cachedAddr.first;
+                    inet = InetAddress(addr);
+                    cached = true;
+                }
+            }
+        }
+        if (cached)
+        {
+            cb(inet);
+            return;
+        }
         if (loop_->isInLoopThread())
         {
             resolveInLoop(hostname, cb);
@@ -56,7 +84,7 @@ class AresResolver : public Resolver,
         }
     };
     void resolveInLoop(const std::string& hostname, const Callback& cb);
-
+    void init();
     trantor::EventLoop* loop_;
     ares_channel ctx_{nullptr};
     bool timerActive_{false};
@@ -76,7 +104,12 @@ class AresResolver : public Resolver,
         static std::mutex mutex_;
         return mutex_;
     }
-
+    static EventLoop* getLoop()
+    {
+        static EventLoopThread loopThread;
+        loopThread.run();
+        return loopThread.getLoop();
+    }
     const size_t timeout_{60};
 
     void onRead(int sockfd);
@@ -107,5 +140,11 @@ class AresResolver : public Resolver,
 #endif
                                          int read,
                                          int write);
+    struct LibraryInitializer
+    {
+        LibraryInitializer();
+        ~LibraryInitializer();
+    };
+    static LibraryInitializer libraryInitializer_;
 };
 }  // namespace trantor
diff --git a/trantor/net/inner/Connector.cc b/trantor/net/inner/Connector.cc
@@ -73,7 +73,10 @@ void Connector::connect()
         case EADDRNOTAVAIL:
         case ECONNREFUSED:
         case ENETUNREACH:
-            retry(sockfd);
+            if (retry_)
+            {
+                retry(sockfd);
+            }
             break;
 
         case EACCES:
diff --git a/trantor/net/inner/NormalResolver.cc b/trantor/net/inner/NormalResolver.cc
@@ -3,6 +3,7 @@
 #ifdef _WIN32
 #include <ws2tcpip.h>
 #else
+#include <sys/socket.h>
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
@@ -29,85 +30,63 @@ void NormalResolver::resolve(const std::string &hostname,
             if (timeout_ == 0 || cachedAddr.second.after(static_cast<double>(
                                      timeout_)) > trantor::Date::date())
             {
-                struct sockaddr_in addr;
-                memset(&addr, 0, sizeof addr);
-                addr.sin_family = AF_INET;
-                addr.sin_port = 0;
-                addr.sin_addr = cachedAddr.first;
-                InetAddress inet(addr);
-                callback(inet);
+                callback(cachedAddr.first);
                 return;
             }
         }
     }
 
-    taskQueue_.runTaskInQueue(
+    concurrentTaskQueue().runTaskInQueue(
         [thisPtr = shared_from_this(), callback, hostname]() {
-#ifdef __linux__
-            struct hostent hent;
-            struct hostent *he = NULL;
-            int herrno = 0;
-            memset(&hent, 0, sizeof(hent));
-            int ret;
-            while (1)
             {
-                ret = gethostbyname_r(hostname.c_str(),
-                                      &hent,
-                                      thisPtr->resolveBuffer_.data(),
-                                      thisPtr->resolveBuffer_.size(),
-                                      &he,
-                                      &herrno);
-                if (ret == ERANGE)
-                {
-                    thisPtr->resolveBuffer_.resize(
-                        thisPtr->resolveBuffer_.size() * 2);
-                }
-                else
+                std::lock_guard<std::mutex> guard(thisPtr->globalMutex());
+                auto iter = thisPtr->globalCache().find(hostname);
+                if (iter != thisPtr->globalCache().end())
                 {
-                    break;
+                    auto &cachedAddr = iter->second;
+                    if (thisPtr->timeout_ == 0 ||
+                        cachedAddr.second.after(static_cast<double>(
+                            thisPtr->timeout_)) > trantor::Date::date())
+                    {
+                        callback(cachedAddr.first);
+                        return;
+                    }
                 }
             }
-            if (ret == 0 && he != NULL)
-#else
-            /// Multi-threads safety
-            static std::mutex mutex_;
-            struct hostent *he = NULL;
-            struct hostent hent;
+            struct addrinfo hints, *res;
+            memset(&hints, 0, sizeof(hints));
+            hints.ai_family = PF_UNSPEC;
+            hints.ai_socktype = SOCK_STREAM;
+            hints.ai_flags = AI_PASSIVE;
+            auto error = getaddrinfo(hostname.data(), nullptr, &hints, &res);
+            if (error == -1 || res == nullptr)
             {
-                std::lock_guard<std::mutex> guard(mutex_);
-                auto result = gethostbyname(hostname.c_str());
-                if (result != NULL)
-                {
-                    memcpy(&hent, result, sizeof(hent));
-                    he = &hent;
-                }
+                LOG_SYSERR << "InetAddress::resolve";
+                callback(InetAddress{});
+                return;
             }
-            if (he != NULL)
-#endif
+            InetAddress inet;
+            if (res->ai_family == AF_INET)
             {
-                assert(he->h_addrtype == AF_INET &&
-                       he->h_length == sizeof(uint32_t));
-
                 struct sockaddr_in addr;
                 memset(&addr, 0, sizeof addr);
-                addr.sin_family = AF_INET;
-                addr.sin_port = 0;
-                addr.sin_addr = *reinterpret_cast<struct in_addr *>(he->h_addr);
-                InetAddress inet(addr);
-                callback(inet);
-                {
-                    std::lock_guard<std::mutex> guard(thisPtr->globalMutex());
-                    thisPtr->globalCache()[hostname].first = addr.sin_addr;
-                    thisPtr->globalCache()[hostname].second =
-                        trantor::Date::date();
-                }
-                return;
+                addr = *reinterpret_cast<struct sockaddr_in *>(res->ai_addr);
+                inet = InetAddress(addr);
             }
-            else
+            else if (res->ai_family == AF_INET6)
             {
-                LOG_SYSERR << "InetAddress::resolve";
-                callback(InetAddress{});
-                return;
+                struct sockaddr_in6 addr;
+                memset(&addr, 0, sizeof addr);
+                addr = *reinterpret_cast<struct sockaddr_in6 *>(res->ai_addr);
+                inet = InetAddress(addr);
+            }
+            callback(inet);
+            {
+                std::lock_guard<std::mutex> guard(thisPtr->globalMutex());
+                auto &addrItem = thisPtr->globalCache()[hostname];
+                addrItem.first = inet;
+                addrItem.second = trantor::Date::date();
             }
+            return;
         });
 }
diff --git a/trantor/net/inner/NormalResolver.h b/trantor/net/inner/NormalResolver.h
