package io.netty.resolver;

import io.netty.util.NetUtil;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.PlatformDependent;
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.io.IOException;
import java.io.Reader;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.regex.Pattern;

/* JADX INFO: loaded from: classes.dex */
public final class HostsFileParser {
    private static final String WINDOWS_DEFAULT_SYSTEM_ROOT = "C:\\Windows";
    private static final String WINDOWS_HOSTS_FILE_RELATIVE_PATH = "\\system32\\drivers\\etc\\hosts";
    private static final String X_PLATFORMS_HOSTS_FILE_PATH = "/etc/hosts";
    private static final Pattern WHITESPACES = Pattern.compile("[ \t]+");
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) HostsFileParser.class);

    private HostsFileParser() {
    }

    private static File locateHostsFile() {
        if (!PlatformDependent.isWindows()) {
            return new File(X_PLATFORMS_HOSTS_FILE_PATH);
        }
        File file = new File(System.getenv("SystemRoot") + WINDOWS_HOSTS_FILE_RELATIVE_PATH);
        return !file.exists() ? new File("C:\\Windows\\system32\\drivers\\etc\\hosts") : file;
    }

    public static Map<String, InetAddress> parse() throws IOException {
        return parse(locateHostsFile());
    }

    public static Map<String, InetAddress> parseSilently() {
        File fileLocateHostsFile = locateHostsFile();
        try {
            return parse(fileLocateHostsFile);
        } catch (IOException e2) {
            logger.warn("Failed to load and parse hosts file at " + fileLocateHostsFile.getPath(), (Throwable) e2);
            return Collections.emptyMap();
        }
    }

    public static Map<String, InetAddress> parse(File file) throws IOException {
        ObjectUtil.checkNotNull(file, "file");
        return (file.exists() && file.isFile()) ? parse(new BufferedReader(new FileReader(file))) : Collections.emptyMap();
    }

    public static Map<String, InetAddress> parse(Reader reader) throws IOException {
        byte[] bArrCreateByteArrayFromIpAddressString;
        ObjectUtil.checkNotNull(reader, "reader");
        BufferedReader bufferedReader = new BufferedReader(reader);
        try {
            HashMap map = new HashMap();
            while (true) {
                String line = bufferedReader.readLine();
                if (line != null) {
                    int iIndexOf = line.indexOf(35);
                    if (iIndexOf != -1) {
                        line = line.substring(0, iIndexOf);
                    }
                    String strTrim = line.trim();
                    if (!strTrim.isEmpty()) {
                        ArrayList arrayList = new ArrayList();
                        for (String str : WHITESPACES.split(strTrim)) {
                            if (!str.isEmpty()) {
                                arrayList.add(str);
                            }
                        }
                        if (arrayList.size() >= 2 && (bArrCreateByteArrayFromIpAddressString = NetUtil.createByteArrayFromIpAddressString((String) arrayList.get(0))) != null) {
                            for (int i = 1; i < arrayList.size(); i++) {
                                String str2 = (String) arrayList.get(i);
                                String lowerCase = str2.toLowerCase(Locale.ENGLISH);
                                if (!map.containsKey(lowerCase)) {
                                    map.put(lowerCase, InetAddress.getByAddress(str2, bArrCreateByteArrayFromIpAddressString));
                                }
                            }
                        }
                    }
                } else {
                    try {
                        break;
                    } catch (IOException e2) {
                    }
                }
            }
            return map;
        } finally {
            try {
                bufferedReader.close();
            } catch (IOException e22) {
                logger.warn("Failed to close a reader", (Throwable) e22);
            }
        }
    }
}