ReferenceCountedOpenSslEngine() — netty Function Reference

Source Code

handler/src/main/java/io/netty/handler/ssl/ReferenceCountedOpenSslEngine.java lines 228–425

    ReferenceCountedOpenSslEngine(ReferenceCountedOpenSslContext context, final ByteBufAllocator alloc, String peerHost,
                                  int peerPort, boolean jdkCompatibilityMode, boolean leakDetection,
                                  String endpointIdentificationAlgorithm, List<SNIServerName> serverNames) {
        super(peerHost, peerPort);
        OpenSsl.ensureAvailability();
        engines = context.engines;
        enableOcsp = context.enableOcsp;
        groups = context.groups.clone();
        this.jdkCompatibilityMode = jdkCompatibilityMode;
        this.alloc = checkNotNull(alloc, "alloc");
        apn = (OpenSslApplicationProtocolNegotiator) context.applicationProtocolNegotiator();
        clientMode = context.isClient();
        this.endpointIdentificationAlgorithm = endpointIdentificationAlgorithm;
        this.serverNames = serverNames;

        session = new ExtendedOpenSslSession(new DefaultOpenSslSession(context.sessionContext())) {
            private String[] peerSupportedSignatureAlgorithms;
            private List<SNIServerName> requestedServerNames;

            @Override
            public List<SNIServerName> getRequestedServerNames() {
                if (clientMode) {
                    List<SNIServerName> names = ReferenceCountedOpenSslEngine.this.serverNames;
                    return names == null ? Collections.emptyList() : Collections.unmodifiableList(names);
                } else {
                    synchronized (ReferenceCountedOpenSslEngine.this) {
                        if (requestedServerNames == null) {
                            if (destroyed) {
                                requestedServerNames = Collections.emptyList();
                            } else {
                                String name = SSL.getSniHostname(ssl);
                                requestedServerNames = (name == null || name.isEmpty()) ?
                                        Collections.emptyList() :
                                        // Convert to bytes as we do not want to do any strict validation of the
                                        // SNIHostName while creating it.
                                        Collections.singletonList(new SNIHostName(name.getBytes(CharsetUtil.UTF_8)));
                            }
                        }
                        return requestedServerNames;
                    }
                }
            }

            @Override
            public String[] getPeerSupportedSignatureAlgorithms() {
                synchronized (ReferenceCountedOpenSslEngine.this) {
                    if (peerSupportedSignatureAlgorithms == null) {
                        if (destroyed) {
                            peerSupportedSignatureAlgorithms = EMPTY_STRINGS;
                        } else {
                            String[] algs = SSL.getSigAlgs(ssl);
                            if (algs == null) {
                                peerSupportedSignatureAlgorithms = EMPTY_STRINGS;
                            } else {
                                Set<String> algorithmList = new LinkedHashSet<>(algs.length);
                                for (String alg: algs) {
                                    String converted = SignatureAlgorithmConverter.toJavaName(alg);

                                    if (converted != null) {
                                        algorithmList.add(converted);
                                    }
                                }
                                peerSupportedSignatureAlgorithms = algorithmList.toArray(EMPTY_STRINGS);
                            }
                        }
                    }
                    return peerSupportedSignatureAlgorithms.clone();
                }
            }

            @Override
            public List<byte[]> getStatusResponses() {
                byte[] ocspResponse = null;
                if (enableOcsp && clientMode) {
                    synchronized (ReferenceCountedOpenSslEngine.this) {
                        if (!destroyed) {
                            ocspResponse = SSL.getOcspResponse(ssl);
                        }
                    }
                }
                return ocspResponse == null ?