package io.netty.util;

import g.a.a.a.a;
import io.netty.handler.codec.dns.DnsRecord;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.logging.InternalLogger;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.net.UnknownHostException;
import kotlinx.serialization.json.internal.AbstractJsonLexerKt;

/* JADX INFO: loaded from: classes.dex */
public final class NetUtil {
    private static final int IPV4_MAX_CHAR_BETWEEN_SEPARATOR = 3;
    private static final boolean IPV4_PREFERRED;
    private static final int IPV4_SEPARATORS = 3;
    private static final boolean IPV6_ADDRESSES_PREFERRED;
    private static final int IPV6_BYTE_COUNT = 16;
    private static final int IPV6_MAX_CHAR_BETWEEN_SEPARATOR = 4;
    private static final int IPV6_MAX_CHAR_COUNT = 39;
    private static final int IPV6_MAX_SEPARATORS = 8;
    private static final int IPV6_MIN_SEPARATORS = 2;
    private static final int IPV6_WORD_COUNT = 8;
    public static final InetAddress LOCALHOST;
    public static final Inet4Address LOCALHOST4;
    public static final Inet6Address LOCALHOST6;
    public static final NetworkInterface LOOPBACK_IF;
    public static final int SOMAXCONN;
    private static final InternalLogger logger;

