package io.netty.resolver.dns;

import g.a.a.a.a;
import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.AddressedEnvelope;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFactory;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPromise;
import io.netty.channel.EventLoop;
import io.netty.channel.FixedRecvByteBufAllocator;
import io.netty.channel.RecvByteBufAllocator;
import io.netty.channel.socket.DatagramChannel;
import io.netty.channel.socket.InternetProtocolFamily;
import io.netty.handler.codec.dns.DatagramDnsQueryEncoder;
import io.netty.handler.codec.dns.DatagramDnsResponse;
import io.netty.handler.codec.dns.DatagramDnsResponseDecoder;
import io.netty.handler.codec.dns.DefaultDnsRawRecord;
import io.netty.handler.codec.dns.DefaultDnsRecordDecoder;
import io.netty.handler.codec.dns.DnsQuestion;
import io.netty.handler.codec.dns.DnsRawRecord;
import io.netty.handler.codec.dns.DnsRecord;
import io.netty.handler.codec.dns.DnsRecordType;
import io.netty.handler.codec.dns.DnsResponse;
import io.netty.resolver.HostsFileEntriesResolver;
import io.netty.resolver.InetNameResolver;
import io.netty.resolver.ResolvedAddressTypes;
import io.netty.util.NetUtil;
import io.netty.util.ReferenceCountUtil;
import io.netty.util.concurrent.FastThreadLocal;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.FutureListener;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.Promise;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.StringUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.net.IDN;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public class DnsNameResolver extends InetNameResolver {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    private static final DatagramDnsResponseDecoder DECODER;
    private static final int DEFAULT_NDOTS;
    public static final ResolvedAddressTypes DEFAULT_RESOLVE_ADDRESS_TYPES;
    public static final String[] DEFAULT_SEARCH_DOMAINS;
    private static final DatagramDnsQueryEncoder ENCODER;
    private static final InternetProtocolFamily[] IPV4_ONLY_RESOLVED_PROTOCOL_FAMILIES;
    private static final DnsRecordType[] IPV4_ONLY_RESOLVED_RECORD_TYPES;
    private static final InternetProtocolFamily[] IPV4_PREFERRED_RESOLVED_PROTOCOL_FAMILIES;
    private static final DnsRecordType[] IPV4_PREFERRED_RESOLVED_RECORD_TYPES;
    private static final InternetProtocolFamily[] IPV6_ONLY_RESOLVED_PROTOCOL_FAMILIES;
    private static final DnsRecordType[] IPV6_ONLY_RESOLVED_RECORD_TYPES;
    private static final InternetProtocolFamily[] IPV6_PREFERRED_RESOLVED_PROTOCOL_FAMILIES;
    private static final DnsRecordType[] IPV6_PREFERRED_RESOLVED_RECORD_TYPES;
    private static final String LOCALHOST = "localhost";
    private static final InetAddress LOCALHOST_ADDRESS;
    private final DnsCache authoritativeDnsServerCache;
    public final DatagramChannel ch;
    public final Future<Channel> channelFuture;
    private final boolean decodeIdn;
    private final DnsQueryLifecycleObserverFactory dnsQueryLifecycleObserverFactory;
    private final DnsServerAddressStreamProvider dnsServerAddressStreamProvider;
    private final HostsFileEntriesResolver hostsFileEntriesResolver;
    private final int maxPayloadSize;
    private final int maxQueriesPerResolve;
    private final FastThreadLocal<DnsServerAddressStream> nameServerAddrStream;
    private final int ndots;
    private final boolean optResourceEnabled;
    private final InternetProtocolFamily preferredAddressType;
    public final DnsQueryContextManager queryContextManager;
    private final long queryTimeoutMillis;
    private final boolean recursionDesired;
    private final DnsCache resolveCache;
    private final DnsRecordType[] resolveRecordTypes;
    private final ResolvedAddressTypes resolvedAddressTypes;
    private final InternetProtocolFamily[] resolvedInternetProtocolFamilies;
    private final String[] searchDomains;
    private final boolean supportsAAAARecords;
    private final boolean supportsARecords;
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) DnsNameResolver.class);
    private static final DnsRecord[] EMPTY_ADDITIONALS = new DnsRecord[0];

    /* JADX INFO: renamed from: io.netty.resolver.dns.DnsNameResolver$5, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass5 {
        public static final /* synthetic */ int[] $SwitchMap$io$netty$resolver$ResolvedAddressTypes;

        static {
            ResolvedAddressTypes.values();
            int[] iArr = new int[4];
            $SwitchMap$io$netty$resolver$ResolvedAddressTypes = iArr;
            try {
                iArr[ResolvedAddressTypes.IPV4_ONLY.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$io$netty$resolver$ResolvedAddressTypes[ResolvedAddressTypes.IPV4_PREFERRED.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$io$netty$resolver$ResolvedAddressTypes[ResolvedAddressTypes.IPV6_ONLY.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$io$netty$resolver$ResolvedAddressTypes[ResolvedAddressTypes.IPV6_PREFERRED.ordinal()] = 4;
            } catch (NoSuchFieldError unused4) {
            }
        }
    }

    public final class DnsResponseHandler extends ChannelInboundHandlerAdapter {
        private final Promise<Channel> channelActivePromise;

        public DnsResponseHandler(Promise<Channel> promise) {
            this.channelActivePromise = promise;
        }

        @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
        public void channelActive(ChannelHandlerContext channelHandlerContext) {
            super.channelActive(channelHandlerContext);
            this.channelActivePromise.setSuccess(channelHandlerContext.channel());
        }

        @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelInboundHandler
        public void channelRead(ChannelHandlerContext channelHandlerContext, Object obj) {
            try {
                DatagramDnsResponse datagramDnsResponse = (DatagramDnsResponse) obj;
                int iId = datagramDnsResponse.id();
                if (DnsNameResolver.logger.isDebugEnabled()) {
                    DnsNameResolver.logger.debug("{} RECEIVED: [{}: {}], {}", DnsNameResolver.this.ch, Integer.valueOf(iId), datagramDnsResponse.sender(), datagramDnsResponse);
                }
                DnsQueryContext dnsQueryContext = DnsNameResolver.this.queryContextManager.get(datagramDnsResponse.sender(), iId);
                if (dnsQueryContext == null) {
                    DnsNameResolver.logger.warn("{} Received a DNS response with an unknown ID: {}", DnsNameResolver.this.ch, Integer.valueOf(iId));
                } else {
                    dnsQueryContext.finish(datagramDnsResponse);
                }
            } finally {
                ReferenceCountUtil.safeRelease(obj);
            }
        }

        @Override // io.netty.channel.ChannelInboundHandlerAdapter, io.netty.channel.ChannelHandlerAdapter, io.netty.channel.ChannelHandler, io.netty.channel.ChannelInboundHandler
        public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable th) {
            DnsNameResolver.logger.warn("{} Unexpected exception: ", DnsNameResolver.this.ch, th);
        }
    }

    /* JADX WARN: Can't wrap try/catch for region: R(12:0|2|(1:4)(2:7|(9:9|6|21|11|14|19|15|16|17)(1:10))|5|6|21|11|14|19|15|16|17) */
    /* JADX WARN: Code restructure failed: missing block: B:13:0x00a2, code lost:
    
        r0 = io.netty.util.internal.EmptyArrays.EMPTY_STRINGS;
     */
    static {
        /*
            java.lang.Class<io.netty.resolver.dns.DnsNameResolver> r0 = io.netty.resolver.dns.DnsNameResolver.class
            java.lang.Class<io.netty.resolver.dns.DnsNameResolver> r0 = io.netty.resolver.dns.DnsNameResolver.class
            io.netty.util.internal.logging.InternalLogger r0 = io.netty.util.internal.logging.InternalLoggerFactory.getInstance(r0)
            io.netty.resolver.dns.DnsNameResolver.logger = r0
            r0 = 0
            io.netty.handler.codec.dns.DnsRecord[] r1 = new io.netty.handler.codec.dns.DnsRecord[r0]
            io.netty.resolver.dns.DnsNameResolver.EMPTY_ADDITIONALS = r1
            r1 = 1
            io.netty.handler.codec.dns.DnsRecordType[] r2 = new io.netty.handler.codec.dns.DnsRecordType[r1]
            io.netty.handler.codec.dns.DnsRecordType r3 = io.netty.handler.codec.dns.DnsRecordType.A
            r2[r0] = r3
            io.netty.resolver.dns.DnsNameResolver.IPV4_ONLY_RESOLVED_RECORD_TYPES = r2
            io.netty.channel.socket.InternetProtocolFamily[] r2 = new io.netty.channel.socket.InternetProtocolFamily[r1]
            io.netty.channel.socket.InternetProtocolFamily r4 = io.netty.channel.socket.InternetProtocolFamily.IPv4
            r2[r0] = r4
            io.netty.resolver.dns.DnsNameResolver.IPV4_ONLY_RESOLVED_PROTOCOL_FAMILIES = r2
            r2 = 2
            io.netty.handler.codec.dns.DnsRecordType[] r5 = new io.netty.handler.codec.dns.DnsRecordType[r2]
            r5[r0] = r3
            io.netty.handler.codec.dns.DnsRecordType r6 = io.netty.handler.codec.dns.DnsRecordType.AAAA
            r5[r1] = r6
            io.netty.resolver.dns.DnsNameResolver.IPV4_PREFERRED_RESOLVED_RECORD_TYPES = r5
            io.netty.channel.socket.InternetProtocolFamily[] r5 = new io.netty.channel.socket.InternetProtocolFamily[r2]
            r5[r0] = r4
            io.netty.channel.socket.InternetProtocolFamily r7 = io.netty.channel.socket.InternetProtocolFamily.IPv6
            r5[r1] = r7
            io.netty.resolver.dns.DnsNameResolver.IPV4_PREFERRED_RESOLVED_PROTOCOL_FAMILIES = r5
            io.netty.handler.codec.dns.DnsRecordType[] r5 = new io.netty.handler.codec.dns.DnsRecordType[r1]
            r5[r0] = r6
            io.netty.resolver.dns.DnsNameResolver.IPV6_ONLY_RESOLVED_RECORD_TYPES = r5
            io.netty.channel.socket.InternetProtocolFamily[] r5 = new io.netty.channel.socket.InternetProtocolFamily[r1]
            r5[r0] = r7
            io.netty.resolver.dns.DnsNameResolver.IPV6_ONLY_RESOLVED_PROTOCOL_FAMILIES = r5
            io.netty.handler.codec.dns.DnsRecordType[] r5 = new io.netty.handler.codec.dns.DnsRecordType[r2]
            r5[r0] = r6
            r5[r1] = r3
            io.netty.resolver.dns.DnsNameResolver.IPV6_PREFERRED_RESOLVED_RECORD_TYPES = r5
            io.netty.channel.socket.InternetProtocolFamily[] r2 = new io.netty.channel.socket.InternetProtocolFamily[r2]
            r2[r0] = r7
            r2[r1] = r4
            io.netty.resolver.dns.DnsNameResolver.IPV6_PREFERRED_RESOLVED_PROTOCOL_FAMILIES = r2
            boolean r2 = io.netty.util.NetUtil.isIpV4StackPreferred()
            if (r2 == 0) goto L60
            io.netty.resolver.ResolvedAddressTypes r2 = io.netty.resolver.ResolvedAddressTypes.IPV4_ONLY
        L59:
            io.netty.resolver.dns.DnsNameResolver.DEFAULT_RESOLVE_ADDRESS_TYPES = r2
            java.net.Inet4Address r2 = io.netty.util.NetUtil.LOCALHOST4
        L5d:
            io.netty.resolver.dns.DnsNameResolver.LOCALHOST_ADDRESS = r2
            goto L70
        L60:
            boolean r2 = io.netty.util.NetUtil.isIpV6AddressesPreferred()
            if (r2 == 0) goto L6d
            io.netty.resolver.ResolvedAddressTypes r2 = io.netty.resolver.ResolvedAddressTypes.IPV6_PREFERRED
            io.netty.resolver.dns.DnsNameResolver.DEFAULT_RESOLVE_ADDRESS_TYPES = r2
            java.net.Inet6Address r2 = io.netty.util.NetUtil.LOCALHOST6
            goto L5d
        L6d:
            io.netty.resolver.ResolvedAddressTypes r2 = io.netty.resolver.ResolvedAddressTypes.IPV4_PREFERRED
            goto L59
        L70:
            java.lang.String r2 = "sun.net.dns.ResolverConfiguration"
            java.lang.Class r2 = java.lang.Class.forName(r2)     // Catch: java.lang.Exception -> La2
            java.lang.String r3 = "open"
            java.lang.Class[] r4 = new java.lang.Class[r0]     // Catch: java.lang.Exception -> La2
            java.lang.reflect.Method r3 = r2.getMethod(r3, r4)     // Catch: java.lang.Exception -> La2
            java.lang.String r4 = "searchlist"
            java.lang.Class[] r5 = new java.lang.Class[r0]     // Catch: java.lang.Exception -> La2
            java.lang.reflect.Method r2 = r2.getMethod(r4, r5)     // Catch: java.lang.Exception -> La2
            r4 = 0
            java.lang.Object[] r5 = new java.lang.Object[r0]     // Catch: java.lang.Exception -> La2
            java.lang.Object r3 = r3.invoke(r4, r5)     // Catch: java.lang.Exception -> La2
            java.lang.Object[] r0 = new java.lang.Object[r0]     // Catch: java.lang.Exception -> La2
            java.lang.Object r0 = r2.invoke(r3, r0)     // Catch: java.lang.Exception -> La2
            java.util.List r0 = (java.util.List) r0     // Catch: java.lang.Exception -> La2
            int r2 = r0.size()     // Catch: java.lang.Exception -> La2
            java.lang.String[] r2 = new java.lang.String[r2]     // Catch: java.lang.Exception -> La2
            java.lang.Object[] r0 = r0.toArray(r2)     // Catch: java.lang.Exception -> La2
            java.lang.String[] r0 = (java.lang.String[]) r0     // Catch: java.lang.Exception -> La2
            goto La4
        La2:
            java.lang.String[] r0 = io.netty.util.internal.EmptyArrays.EMPTY_STRINGS
        La4:
            io.netty.resolver.dns.DnsNameResolver.DEFAULT_SEARCH_DOMAINS = r0
            int r1 = io.netty.resolver.dns.UnixResolverDnsServerAddressStreamProvider.parseEtcResolverFirstNdots()     // Catch: java.lang.Exception -> Laa
        Laa:
            io.netty.resolver.dns.DnsNameResolver.DEFAULT_NDOTS = r1
            io.netty.handler.codec.dns.DatagramDnsResponseDecoder r0 = new io.netty.handler.codec.dns.DatagramDnsResponseDecoder
            r0.<init>()
            io.netty.resolver.dns.DnsNameResolver.DECODER = r0
            io.netty.handler.codec.dns.DatagramDnsQueryEncoder r0 = new io.netty.handler.codec.dns.DatagramDnsQueryEncoder
            r0.<init>()
            io.netty.resolver.dns.DnsNameResolver.ENCODER = r0
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.resolver.dns.DnsNameResolver.<clinit>():void");
    }

    public DnsNameResolver(EventLoop eventLoop, ChannelFactory<? extends DatagramChannel> channelFactory, final DnsCache dnsCache, DnsCache dnsCache2, DnsQueryLifecycleObserverFactory dnsQueryLifecycleObserverFactory, long j2, ResolvedAddressTypes resolvedAddressTypes, boolean z2, int i2, boolean z3, int i3, boolean z4, HostsFileEntriesResolver hostsFileEntriesResolver, DnsServerAddressStreamProvider dnsServerAddressStreamProvider, String[] strArr, int i4, boolean z5) {
        InternetProtocolFamily internetProtocolFamily;
        super(eventLoop);
        this.queryContextManager = new DnsQueryContextManager();
        this.nameServerAddrStream = new FastThreadLocal<DnsServerAddressStream>() { // from class: io.netty.resolver.dns.DnsNameResolver.1
            /* JADX WARN: Can't rename method to resolve collision */
            @Override // io.netty.util.concurrent.FastThreadLocal
            public DnsServerAddressStream initialValue() {
                return DnsNameResolver.this.dnsServerAddressStreamProvider.nameServerAddressStream("");
            }
        };
        this.queryTimeoutMillis = ObjectUtil.checkPositive(j2, "queryTimeoutMillis");
        ResolvedAddressTypes resolvedAddressTypes2 = resolvedAddressTypes != null ? resolvedAddressTypes : DEFAULT_RESOLVE_ADDRESS_TYPES;
        this.resolvedAddressTypes = resolvedAddressTypes2;
        this.recursionDesired = z2;
        this.maxQueriesPerResolve = ObjectUtil.checkPositive(i2, "maxQueriesPerResolve");
        this.maxPayloadSize = ObjectUtil.checkPositive(i3, "maxPayloadSize");
        this.optResourceEnabled = z4;
        this.hostsFileEntriesResolver = (HostsFileEntriesResolver) ObjectUtil.checkNotNull(hostsFileEntriesResolver, "hostsFileEntriesResolver");
        this.dnsServerAddressStreamProvider = (DnsServerAddressStreamProvider) ObjectUtil.checkNotNull(dnsServerAddressStreamProvider, "dnsServerAddressStreamProvider");
        this.resolveCache = (DnsCache) ObjectUtil.checkNotNull(dnsCache, "resolveCache");
        this.authoritativeDnsServerCache = (DnsCache) ObjectUtil.checkNotNull(dnsCache2, "authoritativeDnsServerCache");
        this.dnsQueryLifecycleObserverFactory = z3 ? dnsQueryLifecycleObserverFactory instanceof NoopDnsQueryLifecycleObserverFactory ? new TraceDnsQueryLifeCycleObserverFactory() : new BiDnsQueryLifecycleObserverFactory(new TraceDnsQueryLifeCycleObserverFactory(), dnsQueryLifecycleObserverFactory) : (DnsQueryLifecycleObserverFactory) ObjectUtil.checkNotNull(dnsQueryLifecycleObserverFactory, "dnsQueryLifecycleObserverFactory");
        this.searchDomains = strArr != null ? (String[]) strArr.clone() : DEFAULT_SEARCH_DOMAINS;
        this.ndots = i4 >= 0 ? i4 : DEFAULT_NDOTS;
        this.decodeIdn = z5;
        int iOrdinal = resolvedAddressTypes2.ordinal();
        if (iOrdinal != 0) {
            if (iOrdinal == 1) {
                this.supportsAAAARecords = true;
                this.supportsARecords = false;
                this.resolveRecordTypes = IPV6_ONLY_RESOLVED_RECORD_TYPES;
                this.resolvedInternetProtocolFamilies = IPV6_ONLY_RESOLVED_PROTOCOL_FAMILIES;
            } else if (iOrdinal == 2) {
                this.supportsAAAARecords = true;
                this.supportsARecords = true;
                this.resolveRecordTypes = IPV4_PREFERRED_RESOLVED_RECORD_TYPES;
                this.resolvedInternetProtocolFamilies = IPV4_PREFERRED_RESOLVED_PROTOCOL_FAMILIES;
            } else {
                if (iOrdinal != 3) {
                    throw new IllegalArgumentException("Unknown ResolvedAddressTypes " + resolvedAddressTypes);
                }
                this.supportsAAAARecords = true;
                this.supportsARecords = true;
                this.resolveRecordTypes = IPV6_PREFERRED_RESOLVED_RECORD_TYPES;
                this.resolvedInternetProtocolFamilies = IPV6_PREFERRED_RESOLVED_PROTOCOL_FAMILIES;
            }
            internetProtocolFamily = InternetProtocolFamily.IPv6;
            this.preferredAddressType = internetProtocolFamily;
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(executor());
            bootstrap.channelFactory((ChannelFactory) channelFactory);
            bootstrap.option(ChannelOption.DATAGRAM_CHANNEL_ACTIVE_ON_REGISTRATION, Boolean.TRUE);
            final DnsResponseHandler dnsResponseHandler = new DnsResponseHandler(executor().newPromise());
            bootstrap.handler(new ChannelInitializer<DatagramChannel>() { // from class: io.netty.resolver.dns.DnsNameResolver.2
                @Override // io.netty.channel.ChannelInitializer
                public void initChannel(DatagramChannel datagramChannel) {
                    datagramChannel.pipeline().addLast(DnsNameResolver.DECODER, DnsNameResolver.ENCODER, dnsResponseHandler);
                }
            });
            this.channelFuture = dnsResponseHandler.channelActivePromise;
            DatagramChannel datagramChannel = (DatagramChannel) bootstrap.register().channel();
            this.ch = datagramChannel;
            datagramChannel.config().setRecvByteBufAllocator((RecvByteBufAllocator) new FixedRecvByteBufAllocator(i3));
            datagramChannel.closeFuture().addListener((GenericFutureListener<? extends Future<? super Void>>) new ChannelFutureListener() { // from class: io.netty.resolver.dns.DnsNameResolver.3
                @Override // io.netty.util.concurrent.GenericFutureListener
                public void operationComplete(ChannelFuture channelFuture) {
                    dnsCache.clear();
                }
            });
        }
        this.supportsAAAARecords = false;
        this.supportsARecords = true;
        this.resolveRecordTypes = IPV4_ONLY_RESOLVED_RECORD_TYPES;
        this.resolvedInternetProtocolFamilies = IPV4_ONLY_RESOLVED_PROTOCOL_FAMILIES;
        internetProtocolFamily = InternetProtocolFamily.IPv4;
        this.preferredAddressType = internetProtocolFamily;
        Bootstrap bootstrap2 = new Bootstrap();
        bootstrap2.group(executor());
        bootstrap2.channelFactory((ChannelFactory) channelFactory);
        bootstrap2.option(ChannelOption.DATAGRAM_CHANNEL_ACTIVE_ON_REGISTRATION, Boolean.TRUE);
        final DnsResponseHandler dnsResponseHandler2 = new DnsResponseHandler(executor().newPromise());
        bootstrap2.handler(new ChannelInitializer<DatagramChannel>() { // from class: io.netty.resolver.dns.DnsNameResolver.2
            @Override // io.netty.channel.ChannelInitializer
            public void initChannel(DatagramChannel datagramChannel2) {
                datagramChannel2.pipeline().addLast(DnsNameResolver.DECODER, DnsNameResolver.ENCODER, dnsResponseHandler2);
            }
        });
        this.channelFuture = dnsResponseHandler2.channelActivePromise;
        DatagramChannel datagramChannel2 = (DatagramChannel) bootstrap2.register().channel();
        this.ch = datagramChannel2;
        datagramChannel2.config().setRecvByteBufAllocator((RecvByteBufAllocator) new FixedRecvByteBufAllocator(i3));
        datagramChannel2.closeFuture().addListener((GenericFutureListener<? extends Future<? super Void>>) new ChannelFutureListener() { // from class: io.netty.resolver.dns.DnsNameResolver.3
            @Override // io.netty.util.concurrent.GenericFutureListener
            public void operationComplete(ChannelFuture channelFuture) {
                dnsCache.clear();
            }
        });
    }

    /* JADX WARN: Multi-variable type inference failed */
    private static Promise<AddressedEnvelope<DnsResponse, InetSocketAddress>> cast(Promise<?> promise) {
        return promise;
    }

    private boolean doResolveAllCached(String str, DnsRecord[] dnsRecordArr, Promise<List<InetAddress>> promise, DnsCache dnsCache) {
        List<? extends DnsCacheEntry> list = dnsCache.get(str, dnsRecordArr);
        if (list == null || list.isEmpty()) {
            return false;
        }
        Throwable thCause = list.get(0).cause();
        if (thCause != null) {
            tryFailure(promise, thCause);
            return true;
        }
        ArrayList arrayList = null;
        int size = list.size();
        for (InternetProtocolFamily internetProtocolFamily : this.resolvedInternetProtocolFamilies) {
            for (int i2 = 0; i2 < size; i2++) {
                DnsCacheEntry dnsCacheEntry = list.get(i2);
                if (internetProtocolFamily.addressType().isInstance(dnsCacheEntry.address())) {
                    if (arrayList == null) {
                        arrayList = new ArrayList(size);
                    }
                    arrayList.add(dnsCacheEntry.address());
                }
            }
        }
        if (arrayList == null) {
            return false;
        }
        trySuccess(promise, arrayList);
        return true;
    }

    private void doResolveAllUncached(String str, DnsRecord[] dnsRecordArr, Promise<List<InetAddress>> promise, DnsCache dnsCache) {
        new DnsAddressResolveContext(this, str, dnsRecordArr, this.dnsServerAddressStreamProvider.nameServerAddressStream(str), dnsCache).resolve(promise);
    }

    private boolean doResolveCached(String str, DnsRecord[] dnsRecordArr, Promise<InetAddress> promise, DnsCache dnsCache) {
        List<? extends DnsCacheEntry> list = dnsCache.get(str, dnsRecordArr);
        if (list == null || list.isEmpty()) {
            return false;
        }
        Throwable thCause = list.get(0).cause();
        if (thCause != null) {
            tryFailure(promise, thCause);
            return true;
        }
        int size = list.size();
        for (InternetProtocolFamily internetProtocolFamily : this.resolvedInternetProtocolFamilies) {
            for (int i2 = 0; i2 < size; i2++) {
                DnsCacheEntry dnsCacheEntry = list.get(i2);
                if (internetProtocolFamily.addressType().isInstance(dnsCacheEntry.address())) {
                    trySuccess(promise, dnsCacheEntry.address());
                    return true;
                }
            }
        }
        return false;
    }

    private void doResolveUncached(String str, DnsRecord[] dnsRecordArr, final Promise<InetAddress> promise, DnsCache dnsCache) {
        Promise<List<InetAddress>> promiseNewPromise = executor().newPromise();
        doResolveAllUncached(str, dnsRecordArr, promiseNewPromise, dnsCache);
        promiseNewPromise.addListener((GenericFutureListener<? extends Future<? super List<InetAddress>>>) new FutureListener<List<InetAddress>>() { // from class: io.netty.resolver.dns.DnsNameResolver.4
            @Override // io.netty.util.concurrent.GenericFutureListener
            public void operationComplete(Future<List<InetAddress>> future) {
                if (future.isSuccess()) {
                    DnsNameResolver.trySuccess(promise, future.getNow().get(0));
                } else {
                    DnsNameResolver.tryFailure(promise, future.cause());
                }
            }
        });
    }

    private static String hostname(String str) {
        String ascii = IDN.toASCII(str);
        return (!StringUtil.endsWith(str, '.') || StringUtil.endsWith(ascii, '.')) ? ascii : a.t(ascii, DefaultDnsRecordDecoder.ROOT);
    }

    public static boolean isTimeoutError(Throwable th) {
        return th != null && (th.getCause() instanceof DnsNameResolverTimeoutException);
    }

    public static boolean isTransportOrTimeoutError(Throwable th) {
        return th != null && (th.getCause() instanceof DnsNameResolverException);
    }

    private InetAddress loopbackAddress() {
        return preferredAddressType().localhost();
    }

    private InetSocketAddress nextNameServerAddress() {
        return this.nameServerAddrStream.get().next();
    }

    private Future<List<DnsRecord>> resolveAll(DnsQuestion dnsQuestion, DnsRecord[] dnsRecordArr, Promise<List<DnsRecord>> promise) {
        InetAddress inetAddressResolveHostsFileEntry;
        ByteBuf byteBufWrappedBuffer;
        ByteBuf byteBuf;
        ObjectUtil.checkNotNull(dnsQuestion, "question");
        ObjectUtil.checkNotNull(promise, "promise");
        DnsRecordType dnsRecordTypeType = dnsQuestion.type();
        String strName = dnsQuestion.name();
        DnsRecordType dnsRecordType = DnsRecordType.A;
        if ((dnsRecordTypeType == dnsRecordType || dnsRecordTypeType == DnsRecordType.AAAA) && (inetAddressResolveHostsFileEntry = resolveHostsFileEntry(strName)) != null) {
            if (inetAddressResolveHostsFileEntry instanceof Inet4Address) {
                if (dnsRecordTypeType == dnsRecordType) {
                    byteBufWrappedBuffer = Unpooled.wrappedBuffer(inetAddressResolveHostsFileEntry.getAddress());
                    byteBuf = byteBufWrappedBuffer;
                }
                byteBuf = null;
            } else {
                if ((inetAddressResolveHostsFileEntry instanceof Inet6Address) && dnsRecordTypeType == DnsRecordType.AAAA) {
                    byteBufWrappedBuffer = Unpooled.wrappedBuffer(inetAddressResolveHostsFileEntry.getAddress());
                    byteBuf = byteBufWrappedBuffer;
                }
                byteBuf = null;
            }
            if (byteBuf != null) {
                trySuccess(promise, Collections.singletonList(new DefaultDnsRawRecord(strName, dnsRecordTypeType, 86400L, byteBuf)));
                return promise;
            }
        }
        new DnsRecordResolveContext(this, dnsQuestion, dnsRecordArr, this.dnsServerAddressStreamProvider.nameServerAddressStream(strName)).resolve(promise);
        return promise;
    }

    private InetAddress resolveHostsFileEntry(String str) {
        HostsFileEntriesResolver hostsFileEntriesResolver = this.hostsFileEntriesResolver;
        if (hostsFileEntriesResolver == null) {
            return null;
        }
        InetAddress inetAddressAddress = hostsFileEntriesResolver.address(str, this.resolvedAddressTypes);
        return (inetAddressAddress == null && PlatformDependent.isWindows() && LOCALHOST.equalsIgnoreCase(str)) ? LOCALHOST_ADDRESS : inetAddressAddress;
    }

    private static DnsRecord[] toArray(Iterable<DnsRecord> iterable, boolean z2) {
        Object[] array;
        ObjectUtil.checkNotNull(iterable, "additionals");
        if (iterable instanceof Collection) {
            Collection collection = (Collection) iterable;
            Iterator<DnsRecord> it = iterable.iterator();
            while (it.hasNext()) {
                validateAdditional(it.next(), z2);
            }
            array = collection.toArray(new DnsRecord[collection.size()]);
        } else {
            Iterator<DnsRecord> it2 = iterable.iterator();
            if (!it2.hasNext()) {
                return EMPTY_ADDITIONALS;
            }
            ArrayList arrayList = new ArrayList();
            do {
                DnsRecord next = it2.next();
                validateAdditional(next, z2);
                arrayList.add(next);
            } while (it2.hasNext());
            array = arrayList.toArray(new DnsRecord[arrayList.size()]);
        }
        return (DnsRecord[]) array;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void tryFailure(Promise<?> promise, Throwable th) {
        if (promise.tryFailure(th)) {
            return;
        }
        logger.warn("Failed to notify failure to a promise: {}", promise, th);
    }

    public static <T> void trySuccess(Promise<T> promise, T t2) {
        if (promise.trySuccess(t2)) {
            return;
        }
        logger.warn("Failed to notify success ({}) to a promise: {}", t2, promise);
    }

    private static void validateAdditional(DnsRecord dnsRecord, boolean z2) {
        ObjectUtil.checkNotNull(dnsRecord, "record");
        if (z2 && (dnsRecord instanceof DnsRawRecord)) {
            throw new IllegalArgumentException("DnsRawRecord implementations not allowed: " + dnsRecord);
        }
    }

    public DnsCache authoritativeDnsServerCache() {
        return this.authoritativeDnsServerCache;
    }

    @Override // io.netty.resolver.SimpleNameResolver, io.netty.resolver.NameResolver, java.io.Closeable, java.lang.AutoCloseable
    public void close() {
        if (this.ch.isOpen()) {
            this.ch.close();
        }
    }

    public final DnsQueryLifecycleObserverFactory dnsQueryLifecycleObserverFactory() {
        return this.dnsQueryLifecycleObserverFactory;
    }

    public int dnsRedirectPort(InetAddress inetAddress) {
        return 53;
    }

    @Override // io.netty.resolver.SimpleNameResolver
    public void doResolve(String str, Promise<InetAddress> promise) throws UnknownHostException {
        doResolve(str, EMPTY_ADDITIONALS, promise, this.resolveCache);
    }

    public void doResolve(String str, DnsRecord[] dnsRecordArr, Promise<InetAddress> promise, DnsCache dnsCache) throws UnknownHostException {
        InetAddress inetAddressLoopbackAddress;
        if (str == null || str.isEmpty()) {
            inetAddressLoopbackAddress = loopbackAddress();
        } else {
            byte[] bArrCreateByteArrayFromIpAddressString = NetUtil.createByteArrayFromIpAddressString(str);
            if (bArrCreateByteArrayFromIpAddressString == null) {
                String strHostname = hostname(str);
                InetAddress inetAddressResolveHostsFileEntry = resolveHostsFileEntry(strHostname);
                if (inetAddressResolveHostsFileEntry != null) {
                    promise.setSuccess(inetAddressResolveHostsFileEntry);
                    return;
                } else {
                    if (doResolveCached(strHostname, dnsRecordArr, promise, dnsCache)) {
                        return;
                    }
                    doResolveUncached(strHostname, dnsRecordArr, promise, dnsCache);
                    return;
                }
            }
            inetAddressLoopbackAddress = InetAddress.getByAddress(bArrCreateByteArrayFromIpAddressString);
        }
        promise.setSuccess(inetAddressLoopbackAddress);
    }

    @Override // io.netty.resolver.SimpleNameResolver
    public void doResolveAll(String str, Promise<List<InetAddress>> promise) throws UnknownHostException {
        doResolveAll(str, EMPTY_ADDITIONALS, promise, this.resolveCache);
    }

    public void doResolveAll(String str, DnsRecord[] dnsRecordArr, Promise<List<InetAddress>> promise, DnsCache dnsCache) throws UnknownHostException {
        InetAddress inetAddressLoopbackAddress;
        List<InetAddress> listSingletonList;
        if (str == null || str.isEmpty()) {
            inetAddressLoopbackAddress = loopbackAddress();
        } else {
            byte[] bArrCreateByteArrayFromIpAddressString = NetUtil.createByteArrayFromIpAddressString(str);
            if (bArrCreateByteArrayFromIpAddressString == null) {
                String strHostname = hostname(str);
                InetAddress inetAddressResolveHostsFileEntry = resolveHostsFileEntry(strHostname);
                if (inetAddressResolveHostsFileEntry != null) {
                    listSingletonList = Collections.singletonList(inetAddressResolveHostsFileEntry);
                    promise.setSuccess(listSingletonList);
                } else {
                    if (doResolveAllCached(strHostname, dnsRecordArr, promise, dnsCache)) {
                        return;
                    }
                    doResolveAllUncached(strHostname, dnsRecordArr, promise, dnsCache);
                    return;
                }
            }
            inetAddressLoopbackAddress = InetAddress.getByAddress(bArrCreateByteArrayFromIpAddressString);
        }
        listSingletonList = Collections.singletonList(inetAddressLoopbackAddress);
        promise.setSuccess(listSingletonList);
    }

    @Override // io.netty.resolver.SimpleNameResolver
    public EventLoop executor() {
        return (EventLoop) super.executor();
    }

    public HostsFileEntriesResolver hostsFileEntriesResolver() {
        return this.hostsFileEntriesResolver;
    }

    public final boolean isDecodeIdn() {
        return this.decodeIdn;
    }

    public boolean isOptResourceEnabled() {
        return this.optResourceEnabled;
    }

    public boolean isRecursionDesired() {
        return this.recursionDesired;
    }

    public int maxPayloadSize() {
        return this.maxPayloadSize;
    }

    public int maxQueriesPerResolve() {
        return this.maxQueriesPerResolve;
    }

    public final int ndots() {
        return this.ndots;
    }

    public final InternetProtocolFamily preferredAddressType() {
        return this.preferredAddressType;
    }

    public Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query(DnsQuestion dnsQuestion) {
        return query(nextNameServerAddress(), dnsQuestion);
    }

    public Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query(DnsQuestion dnsQuestion, Promise<AddressedEnvelope<? extends DnsResponse, InetSocketAddress>> promise) {
        return query(nextNameServerAddress(), dnsQuestion, Collections.emptyList(), promise);
    }

    public Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query(DnsQuestion dnsQuestion, Iterable<DnsRecord> iterable) {
        return query(nextNameServerAddress(), dnsQuestion, iterable);
    }

    public Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query(InetSocketAddress inetSocketAddress, DnsQuestion dnsQuestion) {
        return query0(inetSocketAddress, dnsQuestion, EMPTY_ADDITIONALS, this.ch.eventLoop().newPromise());
    }

    public Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query(InetSocketAddress inetSocketAddress, DnsQuestion dnsQuestion, Promise<AddressedEnvelope<? extends DnsResponse, InetSocketAddress>> promise) {
        return query0(inetSocketAddress, dnsQuestion, EMPTY_ADDITIONALS, promise);
    }

    public Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query(InetSocketAddress inetSocketAddress, DnsQuestion dnsQuestion, Iterable<DnsRecord> iterable) {
        return query0(inetSocketAddress, dnsQuestion, toArray(iterable, false), this.ch.eventLoop().newPromise());
    }

    public Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query(InetSocketAddress inetSocketAddress, DnsQuestion dnsQuestion, Iterable<DnsRecord> iterable, Promise<AddressedEnvelope<? extends DnsResponse, InetSocketAddress>> promise) {
        return query0(inetSocketAddress, dnsQuestion, toArray(iterable, false), promise);
    }

    public final Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query0(InetSocketAddress inetSocketAddress, DnsQuestion dnsQuestion, DnsRecord[] dnsRecordArr, ChannelPromise channelPromise, Promise<AddressedEnvelope<? extends DnsResponse, InetSocketAddress>> promise) {
        Promise<AddressedEnvelope<DnsResponse, InetSocketAddress>> promiseCast = cast((Promise) ObjectUtil.checkNotNull(promise, "promise"));
        try {
            new DnsQueryContext(this, inetSocketAddress, dnsQuestion, dnsRecordArr, promiseCast).query(channelPromise);
            return promiseCast;
        } catch (Exception e2) {
            return promiseCast.setFailure(e2);
        }
    }

    public final Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> query0(InetSocketAddress inetSocketAddress, DnsQuestion dnsQuestion, DnsRecord[] dnsRecordArr, Promise<AddressedEnvelope<? extends DnsResponse, InetSocketAddress>> promise) {
        return query0(inetSocketAddress, dnsQuestion, dnsRecordArr, this.ch.newPromise(), promise);
    }

    public long queryTimeoutMillis() {
        return this.queryTimeoutMillis;
    }

    public final Future<InetAddress> resolve(String str, Iterable<DnsRecord> iterable) {
        return resolve(str, iterable, executor().newPromise());
    }

    public final Future<InetAddress> resolve(String str, Iterable<DnsRecord> iterable, Promise<InetAddress> promise) {
        ObjectUtil.checkNotNull(promise, "promise");
        try {
            doResolve(str, toArray(iterable, true), promise, this.resolveCache);
            return promise;
        } catch (Exception e2) {
            return promise.setFailure(e2);
        }
    }

    public final Future<List<DnsRecord>> resolveAll(DnsQuestion dnsQuestion) {
        return resolveAll(dnsQuestion, EMPTY_ADDITIONALS, executor().newPromise());
    }

    public final Future<List<DnsRecord>> resolveAll(DnsQuestion dnsQuestion, Iterable<DnsRecord> iterable) {
        return resolveAll(dnsQuestion, iterable, executor().newPromise());
    }

    public final Future<List<DnsRecord>> resolveAll(DnsQuestion dnsQuestion, Iterable<DnsRecord> iterable, Promise<List<DnsRecord>> promise) {
        return resolveAll(dnsQuestion, toArray(iterable, true), promise);
    }

    public final Future<List<InetAddress>> resolveAll(String str, Iterable<DnsRecord> iterable) {
        return resolveAll(str, iterable, executor().newPromise());
    }

    public final Future<List<InetAddress>> resolveAll(String str, Iterable<DnsRecord> iterable, Promise<List<InetAddress>> promise) {
        ObjectUtil.checkNotNull(promise, "promise");
        try {
            doResolveAll(str, toArray(iterable, true), promise, this.resolveCache);
            return promise;
        } catch (Exception e2) {
            return promise.setFailure(e2);
        }
    }

    public DnsCache resolveCache() {
        return this.resolveCache;
    }

    public final DnsRecordType[] resolveRecordTypes() {
        return this.resolveRecordTypes;
    }

    public ResolvedAddressTypes resolvedAddressTypes() {
        return this.resolvedAddressTypes;
    }

    public InternetProtocolFamily[] resolvedInternetProtocolFamiliesUnsafe() {
        return this.resolvedInternetProtocolFamilies;
    }

    public final String[] searchDomains() {
        return this.searchDomains;
    }

    public final boolean supportsAAAARecords() {
        return this.supportsAAAARecords;
    }

    public final boolean supportsARecords() {
        return this.supportsARecords;
    }

    public DnsServerAddressStream uncachedRedirectDnsServerStream(List<InetSocketAddress> list) {
        return DnsServerAddresses.sequential(list).stream();
    }
}