package io.netty.resolver.dns;

import g.a.a.a.a;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufHolder;
import io.netty.channel.AddressedEnvelope;
import io.netty.channel.ChannelPromise;
import io.netty.channel.EventLoop;
import io.netty.handler.codec.CorruptedFrameException;
import io.netty.handler.codec.dns.DefaultDnsQuestion;
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.handler.codec.dns.DnsResponseCode;
import io.netty.handler.codec.dns.DnsSection;
import io.netty.util.ReferenceCountUtil;
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.ThrowableUtil;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

/* JADX INFO: loaded from: classes.dex */
public abstract class DnsResolveContext<T> {
    public static final /* synthetic */ boolean $assertionsDisabled = false;
    private final DnsRecord[] additionals;
    private int allowedQueries;
    private final int dnsClass;
    private final DnsRecordType[] expectedTypes;
    private List<T> finalResult;
    private final String hostname;
    private final int maxAllowedQueries;
    private final DnsServerAddressStream nameServerAddrs;
    public final DnsNameResolver parent;
    private final Set<Future<AddressedEnvelope<DnsResponse, InetSocketAddress>>> queriesInProgress = Collections.newSetFromMap(new IdentityHashMap());
    private boolean triedCNAME;
    private static final FutureListener<AddressedEnvelope<DnsResponse, InetSocketAddress>> RELEASE_RESPONSE = new FutureListener<AddressedEnvelope<DnsResponse, InetSocketAddress>>() { // from class: io.netty.resolver.dns.DnsResolveContext.1
        @Override // io.netty.util.concurrent.GenericFutureListener
        public void operationComplete(Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> future) {
            if (future.isSuccess()) {
                future.getNow().release();
            }
        }
    };
    private static final RuntimeException NXDOMAIN_QUERY_FAILED_EXCEPTION = (RuntimeException) ThrowableUtil.unknownStackTrace(new RuntimeException("No answer found and NXDOMAIN response code returned"), DnsResolveContext.class, "onResponse(..)");
    private static final RuntimeException CNAME_NOT_FOUND_QUERY_FAILED_EXCEPTION = (RuntimeException) ThrowableUtil.unknownStackTrace(new RuntimeException("No matching CNAME record found"), DnsResolveContext.class, "onResponseCNAME(..)");
    private static final RuntimeException NO_MATCHING_RECORD_QUERY_FAILED_EXCEPTION = (RuntimeException) ThrowableUtil.unknownStackTrace(new RuntimeException("No matching record type found"), DnsResolveContext.class, "onResponseAorAAAA(..)");
    private static final RuntimeException UNRECOGNIZED_TYPE_QUERY_FAILED_EXCEPTION = (RuntimeException) ThrowableUtil.unknownStackTrace(new RuntimeException("Response type was unrecognized"), DnsResolveContext.class, "onResponse(..)");
    private static final RuntimeException NAME_SERVERS_EXHAUSTED_EXCEPTION = (RuntimeException) ThrowableUtil.unknownStackTrace(new RuntimeException("No name servers returned an answer"), DnsResolveContext.class, "tryToFinishResolve(..)");

    public static final class AuthoritativeNameServer {
        public final String domainName;
        public final int dots;
        public AuthoritativeNameServer next;
        public final String nsName;
        public boolean removed;

        public AuthoritativeNameServer(int i2, String str, String str2) {
            this.dots = i2;
            this.nsName = str2;
            this.domainName = str;
        }

        public String domainName() {
            return this.domainName;
        }

        public boolean isRootServer() {
            return this.dots == 1;
        }
    }

    public static final class AuthoritativeNameServerList {
        private int count;
        private AuthoritativeNameServer head;
        private final String questionName;

        public AuthoritativeNameServerList(String str) {
            this.questionName = str.toLowerCase(Locale.US);
        }

