package io.netty.channel.unix;

import g.a.a.a.a;
import io.netty.channel.ChannelException;
import io.netty.channel.unix.Errors;
import io.netty.util.CharsetUtil;
import io.netty.util.NetUtil;
import io.netty.util.internal.ThrowableUtil;
import java.io.FileNotFoundException;
import java.net.ConnectException;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NoRouteToHostException;
import java.net.PortUnreachableException;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.util.concurrent.atomic.AtomicBoolean;
import kotlinx.serialization.json.internal.AbstractJsonLexerKt;

/* JADX INFO: loaded from: classes.dex */
public class Socket extends FileDescriptor {
    private static final Errors.NativeIoException CONNECTION_RESET_EXCEPTION_SENDMSG;
    private static final Errors.NativeIoException CONNECTION_RESET_SHUTDOWN_EXCEPTION;
    private static final Errors.NativeConnectException CONNECT_REFUSED_EXCEPTION;
    private static final Errors.NativeConnectException FINISH_CONNECT_REFUSED_EXCEPTION;
    private static final AtomicBoolean INITIALIZED;
    private static final Errors.NativeIoException SEND_TO_ADDRESS_CONNECTION_RESET_EXCEPTION;
    private static final Errors.NativeIoException SEND_TO_CONNECTION_RESET_EXCEPTION;
    public static final int UDS_SUN_PATH_SIZE;
    private static final ClosedChannelException SHUTDOWN_CLOSED_CHANNEL_EXCEPTION = (ClosedChannelException) a.N(Socket.class, "shutdown(..)");
    private static final ClosedChannelException SEND_TO_CLOSED_CHANNEL_EXCEPTION = (ClosedChannelException) a.N(Socket.class, "sendTo(..)");
    private static final ClosedChannelException SEND_TO_ADDRESS_CLOSED_CHANNEL_EXCEPTION = (ClosedChannelException) a.N(Socket.class, "sendToAddress(..)");
    private static final ClosedChannelException SEND_TO_ADDRESSES_CLOSED_CHANNEL_EXCEPTION = (ClosedChannelException) a.N(Socket.class, "sendToAddresses(..)");

    static {
        int i2 = Errors.ERRNO_EPIPE_NEGATIVE;
        SEND_TO_CONNECTION_RESET_EXCEPTION = (Errors.NativeIoException) ThrowableUtil.unknownStackTrace(Errors.newConnectionResetException("syscall:sendto", i2), Socket.class, "sendTo(..)");
        SEND_TO_ADDRESS_CONNECTION_RESET_EXCEPTION = (Errors.NativeIoException) ThrowableUtil.unknownStackTrace(Errors.newConnectionResetException("syscall:sendto", i2), Socket.class, "sendToAddress");
        CONNECTION_RESET_EXCEPTION_SENDMSG = (Errors.NativeIoException) ThrowableUtil.unknownStackTrace(Errors.newConnectionResetException("syscall:sendmsg", i2), Socket.class, "sendToAddresses(..)");
        CONNECTION_RESET_SHUTDOWN_EXCEPTION = (Errors.NativeIoException) ThrowableUtil.unknownStackTrace(Errors.newConnectionResetException("syscall:shutdown", Errors.ERRNO_ECONNRESET_NEGATIVE), Socket.class, "shutdown");
        int i3 = Errors.ERROR_ECONNREFUSED_NEGATIVE;
        FINISH_CONNECT_REFUSED_EXCEPTION = (Errors.NativeConnectException) ThrowableUtil.unknownStackTrace(new Errors.NativeConnectException("syscall:getsockopt", i3), Socket.class, "finishConnect(..)");
        CONNECT_REFUSED_EXCEPTION = (Errors.NativeConnectException) ThrowableUtil.unknownStackTrace(new Errors.NativeConnectException("syscall:connect", i3), Socket.class, "connect(..)");
        UDS_SUN_PATH_SIZE = LimitsStaticallyReferencedJniMethods.udsSunPathSize();
        INITIALIZED = new AtomicBoolean();
    }

    public Socket(int i2) {
        super(i2);
    }

    private static native int accept(int i2, byte[] bArr);

