package io.netty.handler.ssl;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.handler.ssl.ApplicationProtocolConfig;
import io.netty.internal.tcnative.CertificateVerifier;
import io.netty.internal.tcnative.SSL;
import io.netty.internal.tcnative.SSLContext;
import io.netty.util.AbstractReferenceCounted;
import io.netty.util.ReferenceCounted;
import io.netty.util.ResourceLeakDetector;
import io.netty.util.ResourceLeakDetectorFactory;
import io.netty.util.ResourceLeakTracker;
import io.netty.util.internal.ObjectUtil;
import io.netty.util.internal.PlatformDependent;
import io.netty.util.internal.SystemPropertyUtil;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.security.AccessController;
import java.security.PrivateKey;
import java.security.PrivilegedAction;
import java.security.cert.CertPathValidatorException;
import java.security.cert.Certificate;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.CertificateRevokedException;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import javax.net.ssl.KeyManager;
import javax.net.ssl.SSLEngine;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509ExtendedKeyManager;
import javax.net.ssl.X509ExtendedTrustManager;
import javax.net.ssl.X509KeyManager;
import javax.net.ssl.X509TrustManager;

/* JADX INFO: loaded from: classes.dex */
public abstract class ReferenceCountedOpenSslContext extends SslContext implements ReferenceCounted {
    private static final Integer DH_KEY_LENGTH;
    public static final int VERIFY_DEPTH = 10;
    private final OpenSslApplicationProtocolNegotiator apn;
    private volatile int bioNonApplicationBufferSize;
    public final ClientAuth clientAuth;
    public long ctx;
    public final ReadWriteLock ctxLock;
    public final boolean enableOcsp;
    public final OpenSslEngineMap engineMap;
    public final Certificate[] keyCertChain;
    private final ResourceLeakTracker<ReferenceCountedOpenSslContext> leak;
    private final int mode;
    public final String[] protocols;
    private final AbstractReferenceCounted refCnt;
    private final long sessionCacheSize;
    private final long sessionTimeout;
    private final List<String> unmodifiableCiphers;
    private static final InternalLogger logger = InternalLoggerFactory.getInstance((Class<?>) ReferenceCountedOpenSslContext.class);
    private static final int DEFAULT_BIO_NON_APPLICATION_BUFFER_SIZE = ((Integer) AccessController.doPrivileged(new PrivilegedAction<Integer>() { // from class: io.netty.handler.ssl.ReferenceCountedOpenSslContext.1
        /* JADX WARN: Can't rename method to resolve collision */
        @Override // java.security.PrivilegedAction
        public Integer run() {
            return Integer.valueOf(Math.max(1, SystemPropertyUtil.getInt("io.netty.handler.ssl.openssl.bioNonApplicationBufferSize", 2048)));
        }
    })).intValue();
    private static final ResourceLeakDetector<ReferenceCountedOpenSslContext> leakDetector = ResourceLeakDetectorFactory.instance().newResourceLeakDetector(ReferenceCountedOpenSslContext.class);
    public static final OpenSslApplicationProtocolNegotiator NONE_PROTOCOL_NEGOTIATOR = new OpenSslApplicationProtocolNegotiator() { // from class: io.netty.handler.ssl.ReferenceCountedOpenSslContext.3
        @Override // io.netty.handler.ssl.OpenSslApplicationProtocolNegotiator
        public ApplicationProtocolConfig.Protocol protocol() {
            return ApplicationProtocolConfig.Protocol.NONE;
        }

        @Override // io.netty.handler.ssl.ApplicationProtocolNegotiator
        public List<String> protocols() {
            return Collections.emptyList();
        }

        @Override // io.netty.handler.ssl.OpenSslApplicationProtocolNegotiator
        public ApplicationProtocolConfig.SelectedListenerFailureBehavior selectedListenerFailureBehavior() {
            return ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT;
        }

        @Override // io.netty.handler.ssl.OpenSslApplicationProtocolNegotiator
        public ApplicationProtocolConfig.SelectorFailureBehavior selectorFailureBehavior() {
            return ApplicationProtocolConfig.SelectorFailureBehavior.CHOOSE_MY_LAST_PROTOCOL;
        }
    };