        public void add(DnsRecord dnsRecord) {
            String strDecodeDomainName;
            int i2;
            if (dnsRecord.type() != DnsRecordType.NS || !(dnsRecord instanceof DnsRawRecord) || this.questionName.length() < dnsRecord.name().length()) {
                return;
            }
            String lowerCase = dnsRecord.name().toLowerCase(Locale.US);
            int i3 = 0;
            int length = lowerCase.length() - 1;
            int length2 = this.questionName.length() - 1;
            while (length >= 0) {
                char cCharAt = lowerCase.charAt(length);
                if (this.questionName.charAt(length2) != cCharAt) {
                    return;
                }
                if (cCharAt == '.') {
                    i3++;
                }
                length--;
                length2--;
            }
            AuthoritativeNameServer authoritativeNameServer = this.head;
            if ((authoritativeNameServer != null && authoritativeNameServer.dots > i3) || (strDecodeDomainName = DnsResolveContext.decodeDomainName(((ByteBufHolder) dnsRecord).content())) == null) {
                return;
            }
            AuthoritativeNameServer authoritativeNameServer2 = this.head;
            if (authoritativeNameServer2 == null || (i2 = authoritativeNameServer2.dots) < i3) {
                this.count = 1;
                this.head = new AuthoritativeNameServer(i3, lowerCase, strDecodeDomainName);
            } else {
                if (i2 != i3) {
                    return;
                }
                while (true) {
                    AuthoritativeNameServer authoritativeNameServer3 = authoritativeNameServer2.next;
                    if (authoritativeNameServer3 == null) {
                        authoritativeNameServer2.next = new AuthoritativeNameServer(i3, lowerCase, strDecodeDomainName);
                        this.count++;
                        return;
                    }
                    authoritativeNameServer2 = authoritativeNameServer3;
                }
            }
        }

        public AuthoritativeNameServer remove(String str) {
            for (AuthoritativeNameServer authoritativeNameServer = this.head; authoritativeNameServer != null; authoritativeNameServer = authoritativeNameServer.next) {
                if (!authoritativeNameServer.removed && authoritativeNameServer.nsName.equalsIgnoreCase(str)) {
                    authoritativeNameServer.removed = true;
                    return authoritativeNameServer;
                }
            }
            return null;
        }

        public int size() {
            return this.count;
        }
    }

    public final class DnsCacheIterable implements Iterable<InetSocketAddress> {
        private final List<? extends DnsCacheEntry> entries;

        public DnsCacheIterable(List<? extends DnsCacheEntry> list) {
            this.entries = list;
        }

        @Override // java.lang.Iterable
        public Iterator<InetSocketAddress> iterator() {
            return new Iterator<InetSocketAddress>() { // from class: io.netty.resolver.dns.DnsResolveContext.DnsCacheIterable.1
                public Iterator<? extends DnsCacheEntry> entryIterator;

                {
                    this.entryIterator = DnsCacheIterable.this.entries.iterator();
                }

                @Override // java.util.Iterator
                public boolean hasNext() {
                    return this.entryIterator.hasNext();
                }

                @Override // java.util.Iterator
                public InetSocketAddress next() {
                    InetAddress inetAddressAddress = this.entryIterator.next().address();
                    return new InetSocketAddress(inetAddressAddress, DnsResolveContext.this.parent.dnsRedirectPort(inetAddressAddress));
                }

                @Override // java.util.Iterator
                public void remove() {
                    this.entryIterator.remove();
                }
            };
        }
    }

    public static final class SearchDomainUnknownHostException extends UnknownHostException {
        private static final long serialVersionUID = -8573510133644997085L;

        /* JADX WARN: Illegal instructions before constructor call */
        public SearchDomainUnknownHostException(Throwable th, String str) {
            StringBuilder sbK = a.K("Search domain query failed. Original hostname: '", str, "' ");
            sbK.append(th.getMessage());
            super(sbK.toString());
            setStackTrace(th.getStackTrace());
            initCause(th.getCause());
        }

        @Override // java.lang.Throwable
        public Throwable fillInStackTrace() {
            return this;
        }
    }

    public DnsResolveContext(DnsNameResolver dnsNameResolver, String str, int i2, DnsRecordType[] dnsRecordTypeArr, DnsRecord[] dnsRecordArr, DnsServerAddressStream dnsServerAddressStream) {
        this.parent = dnsNameResolver;
        this.hostname = str;
        this.dnsClass = i2;
        this.expectedTypes = dnsRecordTypeArr;
        this.additionals = dnsRecordArr;
        this.nameServerAddrs = (DnsServerAddressStream) ObjectUtil.checkNotNull(dnsServerAddressStream, "nameServerAddrs");
        int iMaxQueriesPerResolve = dnsNameResolver.maxQueriesPerResolve();
        this.maxAllowedQueries = iMaxQueriesPerResolve;
        this.allowedQueries = iMaxQueriesPerResolve;
    }