    private static native int bind(int i2, byte[] bArr, int i3, int i4);

    private static native int bindDomainSocket(int i2, byte[] bArr);

    private static native int connect(int i2, byte[] bArr, int i3, int i4);

    private static native int connectDomainSocket(int i2, byte[] bArr);

    private static native int disconnect(int i2);

    private static native int finishConnect(int i2);

    private static native int getReceiveBufferSize(int i2);

    private static native int getSendBufferSize(int i2);

    private static native int getSoError(int i2);

    private static native int getSoLinger(int i2);

    private static native int getTrafficClass(int i2);

    public static void initialize() {
        if (INITIALIZED.compareAndSet(false, true)) {
            initialize(NetUtil.isIpV4StackPreferred());
        }
    }

    private static native void initialize(boolean z2);

    private static native int isBroadcast(int i2);

    private static native int isKeepAlive(int i2);

    private static native int isReuseAddress(int i2);

    private static native int isReusePort(int i2);

    private static native int isTcpNoDelay(int i2);

    private static native int listen(int i2, int i3);

    private static native byte[] localAddress(int i2);

    public static Socket newSocketDgram() {
        return new Socket(newSocketDgram0());
    }

    public static int newSocketDgram0() {
        int iNewSocketDgramFd = newSocketDgramFd();
        if (iNewSocketDgramFd >= 0) {
            return iNewSocketDgramFd;
        }
        throw new ChannelException(Errors.newIOException("newSocketDgram", iNewSocketDgramFd));
    }

    private static native int newSocketDgramFd();

    public static Socket newSocketDomain() {
        return new Socket(newSocketDomain0());
    }

    public static int newSocketDomain0() {
        int iNewSocketDomainFd = newSocketDomainFd();
        if (iNewSocketDomainFd >= 0) {
            return iNewSocketDomainFd;
        }
        throw new ChannelException(Errors.newIOException("newSocketDomain", iNewSocketDomainFd));
    }

    private static native int newSocketDomainFd();

    public static Socket newSocketStream() {
        return new Socket(newSocketStream0());
    }

    public static int newSocketStream0() {
        int iNewSocketStreamFd = newSocketStreamFd();
        if (iNewSocketStreamFd >= 0) {
            return iNewSocketStreamFd;
        }
        throw new ChannelException(Errors.newIOException("newSocketStream", iNewSocketStreamFd));
    }

    private static native int newSocketStreamFd();

    private static native int recvFd(int i2);

    private static native DatagramSocketAddress recvFrom(int i2, ByteBuffer byteBuffer, int i3, int i4);

    private static native DatagramSocketAddress recvFromAddress(int i2, long j2, int i3, int i4);

    private static native byte[] remoteAddress(int i2);

    private static native int sendFd(int i2, int i3);

    private static native int sendTo(int i2, ByteBuffer byteBuffer, int i3, int i4, byte[] bArr, int i5, int i6);

    private static native int sendToAddress(int i2, long j2, int i3, int i4, byte[] bArr, int i5, int i6);

    private static native int sendToAddresses(int i2, long j2, int i3, byte[] bArr, int i4, int i5);

    private static native void setBroadcast(int i2, int i3);

    private static native void setKeepAlive(int i2, int i3);

    private static native void setReceiveBufferSize(int i2, int i3);

    private static native void setReuseAddress(int i2, int i3);

    private static native void setReusePort(int i2, int i3);

    private static native void setSendBufferSize(int i2, int i3);

    private static native void setSoLinger(int i2, int i3);

    private static native void setTcpNoDelay(int i2, int i3);

    private static native void setTrafficClass(int i2, int i3);

    private static native int shutdown(int i2, boolean z2, boolean z3);

    public final int accept(byte[] bArr) throws Errors.NativeIoException {
        int iAccept = accept(this.fd, bArr);
        if (iAccept >= 0) {
            return iAccept;
        }
        if (iAccept == Errors.ERRNO_EAGAIN_NEGATIVE || iAccept == Errors.ERRNO_EWOULDBLOCK_NEGATIVE) {
            return -1;
        }
        throw Errors.newIOException("accept", iAccept);
    }

