Backport search domains support, close AsyncHttpClient#1207

Author: slandelle

netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolver.java

@@ -42,10 +42,13 @@
 import io.netty.util.concurrent.FastThreadLocal;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.Promise;
+import io.netty.util.internal.EmptyArrays;
 import io.netty.util.internal.PlatformDependent;
+import io.netty.util.internal.StringUtil2;
 import io.netty.util.internal.logging.InternalLogger;
 import io.netty.util.internal.logging.InternalLoggerFactory;
 
+import java.lang.reflect.Method;
 import java.net.IDN;
 import java.net.Inet4Address;
 import java.net.InetAddress;
@@ -67,6 +70,7 @@ public class DnsNameResolver extends InetNameResolver {
     private static final InetAddress LOCALHOST_ADDRESS;
 
     static final InternetProtocolFamily[] DEFAULT_RESOLVE_ADDRESS_TYPES = new InternetProtocolFamily[2];
+    static final String[] DEFAULT_SEACH_DOMAINS;
 
     static {
         // Note that we did not use SystemPropertyUtil.getBoolean() here to emulate the behavior of JDK.
@@ -83,6 +87,24 @@ public class DnsNameResolver extends InetNameResolver {
         }
     }
 
+    static {
+        String[] searchDomains;
+        try {
+            Class<?> configClass = Class.forName("sun.net.dns.ResolverConfiguration");
+            Method open = configClass.getMethod("open");
+            Method nameservers = configClass.getMethod("searchlist");
+            Object instance = open.invoke(null);
+
+            @SuppressWarnings("unchecked")
+            List<String> list = (List<String>) nameservers.invoke(instance);
+            searchDomains = list.toArray(new String[list.size()]);
+        } catch (Exception ignore) {
+            // Failed to get the system name search domain list.
+            searchDomains = EmptyArrays.EMPTY_STRINGS;
+        }
+        DEFAULT_SEACH_DOMAINS = searchDomains;
+    }
+
     private static final DatagramDnsResponseDecoder DECODER = new DatagramDnsResponseDecoder();
     private static final DatagramDnsQueryEncoder ENCODER = new DatagramDnsQueryEncoder();
 
@@ -116,6 +138,8 @@ protected DnsServerAddressStream initialValue() throws Exception {
     private final int maxPayloadSize;
     private final boolean optResourceEnabled;
     private final HostsFileEntriesResolver hostsFileEntriesResolver;
+    private final String[] searchDomains;
+    private final int ndots;
 
     /**
      * Creates a new DNS-based name resolver that communicates with the specified list of DNS servers.
@@ -134,6 +158,8 @@ protected DnsServerAddressStream initialValue() throws Exception {
      * @param maxPayloadSize the capacity of the datagram packet buffer
      * @param optResourceEnabled if automatic inclusion of a optional records is enabled
      * @param hostsFileEntriesResolver the {@link HostsFileEntriesResolver} used to check for local aliases
+     * @param searchDomains the list of search domain
+     * @param ndots the ndots value
      */
     public DnsNameResolver(
             EventLoop eventLoop,
@@ -147,7 +173,9 @@ public DnsNameResolver(
             boolean traceEnabled,
             int maxPayloadSize,
             boolean optResourceEnabled,
-            HostsFileEntriesResolver hostsFileEntriesResolver) {
+            HostsFileEntriesResolver hostsFileEntriesResolver,
+            String[] searchDomains,
+            int ndots) {
 
         super(eventLoop);
         checkNotNull(channelFactory, "channelFactory");
@@ -161,6 +189,8 @@ public DnsNameResolver(
         this.optResourceEnabled = optResourceEnabled;
         this.hostsFileEntriesResolver = checkNotNull(hostsFileEntriesResolver, "hostsFileEntriesResolver");
         this.resolveCache = resolveCache;
+        this.searchDomains = checkNotNull(searchDomains, "searchDomains").clone();
+        this.ndots = checkPositive(ndots, "ndots");
 
         Bootstrap b = new Bootstrap();
         b.group(executor());
@@ -214,6 +244,14 @@ InternetProtocolFamily[] resolveAddressTypesUnsafe() {
         return resolvedAddressTypes;
     }
 
+    final String[] searchDomains() {
+        return searchDomains;
+    }
+
+    final int ndots() {
+        return ndots;
+    }
+
     /**
      * Returns {@code true} if and only if this resolver sends a DNS query with the RD (recursion desired) flag set.
      * The default value is {@code true}.
@@ -375,25 +413,37 @@ private static void setSuccess(Promise<InetAddress> promise, InetAddress result)
     private void doResolveUncached(String hostname,
                                    Promise<InetAddress> promise,
                                    DnsCache resolveCache) {
-        final DnsNameResolverContext<InetAddress> ctx =
-                new DnsNameResolverContext<InetAddress>(this, hostname, promise, resolveCache) {
-                    @Override
-                    protected boolean finishResolve(
-                            InternetProtocolFamily f, List<DnsCacheEntry> resolvedEntries) {
-
-                        final int numEntries = resolvedEntries.size();
-                        for (int i = 0; i < numEntries; i++) {
-                            final InetAddress a = resolvedEntries.get(i).address();
-                            if (addressMatchFamily(a, f)) {
-                                setSuccess(promise(), a);
-                                return true;
-                            }
-                        }
-                        return false;
-                    }
-                };
+        SingleResolverContext ctx = new SingleResolverContext(this, hostname, resolveCache);
+        ctx.resolve(promise);
+    }
+
+    final class SingleResolverContext extends DnsNameResolverContext<InetAddress> {
+
+        SingleResolverContext(DnsNameResolver parent, String hostname, DnsCache resolveCache) {
+            super(parent, hostname, resolveCache);
+        }
 
-        ctx.resolve();
+        @Override
+        DnsNameResolverContext<InetAddress> newResolverContext(DnsNameResolver parent,
+                                                                         String hostname, DnsCache resolveCache) {
+            return new SingleResolverContext(parent, hostname, resolveCache);
+        }
+
+        @Override
+        boolean finishResolve(
+                InternetProtocolFamily f, List<DnsCacheEntry> resolvedEntries,
+            Promise<InetAddress> promise) {
+
+            final int numEntries = resolvedEntries.size();
+            for (int i = 0; i < numEntries; i++) {
+                final InetAddress a = resolvedEntries.get(i).address();
+                if (addressMatchFamily(a, f)) {
+                    setSuccess(promise, a);
+                    return true;
+                }
+            }
+            return false;
+        }
     }
 
     @Override
@@ -471,40 +521,56 @@ private boolean doResolveAllCached(String hostname,
         return true;
     }
 
-    private void doResolveAllUncached(final String hostname,
-                                      final Promise<List<InetAddress>> promise,
-                                      DnsCache resolveCache) {
-        final DnsNameResolverContext<List<InetAddress>> ctx =
-                new DnsNameResolverContext<List<InetAddress>>(this, hostname, promise, resolveCache) {
-                    @Override
-                    protected boolean finishResolve(
-                            InternetProtocolFamily f, List<DnsCacheEntry> resolvedEntries) {
-
-                        List<InetAddress> result = null;
-                        final int numEntries = resolvedEntries.size();
-                        for (int i = 0; i < numEntries; i++) {
-                            final InetAddress a = resolvedEntries.get(i).address();
-                            if (addressMatchFamily(a, f)) {
-                                if (result == null) {
-                                    result = new ArrayList<InetAddress>(numEntries);
-                                }
-                                result.add(a);
-                            }
-                        }
+    final class ListResolverContext extends DnsNameResolverContext<List<InetAddress>> {
+        ListResolverContext(DnsNameResolver parent, String hostname, DnsCache resolveCache) {
+            super(parent, hostname, resolveCache);
+        }
 
-                        if (result != null) {
-                            promise().trySuccess(result);
-                            return true;
-                        }
-                        return false;
+        @Override
+        DnsNameResolverContext<List<InetAddress>> newResolverContext(DnsNameResolver parent, String hostname,
+                                                                               DnsCache resolveCache) {
+            return new ListResolverContext(parent, hostname, resolveCache);
+        }
+
+        @Override
+        boolean finishResolve(
+            InternetProtocolFamily f, List<DnsCacheEntry> resolvedEntries,
+            Promise<List<InetAddress>> promise) {
+
+            List<InetAddress> result = null;
+            final int numEntries = resolvedEntries.size();
+            for (int i = 0; i < numEntries; i++) {
+                final InetAddress a = resolvedEntries.get(i).address();
+                if (addressMatchFamily(a, f)) {
+                    if (result == null) {
+                        result = new ArrayList<InetAddress>(numEntries);
                     }
-                };
+                    result.add(a);
+                }
+            }
+
+            if (result != null) {
+                promise.trySuccess(result);
+                return true;
+            }
+            return false;
+        }
+    }
 
-        ctx.resolve();
+    private void doResolveAllUncached(String hostname,
+                                      Promise<List<InetAddress>> promise,
+                                      DnsCache resolveCache) {
+        DnsNameResolverContext<List<InetAddress>> ctx = new ListResolverContext(this, hostname, resolveCache);
+        ctx.resolve(promise);
     }
 
     private static String hostname(String inetHost) {
-        return IDN.toASCII(inetHost);
+        String hostname = IDN.toASCII(inetHost);
+        // Check for http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6894622
+        if (StringUtil2.endsWith(inetHost, '.') && !StringUtil2.endsWith(hostname, '.')) {
+            hostname += ".";
+        }
+        return hostname;
     }
 
     /**

netty-bp/resolver-dns/src/main/java/io/netty/resolver/dns/DnsNameResolverBuilder.java

@@ -49,6 +49,8 @@ public final class DnsNameResolverBuilder {
     private int maxPayloadSize = 4096;
     private boolean optResourceEnabled = true;
     private HostsFileEntriesResolver hostsFileEntriesResolver = HostsFileEntriesResolver.DEFAULT;
+    private String[] searchDomains = DnsNameResolver.DEFAULT_SEACH_DOMAINS;
+    private int ndots = 1;
 
     /**
      * Creates a new builder.
@@ -286,6 +288,46 @@ public DnsNameResolverBuilder hostsFileEntriesResolver(HostsFileEntriesResolver
         return this;
     }
 
+    /**
+     * Set the list of search domains of the resolver.
+     *
+     * @param searchDomains the search domains
+     * @return {@code this}
+     */
+    public DnsNameResolverBuilder searchDomains(Iterable<String> searchDomains) {
+        checkNotNull(searchDomains, "searchDomains");
+
+        final List<String> list =
+            InternalThreadLocalMap.get().arrayList(4);
+
+        for (String f : searchDomains) {
+            if (f == null) {
+                break;
+            }
+
+            // Avoid duplicate entries.
+            if (list.contains(f)) {
+                continue;
+            }
+
+            list.add(f);
+        }
+
+        this.searchDomains = list.toArray(new String[list.size()]);
+        return this;
+    }
+
+  /**
+   * Set the number of dots which must appear in a name before an initial absolute query is made.
+   *
+   * @param ndots the ndots value
+   * @return {@code this}
+   */
+    public DnsNameResolverBuilder ndots(int ndots) {
+        this.ndots = ndots;
+        return this;
+    }
+
     /**
      * Returns a new {@link DnsNameResolver} instance.
      *
@@ -312,6 +354,8 @@ public DnsNameResolver build() {
                 traceEnabled,
                 maxPayloadSize,
                 optResourceEnabled,
-                hostsFileEntriesResolver);
+                hostsFileEntriesResolver,
+                searchDomains,
+                ndots);
     }
 }