QuicheQuicSslContext() — netty Function Reference

Source Code

codec-classes-quic/src/main/java/io/netty/handler/codec/quic/QuicheQuicSslContext.java lines 154–283

    QuicheQuicSslContext(boolean server, long sessionTimeout, long sessionCacheSize,
                         ClientAuth clientAuth, @Nullable TrustManagerFactory trustManagerFactory,
                         @Nullable KeyManagerFactory keyManagerFactory, String password,
                         @Nullable Mapping<? super String, ? extends QuicSslContext> mapping,
                         @Nullable Boolean earlyData, @Nullable BoringSSLKeylog keylog,
                         String[] applicationProtocols, Map.Entry<SslContextOption<?>, Object>... ctxOptions) {
        Quic.ensureAvailability();
        this.server = server;
        this.clientAuth = server ? checkNotNull(clientAuth, "clientAuth") : ClientAuth.NONE;
        final X509TrustManager trustManager;
        if (trustManagerFactory == null) {
            try {
                trustManagerFactory =
                        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
                trustManagerFactory.init((KeyStore) null);
                trustManager = chooseTrustManager(trustManagerFactory);
            } catch (Exception e) {
                throw new IllegalStateException(e);
            }
        } else {
            trustManager = chooseTrustManager(trustManagerFactory);
        }
        final X509ExtendedKeyManager keyManager;
        if (keyManagerFactory == null) {
            if (server) {
                throw new IllegalArgumentException("No KeyManagerFactory");
            }
            keyManager = null;
        } else {
            keyManager = chooseKeyManager(keyManagerFactory);
        }
        String[] groups = NAMED_GROUPS;
        String[] sigalgs = EmptyArrays.EMPTY_STRINGS;
        Map<String, String> serverKeyTypes = null;
        Set<String> clientKeyTypes = null;

        if (ctxOptions != null) {
            for (Map.Entry<SslContextOption<?>, Object> ctxOpt : ctxOptions) {
                SslContextOption<?> option = ctxOpt.getKey();

                if (option == BoringSSLContextOption.GROUPS) {
                    String[] groupsArray = (String[]) ctxOpt.getValue();
                    Set<String> groupsSet = new LinkedHashSet<String>(groupsArray.length);
                    for (String group : groupsArray) {
                        groupsSet.add(GroupsConverter.toBoringSSL(group));
                    }
                    groups = groupsSet.toArray(EmptyArrays.EMPTY_STRINGS);
                } else if (option == BoringSSLContextOption.SIGNATURE_ALGORITHMS) {
                    String[] sigalgsArray = (String[]) ctxOpt.getValue();
                    Set<String> sigalgsSet = new LinkedHashSet<String>(sigalgsArray.length);
                    for (String sigalg : sigalgsArray) {
                        sigalgsSet.add(sigalg);
                    }
                    sigalgs = sigalgsSet.toArray(EmptyArrays.EMPTY_STRINGS);
                } else if (option == BoringSSLContextOption.CLIENT_KEY_TYPES) {
                    clientKeyTypes = (Set<String>) ctxOpt.getValue();
                } else if (option == BoringSSLContextOption.SERVER_KEY_TYPES) {
                    serverKeyTypes = (Map<String, String>) ctxOpt.getValue();
                } else {
                    LOGGER.debug("Skipping unsupported " + SslContextOption.class.getSimpleName()
                            + ": " + ctxOpt.getKey());
                }
            }
        }
        final BoringSSLPrivateKeyMethod privateKeyMethod;
        if (keyManagerFactory instanceof  BoringSSLKeylessManagerFactory) {
            privateKeyMethod = new BoringSSLAsyncPrivateKeyMethodAdapter(engineMap,
                    ((BoringSSLKeylessManagerFactory) keyManagerFactory).privateKeyMethod);
        } else {
            privateKeyMethod = null;
        }
        sessionCache = server ? null : new QuicClientSessionCache();
        int verifyMode = server ? boringSSLVerifyModeForServer(this.clientAuth) : BoringSSL.SSL_VERIFY_PEER;
        nativeSslContext = new NativeSslContext(BoringSSL.SSLContext_new(server, applicationProtocols,
                new BoringSSLHandshakeCompleteCallback(engineMap),
                new BoringSSLCertificateCallback(engineMap, keyManager, password, serverKeyTypes, clientKeyTypes),
                new BoringSSLCertificateVerifyCallback(engineMap, trustManager),
                mapping == null ? null : new BoringSSLTlsextServernameCallback(engineMap, mapping),
                keylog == null ? null : new BoringSSLKeylogCallback(engineMap, keylog),
                server ? null : new BoringSSLSessionCallback(engineMap, sessionCache), privateKeyMethod,
                sessionTicketCallback, verifyMode,