    public final void bind(SocketAddress socketAddress) {
        if (socketAddress instanceof InetSocketAddress) {
            InetSocketAddress inetSocketAddress = (InetSocketAddress) socketAddress;
            NativeInetAddress nativeInetAddressNewInstance = NativeInetAddress.newInstance(inetSocketAddress.getAddress());
            int iBind = bind(this.fd, nativeInetAddressNewInstance.address, nativeInetAddressNewInstance.scopeId, inetSocketAddress.getPort());
            if (iBind < 0) {
                throw Errors.newIOException("bind", iBind);
            }
            return;
        }
        if (socketAddress instanceof DomainSocketAddress) {
            int iBindDomainSocket = bindDomainSocket(this.fd, ((DomainSocketAddress) socketAddress).path().getBytes(CharsetUtil.UTF_8));
            if (iBindDomainSocket < 0) {
                throw Errors.newIOException("bind", iBindDomainSocket);
            }
        } else {
            throw new Error("Unexpected SocketAddress implementation " + socketAddress);
        }
    }

    public final boolean connect(SocketAddress socketAddress) throws ConnectException, FileNotFoundException, NoRouteToHostException {
        int iConnectDomainSocket;
        if (socketAddress instanceof InetSocketAddress) {
            InetSocketAddress inetSocketAddress = (InetSocketAddress) socketAddress;
            NativeInetAddress nativeInetAddressNewInstance = NativeInetAddress.newInstance(inetSocketAddress.getAddress());
            iConnectDomainSocket = connect(this.fd, nativeInetAddressNewInstance.address, nativeInetAddressNewInstance.scopeId, inetSocketAddress.getPort());
        } else {
            if (!(socketAddress instanceof DomainSocketAddress)) {
                throw new Error("Unexpected SocketAddress implementation " + socketAddress);
            }
            iConnectDomainSocket = connectDomainSocket(this.fd, ((DomainSocketAddress) socketAddress).path().getBytes(CharsetUtil.UTF_8));
        }
        if (iConnectDomainSocket >= 0) {
            return true;
        }
        if (iConnectDomainSocket == Errors.ERRNO_EINPROGRESS_NEGATIVE) {
            return false;
        }
        Errors.throwConnectException("connect", CONNECT_REFUSED_EXCEPTION, iConnectDomainSocket);
        return true;
    }

    public final void disconnect() throws ConnectException, FileNotFoundException, NoRouteToHostException {
        int iDisconnect = disconnect(this.fd);
        if (iDisconnect < 0) {
            Errors.throwConnectException("disconnect", FINISH_CONNECT_REFUSED_EXCEPTION, iDisconnect);
        }
    }

    public final boolean finishConnect() throws ConnectException, FileNotFoundException, NoRouteToHostException {
        int iFinishConnect = finishConnect(this.fd);
        if (iFinishConnect >= 0) {
            return true;
        }
        if (iFinishConnect == Errors.ERRNO_EINPROGRESS_NEGATIVE) {
            return false;
        }
        Errors.throwConnectException("finishConnect", FINISH_CONNECT_REFUSED_EXCEPTION, iFinishConnect);
        return true;
    }

    public final int getReceiveBufferSize() {
        return getReceiveBufferSize(this.fd);
    }

    public final int getSendBufferSize() {
        return getSendBufferSize(this.fd);
    }

    public final int getSoError() {
        return getSoError(this.fd);
    }

    public final int getSoLinger() {
        return getSoLinger(this.fd);
    }

    public final int getTrafficClass() {
        return getTrafficClass(this.fd);
    }

    public final boolean isBroadcast() {
        return isBroadcast(this.fd) != 0;
    }

    public final boolean isInputShutdown() {
        return FileDescriptor.isInputShutdown(this.state);
    }

    public final boolean isKeepAlive() {
        return isKeepAlive(this.fd) != 0;
    }

    public final boolean isOutputShutdown() {
        return FileDescriptor.isOutputShutdown(this.state);
    }

    public final boolean isReuseAddress() {
        return isReuseAddress(this.fd) != 0;
    }

    public final boolean isReusePort() {
        return isReusePort(this.fd) != 0;
    }

