Method initialize

libminifi/src/io/tls/TLSSocket.cpp:57–149

* The memory barrier is defined by the singleton */

 * The memory barrier is defined by the singleton
 */
int16_t TLSContext::initialize(bool server_method) {
  if (ctx) {
    return error_value;
  }

  logger_->log_debug("initializing %X", this);

  if (nullptr == OpenSSLInitializer::getInstance()) {
    return error_value;
  }

  std::string clientAuthStr;
  bool needClientCert = true;
  if (!(configure_->get(Configure::nifi_security_need_ClientAuth, clientAuthStr) && org::apache::nifi::minifi::utils::StringUtils::StringToBool(clientAuthStr, needClientCert))) {
    needClientCert = true;
  }
  const SSL_METHOD *method;
  method = server_method ? TLSv1_2_server_method() : TLSv1_2_client_method();
  auto local_context = std::unique_ptr<SSL_CTX, decltype(&deleteContext)>(SSL_CTX_new(method), deleteContext);
  if (local_context == nullptr) {
    logger_->log_error("Could not create SSL context, error: %s.", std::strerror(errno));
    error_value = TLS_ERROR_CONTEXT;
    return error_value;
  }

  if (needClientCert) {
    std::string certificate;
    std::string privatekey;
    std::string passphrase;
    std::string caCertificate;

    if (ssl_service_ != nullptr) {
      if (!ssl_service_->configure_ssl_context(local_context.get())) {
        error_value = TLS_ERROR_CERT_ERROR;
        return error_value;
      }
      ctx = std::move(local_context);
      error_value = TLS_GOOD;
      return 0;
    }

    if (!(configure_->get(Configure::nifi_security_client_certificate, certificate) && configure_->get(Configure::nifi_security_client_private_key, privatekey))) {
        logger_->log_error("Certificate and Private Key PEM file not configured, error: %s.", std::strerror(errno));
        error_value = TLS_ERROR_PEM_MISSING;
        return error_value;
    }
    // load certificates and private key in PEM format
    if (SSL_CTX_use_certificate_chain_file(local_context.get(), certificate.c_str()) <= 0) {
      logger_->log_error("Could not load certificate %s, for %X and %X error : %s", certificate, this, local_context.get(), std::strerror(errno));
      error_value = TLS_ERROR_CERT_MISSING;
      return error_value;
    }
    if (configure_->get(Configure::nifi_security_client_pass_phrase, passphrase)) {
      std::ifstream file(passphrase.c_str(), std::ifstream::in);
      if (file.good()) {
        // if we have been given a file copy that, otherwise treat the passphrase as a password
        std::string password;
        password.assign((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());