Fix on domain resolver

Author: Coldwings

net/utils.cpp

@@ -266,36 +266,59 @@ class DefaultResolver : public Resolver {
     struct IPAddrList : public intrusive_list<IPAddrNode>, spinlock {
         ~IPAddrList() { delete_all(); }
     };
+    struct ResolveCtx {
+        std::string host;
+        Delegate<bool, IPAddr> filter;
+        spinlock lock;
+        IPAddrList *addrs;
+        photon::semaphore sem;
+    };
     IPAddr do_resolve(std::string_view host, Delegate<bool, IPAddr> filter) {
         auto ctr = [&]() -> IPAddrList* {
             auto addrs = new IPAddrList();
-            photon::semaphore sem;
-            std::thread([&]() {
-                auto now = std::chrono::steady_clock::now();
+            std::shared_ptr<ResolveCtx> ctx = std::make_shared<ResolveCtx>();
+            ctx->addrs = addrs;
+            ctx->host = std::string(host);
+            ctx->filter = filter;
+            std::thread([ctx]() {
                 IPAddrList ret;
                 auto cb = [&](IPAddr addr) -> int {
-                    if (filter && !filter.fire(addr))
+                    SCOPED_LOCK(ctx->lock);
+                    if (ctx->filter && !ctx->filter.fire(addr))
                         return 0;
                     ret.push_back(new IPAddrNode(addr));
                     return 0;
                 };
-                _gethostbyname(host, cb);
-                auto time_elapsed = std::chrono::duration_cast<std::chrono::microseconds>(
-                                        std::chrono::steady_clock::now() - now).count();
-                if ((uint64_t)time_elapsed <= resolve_timeout_) {
-                    addrs->push_back(std::move(ret));
-                    sem.signal(1);
-                } else {
-                    LOG_ERROR("resolve timeout");
-                    while(!ret.empty())
-                        delete ret.pop_front();
+                _gethostbyname(ctx->host, cb);
+                {
+                    SCOPED_LOCK(ctx->lock);
+                    if (ctx->addrs) {
+                        ctx->addrs->push_back(std::move(ret));
+                        ctx->sem.signal(1);
+                    } else {
+                        LOG_ERROR("resolve timeout");
+                        while(!ret.empty())
+                            delete ret.pop_front();
+                    }
                 }
             }).detach();
-            sem.wait(1, resolve_timeout_);
+            ctx->sem.wait(1, resolve_timeout_);
+            {
+                SCOPED_LOCK(ctx->lock);
+                ctx->addrs = nullptr;
+                ctx->filter = {};
+            }
+            if (addrs->empty()) {
+                delete addrs;
+                return nullptr;
+            }
             return addrs;
         };
-        auto ips = dnscache_.borrow(host, ctr);
-        if (ips->empty()) LOG_ERRNO_RETURN(0, IPAddr(), "Domain resolution for '`' failed", host);
+        auto ips = dnscache_.borrow(host, ctr, 1UL * 1000);
+        if (!ips || ips->empty()) {
+            ips.recycle(true);
+            LOG_ERRNO_RETURN(0, IPAddr(), "Domain resolution for '`' failed", host);
+        }
         SCOPED_LOCK(*ips);
         auto ret = ips->front();
         ips->node = ret->next();  // access in round robin order