    /* JADX INFO: renamed from: io.netty.handler.ssl.ReferenceCountedOpenSslContext$5, reason: invalid class name */
    public static /* synthetic */ class AnonymousClass5 {
        public static final /* synthetic */ int[] $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$Protocol;
        public static final /* synthetic */ int[] $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$SelectedListenerFailureBehavior;
        public static final /* synthetic */ int[] $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$SelectorFailureBehavior;

        static {
            ApplicationProtocolConfig.SelectedListenerFailureBehavior.values();
            int[] iArr = new int[3];
            $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$SelectedListenerFailureBehavior = iArr;
            try {
                iArr[ApplicationProtocolConfig.SelectedListenerFailureBehavior.CHOOSE_MY_LAST_PROTOCOL.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$SelectedListenerFailureBehavior[ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            ApplicationProtocolConfig.SelectorFailureBehavior.values();
            int[] iArr2 = new int[3];
            $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$SelectorFailureBehavior = iArr2;
            try {
                iArr2[ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE.ordinal()] = 1;
            } catch (NoSuchFieldError unused3) {
            }
            try {
                $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$SelectorFailureBehavior[ApplicationProtocolConfig.SelectorFailureBehavior.CHOOSE_MY_LAST_PROTOCOL.ordinal()] = 2;
            } catch (NoSuchFieldError unused4) {
            }
            ApplicationProtocolConfig.Protocol.values();
            int[] iArr3 = new int[4];
            $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$Protocol = iArr3;
            try {
                iArr3[ApplicationProtocolConfig.Protocol.NPN.ordinal()] = 1;
            } catch (NoSuchFieldError unused5) {
            }
            try {
                $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$Protocol[ApplicationProtocolConfig.Protocol.ALPN.ordinal()] = 2;
            } catch (NoSuchFieldError unused6) {
            }
            try {
                $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$Protocol[ApplicationProtocolConfig.Protocol.NPN_AND_ALPN.ordinal()] = 3;
            } catch (NoSuchFieldError unused7) {
            }
            try {
                $SwitchMap$io$netty$handler$ssl$ApplicationProtocolConfig$Protocol[ApplicationProtocolConfig.Protocol.NONE.ordinal()] = 4;
            } catch (NoSuchFieldError unused8) {
            }
        }
    }

    public static abstract class AbstractCertificateVerifier extends CertificateVerifier {
        private final OpenSslEngineMap engineMap;

        public AbstractCertificateVerifier(OpenSslEngineMap openSslEngineMap) {
            this.engineMap = openSslEngineMap;
        }

        public final int verify(long j2, byte[][] bArr, String str) {
            X509Certificate[] x509CertificateArrCertificates = ReferenceCountedOpenSslContext.certificates(bArr);
            ReferenceCountedOpenSslEngine referenceCountedOpenSslEngine = this.engineMap.get(j2);
            try {
                verify(referenceCountedOpenSslEngine, x509CertificateArrCertificates, str);
                return CertificateVerifier.X509_V_OK;
            } catch (Throwable th) {
                ReferenceCountedOpenSslContext.logger.debug("verification of certificate failed", (Throwable) th);
                SSLHandshakeException sSLHandshakeException = new SSLHandshakeException("General OpenSslEngine problem");
                sSLHandshakeException.initCause(th);
                referenceCountedOpenSslEngine.handshakeException = sSLHandshakeException;
                if (th instanceof OpenSslCertificateException) {
                    return th.errorCode();
                }
                if (th instanceof CertificateExpiredException) {
                    return CertificateVerifier.X509_V_ERR_CERT_HAS_EXPIRED;
                }
                if (th instanceof CertificateNotYetValidException) {
                    return CertificateVerifier.X509_V_ERR_CERT_NOT_YET_VALID;
                }
                if (PlatformDependent.javaVersion() >= 7) {
                    if (th instanceof CertificateRevokedException) {
                        return CertificateVerifier.X509_V_ERR_CERT_REVOKED;
                    }
                    for (Throwable cause = th.getCause(); cause != null; cause = cause.getCause()) {
                        if (cause instanceof CertPathValidatorException) {
                            CertPathValidatorException.Reason reason = ((CertPathValidatorException) cause).getReason();
                            if (reason == CertPathValidatorException.BasicReason.EXPIRED) {
                                return CertificateVerifier.X509_V_ERR_CERT_HAS_EXPIRED;
                            }
                            if (reason == CertPathValidatorException.BasicReason.NOT_YET_VALID) {
                                return CertificateVerifier.X509_V_ERR_CERT_NOT_YET_VALID;
                            }
                            if (reason == CertPathValidatorException.BasicReason.REVOKED) {
                                return CertificateVerifier.X509_V_ERR_CERT_REVOKED;
                            }
                        }
                    }
                }
                return CertificateVerifier.X509_V_ERR_UNSPECIFIED;
            }
        }

        public abstract void verify(ReferenceCountedOpenSslEngine referenceCountedOpenSslEngine, X509Certificate[] x509CertificateArr, String str);
    }

    public static final class DefaultOpenSslEngineMap implements OpenSslEngineMap {
        private final Map<Long, ReferenceCountedOpenSslEngine> engines;

        private DefaultOpenSslEngineMap() {
            this.engines = PlatformDependent.newConcurrentHashMap();
        }

        @Override // io.netty.handler.ssl.OpenSslEngineMap
        public void add(ReferenceCountedOpenSslEngine referenceCountedOpenSslEngine) {
            this.engines.put(Long.valueOf(referenceCountedOpenSslEngine.sslPointer()), referenceCountedOpenSslEngine);
        }

        @Override // io.netty.handler.ssl.OpenSslEngineMap
        public ReferenceCountedOpenSslEngine get(long j2) {
            return this.engines.get(Long.valueOf(j2));
        }

        @Override // io.netty.handler.ssl.OpenSslEngineMap
        public ReferenceCountedOpenSslEngine remove(long j2) {
            return this.engines.remove(Long.valueOf(j2));
        }
    }

    static {
        Integer numValueOf = null;
        try {
            String str = (String) AccessController.doPrivileged(new PrivilegedAction<String>() { // from class: io.netty.handler.ssl.ReferenceCountedOpenSslContext.4
                @Override // java.security.PrivilegedAction
                public String run() {
                    return SystemPropertyUtil.get("jdk.tls.ephemeralDHKeySize");
                }
            });
            if (str != null) {
                try {
                    numValueOf = Integer.valueOf(str);
                } catch (NumberFormatException unused) {
                    logger.debug("ReferenceCountedOpenSslContext supports -Djdk.tls.ephemeralDHKeySize={int}, but got: " + str);
                }
            }
        } catch (Throwable unused2) {
        }
        DH_KEY_LENGTH = numValueOf;
    }

    public ReferenceCountedOpenSslContext(Iterable<String> iterable, CipherSuiteFilter cipherSuiteFilter, ApplicationProtocolConfig applicationProtocolConfig, long j2, long j3, int i2, Certificate[] certificateArr, ClientAuth clientAuth, String[] strArr, boolean z2, boolean z3, boolean z4) {
        this(iterable, cipherSuiteFilter, toNegotiator(applicationProtocolConfig), j2, j3, i2, certificateArr, clientAuth, strArr, z2, z3, z4);
    }

    /* JADX WARN: Multi-variable type inference failed */
    public ReferenceCountedOpenSslContext(Iterable<String> iterable, CipherSuiteFilter cipherSuiteFilter, OpenSslApplicationProtocolNegotiator openSslApplicationProtocolNegotiator, long j2, long j3, int i2, Certificate[] certificateArr, ClientAuth clientAuth, String[] strArr, boolean z2, boolean z3, boolean z4) {
        long j4;
        super(z2);
        this.refCnt = new AbstractReferenceCounted() { // from class: io.netty.handler.ssl.ReferenceCountedOpenSslContext.2
            public static final /* synthetic */ boolean $assertionsDisabled = false;

            @Override // io.netty.util.AbstractReferenceCounted
            public void deallocate() {
                ReferenceCountedOpenSslContext.this.destroy();
                if (ReferenceCountedOpenSslContext.this.leak != null) {
                    ReferenceCountedOpenSslContext.this.leak.close(ReferenceCountedOpenSslContext.this);
                }
            }

            @Override // io.netty.util.ReferenceCounted
            public ReferenceCounted touch(Object obj) {
                if (ReferenceCountedOpenSslContext.this.leak != null) {
                    ReferenceCountedOpenSslContext.this.leak.record(obj);
                }
                return ReferenceCountedOpenSslContext.this;
            }
        };
        this.engineMap = new DefaultOpenSslEngineMap();
        this.ctxLock = new ReentrantReadWriteLock();
        this.bioNonApplicationBufferSize = DEFAULT_BIO_NON_APPLICATION_BUFFER_SIZE;
        OpenSsl.ensureAvailability();
        if (z3 && !OpenSsl.isOcspSupported()) {
            throw new IllegalStateException("OCSP is not supported.");
        }
        if (i2 != 1 && i2 != 0) {
            throw new IllegalArgumentException("mode most be either SSL.SSL_MODE_SERVER or SSL.SSL_MODE_CLIENT");
        }
        this.leak = z4 ? leakDetector.track(this) : null;
        this.mode = i2;
        this.clientAuth = isServer() ? (ClientAuth) ObjectUtil.checkNotNull(clientAuth, "clientAuth") : ClientAuth.NONE;
        this.protocols = strArr;
        this.enableOcsp = z3;
        this.keyCertChain = certificateArr != null ? (Certificate[]) certificateArr.clone() : null;
        List<String> listAsList = Arrays.asList(((CipherSuiteFilter) ObjectUtil.checkNotNull(cipherSuiteFilter, "cipherFilter")).filterCipherSuites(iterable, OpenSsl.DEFAULT_CIPHERS, OpenSsl.availableJavaCipherSuites()));
        this.unmodifiableCiphers = listAsList;
        this.apn = (OpenSslApplicationProtocolNegotiator) ObjectUtil.checkNotNull(openSslApplicationProtocolNegotiator, "apn");
        try {
            try {
                long jMake = SSLContext.make(31, i2);
                this.ctx = jMake;
                SSLContext.setOptions(jMake, SSLContext.getOptions(jMake) | SSL.SSL_OP_NO_SSLv2 | SSL.SSL_OP_NO_SSLv3 | SSL.SSL_OP_CIPHER_SERVER_PREFERENCE | SSL.SSL_OP_NO_COMPRESSION | SSL.SSL_OP_NO_TICKET);
                long j5 = this.ctx;
                SSLContext.setMode(j5, SSLContext.getMode(j5) | SSL.SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
                Integer num = DH_KEY_LENGTH;
                if (num != null) {
                    SSLContext.setTmpDHLength(this.ctx, num.intValue());
                }
                try {
                    SSLContext.setCipherSuite(this.ctx, CipherSuiteConverter.toOpenSsl(listAsList));
                    List<String> listProtocols = openSslApplicationProtocolNegotiator.protocols();
                    if (!listProtocols.isEmpty()) {
                        String[] strArr2 = (String[]) listProtocols.toArray(new String[listProtocols.size()]);
                        int iOpensslSelectorFailureBehavior = opensslSelectorFailureBehavior(openSslApplicationProtocolNegotiator.selectorFailureBehavior());
                        int iOrdinal = openSslApplicationProtocolNegotiator.protocol().ordinal();
                        if (iOrdinal != 1) {
                            if (iOrdinal == 2) {
                                j4 = this.ctx;
                            } else {
                                if (iOrdinal != 3) {
                                    throw new Error();
                                }
                                SSLContext.setNpnProtos(this.ctx, strArr2, iOpensslSelectorFailureBehavior);
                                j4 = this.ctx;
                            }
                            SSLContext.setAlpnProtos(j4, strArr2, iOpensslSelectorFailureBehavior);
                        } else {
                            SSLContext.setNpnProtos(this.ctx, strArr2, iOpensslSelectorFailureBehavior);
                        }
                    }
                    if (j2 > 0) {
                        this.sessionCacheSize = j2;
                        SSLContext.setSessionCacheSize(this.ctx, j2);
                    } else {
                        long sessionCacheSize = SSLContext.setSessionCacheSize(this.ctx, 20480L);
                        this.sessionCacheSize = sessionCacheSize;
                        SSLContext.setSessionCacheSize(this.ctx, sessionCacheSize);
                    }
                    if (j3 > 0) {
                        this.sessionTimeout = j3;
                        SSLContext.setSessionCacheTimeout(this.ctx, j3);
                    } else {
                        long sessionCacheTimeout = SSLContext.setSessionCacheTimeout(this.ctx, 300L);
                        this.sessionTimeout = sessionCacheTimeout;
                        SSLContext.setSessionCacheTimeout(this.ctx, sessionCacheTimeout);
                    }
                    if (z3) {
                        SSLContext.enableOcsp(this.ctx, isClient());
                    }
                } catch (SSLException e2) {
                    throw e2;
                } catch (Exception e3) {
                    throw new SSLException("failed to set cipher suite: " + this.unmodifiableCiphers, e3);
                }
            } catch (Exception e4) {
                throw new SSLException("failed to create an SSL_CTX", e4);
            }
        } catch (Throwable th) {
            release();
            throw th;
        }
    }

    public static X509Certificate[] certificates(byte[][] bArr) {
        int length = bArr.length;
        X509Certificate[] x509CertificateArr = new X509Certificate[length];
        for (int i2 = 0; i2 < length; i2++) {
            x509CertificateArr[i2] = new OpenSslX509Certificate(bArr[i2]);
        }
        return x509CertificateArr;
    }

    public static X509TrustManager chooseTrustManager(TrustManager[] trustManagerArr) {
        for (TrustManager trustManager : trustManagerArr) {
            if (trustManager instanceof X509TrustManager) {
                return (X509TrustManager) trustManager;
            }
        }
        throw new IllegalStateException("no X509TrustManager found");
    }

    public static X509KeyManager chooseX509KeyManager(KeyManager[] keyManagerArr) {
        for (KeyManager keyManager : keyManagerArr) {
            if (keyManager instanceof X509KeyManager) {
                return (X509KeyManager) keyManager;
            }
        }
        throw new IllegalStateException("no X509KeyManager found");
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void destroy() {
        Lock lockWriteLock = this.ctxLock.writeLock();
        lockWriteLock.lock();
        try {
            long j2 = this.ctx;
            if (j2 != 0) {
                if (this.enableOcsp) {
                    SSLContext.disableOcsp(j2);
                }
                SSLContext.free(this.ctx);
                this.ctx = 0L;
            }
        } finally {
            lockWriteLock.unlock();
        }
    }

    public static void freeBio(long j2) {
        if (j2 != 0) {
            SSL.freeBIO(j2);
        }
    }

    private static long newBIO(ByteBuf byteBuf) {
        try {
            long jNewMemBIO = SSL.newMemBIO();
            int i2 = byteBuf.readableBytes();
            if (SSL.bioWrite(jNewMemBIO, OpenSsl.memoryAddress(byteBuf) + ((long) byteBuf.readerIndex()), i2) == i2) {
                return jNewMemBIO;
            }
            SSL.freeBIO(jNewMemBIO);
            throw new IllegalStateException("Could not write data to memory BIO");
        } finally {
            byteBuf.release();
        }
    }

    private static int opensslSelectorFailureBehavior(ApplicationProtocolConfig.SelectorFailureBehavior selectorFailureBehavior) {
        int iOrdinal = selectorFailureBehavior.ordinal();
        if (iOrdinal == 1) {
            return 0;
        }
        if (iOrdinal == 2) {
            return 1;
        }
        throw new Error();
    }

    /* JADX WARN: Removed duplicated region for block: B:14:0x002e  */
    /* JADX WARN: Removed duplicated region for block: B:16:0x0032  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct add '--show-bad-code' argument
    */
    public static void setKeyMaterial(long r15, java.security.cert.X509Certificate[] r17, java.security.PrivateKey r18, java.lang.String r19) {
        /*
            r1 = 0
            r3 = 0
            io.netty.buffer.ByteBufAllocator r0 = io.netty.buffer.ByteBufAllocator.DEFAULT     // Catch: java.lang.Throwable -> L59 java.lang.Exception -> L5d javax.net.ssl.SSLException -> L68
            r4 = 1
            r5 = r17
            io.netty.handler.ssl.PemEncoded r3 = io.netty.handler.ssl.PemX509Certificate.toPEM(r0, r4, r5)     // Catch: java.lang.Throwable -> L59 java.lang.Exception -> L5d javax.net.ssl.SSLException -> L68
            io.netty.handler.ssl.PemEncoded r5 = r3.retain()     // Catch: java.lang.Throwable -> L59 java.lang.Exception -> L5d javax.net.ssl.SSLException -> L68
            long r13 = toBIO(r0, r5)     // Catch: java.lang.Throwable -> L59 java.lang.Exception -> L5d javax.net.ssl.SSLException -> L68
            io.netty.handler.ssl.PemEncoded r5 = r3.retain()     // Catch: java.lang.Throwable -> L50 java.lang.Exception -> L53 javax.net.ssl.SSLException -> L56
            long r10 = toBIO(r0, r5)     // Catch: java.lang.Throwable -> L50 java.lang.Exception -> L53 javax.net.ssl.SSLException -> L56
            if (r18 == 0) goto L2c
            long r1 = toBIO(r18)     // Catch: java.lang.Throwable -> L23 java.lang.Exception -> L26 javax.net.ssl.SSLException -> L29
            goto L2c
        L23:
            r0 = move-exception
            r4 = r10
            goto L6d
        L26:
            r0 = move-exception
            r4 = r10
            goto L60
        L29:
            r0 = move-exception
            r4 = r10
            goto L6b
        L2c:
            if (r19 != 0) goto L32
            java.lang.String r0 = ""
            r12 = r0
            goto L34
        L32:
            r12 = r19
        L34:
            r6 = r15
            r8 = r13
            r4 = r10
            r10 = r1
            io.netty.internal.tcnative.SSLContext.setCertificateBio(r6, r8, r10, r12)     // Catch: java.lang.Exception -> L4c javax.net.ssl.SSLException -> L4e java.lang.Throwable -> L6c
            r0 = 1
            io.netty.internal.tcnative.SSLContext.setCertificateChainBio(r6, r4, r0)     // Catch: java.lang.Exception -> L4c javax.net.ssl.SSLException -> L4e java.lang.Throwable -> L6c
            freeBio(r1)
            freeBio(r13)
            freeBio(r4)
            r3.release()
            return
        L4c:
            r0 = move-exception
            goto L60
        L4e:
            r0 = move-exception
            goto L6b
        L50:
            r0 = move-exception
            r4 = r1
            goto L6d
        L53:
            r0 = move-exception
            r4 = r1
            goto L60
        L56:
            r0 = move-exception
            r4 = r1
            goto L6b
        L59:
            r0 = move-exception
            r4 = r1
            r13 = r4
            goto L6d
        L5d:
            r0 = move-exception
            r4 = r1
            r13 = r4
        L60:
            javax.net.ssl.SSLException r6 = new javax.net.ssl.SSLException     // Catch: java.lang.Throwable -> L6c
            java.lang.String r7 = "failed to set certificate and key"
            r6.<init>(r7, r0)     // Catch: java.lang.Throwable -> L6c
            throw r6     // Catch: java.lang.Throwable -> L6c
        L68:
            r0 = move-exception
            r4 = r1
            r13 = r4
        L6b:
            throw r0     // Catch: java.lang.Throwable -> L6c
        L6c:
            r0 = move-exception
        L6d:
            freeBio(r1)
            freeBio(r13)
            freeBio(r4)
            if (r3 == 0) goto L7b
            r3.release()
        L7b:
            throw r0
        */
        throw new UnsupportedOperationException("Method not decompiled: io.netty.handler.ssl.ReferenceCountedOpenSslContext.setKeyMaterial(long, java.security.cert.X509Certificate[], java.security.PrivateKey, java.lang.String):void");
    }

    public static long toBIO(ByteBufAllocator byteBufAllocator, PemEncoded pemEncoded) {
        try {
            ByteBuf byteBufContent = pemEncoded.content();
            if (byteBufContent.isDirect()) {
                return newBIO(byteBufContent.retainedSlice());
            }
            ByteBuf byteBufDirectBuffer = byteBufAllocator.directBuffer(byteBufContent.readableBytes());
            try {
                byteBufDirectBuffer.writeBytes(byteBufContent, byteBufContent.readerIndex(), byteBufContent.readableBytes());
                long jNewBIO = newBIO(byteBufDirectBuffer.retainedSlice());
                try {
                    if (pemEncoded.isSensitive()) {
                        SslUtils.zeroout(byteBufDirectBuffer);
                    }
                    return jNewBIO;
                } finally {
                }
            } catch (Throwable th) {
                try {
                    if (pemEncoded.isSensitive()) {
                        SslUtils.zeroout(byteBufDirectBuffer);
                    }
                    throw th;
                } finally {
                }
            }
        } finally {
            pemEncoded.release();
        }
    }

    public static long toBIO(PrivateKey privateKey) {
        if (privateKey == null) {
            return 0L;
        }
        ByteBufAllocator byteBufAllocator = ByteBufAllocator.DEFAULT;
        PemEncoded pem = PemPrivateKey.toPEM(byteBufAllocator, true, privateKey);
        try {
            return toBIO(byteBufAllocator, pem.retain());
        } finally {
            pem.release();
        }
    }

    public static long toBIO(X509Certificate... x509CertificateArr) {
        if (x509CertificateArr == null) {
            return 0L;
        }
        if (x509CertificateArr.length == 0) {
            throw new IllegalArgumentException("certChain can't be empty");
        }
        ByteBufAllocator byteBufAllocator = ByteBufAllocator.DEFAULT;
        PemEncoded pem = PemX509Certificate.toPEM(byteBufAllocator, true, x509CertificateArr);
        try {
            return toBIO(byteBufAllocator, pem.retain());
        } finally {
            pem.release();
        }
    }

    public static OpenSslApplicationProtocolNegotiator toNegotiator(ApplicationProtocolConfig applicationProtocolConfig) {
        int iOrdinal;
        if (applicationProtocolConfig != null && (iOrdinal = applicationProtocolConfig.protocol().ordinal()) != 0) {
            if (iOrdinal != 1 && iOrdinal != 2 && iOrdinal != 3) {
                throw new Error();
            }
            int iOrdinal2 = applicationProtocolConfig.selectedListenerFailureBehavior().ordinal();
            if (iOrdinal2 != 0 && iOrdinal2 != 2) {
                throw new UnsupportedOperationException("OpenSSL provider does not support " + applicationProtocolConfig.selectedListenerFailureBehavior() + " behavior");
            }
            int iOrdinal3 = applicationProtocolConfig.selectorFailureBehavior().ordinal();
            if (iOrdinal3 == 1 || iOrdinal3 == 2) {
                return new OpenSslDefaultApplicationProtocolNegotiator(applicationProtocolConfig);
            }
            throw new UnsupportedOperationException("OpenSSL provider does not support " + applicationProtocolConfig.selectorFailureBehavior() + " behavior");
        }
        return NONE_PROTOCOL_NEGOTIATOR;
    }

    public static boolean useExtendedKeyManager(X509KeyManager x509KeyManager) {
        return PlatformDependent.javaVersion() >= 7 && (x509KeyManager instanceof X509ExtendedKeyManager);
    }

    public static boolean useExtendedTrustManager(X509TrustManager x509TrustManager) {
        return PlatformDependent.javaVersion() >= 7 && (x509TrustManager instanceof X509ExtendedTrustManager);
    }

    @Override // io.netty.handler.ssl.SslContext
    public ApplicationProtocolNegotiator applicationProtocolNegotiator() {
        return this.apn;
    }

    @Override // io.netty.handler.ssl.SslContext
    public final List<String> cipherSuites() {
        return this.unmodifiableCiphers;
    }

    @Deprecated
    public final long context() {
        Lock lock = this.ctxLock.readLock();
        lock.lock();
        try {
            return this.ctx;
        } finally {
            lock.unlock();
        }
    }

    public int getBioNonApplicationBufferSize() {
        return this.bioNonApplicationBufferSize;
    }

    @Deprecated
    public boolean getRejectRemoteInitiatedRenegotiation() {
        return true;
    }

    @Override // io.netty.handler.ssl.SslContext
    public final boolean isClient() {
        return this.mode == 0;
    }

    public abstract OpenSslKeyMaterialManager keyMaterialManager();

    @Override // io.netty.handler.ssl.SslContext
    public final SSLEngine newEngine(ByteBufAllocator byteBufAllocator) {
        return newEngine(byteBufAllocator, null, -1);
    }

    @Override // io.netty.handler.ssl.SslContext
    public final SSLEngine newEngine(ByteBufAllocator byteBufAllocator, String str, int i2) {
        return newEngine0(byteBufAllocator, str, i2, true);
    }

    public SSLEngine newEngine0(ByteBufAllocator byteBufAllocator, String str, int i2, boolean z2) {
        return new ReferenceCountedOpenSslEngine(this, byteBufAllocator, str, i2, z2, true);
    }

    @Override // io.netty.handler.ssl.SslContext
    public final SslHandler newHandler(ByteBufAllocator byteBufAllocator, String str, int i2, boolean z2) {
        return new SslHandler(newEngine0(byteBufAllocator, str, i2, false), z2);
    }

    @Override // io.netty.handler.ssl.SslContext
    public final SslHandler newHandler(ByteBufAllocator byteBufAllocator, boolean z2) {
        return new SslHandler(newEngine0(byteBufAllocator, null, -1, false), z2);
    }

    @Override // io.netty.util.ReferenceCounted
    public final int refCnt() {
        return this.refCnt.refCnt();
    }

    @Override // io.netty.util.ReferenceCounted
    public final boolean release() {
        return this.refCnt.release();
    }

    @Override // io.netty.util.ReferenceCounted
    public final boolean release(int i2) {
        return this.refCnt.release(i2);
    }

    @Override // io.netty.util.ReferenceCounted
    public final ReferenceCounted retain() {
        this.refCnt.retain();
        return this;
    }

    @Override // io.netty.util.ReferenceCounted
    public final ReferenceCounted retain(int i2) {
        this.refCnt.retain(i2);
        return this;
    }

    @Override // io.netty.handler.ssl.SslContext
    public final long sessionCacheSize() {
        return this.sessionCacheSize;
    }

    @Override // io.netty.handler.ssl.SslContext
    public abstract OpenSslSessionContext sessionContext();

    @Override // io.netty.handler.ssl.SslContext
    public final long sessionTimeout() {
        return this.sessionTimeout;
    }

    public void setBioNonApplicationBufferSize(int i2) {
        this.bioNonApplicationBufferSize = ObjectUtil.checkPositiveOrZero(i2, "bioNonApplicationBufferSize");
    }

    @Deprecated
    public void setRejectRemoteInitiatedRenegotiation(boolean z2) {
        if (!z2) {
            throw new UnsupportedOperationException("Renegotiation is not supported");
        }
    }

    @Deprecated
    public final void setTicketKeys(byte[] bArr) {
        sessionContext().setTicketKeys(bArr);
    }

    @Deprecated
    public final long sslCtxPointer() {
        Lock lock = this.ctxLock.readLock();
        lock.lock();
        try {
            return this.ctx;
        } finally {
            lock.unlock();
        }
    }

    @Deprecated
    public final OpenSslSessionStats stats() {
        return sessionContext().stats();
    }

    @Override // io.netty.util.ReferenceCounted
    public final ReferenceCounted touch() {
        this.refCnt.touch();
        return this;
    }

    @Override // io.netty.util.ReferenceCounted
    public final ReferenceCounted touch(Object obj) {
        this.refCnt.touch(obj);
        return this;
    }
}