    public final boolean isShutdown() {
        int i2 = this.state;
        return FileDescriptor.isInputShutdown(i2) && FileDescriptor.isOutputShutdown(i2);
    }

    public final boolean isTcpNoDelay() {
        return isTcpNoDelay(this.fd) != 0;
    }

    public final void listen(int i2) throws Errors.NativeIoException {
        int iListen = listen(this.fd, i2);
        if (iListen < 0) {
            throw Errors.newIOException("listen", iListen);
        }
    }

    public final InetSocketAddress localAddress() {
        byte[] bArrLocalAddress = localAddress(this.fd);
        if (bArrLocalAddress == null) {
            return null;
        }
        return NativeInetAddress.address(bArrLocalAddress, 0, bArrLocalAddress.length);
    }

    public final int recvFd() throws Errors.NativeIoException {
        int iRecvFd = recvFd(this.fd);
        if (iRecvFd > 0) {
            return iRecvFd;
        }
        if (iRecvFd == 0) {
            return -1;
        }
        if (iRecvFd == Errors.ERRNO_EAGAIN_NEGATIVE || iRecvFd == Errors.ERRNO_EWOULDBLOCK_NEGATIVE) {
            return 0;
        }
        throw Errors.newIOException("recvFd", iRecvFd);
    }

    public final DatagramSocketAddress recvFrom(ByteBuffer byteBuffer, int i2, int i3) {
        return recvFrom(this.fd, byteBuffer, i2, i3);
    }

    public final DatagramSocketAddress recvFromAddress(long j2, int i2, int i3) {
        return recvFromAddress(this.fd, j2, i2, i3);
    }

    public final InetSocketAddress remoteAddress() {
        byte[] bArrRemoteAddress = remoteAddress(this.fd);
        if (bArrRemoteAddress == null) {
            return null;
        }
        return NativeInetAddress.address(bArrRemoteAddress, 0, bArrRemoteAddress.length);
    }

    public final int sendFd(int i2) throws Errors.NativeIoException {
        int iSendFd = sendFd(this.fd, i2);
        if (iSendFd >= 0) {
            return iSendFd;
        }
        if (iSendFd == Errors.ERRNO_EAGAIN_NEGATIVE || iSendFd == Errors.ERRNO_EWOULDBLOCK_NEGATIVE) {
            return -1;
        }
        throw Errors.newIOException("sendFd", iSendFd);
    }

    public final int sendTo(ByteBuffer byteBuffer, int i2, int i3, InetAddress inetAddress, int i4) throws PortUnreachableException {
        byte[] bArrIpv4MappedIpv6Address;
        int scopeId;
        if (inetAddress instanceof Inet6Address) {
            byte[] address = inetAddress.getAddress();
            scopeId = ((Inet6Address) inetAddress).getScopeId();
            bArrIpv4MappedIpv6Address = address;
        } else {
            bArrIpv4MappedIpv6Address = NativeInetAddress.ipv4MappedIpv6Address(inetAddress.getAddress());
            scopeId = 0;
        }
        int iSendTo = sendTo(this.fd, byteBuffer, i2, i3, bArrIpv4MappedIpv6Address, scopeId, i4);
        if (iSendTo >= 0) {
            return iSendTo;
        }
        if (iSendTo != Errors.ERROR_ECONNREFUSED_NEGATIVE) {
            return Errors.ioResult("sendTo", iSendTo, SEND_TO_CONNECTION_RESET_EXCEPTION, SEND_TO_CLOSED_CHANNEL_EXCEPTION);
        }
        throw new PortUnreachableException("sendTo failed");
    }