    private void addNameServerToCache(AuthoritativeNameServer authoritativeNameServer, InetAddress inetAddress, long j2) {
        if (authoritativeNameServer.isRootServer()) {
            return;
        }
        this.parent.authoritativeDnsServerCache().cache(authoritativeNameServer.domainName(), this.additionals, inetAddress, j2, this.parent.ch.eventLoop());
    }

    private static Map<String, String> buildAliasMap(DnsResponse dnsResponse) {
        String strDecodeDomainName;
        int iCount = dnsResponse.count(DnsSection.ANSWER);
        HashMap map = null;
        for (int i2 = 0; i2 < iCount; i2++) {
            DnsRecord dnsRecordRecordAt = dnsResponse.recordAt(DnsSection.ANSWER, i2);
            if (dnsRecordRecordAt.type() == DnsRecordType.CNAME && (dnsRecordRecordAt instanceof DnsRawRecord) && (strDecodeDomainName = decodeDomainName(((ByteBufHolder) dnsRecordRecordAt).content())) != null) {
                if (map == null) {
                    map = new HashMap(Math.min(8, iCount));
                }
                String strName = dnsRecordRecordAt.name();
                Locale locale = Locale.US;
                map.put(strName.toLowerCase(locale), strDecodeDomainName.toLowerCase(locale));
            }
        }
        return map != null ? map : Collections.emptyMap();
    }

