void ValidateResultCallbackImpl::onSslHandshakeCancelled() { extended_socket_info_.reset(); }

                                                        uint8_t tls_alert) {

  if (!extended_socket_info_.has_value()) {

    return;

  }

  extended_socket_info_->setCertificateValidationStatus(detailed_status);

  extended_socket_info_->setCertificateValidationAlert(tls_alert);

  if (!error_details.empty()) {

    extended_socket_info_->setCertificateValidationError(error_details);

  }

  extended_socket_info_->onCertificateValidationCompleted(succeeded, true);

}

void CertificateSelectionCallbackImpl::onSslHandshakeCancelled() { extended_socket_info_.reset(); }

    OptRef<const Ssl::TlsContext> selected_ctx, bool staple) {

  if (!extended_socket_info_.has_value()) {

  extended_socket_info_->onCertificateSelectionCompleted(selected_ctx, staple, true);

}

SslExtendedSocketInfoImpl::~SslExtendedSocketInfoImpl() {

  if (cert_validate_result_callback_.has_value()) {

    cert_validate_result_callback_->onSslHandshakeCancelled();

  }

  if (cert_selection_callback_.has_value()) {

    cert_selection_callback_->onSslHandshakeCancelled();

  }

}

    Envoy::Ssl::ClientValidationStatus validated) {

  certificate_validation_status_ = validated;

}

Envoy::Ssl::ClientValidationStatus SslExtendedSocketInfoImpl::certificateValidationStatus() const {

  return certificate_validation_status_;

}

void SslExtendedSocketInfoImpl::onCertificateValidationCompleted(bool succeeded, bool async) {

  cert_validation_result_ =

      succeeded ? Ssl::ValidateStatus::Successful : Ssl::ValidateStatus::Failed;

  if (cert_validate_result_callback_.has_value()) {

    cert_validate_result_callback_.reset();

    if (async) {

      ssl_handshaker_.handshakeCallbacks()->onAsynchronousCertValidationComplete();

    }

  }

}

Ssl::ValidateResultCallbackPtr SslExtendedSocketInfoImpl::createValidateResultCallback() {

  auto callback = std::make_unique<ValidateResultCallbackImpl>(

      ssl_handshaker_.handshakeCallbacks()->connection().dispatcher(), *this);

  cert_validate_result_callback_ = *callback;

  cert_validation_result_ = Ssl::ValidateStatus::Pending;

  return callback;

}

    OptRef<const Ssl::TlsContext> selected_ctx, bool staple, bool async) {

  RELEASE_ASSERT(cert_selection_result_ == Ssl::CertificateSelectionStatus::Pending,

                 "onCertificateSelectionCompleted twice");

  if (!selected_ctx.has_value()) {

    cert_selection_result_ = Ssl::CertificateSelectionStatus::Failed;

  } else {

    cert_selection_result_ = Ssl::CertificateSelectionStatus::Successful;

    RELEASE_ASSERT(SSL_set_SSL_CTX(ssl_handshaker_.ssl(), selected_ctx->ssl_ctx_.get()) != nullptr,

                   "");

    if (staple) {

      RELEASE_ASSERT(selected_ctx->ocsp_response_,

                     "OCSP response must be present under OcspStapleAction::Staple");

      const std::vector<uint8_t>& resp_bytes = selected_ctx->ocsp_response_->rawBytes();

      const int rc =

          SSL_set_ocsp_response(ssl_handshaker_.ssl(), resp_bytes.data(), resp_bytes.size());

      RELEASE_ASSERT(rc != 0, "");

    }

  }

  if (cert_selection_callback_.has_value()) {

    cert_selection_callback_.reset();

    if (async) {

      ssl_handshaker_.handshakeCallbacks()->onAsynchronousCertificateSelectionComplete();

    }

  }

}

SslExtendedSocketInfoImpl::createCertificateSelectionCallback() {

  auto callback = std::make_unique<CertificateSelectionCallbackImpl>(

      ssl_handshaker_.handshakeCallbacks()->connection().dispatcher(), *this);

  cert_selection_callback_ = *callback;

  cert_selection_result_ = Ssl::CertificateSelectionStatus::Pending;

  return callback;

}

    : ssl_(std::move(ssl)), handshake_callbacks_(handshake_callbacks),

      extended_socket_info_(*this) {

  SSL_set_ex_data(ssl_.get(), ssl_extended_socket_info_index, &(this->extended_socket_info_));

}

Network::PostIoAction SslHandshakerImpl::doHandshake() {

  ASSERT(state_ != Ssl::SocketState::HandshakeComplete && state_ != Ssl::SocketState::ShutdownSent);

  int rc = SSL_do_handshake(ssl());

  if (rc == 1) {

    state_ = Ssl::SocketState::HandshakeComplete;

    handshake_callbacks_->onSuccess(ssl());

    return handshake_callbacks_->connection().state() == Network::Connection::State::Open

               ? PostIoAction::KeepOpen

               : PostIoAction::Close;

  } else {

    int err = SSL_get_error(ssl(), rc);

    ENVOY_CONN_LOG(trace, "ssl error occurred while read: {}", handshake_callbacks_->connection(),

                   Utility::getErrorDescription(err));

    switch (err) {

    case SSL_ERROR_WANT_READ:

    case SSL_ERROR_WANT_WRITE:

      return PostIoAction::KeepOpen;

    case SSL_ERROR_PENDING_CERTIFICATE:

    case SSL_ERROR_WANT_PRIVATE_KEY_OPERATION:

    case SSL_ERROR_WANT_CERTIFICATE_VERIFY:

    case SSL_ERROR_WANT_X509_LOOKUP:

      state_ = Ssl::SocketState::HandshakeInProgress;

      return PostIoAction::KeepOpen;

    default:

      handshake_callbacks_->onFailure();

      return PostIoAction::Close;

    }

  }

}