package io.netty.util.internal;

import g.a.a.a.a;
import io.netty.util.NetUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

/* JADX INFO: loaded from: classes.dex */
public final class MacAddressUtil {
    private static final int EUI48_MAC_ADDRESS_LENGTH = 6;
    private static final int EUI64_MAC_ADDRESS_LENGTH = 8;
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) MacAddressUtil.class);

    private MacAddressUtil() {
    }

    public static byte[] bestAvailableMac() {
        int iCompareAddresses;
        byte[] bArr = EmptyArrays.EMPTY_BYTES;
        InetAddress inetAddress = NetUtil.LOCALHOST4;
        LinkedHashMap linkedHashMap = new LinkedHashMap();
        try {
            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
            if (networkInterfaces != null) {
                while (networkInterfaces.hasMoreElements()) {
                    NetworkInterface networkInterfaceNextElement = networkInterfaces.nextElement();
                    Enumeration<InetAddress> enumerationAddressesFromNetworkInterface = SocketUtils.addressesFromNetworkInterface(networkInterfaceNextElement);
                    if (enumerationAddressesFromNetworkInterface.hasMoreElements()) {
                        InetAddress inetAddressNextElement = enumerationAddressesFromNetworkInterface.nextElement();
                        if (!inetAddressNextElement.isLoopbackAddress()) {
                            linkedHashMap.put(networkInterfaceNextElement, inetAddressNextElement);
                        }
                    }
                }
            }
        } catch (SocketException e2) {
            logger.warn("Failed to retrieve the list of available network interfaces", (Throwable) e2);
        }
        Iterator it = linkedHashMap.entrySet().iterator();
        while (true) {
            boolean z2 = false;
            if (!it.hasNext()) {
                break;
            }
            Map.Entry entry = (Map.Entry) it.next();
            NetworkInterface networkInterface = (NetworkInterface) entry.getKey();
            InetAddress inetAddress2 = (InetAddress) entry.getValue();
            if (!networkInterface.isVirtual()) {
                try {
                    byte[] bArrHardwareAddressFromNetworkInterface = SocketUtils.hardwareAddressFromNetworkInterface(networkInterface);
                    int iCompareAddresses2 = compareAddresses(bArr, bArrHardwareAddressFromNetworkInterface);
                    if (iCompareAddresses2 < 0 || (iCompareAddresses2 == 0 && ((iCompareAddresses = compareAddresses(inetAddress, inetAddress2)) < 0 || (iCompareAddresses == 0 && bArr.length < bArrHardwareAddressFromNetworkInterface.length)))) {
                        z2 = true;
                    }
                    if (z2) {
                        inetAddress = inetAddress2;
                        bArr = bArrHardwareAddressFromNetworkInterface;
                    }
                } catch (SocketException e3) {
                    logger.debug("Failed to get the hardware address of a network interface: {}", networkInterface, e3);
                }
            }
        }
        if (bArr == EmptyArrays.EMPTY_BYTES) {
            return null;
        }
        if (bArr.length != 6) {
            return Arrays.copyOf(bArr, 8);
        }
        byte[] bArr2 = new byte[8];
        System.arraycopy(bArr, 0, bArr2, 0, 3);
        bArr2[3] = -1;
        bArr2[4] = -2;
        System.arraycopy(bArr, 3, bArr2, 5, 3);
        return bArr2;
    }

    private static int compareAddresses(InetAddress inetAddress, InetAddress inetAddress2) {
        return scoreAddress(inetAddress) - scoreAddress(inetAddress2);
    }

    public static int compareAddresses(byte[] bArr, byte[] bArr2) {
        boolean z2;
        if (bArr2 == null || bArr2.length < 6) {
            return 1;
        }
        int length = bArr2.length;
        int i2 = 0;
        while (true) {
            if (i2 < length) {
                byte b2 = bArr2[i2];
                if (b2 != 0 && b2 != 1) {
                    z2 = false;
                    break;
                }
                i2++;
            } else {
                z2 = true;
                break;
            }
        }
        if (!z2 && (bArr2[0] & 1) == 0) {
            return (bArr2[0] & 2) == 0 ? (bArr.length == 0 || (bArr[0] & 2) != 0) ? -1 : 0 : (bArr.length == 0 || (bArr[0] & 2) != 0) ? 0 : 1;
        }
        return 1;
    }

    public static byte[] defaultMachineId() {
        byte[] bArrBestAvailableMac = bestAvailableMac();
        if (bArrBestAvailableMac != null) {
            return bArrBestAvailableMac;
        }
        byte[] bArr = new byte[8];
        PlatformDependent.threadLocalRandom().nextBytes(bArr);
        logger.warn("Failed to find a usable hardware address from the network interfaces; using random bytes: {}", formatAddress(bArr));
        return bArr;
    }

    public static String formatAddress(byte[] bArr) {
        StringBuilder sb = new StringBuilder(24);
        for (byte b2 : bArr) {
            sb.append(String.format("%02x:", Integer.valueOf(b2 & 255)));
        }
        return sb.substring(0, sb.length() - 1);
    }

    public static byte[] parseMAC(String str) {
        char cCharAt;
        int i2;
        int length = str.length();
        if (length == 17) {
            cCharAt = str.charAt(2);
            validateMacSeparator(cCharAt);
            i2 = 6;
        } else {
            if (length != 23) {
                throw new IllegalArgumentException("value is not supported [MAC-48, EUI-48, EUI-64]");
            }
            cCharAt = str.charAt(2);
            validateMacSeparator(cCharAt);
            i2 = 8;
        }
        byte[] bArr = new byte[i2];
        int length2 = bArr.length - 1;
        int i3 = 0;
        int i4 = 0;
        while (i3 < length2) {
            int i5 = i4 + 2;
            bArr[i3] = StringUtil.decodeHexByte(str, i4);
            if (str.charAt(i5) != cCharAt) {
                throw new IllegalArgumentException("expected separator '" + cCharAt + " but got '" + str.charAt(i5) + "' at index: " + i5);
            }
            i3++;
            i4 += 3;
        }
        bArr[length2] = StringUtil.decodeHexByte(str, i4);
        return bArr;
    }

    private static int scoreAddress(InetAddress inetAddress) {
        if (inetAddress.isAnyLocalAddress() || inetAddress.isLoopbackAddress()) {
            return 0;
        }
        if (inetAddress.isMulticastAddress()) {
            return 1;
        }
        if (inetAddress.isLinkLocalAddress()) {
            return 2;
        }
        return inetAddress.isSiteLocalAddress() ? 3 : 4;
    }

    private static void validateMacSeparator(char c2) {
        if (c2 != ':' && c2 != '-') {
            throw new IllegalArgumentException(a.k("unsupported separator: ", c2, " (expected: [:-])"));
        }
    }
}