    public static String decodeDomainName(ByteBuf byteBuf) {
        byteBuf.markReaderIndex();
        try {
            return DefaultDnsRecordDecoder.decodeName(byteBuf);
        } catch (CorruptedFrameException unused) {
            return null;
        } finally {
            byteBuf.resetReaderIndex();
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void doSearchDomainQuery(String str, FutureListener<List<T>> futureListener) {
        DnsResolveContext<T> dnsResolveContextNewResolverContext = newResolverContext(this.parent, str, this.dnsClass, this.expectedTypes, this.additionals, this.nameServerAddrs);
        Promise<List<T>> promiseNewPromise = this.parent.executor().newPromise();
        dnsResolveContextNewResolverContext.internalResolve(promiseNewPromise);
        promiseNewPromise.addListener((GenericFutureListener<? extends Future<? super List<T>>>) futureListener);
    }

    private static AuthoritativeNameServerList extractAuthoritativeNameServers(String str, DnsResponse dnsResponse) {
        int iCount = dnsResponse.count(DnsSection.AUTHORITY);
        if (iCount == 0) {
            return null;
        }
        AuthoritativeNameServerList authoritativeNameServerList = new AuthoritativeNameServerList(str);
        for (int i2 = 0; i2 < iCount; i2++) {
            authoritativeNameServerList.add(dnsResponse.recordAt(DnsSection.AUTHORITY, i2));
        }
        return authoritativeNameServerList;
    }

    private void finishResolve(Promise<List<T>> promise, Throwable th) {
        if (!this.queriesInProgress.isEmpty()) {
            Iterator<Future<AddressedEnvelope<DnsResponse, InetSocketAddress>>> it = this.queriesInProgress.iterator();
            while (it.hasNext()) {
                Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> next = it.next();
                it.remove();
                if (!next.cancel(false)) {
                    next.addListener(RELEASE_RESPONSE);
                }
            }
        }
        List<T> list = this.finalResult;
        if (list != null) {
            DnsNameResolver.trySuccess(promise, list);
            return;
        }
        int i2 = this.maxAllowedQueries - this.allowedQueries;
        StringBuilder sb = new StringBuilder(64);
        sb.append("failed to resolve '");
        sb.append(this.hostname);
        sb.append('\'');
        if (i2 > 1) {
            if (i2 < this.maxAllowedQueries) {
                sb.append(" after ");
                sb.append(i2);
                sb.append(" queries ");
            } else {
                sb.append(". Exceeded max queries per resolve ");
                sb.append(this.maxAllowedQueries);
                sb.append(' ');
            }
        }
        UnknownHostException unknownHostException = new UnknownHostException(sb.toString());
        if (th == null) {
            cache(this.hostname, this.additionals, unknownHostException);
        } else {
            unknownHostException.initCause(th);
        }
        promise.tryFailure(unknownHostException);
    }

    private void followCname(DnsQuestion dnsQuestion, String str, DnsQueryLifecycleObserver dnsQueryLifecycleObserver, Promise<List<T>> promise) {
        DnsServerAddressStream nameServers = getNameServers(str);
        try {
            DnsQuestion dnsQuestionNewQuestion = newQuestion(str, dnsQuestion.type());
            query(nameServers, 0, dnsQuestionNewQuestion, dnsQueryLifecycleObserver.queryCNAMEd(dnsQuestionNewQuestion), promise, null);
        } catch (Throwable th) {
            dnsQueryLifecycleObserver.queryFailed(th);
            PlatformDependent.throwException(th);
        }
    }

    private DnsServerAddressStream getNameServers(String str) {
        DnsServerAddressStream nameServersFromCache = getNameServersFromCache(str);
        return nameServersFromCache == null ? this.nameServerAddrs.duplicate() : nameServersFromCache;
    }

    private DnsServerAddressStream getNameServersFromCache(String str) {
        int length = str.length();
        if (length == 0) {
            return null;
        }
        if (str.charAt(length - 1) != '.') {
            str = a.t(str, DefaultDnsRecordDecoder.ROOT);
        }
        int iIndexOf = str.indexOf(46);
        if (iIndexOf == str.length() - 1) {
            return null;
        }
        while (true) {
            str = str.substring(iIndexOf + 1);
            iIndexOf = str.indexOf(46);
            if (iIndexOf <= 0 || iIndexOf == str.length() - 1) {
                break;
            }
            List<? extends DnsCacheEntry> list = this.parent.authoritativeDnsServerCache().get(str, this.additionals);
            if (list != null && !list.isEmpty()) {
                return DnsServerAddresses.sequential(new DnsCacheIterable(list)).stream();
            }
        }
        return null;
    }

    private boolean handleRedirect(DnsQuestion dnsQuestion, AddressedEnvelope<DnsResponse, InetSocketAddress> addressedEnvelope, DnsQueryLifecycleObserver dnsQueryLifecycleObserver, Promise<List<T>> promise) {
        AuthoritativeNameServerList authoritativeNameServerListExtractAuthoritativeNameServers;
        String strName;
        AuthoritativeNameServer authoritativeNameServerRemove;
        InetAddress inetAddressDecodeAddress;
        DnsResponse dnsResponseContent = addressedEnvelope.content();
        if (dnsResponseContent.count(DnsSection.ANSWER) == 0 && (authoritativeNameServerListExtractAuthoritativeNameServers = extractAuthoritativeNameServers(dnsQuestion.name(), dnsResponseContent)) != null) {
            ArrayList arrayList = new ArrayList(authoritativeNameServerListExtractAuthoritativeNameServers.size());
            int iCount = dnsResponseContent.count(DnsSection.ADDITIONAL);
            for (int i2 = 0; i2 < iCount; i2++) {
                DnsRecord dnsRecordRecordAt = dnsResponseContent.recordAt(DnsSection.ADDITIONAL, i2);
                if ((dnsRecordRecordAt.type() != DnsRecordType.A || this.parent.supportsARecords()) && ((dnsRecordRecordAt.type() != DnsRecordType.AAAA || this.parent.supportsAAAARecords()) && (authoritativeNameServerRemove = authoritativeNameServerListExtractAuthoritativeNameServers.remove((strName = dnsRecordRecordAt.name()))) != null && (inetAddressDecodeAddress = DnsAddressDecoder.decodeAddress(dnsRecordRecordAt, strName, this.parent.isDecodeIdn())) != null)) {
                    arrayList.add(new InetSocketAddress(inetAddressDecodeAddress, this.parent.dnsRedirectPort(inetAddressDecodeAddress)));
                    addNameServerToCache(authoritativeNameServerRemove, inetAddressDecodeAddress, dnsRecordRecordAt.timeToLive());
                }
            }
            if (!arrayList.isEmpty()) {
                query(this.parent.uncachedRedirectDnsServerStream(arrayList), 0, dnsQuestion, dnsQueryLifecycleObserver.queryRedirected(Collections.unmodifiableList(arrayList)), promise, null);
                return true;
            }
        }
        return false;
    }

    private boolean hasNDots() {
        int i2 = 0;
        for (int length = this.hostname.length() - 1; length >= 0; length--) {
            if (this.hostname.charAt(length) == '.' && (i2 = i2 + 1) >= this.parent.ndots()) {
                return true;
            }
        }
        return false;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void internalResolve(Promise<List<T>> promise) {
        DnsServerAddressStream nameServers = getNameServers(this.hostname);
        int length = this.expectedTypes.length - 1;
        for (int i2 = 0; i2 < length; i2++) {
            if (!query(this.hostname, this.expectedTypes[i2], nameServers.duplicate(), promise, (Throwable) null)) {
                return;
            }
        }
        query(this.hostname, this.expectedTypes[length], nameServers, promise, (Throwable) null);
    }

    private DnsQuestion newQuestion(String str, DnsRecordType dnsRecordType) {
        try {
            return new DefaultDnsQuestion(str, dnsRecordType, this.dnsClass);
        } catch (IllegalArgumentException unused) {
            return null;
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:22:0x0060  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private void onExpectedResponse(io.netty.handler.codec.dns.DnsQuestion r16, io.netty.channel.AddressedEnvelope<io.netty.handler.codec.dns.DnsResponse, java.net.InetSocketAddress> r17, io.netty.resolver.dns.DnsQueryLifecycleObserver r18, io.netty.util.concurrent.Promise<java.util.List<T>> r19) {
        /*
            r15 = this;
            r0 = r15
            r1 = r18
            java.lang.Object r2 = r17.content()
            io.netty.handler.codec.dns.DnsResponse r2 = (io.netty.handler.codec.dns.DnsResponse) r2
            java.util.Map r3 = buildAliasMap(r2)
            io.netty.handler.codec.dns.DnsSection r4 = io.netty.handler.codec.dns.DnsSection.ANSWER
            int r4 = r2.count(r4)
            r5 = 0
            r6 = r5
            r7 = r6
        L16:
            if (r6 >= r4) goto L90
            io.netty.handler.codec.dns.DnsSection r8 = io.netty.handler.codec.dns.DnsSection.ANSWER
            io.netty.handler.codec.dns.DnsRecord r8 = r2.recordAt(r8, r6)
            io.netty.handler.codec.dns.DnsRecordType r9 = r8.type()
            io.netty.handler.codec.dns.DnsRecordType[] r10 = r0.expectedTypes
            int r11 = r10.length
            r12 = r5
        L26:
            r13 = 1
            if (r12 >= r11) goto L32
            r14 = r10[r12]
            if (r9 != r14) goto L2f
            r9 = r13
            goto L33
        L2f:
            int r12 = r12 + 1
            goto L26
        L32:
            r9 = r5
        L33:
            if (r9 != 0) goto L36
            goto L8d
        L36:
            java.lang.String r9 = r16.name()
            java.util.Locale r10 = java.util.Locale.US
            java.lang.String r9 = r9.toLowerCase(r10)
            java.lang.String r11 = r8.name()
            java.lang.String r10 = r11.toLowerCase(r10)
            boolean r11 = r10.equals(r9)
            if (r11 != 0) goto L60
        L4e:
            java.lang.Object r9 = r3.get(r9)
            java.lang.String r9 = (java.lang.String) r9
            boolean r11 = r10.equals(r9)
            if (r11 == 0) goto L5b
            goto L5d
        L5b:
            if (r9 != 0) goto L4e
        L5d:
            if (r9 != 0) goto L60
            goto L8d
        L60:
            java.lang.String r9 = r0.hostname
            io.netty.handler.codec.dns.DnsRecord[] r10 = r0.additionals
            io.netty.resolver.dns.DnsNameResolver r11 = r0.parent
            io.netty.channel.socket.DatagramChannel r11 = r11.ch
            io.netty.channel.EventLoop r11 = r11.eventLoop()
            java.lang.Object r9 = r15.convertRecord(r8, r9, r10, r11)
            if (r9 != 0) goto L73
            goto L8d
        L73:
            java.util.List<T> r7 = r0.finalResult
            if (r7 != 0) goto L80
            java.util.ArrayList r7 = new java.util.ArrayList
            r10 = 8
            r7.<init>(r10)
            r0.finalResult = r7
        L80:
            java.util.List<T> r7 = r0.finalResult
            r7.add(r9)
            java.lang.String r7 = r0.hostname
            io.netty.handler.codec.dns.DnsRecord[] r10 = r0.additionals
            r15.cache(r7, r10, r8, r9)
            r7 = r13
        L8d:
            int r6 = r6 + 1
            goto L16
        L90:
            if (r7 == 0) goto L96
            r18.querySucceed()
            return
        L96:
            boolean r2 = r3.isEmpty()
            if (r2 == 0) goto La2
            java.lang.RuntimeException r2 = io.netty.resolver.dns.DnsResolveContext.NO_MATCHING_RECORD_QUERY_FAILED_EXCEPTION
            r1.queryFailed(r2)
            goto La9
        La2:
            r2 = r16
            r4 = r19
            r15.onResponseCNAME(r2, r3, r1, r4)
        La9:
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.resolver.dns.DnsResolveContext.onExpectedResponse(io.netty.handler.codec.dns.DnsQuestion, io.netty.channel.AddressedEnvelope, io.netty.resolver.dns.DnsQueryLifecycleObserver, io.netty.util.concurrent.Promise):void");
    }

    private void onResponseCNAME(DnsQuestion dnsQuestion, AddressedEnvelope<DnsResponse, InetSocketAddress> addressedEnvelope, DnsQueryLifecycleObserver dnsQueryLifecycleObserver, Promise<List<T>> promise) {
        onResponseCNAME(dnsQuestion, buildAliasMap(addressedEnvelope.content()), dnsQueryLifecycleObserver, promise);
    }

    private void onResponseCNAME(DnsQuestion dnsQuestion, Map<String, String> map, DnsQueryLifecycleObserver dnsQueryLifecycleObserver, Promise<List<T>> promise) {
        String strRemove;
        String lowerCase = dnsQuestion.name().toLowerCase(Locale.US);
        boolean z2 = false;
        while (!map.isEmpty() && (strRemove = map.remove(lowerCase)) != null) {
            z2 = true;
            lowerCase = strRemove;
        }
        if (z2) {
            followCname(dnsQuestion, lowerCase, dnsQueryLifecycleObserver, promise);
        } else {
            dnsQueryLifecycleObserver.queryFailed(CNAME_NOT_FOUND_QUERY_FAILED_EXCEPTION);
        }
    }

    private void query(final DnsServerAddressStream dnsServerAddressStream, final int i2, final DnsQuestion dnsQuestion, final DnsQueryLifecycleObserver dnsQueryLifecycleObserver, final Promise<List<T>> promise, Throwable th) {
        if (i2 >= dnsServerAddressStream.size() || this.allowedQueries == 0 || promise.isCancelled()) {
            tryToFinishResolve(dnsServerAddressStream, i2, dnsQuestion, dnsQueryLifecycleObserver, promise, th);
            return;
        }
        this.allowedQueries--;
        InetSocketAddress next = dnsServerAddressStream.next();
        ChannelPromise channelPromiseNewPromise = this.parent.ch.newPromise();
        DnsNameResolver dnsNameResolver = this.parent;
        Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> futureQuery0 = dnsNameResolver.query0(next, dnsQuestion, this.additionals, channelPromiseNewPromise, dnsNameResolver.ch.eventLoop().newPromise());
        this.queriesInProgress.add(futureQuery0);
        dnsQueryLifecycleObserver.queryWritten(next, channelPromiseNewPromise);
        futureQuery0.addListener(new FutureListener<AddressedEnvelope<DnsResponse, InetSocketAddress>>() { // from class: io.netty.resolver.dns.DnsResolveContext.3
            @Override // io.netty.util.concurrent.GenericFutureListener
            public void operationComplete(Future<AddressedEnvelope<DnsResponse, InetSocketAddress>> future) {
                DnsResolveContext.this.queriesInProgress.remove(future);
                if (promise.isDone() || future.isCancelled()) {
                    dnsQueryLifecycleObserver.queryCancelled(DnsResolveContext.this.allowedQueries);
                    AddressedEnvelope<DnsResponse, InetSocketAddress> now = future.getNow();
                    if (now != null) {
                        now.release();
                        return;
                    }
                    return;
                }
                Throwable thCause = future.cause();
                try {
                    if (thCause == null) {
                        DnsResolveContext.this.onResponse(dnsServerAddressStream, i2, dnsQuestion, future.getNow(), dnsQueryLifecycleObserver, promise);
                    } else {
                        dnsQueryLifecycleObserver.queryFailed(thCause);
                        DnsResolveContext.this.query(dnsServerAddressStream, i2 + 1, dnsQuestion, promise, thCause);
                    }
                } finally {
                    DnsResolveContext.this.tryToFinishResolve(dnsServerAddressStream, i2, dnsQuestion, NoopDnsQueryLifecycleObserver.INSTANCE, promise, thCause);
                }
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void query(DnsServerAddressStream dnsServerAddressStream, int i2, DnsQuestion dnsQuestion, Promise<List<T>> promise, Throwable th) {
        query(dnsServerAddressStream, i2, dnsQuestion, this.parent.dnsQueryLifecycleObserverFactory().newDnsQueryLifecycleObserver(dnsQuestion), promise, th);
    }

    private boolean query(String str, DnsRecordType dnsRecordType, DnsServerAddressStream dnsServerAddressStream, Promise<List<T>> promise, Throwable th) {
        DnsQuestion dnsQuestionNewQuestion = newQuestion(str, dnsRecordType);
        if (dnsQuestionNewQuestion == null) {
            return false;
        }
        query(dnsServerAddressStream, 0, dnsQuestionNewQuestion, promise, th);
        return true;
    }

    public abstract void cache(String str, DnsRecord[] dnsRecordArr, DnsRecord dnsRecord, T t2);

    public abstract void cache(String str, DnsRecord[] dnsRecordArr, UnknownHostException unknownHostException);

    public abstract boolean containsExpectedResult(List<T> list);

    public abstract T convertRecord(DnsRecord dnsRecord, String str, DnsRecord[] dnsRecordArr, EventLoop eventLoop);

    public abstract DnsResolveContext<T> newResolverContext(DnsNameResolver dnsNameResolver, String str, int i2, DnsRecordType[] dnsRecordTypeArr, DnsRecord[] dnsRecordArr, DnsServerAddressStream dnsServerAddressStream);

    public void onResponse(DnsServerAddressStream dnsServerAddressStream, int i2, DnsQuestion dnsQuestion, AddressedEnvelope<DnsResponse, InetSocketAddress> addressedEnvelope, DnsQueryLifecycleObserver dnsQueryLifecycleObserver, Promise<List<T>> promise) {
        try {
            DnsResponseCode dnsResponseCodeCode = addressedEnvelope.content().code();
            if (dnsResponseCodeCode != DnsResponseCode.NOERROR) {
                if (dnsResponseCodeCode != DnsResponseCode.NXDOMAIN) {
                    query(dnsServerAddressStream, i2 + 1, dnsQuestion, dnsQueryLifecycleObserver.queryNoAnswer(dnsResponseCodeCode), promise, null);
                } else {
                    dnsQueryLifecycleObserver.queryFailed(NXDOMAIN_QUERY_FAILED_EXCEPTION);
                }
                return;
            }
            if (handleRedirect(dnsQuestion, addressedEnvelope, dnsQueryLifecycleObserver, promise)) {
                return;
            }
            DnsRecordType dnsRecordTypeType = dnsQuestion.type();
            if (dnsRecordTypeType == DnsRecordType.CNAME) {
                onResponseCNAME(dnsQuestion, addressedEnvelope, dnsQueryLifecycleObserver, promise);
                return;
            }
            for (DnsRecordType dnsRecordType : this.expectedTypes) {
                if (dnsRecordTypeType == dnsRecordType) {
                    onExpectedResponse(dnsQuestion, addressedEnvelope, dnsQueryLifecycleObserver, promise);
                    return;
                }
            }
            dnsQueryLifecycleObserver.queryFailed(UNRECOGNIZED_TYPE_QUERY_FAILED_EXCEPTION);
        } finally {
            ReferenceCountUtil.safeRelease(addressedEnvelope);
        }
    }

    public void resolve(Promise<List<T>> promise) {
        String str;
        String[] strArrSearchDomains = this.parent.searchDomains();
        if (strArrSearchDomains.length == 0 || this.parent.ndots() == 0 || StringUtil.endsWith(this.hostname, '.')) {
            internalResolve(promise);
            return;
        }
        boolean zHasNDots = hasNDots();
        if (zHasNDots) {
            str = this.hostname;
        } else {
            str = this.hostname + '.' + strArrSearchDomains[0];
        }
        doSearchDomainQuery(str, new FutureListener<List<T>>(!zHasNDots ? 1 : 0, promise, strArrSearchDomains, zHasNDots) { // from class: io.netty.resolver.dns.DnsResolveContext.2
            private int searchDomainIdx;
            public final /* synthetic */ int val$initialSearchDomainIdx;
            public final /* synthetic */ Promise val$promise;
            public final /* synthetic */ String[] val$searchDomains;
            public final /* synthetic */ boolean val$startWithoutSearchDomain;

            {
                this.val$initialSearchDomainIdx = i;
                this.val$promise = promise;
                this.val$searchDomains = strArrSearchDomains;
                this.val$startWithoutSearchDomain = zHasNDots;
                this.searchDomainIdx = i;
            }

            @Override // io.netty.util.concurrent.GenericFutureListener
            public void operationComplete(Future<List<T>> future) {
                Promise promise2;
                SearchDomainUnknownHostException searchDomainUnknownHostException;
                Throwable thCause = future.cause();
                if (thCause == null) {
                    this.val$promise.trySuccess(future.getNow());
                    return;
                }
                if (DnsNameResolver.isTransportOrTimeoutError(thCause)) {
                    promise2 = this.val$promise;
                    searchDomainUnknownHostException = new SearchDomainUnknownHostException(thCause, DnsResolveContext.this.hostname);
                } else {
                    if (this.searchDomainIdx < this.val$searchDomains.length) {
                        DnsResolveContext dnsResolveContext = DnsResolveContext.this;
                        StringBuilder sb = new StringBuilder();
                        sb.append(DnsResolveContext.this.hostname);
                        sb.append('.');
                        String[] strArr = this.val$searchDomains;
                        int i2 = this.searchDomainIdx;
                        this.searchDomainIdx = i2 + 1;
                        sb.append(strArr[i2]);
                        dnsResolveContext.doSearchDomainQuery(sb.toString(), this);
                        return;
                    }
                    if (!this.val$startWithoutSearchDomain) {
                        DnsResolveContext.this.internalResolve(this.val$promise);
                        return;
                    } else {
                        promise2 = this.val$promise;
                        searchDomainUnknownHostException = new SearchDomainUnknownHostException(thCause, DnsResolveContext.this.hostname);
                    }
                }
                promise2.tryFailure(searchDomainUnknownHostException);
            }
        });
    }

    public void tryToFinishResolve(DnsServerAddressStream dnsServerAddressStream, int i2, DnsQuestion dnsQuestion, DnsQueryLifecycleObserver dnsQueryLifecycleObserver, Promise<List<T>> promise, Throwable th) {
        if (!this.queriesInProgress.isEmpty()) {
            dnsQueryLifecycleObserver.queryCancelled(this.allowedQueries);
            List<T> list = this.finalResult;
            if (list == null || !containsExpectedResult(list)) {
                return;
            }
            finishResolve(promise, th);
            return;
        }
        if (this.finalResult != null) {
            dnsQueryLifecycleObserver.queryCancelled(this.allowedQueries);
        } else {
            if (i2 < dnsServerAddressStream.size()) {
                int i3 = 1 + i2;
                if (dnsQueryLifecycleObserver == NoopDnsQueryLifecycleObserver.INSTANCE) {
                    query(dnsServerAddressStream, i3, dnsQuestion, promise, th);
                    return;
                } else {
                    query(dnsServerAddressStream, i3, dnsQuestion, dnsQueryLifecycleObserver, promise, th);
                    return;
                }
            }
            dnsQueryLifecycleObserver.queryFailed(NAME_SERVERS_EXHAUSTED_EXCEPTION);
            if (th == null && !this.triedCNAME) {
                this.triedCNAME = true;
                String str = this.hostname;
                query(str, DnsRecordType.CNAME, getNameServers(str), promise, (Throwable) null);
                return;
            }
        }
        finishResolve(promise, th);
    }
}