package io.netty.resolver.dns;

import io.netty.util.NetUtil;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.SocketUtils;
import io.netty.util.internal.StringUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/* JADX INFO: loaded from: classes.dex */
public final class UnixResolverDnsServerAddressStreamProvider implements DnsServerAddressStreamProvider {
    public static final int DEFAULT_NDOTS = 1;
    private static final String DOMAIN_ROW_LABEL = "domain";
    private static final String ETC_RESOLVER_DIR = "/etc/resolver";
    private static final String ETC_RESOLV_CONF_FILE = "/etc/resolv.conf";
    private static final String NAMESERVER_ROW_LABEL = "nameserver";
    private static final String NDOTS_LABEL = "ndots:";
    private static final String OPTIONS_ROW_LABEL = "options";
    private static final String PORT_ROW_LABEL = "port";
    private static final String SORTLIST_ROW_LABEL = "sortlist";
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) UnixResolverDnsServerAddressStreamProvider.class);
    private final DnsServerAddresses defaultNameServerAddresses;
    private final Map<String, DnsServerAddresses> domainToNameServerStreamMap;

    public UnixResolverDnsServerAddressStreamProvider(File file, File... fileArr) throws Throwable {
        Map<? extends String, ? extends DnsServerAddresses> map = parse((File) ObjectUtil.checkNotNull(file, "etcResolvConf"));
        boolean z2 = (fileArr == null || fileArr.length == 0) ? false : true;
        Map<String, DnsServerAddresses> map2 = z2 ? parse(fileArr) : map;
        this.domainToNameServerStreamMap = map2;
        DnsServerAddresses dnsServerAddresses = map.get(file.getName());
        if (dnsServerAddresses == null) {
            Collection<? extends DnsServerAddresses> collectionValues = map.values();
            if (collectionValues.isEmpty()) {
                throw new IllegalArgumentException(file + " didn't provide any name servers");
            }
            this.defaultNameServerAddresses = collectionValues.iterator().next();
        } else {
            this.defaultNameServerAddresses = dnsServerAddresses;
        }
        if (z2) {
            map2.putAll(map);
        }
    }

    public UnixResolverDnsServerAddressStreamProvider(String str, String str2) {
        this(str == null ? null : new File(str), str2 != null ? new File(str2).listFiles() : null);
    }

    private boolean mayOverrideNameServers() {
        return (this.domainToNameServerStreamMap.isEmpty() && this.defaultNameServerAddresses.stream().next() == null) ? false : true;
    }

    private static Map<String, DnsServerAddresses> parse(File... fileArr) throws Throwable {
        int i2;
        char c2;
        int i3;
        char cCharAt;
        HashMap map = new HashMap(fileArr.length << 1);
        int length = fileArr.length;
        int i4 = 0;
        int i5 = 0;
        while (i5 < length) {
            File file = fileArr[i5];
            if (file.isFile()) {
                FileReader fileReader = new FileReader(file);
                BufferedReader bufferedReader = null;
                try {
                    BufferedReader bufferedReader2 = new BufferedReader(fileReader);
                    try {
                        char c3 = 2;
                        ArrayList arrayList = new ArrayList(2);
                        String name = file.getName();
                        int i6 = 53;
                        while (true) {
                            String line = bufferedReader2.readLine();
                            if (line != null) {
                                String strTrim = line.trim();
                                if (strTrim.isEmpty() || (cCharAt = strTrim.charAt(i4)) == '#' || cCharAt == ';') {
                                    c2 = c3;
                                    i3 = i4;
                                } else if (strTrim.startsWith(NAMESERVER_ROW_LABEL)) {
                                    int iIndexOfNonWhiteSpace = StringUtil.indexOfNonWhiteSpace(strTrim, 10);
                                    if (iIndexOfNonWhiteSpace < 0) {
                                        throw new IllegalArgumentException("error parsing label nameserver in file " + file + ". value: " + strTrim);
                                    }
                                    String strSubstring = strTrim.substring(iIndexOfNonWhiteSpace);
                                    if (NetUtil.isValidIpV4Address(strSubstring) || NetUtil.isValidIpV6Address(strSubstring)) {
                                        i3 = i4;
                                    } else {
                                        int iLastIndexOf = strSubstring.lastIndexOf(46);
                                        int i7 = iLastIndexOf + 1;
                                        if (i7 >= strSubstring.length()) {
                                            throw new IllegalArgumentException("error parsing label nameserver in file " + file + ". invalid IP value: " + strTrim);
                                        }
                                        int i8 = Integer.parseInt(strSubstring.substring(i7));
                                        i3 = 0;
                                        strSubstring = strSubstring.substring(0, iLastIndexOf);
                                        i6 = i8;
                                    }
                                    arrayList.add(SocketUtils.socketAddress(strSubstring, i6));
                                    c2 = 2;
                                } else {
                                    i3 = i4;
                                    if (strTrim.startsWith(DOMAIN_ROW_LABEL)) {
                                        int iIndexOfNonWhiteSpace2 = StringUtil.indexOfNonWhiteSpace(strTrim, 6);
                                        if (iIndexOfNonWhiteSpace2 < 0) {
                                            throw new IllegalArgumentException("error parsing label domain in file " + file + " value: " + strTrim);
                                        }
                                        String strSubstring2 = strTrim.substring(iIndexOfNonWhiteSpace2);
                                        if (!arrayList.isEmpty()) {
                                            putIfAbsent(map, strSubstring2, arrayList);
                                        }
                                        c2 = 2;
                                        arrayList = new ArrayList(2);
                                        name = strSubstring2;
                                    } else {
                                        c2 = 2;
                                        if (strTrim.startsWith("port")) {
                                            int iIndexOfNonWhiteSpace3 = StringUtil.indexOfNonWhiteSpace(strTrim, 4);
                                            if (iIndexOfNonWhiteSpace3 < 0) {
                                                throw new IllegalArgumentException("error parsing label port in file " + file + " value: " + strTrim);
                                            }
                                            i6 = Integer.parseInt(strTrim.substring(iIndexOfNonWhiteSpace3));
                                        } else if (strTrim.startsWith(SORTLIST_ROW_LABEL)) {
                                            logger.info("row type {} not supported. ignoring line: {}", SORTLIST_ROW_LABEL, strTrim);
                                        }
                                    }
                                }
                                i4 = i3;
                                c3 = c2;
                            } else {
                                i2 = i4;
                                if (!arrayList.isEmpty()) {
                                    putIfAbsent(map, name, arrayList);
                                }
                                bufferedReader2.close();
                            }
                        }
                    } catch (Throwable th) {
                        th = th;
                        bufferedReader = bufferedReader2;
                        if (bufferedReader == null) {
                            fileReader.close();
                        } else {
                            bufferedReader.close();
                        }
                        throw th;
                    }
                } catch (Throwable th2) {
                    th = th2;
                }
            } else {
                i2 = i4;
            }
            i5++;
            i4 = i2;
        }
        return map;
    }

    public static int parseEtcResolverFirstNdots() {
        return parseEtcResolverFirstNdots(new File(ETC_RESOLV_CONF_FILE));
    }

    /* JADX WARN: Code restructure failed: missing block: B:10:0x0021, code lost:
    
        r2 = r2 + 6;
        r3 = r5.indexOf(32, r2);
     */
    /* JADX WARN: Code restructure failed: missing block: B:11:0x0029, code lost:
    
        if (r3 >= 0) goto L13;
     */
    /* JADX WARN: Code restructure failed: missing block: B:12:0x002b, code lost:
    
        r3 = r5.length();
     */
    /* JADX WARN: Code restructure failed: missing block: B:13:0x002f, code lost:
    
        r5 = java.lang.Integer.parseInt(r5.substring(r2, r3));
     */
    /* JADX WARN: Code restructure failed: missing block: B:14:0x0037, code lost:
    
        r1.close();
     */
    /* JADX WARN: Code restructure failed: missing block: B:15:0x003a, code lost:
    
        return r5;
     */
    /* JADX WARN: Code restructure failed: missing block: B:8:0x0019, code lost:
    
        r2 = r5.indexOf(io.netty.resolver.dns.UnixResolverDnsServerAddressStreamProvider.NDOTS_LABEL);
     */
    /* JADX WARN: Code restructure failed: missing block: B:9:0x001f, code lost:
    
        if (r2 < 0) goto L16;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static int parseEtcResolverFirstNdots(java.io.File r5) throws java.lang.Throwable {
        /*
            java.io.FileReader r0 = new java.io.FileReader
            r0.<init>(r5)
            r5 = 0
            java.io.BufferedReader r1 = new java.io.BufferedReader     // Catch: java.lang.Throwable -> L42
            r1.<init>(r0)     // Catch: java.lang.Throwable -> L42
        Lb:
            java.lang.String r5 = r1.readLine()     // Catch: java.lang.Throwable -> L40
            if (r5 == 0) goto L3b
            java.lang.String r2 = "options"
            boolean r2 = r5.startsWith(r2)     // Catch: java.lang.Throwable -> L40
            if (r2 == 0) goto Lb
            java.lang.String r2 = "ndots:"
            int r2 = r5.indexOf(r2)     // Catch: java.lang.Throwable -> L40
            if (r2 < 0) goto L3b
            int r2 = r2 + 6
            r3 = 32
            int r3 = r5.indexOf(r3, r2)     // Catch: java.lang.Throwable -> L40
            if (r3 >= 0) goto L2f
            int r3 = r5.length()     // Catch: java.lang.Throwable -> L40
        L2f:
            java.lang.String r5 = r5.substring(r2, r3)     // Catch: java.lang.Throwable -> L40
            int r5 = java.lang.Integer.parseInt(r5)     // Catch: java.lang.Throwable -> L40
            r1.close()
            return r5
        L3b:
            r1.close()
            r5 = 1
            return r5
        L40:
            r5 = move-exception
            goto L46
        L42:
            r1 = move-exception
            r4 = r1
            r1 = r5
            r5 = r4
        L46:
            if (r1 != 0) goto L4c
            r0.close()
            goto L4f
        L4c:
            r1.close()
        L4f:
            throw r5
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.resolver.dns.UnixResolverDnsServerAddressStreamProvider.parseEtcResolverFirstNdots(java.io.File):int");
    }

    public static DnsServerAddressStreamProvider parseSilently() {
        try {
            UnixResolverDnsServerAddressStreamProvider unixResolverDnsServerAddressStreamProvider = new UnixResolverDnsServerAddressStreamProvider(ETC_RESOLV_CONF_FILE, ETC_RESOLVER_DIR);
            return unixResolverDnsServerAddressStreamProvider.mayOverrideNameServers() ? unixResolverDnsServerAddressStreamProvider : DefaultDnsServerAddressStreamProvider.INSTANCE;
        } catch (Exception e2) {
            logger.debug("failed to parse {} and/or {}", ETC_RESOLV_CONF_FILE, ETC_RESOLVER_DIR, e2);
            return DefaultDnsServerAddressStreamProvider.INSTANCE;
        }
    }

    private static void putIfAbsent(Map<String, DnsServerAddresses> map, String str, DnsServerAddresses dnsServerAddresses) {
        DnsServerAddresses dnsServerAddressesPut = map.put(str, dnsServerAddresses);
        if (dnsServerAddressesPut != null) {
            map.put(str, dnsServerAddressesPut);
            logger.debug("Domain name {} already maps to addresses {} so new addresses {} will be discarded", str, dnsServerAddressesPut, dnsServerAddresses);
        }
    }

    private static void putIfAbsent(Map<String, DnsServerAddresses> map, String str, List<InetSocketAddress> list) {
        putIfAbsent(map, str, DnsServerAddresses.sequential(list));
    }

    /* JADX WARN: Code restructure failed: missing block: B:13:0x002d, code lost:
    
        return r3.defaultNameServerAddresses.stream();
     */
    @Override // io.netty.resolver.dns.DnsServerAddressStreamProvider
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public io.netty.resolver.dns.DnsServerAddressStream nameServerAddressStream(java.lang.String r4) {
        /*
            r3 = this;
        L0:
            r0 = 46
            r1 = 1
            int r0 = r4.indexOf(r0, r1)
            if (r0 < 0) goto L27
            int r2 = r4.length()
            int r2 = r2 - r1
            if (r0 != r2) goto L11
            goto L27
        L11:
            java.util.Map<java.lang.String, io.netty.resolver.dns.DnsServerAddresses> r1 = r3.domainToNameServerStreamMap
            java.lang.Object r1 = r1.get(r4)
            io.netty.resolver.dns.DnsServerAddresses r1 = (io.netty.resolver.dns.DnsServerAddresses) r1
            if (r1 == 0) goto L20
            io.netty.resolver.dns.DnsServerAddressStream r4 = r1.stream()
            return r4
        L20:
            int r0 = r0 + 1
            java.lang.String r4 = r4.substring(r0)
            goto L0
        L27:
            io.netty.resolver.dns.DnsServerAddresses r4 = r3.defaultNameServerAddresses
            io.netty.resolver.dns.DnsServerAddressStream r4 = r4.stream()
            return r4
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.resolver.dns.UnixResolverDnsServerAddressStreamProvider.nameServerAddressStream(java.lang.String):io.netty.resolver.dns.DnsServerAddressStream");
    }
}