    public final int sendToAddress(long j2, int i2, int i3, InetAddress inetAddress, int i4) throws PortUnreachableException {
        byte[] bArrIpv4MappedIpv6Address;
        int scopeId;
        if (inetAddress instanceof Inet6Address) {
            byte[] address = inetAddress.getAddress();
            scopeId = ((Inet6Address) inetAddress).getScopeId();
            bArrIpv4MappedIpv6Address = address;
        } else {
            bArrIpv4MappedIpv6Address = NativeInetAddress.ipv4MappedIpv6Address(inetAddress.getAddress());
            scopeId = 0;
        }
        int iSendToAddress = sendToAddress(this.fd, j2, i2, i3, bArrIpv4MappedIpv6Address, scopeId, i4);
        if (iSendToAddress >= 0) {
            return iSendToAddress;
        }
        if (iSendToAddress != Errors.ERROR_ECONNREFUSED_NEGATIVE) {
            return Errors.ioResult("sendToAddress", iSendToAddress, SEND_TO_ADDRESS_CONNECTION_RESET_EXCEPTION, SEND_TO_ADDRESS_CLOSED_CHANNEL_EXCEPTION);
        }
        throw new PortUnreachableException("sendToAddress failed");
    }

    public final int sendToAddresses(long j2, int i2, InetAddress inetAddress, int i3) throws PortUnreachableException {
        byte[] bArrIpv4MappedIpv6Address;
        int scopeId;
        if (inetAddress instanceof Inet6Address) {
            byte[] address = inetAddress.getAddress();
            scopeId = ((Inet6Address) inetAddress).getScopeId();
            bArrIpv4MappedIpv6Address = address;
        } else {
            bArrIpv4MappedIpv6Address = NativeInetAddress.ipv4MappedIpv6Address(inetAddress.getAddress());
            scopeId = 0;
        }
        int iSendToAddresses = sendToAddresses(this.fd, j2, i2, bArrIpv4MappedIpv6Address, scopeId, i3);
        if (iSendToAddresses >= 0) {
            return iSendToAddresses;
        }
        if (iSendToAddresses != Errors.ERROR_ECONNREFUSED_NEGATIVE) {
            return Errors.ioResult("sendToAddresses", iSendToAddresses, CONNECTION_RESET_EXCEPTION_SENDMSG, SEND_TO_ADDRESSES_CLOSED_CHANNEL_EXCEPTION);
        }
        throw new PortUnreachableException("sendToAddresses failed");
    }

    public final void setBroadcast(boolean z2) {
        setBroadcast(this.fd, z2 ? 1 : 0);
    }

    public final void setKeepAlive(boolean z2) {
        setKeepAlive(this.fd, z2 ? 1 : 0);
    }

    public final void setReceiveBufferSize(int i2) {
        setReceiveBufferSize(this.fd, i2);
    }

    public final void setReuseAddress(boolean z2) {
        setReuseAddress(this.fd, z2 ? 1 : 0);
    }

    public final void setReusePort(boolean z2) {
        setReusePort(this.fd, z2 ? 1 : 0);
    }

    public final void setSendBufferSize(int i2) {
        setSendBufferSize(this.fd, i2);
    }

    public final void setSoLinger(int i2) {
        setSoLinger(this.fd, i2);
    }

    public final void setTcpNoDelay(boolean z2) {
        setTcpNoDelay(this.fd, z2 ? 1 : 0);
    }

    public final void setTrafficClass(int i2) {
        setTrafficClass(this.fd, i2);
    }

    public final void shutdown() {
        shutdown(true, true);
    }

    public final void shutdown(boolean z2, boolean z3) {
        int i2;
        int iInputShutdown;
        do {
            i2 = this.state;
            if (FileDescriptor.isClosed(i2)) {
                throw new ClosedChannelException();
            }
            iInputShutdown = (!z2 || FileDescriptor.isInputShutdown(i2)) ? i2 : FileDescriptor.inputShutdown(i2);
            if (z3 && !FileDescriptor.isOutputShutdown(iInputShutdown)) {
                iInputShutdown = FileDescriptor.outputShutdown(iInputShutdown);
            }
            if (iInputShutdown == i2) {
                return;
            }
        } while (!casState(i2, iInputShutdown));
        int iShutdown = shutdown(this.fd, z2, z3);
        if (iShutdown < 0) {
            Errors.ioResult("shutdown", iShutdown, CONNECTION_RESET_SHUTDOWN_EXCEPTION, SHUTDOWN_CLOSED_CHANNEL_EXCEPTION);
        }
    }

    @Override // io.netty.channel.unix.FileDescriptor
    public String toString() {
        return a.w(a.F("Socket{fd="), this.fd, AbstractJsonLexerKt.END_OBJ);
    }
}