    /* JADX WARN: Code restructure failed: missing block: B:42:0x00d9, code lost:
    
        r10 = r8.nextElement();
        r6 = r7;
     */
    /* JADX WARN: Type inference fix 'apply assigned field type' failed
    java.lang.UnsupportedOperationException: ArgType.getObject(), call class: class jadx.core.dex.instructions.args.ArgType$UnknownArg
    	at jadx.core.dex.instructions.args.ArgType.getObject(ArgType.java:593)
    	at jadx.core.dex.attributes.nodes.ClassTypeVarsAttr.getTypeVarsMapFor(ClassTypeVarsAttr.java:35)
    	at jadx.core.dex.nodes.utils.TypeUtils.replaceClassGenerics(TypeUtils.java:177)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.insertExplicitUseCast(FixTypesVisitor.java:397)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.tryFieldTypeWithNewCasts(FixTypesVisitor.java:359)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.applyFieldType(FixTypesVisitor.java:309)
    	at jadx.core.dex.visitors.typeinference.FixTypesVisitor.visit(FixTypesVisitor.java:94)
     */
    static {
        /*
            Method dump skipped, instruction units count: 352
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.util.NetUtil.<clinit>():void");
    }

    private NetUtil() {
    }

    public static String bytesToIpAddress(byte[] bArr) {
        return bytesToIpAddress(bArr, 0, bArr.length);
    }

    public static String bytesToIpAddress(byte[] bArr, int i2, int i3) {
        if (i3 != 4) {
            if (i3 == 16) {
                return toAddressString(bArr, i2, false);
            }
            throw new IllegalArgumentException(a.n("length: ", i3, " (expected: 4 or 16)"));
        }
        StringBuilder sb = new StringBuilder(15);
        sb.append(bArr[i2] & 255);
        sb.append('.');
        sb.append(bArr[i2 + 1] & 255);
        sb.append('.');
        sb.append(bArr[i2 + 2] & 255);
        sb.append('.');
        sb.append(bArr[i2 + 3] & 255);
        return sb.toString();
    }

    public static byte[] createByteArrayFromIpAddressString(String str) {
        if (isValidIpV4Address(str)) {
            return validIpV4ToBytes(str);
        }
        if (!isValidIpV6Address(str)) {
            return null;
        }
        if (str.charAt(0) == '[') {
            str = str.substring(1, str.length() - 1);
        }
        int iIndexOf = str.indexOf(37);
        if (iIndexOf >= 0) {
            str = str.substring(0, iIndexOf);
        }
        return getIPv6ByName(str, true);
    }

    private static int decimalDigit(String str, int i2) {
        return str.charAt(i2) - '0';
    }

    public static Inet6Address getByName(CharSequence charSequence) {
        return getByName(charSequence, true);
    }

    public static Inet6Address getByName(CharSequence charSequence, boolean z2) {
        byte[] iPv6ByName = getIPv6ByName(charSequence, z2);
        if (iPv6ByName == null) {
            return null;
        }
        try {
            return Inet6Address.getByAddress((String) null, iPv6ByName, -1);
        } catch (UnknownHostException e2) {
            throw new RuntimeException(e2);
        }
    }

    public static String getHostname(InetSocketAddress inetSocketAddress) {
        return PlatformDependent.javaVersion() >= 7 ? inetSocketAddress.getHostString() : inetSocketAddress.getHostName();
    }

    /* JADX WARN: Code restructure failed: missing block: B:116:0x0186, code lost:
    
        if (r19.charAt(0) == ':') goto L120;
     */
    /* JADX WARN: Code restructure failed: missing block: B:126:0x0199, code lost:
    
        if (r7 <= 2) goto L127;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    private static byte[] getIPv6ByName(java.lang.CharSequence r19, boolean r20) {
        /*
            Method dump skipped, instruction units count: 649
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.util.NetUtil.getIPv6ByName(java.lang.CharSequence, boolean):byte[]");
    }

    private static boolean inRangeEndExclusive(int i2, int i3, int i4) {
        return i2 >= i3 && i2 < i4;
    }

    public static String intToIpAddress(int i2) {
        StringBuilder sb = new StringBuilder(15);
        sb.append((i2 >> 24) & DnsRecord.CLASS_ANY);
        sb.append('.');
        sb.append((i2 >> 16) & DnsRecord.CLASS_ANY);
        sb.append('.');
        sb.append((i2 >> 8) & DnsRecord.CLASS_ANY);
        sb.append('.');
        sb.append(i2 & DnsRecord.CLASS_ANY);
        return sb.toString();
    }

    private static byte ipv4WordToByte(String str, int i2, int i3) {
        int iDecimalDigit = decimalDigit(str, i2);
        int i4 = i2 + 1;
        if (i4 == i3) {
            return (byte) iDecimalDigit;
        }
        int iDecimalDigit2 = (iDecimalDigit * 10) + decimalDigit(str, i4);
        int i5 = i4 + 1;
        return i5 == i3 ? (byte) iDecimalDigit2 : (byte) ((iDecimalDigit2 * 10) + decimalDigit(str, i5));
    }

    public static boolean isIpV4StackPreferred() {
        return IPV4_PREFERRED;
    }

    public static boolean isIpV6AddressesPreferred() {
        return IPV6_ADDRESSES_PREFERRED;
    }

    private static boolean isValidHexChar(char c2) {
        return (c2 >= '0' && c2 <= '9') || (c2 >= 'A' && c2 <= 'F') || (c2 >= 'a' && c2 <= 'f');
    }

    private static boolean isValidIPv4Mapped(byte[] bArr, int i2, int i3, int i4) {
        boolean z2 = i4 + i3 >= 14;
        return i2 <= 12 && i2 >= 2 && (!z2 || i3 < 12) && isValidIPv4MappedSeparators(bArr[i2 + (-1)], bArr[i2 + (-2)], z2) && PlatformDependent.isZero(bArr, 0, i2 + (-3));
    }

    private static boolean isValidIPv4MappedChar(char c2) {
        return c2 == 'f' || c2 == 'F';
    }

    private static boolean isValidIPv4MappedSeparators(byte b2, byte b3, boolean z2) {
        return b2 == b3 && (b2 == 0 || (!z2 && b3 == -1));
    }

    private static boolean isValidIpV4Address(AsciiString asciiString, int i2, int i3) {
        int iIndexOf;
        int i4;
        int iIndexOf2;
        int i5;
        int iIndexOf3;
        int i6 = i3 - i2;
        return i6 <= 15 && i6 >= 7 && (iIndexOf = asciiString.indexOf('.', i2 + 1)) > 0 && isValidIpV4Word(asciiString, i2, iIndexOf) && (iIndexOf2 = asciiString.indexOf('.', (i4 = iIndexOf + 2))) > 0 && isValidIpV4Word(asciiString, i4 - 1, iIndexOf2) && (iIndexOf3 = asciiString.indexOf('.', (i5 = iIndexOf2 + 2))) > 0 && isValidIpV4Word(asciiString, i5 - 1, iIndexOf3) && isValidIpV4Word(asciiString, iIndexOf3 + 1, i3);
    }

    public static boolean isValidIpV4Address(CharSequence charSequence) {
        return isValidIpV4Address(charSequence, 0, charSequence.length());
    }

    private static boolean isValidIpV4Address(CharSequence charSequence, int i2, int i3) {
        return charSequence instanceof String ? isValidIpV4Address((String) charSequence, i2, i3) : charSequence instanceof AsciiString ? isValidIpV4Address((AsciiString) charSequence, i2, i3) : isValidIpV4Address0(charSequence, i2, i3);
    }

    public static boolean isValidIpV4Address(String str) {
        return isValidIpV4Address(str, 0, str.length());
    }

    private static boolean isValidIpV4Address(String str, int i2, int i3) {
        int iIndexOf;
        int i4;
        int iIndexOf2;
        int i5;
        int iIndexOf3;
        int i6 = i3 - i2;
        return i6 <= 15 && i6 >= 7 && (iIndexOf = str.indexOf(46, i2 + 1)) > 0 && isValidIpV4Word(str, i2, iIndexOf) && (iIndexOf2 = str.indexOf(46, (i4 = iIndexOf + 2))) > 0 && isValidIpV4Word(str, i4 - 1, iIndexOf2) && (iIndexOf3 = str.indexOf(46, (i5 = iIndexOf2 + 2))) > 0 && isValidIpV4Word(str, i5 - 1, iIndexOf3) && isValidIpV4Word(str, iIndexOf3 + 1, i3);
    }

    private static boolean isValidIpV4Address0(CharSequence charSequence, int i2, int i3) {
        int iIndexOf;
        int i4;
        int iIndexOf2;
        int i5;
        int iIndexOf3;
        int i6 = i3 - i2;
        return i6 <= 15 && i6 >= 7 && (iIndexOf = AsciiString.indexOf(charSequence, '.', i2 + 1)) > 0 && isValidIpV4Word(charSequence, i2, iIndexOf) && (iIndexOf2 = AsciiString.indexOf(charSequence, '.', (i4 = iIndexOf + 2))) > 0 && isValidIpV4Word(charSequence, i4 - 1, iIndexOf2) && (iIndexOf3 = AsciiString.indexOf(charSequence, '.', (i5 = iIndexOf2 + 2))) > 0 && isValidIpV4Word(charSequence, i5 - 1, iIndexOf3) && isValidIpV4Word(charSequence, iIndexOf3 + 1, i3);
    }

    private static boolean isValidIpV4Word(CharSequence charSequence, int i2, int i3) {
        char cCharAt;
        char cCharAt2;
        int i4 = i3 - i2;
        if (i4 < 1 || i4 > 3 || (cCharAt = charSequence.charAt(i2)) < '0') {
            return false;
        }
        if (i4 != 3) {
            if (cCharAt <= '9') {
                return i4 == 1 || isValidNumericChar(charSequence.charAt(i2 + 1));
            }
            return false;
        }
        char cCharAt3 = charSequence.charAt(i2 + 1);
        if (cCharAt3 < '0' || (cCharAt2 = charSequence.charAt(i2 + 2)) < '0') {
            return false;
        }
        if (cCharAt > '1' || cCharAt3 > '9' || cCharAt2 > '9') {
            if (cCharAt != '2' || cCharAt3 > '5') {
                return false;
            }
            if (cCharAt2 > '5' && (cCharAt3 >= '5' || cCharAt2 > '9')) {
                return false;
            }
        }
        return true;
    }

    /* JADX WARN: Code restructure failed: missing block: B:102:?, code lost:
    
        return false;
     */
    /* JADX WARN: Code restructure failed: missing block: B:103:?, code lost:
    
        return false;
     */
    /* JADX WARN: Code restructure failed: missing block: B:104:?, code lost:
    
        return false;
     */
    /* JADX WARN: Code restructure failed: missing block: B:105:?, code lost:
    
        return false;
     */
    /* JADX WARN: Code restructure failed: missing block: B:75:0x00d3, code lost:
    
        if (r3 >= 0) goto L80;
     */
    /* JADX WARN: Code restructure failed: missing block: B:76:0x00d5, code lost:
    
        if (r1 != 7) goto L102;
     */
    /* JADX WARN: Code restructure failed: missing block: B:77:0x00d7, code lost:
    
        if (r8 <= 0) goto L103;
     */
    /* JADX WARN: Code restructure failed: missing block: B:79:0x00da, code lost:
    
        return true;
     */
    /* JADX WARN: Code restructure failed: missing block: B:81:0x00dd, code lost:
    
        if ((r3 + 2) == r0) goto L86;
     */
    /* JADX WARN: Code restructure failed: missing block: B:82:0x00df, code lost:
    
        if (r8 <= 0) goto L104;
     */
    /* JADX WARN: Code restructure failed: missing block: B:84:0x00e3, code lost:
    
        if (r1 < 8) goto L86;
     */
    /* JADX WARN: Code restructure failed: missing block: B:85:0x00e5, code lost:
    
        if (r3 > r4) goto L105;
     */
    /* JADX WARN: Code restructure failed: missing block: B:87:0x00e8, code lost:
    
        return true;
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static boolean isValidIpV6Address(java.lang.CharSequence r14) {
        /*
            Method dump skipped, instruction units count: 233
            To view this dump add '--comments-level debug' option
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.util.NetUtil.isValidIpV6Address(java.lang.CharSequence):boolean");
    }

    public static boolean isValidIpV6Address(String str) {
        return isValidIpV6Address((CharSequence) str);
    }

    private static boolean isValidNumericChar(char c2) {
        return c2 >= '0' && c2 <= '9';
    }

    private static StringBuilder newSocketAddressStringBuilder(String str, String str2, boolean z2) {
        int length = str.length();
        if (z2) {
            StringBuilder sb = new StringBuilder(str2.length() + length + 1);
            sb.append(str);
            return sb;
        }
        StringBuilder sb2 = new StringBuilder(str2.length() + length + 3);
        if (length > 1 && str.charAt(0) == '[' && str.charAt(length - 1) == ']') {
            sb2.append(str);
            return sb2;
        }
        sb2.append(AbstractJsonLexerKt.BEGIN_LIST);
        sb2.append(str);
        sb2.append(AbstractJsonLexerKt.END_LIST);
        return sb2;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static Integer sysctlGetInt(String str) throws IOException {
        Process processStart = new ProcessBuilder("sysctl", str).start();
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(processStart.getInputStream()));
            try {
                String line = bufferedReader.readLine();
                if (line.startsWith(str)) {
                    for (int length = line.length() - 1; length > str.length(); length--) {
                        if (!Character.isDigit(line.charAt(length))) {
                            Integer numValueOf = Integer.valueOf(line.substring(length + 1, line.length()));
                            processStart.destroy();
                            return numValueOf;
                        }
                    }
                }
                processStart.destroy();
                return null;
            } finally {
                bufferedReader.close();
            }
        } catch (Throwable th) {
            if (processStart != null) {
                processStart.destroy();
            }
            throw th;
        }
    }

    public static String toAddressString(InetAddress inetAddress) {
        return toAddressString(inetAddress, false);
    }

    public static String toAddressString(InetAddress inetAddress, boolean z2) {
        if (inetAddress instanceof Inet4Address) {
            return inetAddress.getHostAddress();
        }
        if (inetAddress instanceof Inet6Address) {
            return toAddressString(inetAddress.getAddress(), 0, z2);
        }
        throw new IllegalArgumentException("Unhandled type: " + inetAddress);
    }

    private static String toAddressString(byte[] bArr, int i2, boolean z2) {
        int i3;
        int i4;
        int[] iArr = new int[8];
        int i5 = i2 + 8;
        while (true) {
            i3 = 1;
            if (i2 >= i5) {
                break;
            }
            int i6 = i2 << 1;
            iArr[i2] = (bArr[i6 + 1] & 255) | ((bArr[i6] & 255) << 8);
            i2++;
        }
        int i7 = -1;
        boolean z3 = false;
        int i8 = -1;
        int i9 = -1;
        int i10 = 0;
        int i11 = 0;
        while (i10 < 8) {
            if (iArr[i10] == 0) {
                if (i8 < 0) {
                    i8 = i10;
                }
            } else if (i8 >= 0) {
                int i12 = i10 - i8;
                if (i12 > i11) {
                    i11 = i12;
                } else {
                    i8 = i9;
                }
                i9 = i8;
                i8 = -1;
            }
            i10++;
        }
        if (i8 < 0 || (i4 = i10 - i8) <= i11) {
            i8 = i9;
        } else {
            i11 = i4;
        }
        if (i11 == 1) {
            i11 = 0;
        } else {
            i7 = i8;
        }
        int i13 = i11 + i7;
        StringBuilder sb = new StringBuilder(39);
        if (i13 < 0) {
            sb.append(Integer.toHexString(iArr[0]));
            while (i3 < 8) {
                sb.append(AbstractJsonLexerKt.COLON);
                sb.append(Integer.toHexString(iArr[i3]));
                i3++;
            }
        } else {
            if (inRangeEndExclusive(0, i7, i13)) {
                sb.append("::");
                if (z2 && i13 == 5 && iArr[5] == 65535) {
                    z3 = true;
                }
            } else {
                sb.append(Integer.toHexString(iArr[0]));
            }
            while (i3 < 8) {
                if (!inRangeEndExclusive(i3, i7, i13)) {
                    if (!inRangeEndExclusive(i3 - 1, i7, i13)) {
                        if (!z3 || i3 == 6) {
                            sb.append(AbstractJsonLexerKt.COLON);
                        } else {
                            sb.append('.');
                        }
                    }
                    if (!z3 || i3 <= 5) {
                        sb.append(Integer.toHexString(iArr[i3]));
                    } else {
                        sb.append(iArr[i3] >> 8);
                        sb.append('.');
                        sb.append(iArr[i3] & DnsRecord.CLASS_ANY);
                    }
                } else if (!inRangeEndExclusive(i3 - 1, i7, i13)) {
                    sb.append("::");
                }
                i3++;
            }
        }
        return sb.toString();
    }

    public static String toSocketAddressString(String str, int i2) {
        String strValueOf = String.valueOf(i2);
        StringBuilder sbNewSocketAddressStringBuilder = newSocketAddressStringBuilder(str, strValueOf, !isValidIpV6Address(str));
        sbNewSocketAddressStringBuilder.append(AbstractJsonLexerKt.COLON);
        sbNewSocketAddressStringBuilder.append(strValueOf);
        return sbNewSocketAddressStringBuilder.toString();
    }

    public static String toSocketAddressString(InetSocketAddress inetSocketAddress) {
        StringBuilder sbNewSocketAddressStringBuilder;
        String strValueOf = String.valueOf(inetSocketAddress.getPort());
        if (inetSocketAddress.isUnresolved()) {
            sbNewSocketAddressStringBuilder = newSocketAddressStringBuilder(getHostname(inetSocketAddress), strValueOf, !isValidIpV6Address(r2));
        } else {
            InetAddress address = inetSocketAddress.getAddress();
            sbNewSocketAddressStringBuilder = newSocketAddressStringBuilder(toAddressString(address), strValueOf, address instanceof Inet4Address);
        }
        sbNewSocketAddressStringBuilder.append(AbstractJsonLexerKt.COLON);
        sbNewSocketAddressStringBuilder.append(strValueOf);
        return sbNewSocketAddressStringBuilder.toString();
    }

    public static byte[] validIpV4ToBytes(String str) {
        int iIndexOf = str.indexOf(46, 1);
        int i2 = iIndexOf + 1;
        int iIndexOf2 = str.indexOf(46, iIndexOf + 2);
        int iIndexOf3 = str.indexOf(46, iIndexOf2 + 2);
        return new byte[]{ipv4WordToByte(str, 0, iIndexOf), ipv4WordToByte(str, i2, iIndexOf2), ipv4WordToByte(str, iIndexOf2 + 1, iIndexOf3), ipv4WordToByte(str, iIndexOf3 + 1, str.length())};
    }
}