| // Copyright 2026 The BoringSSL Authors | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // https://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| //! TLS Errors | |
| use alloc::boxed::Box; | |
| use core::{ | |
| any::Any, | |
| ffi::{ | |
| CStr, | |
| c_int, | |
| c_uint, // | |
| }, | |
| fmt::{ | |
| Debug, | |
| Display, | |
| Formatter, | |
| Result as FmtResult, // | |
| }, // | |
| }; | |
| use bssl_macros::bssl_enum; | |
| use bssl_sys::LibCode; | |
| use bssl_x509::errors::{ | |
| PemReason, | |
| PkiError, // | |
| }; | |
| use crate::config::ConfigurationError; | |
| /// Top-level errors | |
| #[derive(Debug)] | |
| pub enum Error { | |
| /// Error reported by the BoringSSL library | |
| #[allow(private_interfaces)] | |
| Library(u32, Option<LibCode>, Option<i32>), | |
| /// Configuration errors | |
| Configuration(ConfigurationError), | |
| /// Other TLS errors with reason | |
| TlsReason(TlsErrorReason), | |
| /// PEM encoding failures | |
| PemReason(PemReason), | |
| /// Quic errors, | |
| Quic(QuicError), | |
| /// IO errors | |
| Io(IoError), | |
| /// PKI errors | |
| Pki(PkiError), | |
| /// Unknown error which should be reported as bug | |
| Unknown(Box<dyn Any + Send + Sync>), | |
| } | |
| impl From<PkiError> for Error { | |
| fn from(err: PkiError) -> Self { | |
| Self::Pki(err) | |
| } | |
| } | |
| impl Error { | |
| #[allow(irrefutable_let_patterns)] | |
| fn extract_err_from_code(packed_error: c_uint) -> Self { | |
| let lib = unsafe { | |
| // Safety: extracting error source does not have side-effect and only access static data. | |
| bssl_sys::ERR_GET_LIB(packed_error) | |
| }; | |
| let Ok(lib) = i32::try_from(lib) else { | |
| return Self::Library(packed_error, None, None); | |
| }; | |
| let Ok(lib) = LibCode::try_from(lib) else { | |
| return Self::Library(packed_error, None, None); | |
| }; | |
| let reason = unsafe { | |
| // Safety: extracting error reason does not have side-effect and only access static data. | |
| bssl_sys::ERR_GET_REASON(packed_error) | |
| }; | |
| let Ok(reason) = i32::try_from(reason) else { | |
| return Self::Library(packed_error, Some(lib), None); | |
| }; | |
| let ret_unknown_reason = || Self::Library(packed_error, Some(lib), Some(reason)); | |
| match lib { | |
| LibCode::Ssl => { | |
| let Ok(reason) = TlsErrorReason::try_from(reason) else { | |
| return ret_unknown_reason(); | |
| }; | |
| Self::TlsReason(reason) | |
| } | |
| LibCode::Pem => { | |
| let Ok(reason) = PemReason::try_from(reason) else { | |
| return ret_unknown_reason(); | |
| }; | |
| Self::PemReason(reason) | |
| } | |
| _ => Self::Library(packed_error, Some(lib), Some(reason)), | |
| } | |
| } | |
| fn is_trivial(&self) -> bool { | |
| matches!(self, Self::Library(0, _, _)) | |
| } | |
| pub(crate) fn extract_lib_err() -> Self { | |
| let packed_error = unsafe { | |
| // Safety: extracting error code does not have side-effect | |
| bssl_sys::ERR_get_error() | |
| }; | |
| let error = Self::extract_err_from_code(packed_error); | |
| unsafe { | |
| // Safety: we only clear the error queue on the current thread. | |
| bssl_sys::ERR_clear_error(); | |
| } | |
| error | |
| } | |
| pub(crate) fn extract_tls_err(code: c_int) -> Result<TlsRetryReason, Self> { | |
| let lib_err = Self::extract_lib_err(); | |
| if code == bssl_sys::SSL_ERROR_SSL { | |
| return Err(lib_err); | |
| } | |
| if let Ok(reason) = TlsRetryReason::try_from(code) { | |
| return Ok(reason); | |
| } | |
| if lib_err.is_trivial() { | |
| Err(Self::Unknown(Box::new(alloc::format!( | |
| "unknown tls error ({code})" | |
| )))) | |
| } else { | |
| Err(lib_err) | |
| } | |
| } | |
| } | |
| impl core::error::Error for Error { | |
| fn source(&self) -> Option<&(dyn core::error::Error + 'static)> { | |
| None | |
| } | |
| fn description(&self) -> &str { | |
| "BoringSSL error; use Display for details" | |
| } | |
| fn cause(&self) -> Option<&dyn core::error::Error> { | |
| self.source() | |
| } | |
| } | |
| impl Display for Error { | |
| fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { | |
| match self { | |
| &Error::Library(code, _, _) => { | |
| // Here the buffer is 120 bytes and BoringSSL uses this buffer size | |
| // to hold the error string. | |
| // Therefore, this ought to be sufficient for a human-readable message. | |
| let mut err_str = [0; bssl_sys::ERR_ERROR_STRING_BUF_LEN as usize]; | |
| unsafe { | |
| // Safety: | |
| // - err_str is non-null and valid, so we do not need FFI-specific pointer conversion. | |
| bssl_sys::ERR_error_string_n(code, err_str.as_mut_ptr(), err_str.len()); | |
| } | |
| let err_str = unsafe { | |
| // Safety: | |
| // - err_str is still valid; | |
| // - `ERR_error_string_n` guarantees that | |
| CStr::from_ptr(err_str.as_ptr()) | |
| }; | |
| f.write_str(&err_str.to_string_lossy()) | |
| } | |
| Error::Configuration(err) => Display::fmt(err, f), | |
| Error::TlsReason(err) => Display::fmt(err, f), | |
| Error::PemReason(err) => Debug::fmt(err, f), | |
| Error::Quic(err) => Display::fmt(err, f), | |
| Error::Io(err) => Display::fmt(err, f), | |
| Error::Pki(err) => Display::fmt(err, f), | |
| Error::Unknown(err) => err.fmt(f), | |
| } | |
| } | |
| } | |
| bssl_enum! { | |
| /// SSL reason codes. | |
| #[derive(Debug, Copy, Clone, PartialEq, Eq)] | |
| pub enum TlsErrorReason: i32 { | |
| /// `SSL_R_APP_DATA_IN_HANDSHAKE` | |
| AppDataInHandshake = bssl_sys::SSL_R_APP_DATA_IN_HANDSHAKE as i32, | |
| /// `SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT` | |
| AttemptToReuseSessionInDifferentContext = bssl_sys::SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT as i32, | |
| /// `SSL_R_BAD_ALERT` | |
| BadAlert = bssl_sys::SSL_R_BAD_ALERT as i32, | |
| /// `SSL_R_BAD_CHANGE_CIPHER_SPEC` | |
| BadChangeCipherSpec = bssl_sys::SSL_R_BAD_CHANGE_CIPHER_SPEC as i32, | |
| /// `SSL_R_BAD_DATA_RETURNED_BY_CALLBACK` | |
| BadDataReturnedByCallback = bssl_sys::SSL_R_BAD_DATA_RETURNED_BY_CALLBACK as i32, | |
| /// `SSL_R_BAD_DH_P_LENGTH` | |
| BadDhPLength = bssl_sys::SSL_R_BAD_DH_P_LENGTH as i32, | |
| /// `SSL_R_BAD_DIGEST_LENGTH` | |
| BadDigestLength = bssl_sys::SSL_R_BAD_DIGEST_LENGTH as i32, | |
| /// `SSL_R_BAD_ECC_CERT` | |
| BadEccCert = bssl_sys::SSL_R_BAD_ECC_CERT as i32, | |
| /// `SSL_R_BAD_ECPOINT` | |
| BadEcpoint = bssl_sys::SSL_R_BAD_ECPOINT as i32, | |
| /// `SSL_R_BAD_HANDSHAKE_RECORD` | |
| BadHandshakeRecord = bssl_sys::SSL_R_BAD_HANDSHAKE_RECORD as i32, | |
| /// `SSL_R_BAD_HELLO_REQUEST` | |
| BadHelloRequest = bssl_sys::SSL_R_BAD_HELLO_REQUEST as i32, | |
| /// `SSL_R_BAD_LENGTH` | |
| BadLength = bssl_sys::SSL_R_BAD_LENGTH as i32, | |
| /// `SSL_R_BAD_PACKET_LENGTH` | |
| BadPacketLength = bssl_sys::SSL_R_BAD_PACKET_LENGTH as i32, | |
| /// `SSL_R_BAD_RSA_ENCRYPT` | |
| BadRsaEncrypt = bssl_sys::SSL_R_BAD_RSA_ENCRYPT as i32, | |
| /// `SSL_R_BAD_SIGNATURE` | |
| BadSignature = bssl_sys::SSL_R_BAD_SIGNATURE as i32, | |
| /// `SSL_R_BAD_SRTP_MKI_VALUE` | |
| BadSrtpMkiValue = bssl_sys::SSL_R_BAD_SRTP_MKI_VALUE as i32, | |
| /// `SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST` | |
| BadSrtpProtectionProfileList = bssl_sys::SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST as i32, | |
| /// `SSL_R_BAD_SSL_FILETYPE` | |
| BadSslFiletype = bssl_sys::SSL_R_BAD_SSL_FILETYPE as i32, | |
| /// `SSL_R_BAD_WRITE_RETRY` | |
| BadWriteRetry = bssl_sys::SSL_R_BAD_WRITE_RETRY as i32, | |
| /// `SSL_R_BIO_NOT_SET` | |
| BioNotSet = bssl_sys::SSL_R_BIO_NOT_SET as i32, | |
| /// `SSL_R_BN_LIB` | |
| BnLib = bssl_sys::SSL_R_BN_LIB as i32, | |
| /// `SSL_R_BUFFER_TOO_SMALL` | |
| BufferTooSmall = bssl_sys::SSL_R_BUFFER_TOO_SMALL as i32, | |
| /// `SSL_R_CA_DN_LENGTH_MISMATCH` | |
| CaDnLengthMismatch = bssl_sys::SSL_R_CA_DN_LENGTH_MISMATCH as i32, | |
| /// `SSL_R_CA_DN_TOO_LONG` | |
| CaDnTooLong = bssl_sys::SSL_R_CA_DN_TOO_LONG as i32, | |
| /// `SSL_R_CCS_RECEIVED_EARLY` | |
| CcsReceivedEarly = bssl_sys::SSL_R_CCS_RECEIVED_EARLY as i32, | |
| /// `SSL_R_CERTIFICATE_VERIFY_FAILED` | |
| CertificateVerifyFailed = bssl_sys::SSL_R_CERTIFICATE_VERIFY_FAILED as i32, | |
| /// `SSL_R_CERT_CB_ERROR` | |
| CertCbError = bssl_sys::SSL_R_CERT_CB_ERROR as i32, | |
| /// `SSL_R_CERT_LENGTH_MISMATCH` | |
| CertLengthMismatch = bssl_sys::SSL_R_CERT_LENGTH_MISMATCH as i32, | |
| /// `SSL_R_CHANNEL_ID_NOT_P256` | |
| ChannelIdNotP256 = bssl_sys::SSL_R_CHANNEL_ID_NOT_P256 as i32, | |
| /// `SSL_R_CHANNEL_ID_SIGNATURE_INVALID` | |
| ChannelIdSignatureInvalid = bssl_sys::SSL_R_CHANNEL_ID_SIGNATURE_INVALID as i32, | |
| /// `SSL_R_CIPHER_OR_HASH_UNAVAILABLE` | |
| CipherOrHashUnavailable = bssl_sys::SSL_R_CIPHER_OR_HASH_UNAVAILABLE as i32, | |
| /// `SSL_R_CLIENTHELLO_PARSE_FAILED` | |
| ClienthelloParseFailed = bssl_sys::SSL_R_CLIENTHELLO_PARSE_FAILED as i32, | |
| /// `SSL_R_CLIENTHELLO_TLSEXT` | |
| ClienthelloTlsext = bssl_sys::SSL_R_CLIENTHELLO_TLSEXT as i32, | |
| /// `SSL_R_CONNECTION_REJECTED` | |
| ConnectionRejected = bssl_sys::SSL_R_CONNECTION_REJECTED as i32, | |
| /// `SSL_R_CONNECTION_TYPE_NOT_SET` | |
| ConnectionTypeNotSet = bssl_sys::SSL_R_CONNECTION_TYPE_NOT_SET as i32, | |
| /// `SSL_R_CUSTOM_EXTENSION_ERROR` | |
| CustomExtensionError = bssl_sys::SSL_R_CUSTOM_EXTENSION_ERROR as i32, | |
| /// `SSL_R_DATA_LENGTH_TOO_LONG` | |
| DataLengthTooLong = bssl_sys::SSL_R_DATA_LENGTH_TOO_LONG as i32, | |
| /// `SSL_R_DECODE_ERROR` | |
| DecodeError = bssl_sys::SSL_R_DECODE_ERROR as i32, | |
| /// `SSL_R_DECRYPTION_FAILED` | |
| DecryptionFailed = bssl_sys::SSL_R_DECRYPTION_FAILED as i32, | |
| /// `SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC` | |
| DecryptionFailedOrBadRecordMac = bssl_sys::SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC as i32, | |
| /// `SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG` | |
| DhPublicValueLengthIsWrong = bssl_sys::SSL_R_DH_PUBLIC_VALUE_LENGTH_IS_WRONG as i32, | |
| /// `SSL_R_DH_P_TOO_LONG` | |
| DhPTooLong = bssl_sys::SSL_R_DH_P_TOO_LONG as i32, | |
| /// `SSL_R_DIGEST_CHECK_FAILED` | |
| DigestCheckFailed = bssl_sys::SSL_R_DIGEST_CHECK_FAILED as i32, | |
| /// `SSL_R_DTLS_MESSAGE_TOO_BIG` | |
| DtlsMessageTooBig = bssl_sys::SSL_R_DTLS_MESSAGE_TOO_BIG as i32, | |
| /// `SSL_R_ECC_CERT_NOT_FOR_SIGNING` | |
| EccCertNotForSigning = bssl_sys::SSL_R_ECC_CERT_NOT_FOR_SIGNING as i32, | |
| /// `SSL_R_EMS_STATE_INCONSISTENT` | |
| EmsStateInconsistent = bssl_sys::SSL_R_EMS_STATE_INCONSISTENT as i32, | |
| /// `SSL_R_ENCRYPTED_LENGTH_TOO_LONG` | |
| EncryptedLengthTooLong = bssl_sys::SSL_R_ENCRYPTED_LENGTH_TOO_LONG as i32, | |
| /// `SSL_R_ERROR_ADDING_EXTENSION` | |
| ErrorAddingExtension = bssl_sys::SSL_R_ERROR_ADDING_EXTENSION as i32, | |
| /// `SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST` | |
| ErrorInReceivedCipherList = bssl_sys::SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST as i32, | |
| /// `SSL_R_ERROR_PARSING_EXTENSION` | |
| ErrorParsingExtension = bssl_sys::SSL_R_ERROR_PARSING_EXTENSION as i32, | |
| /// `SSL_R_EXCESSIVE_MESSAGE_SIZE` | |
| ExcessiveMessageSize = bssl_sys::SSL_R_EXCESSIVE_MESSAGE_SIZE as i32, | |
| /// `SSL_R_EXTRA_DATA_IN_MESSAGE` | |
| ExtraDataInMessage = bssl_sys::SSL_R_EXTRA_DATA_IN_MESSAGE as i32, | |
| /// `SSL_R_FRAGMENT_MISMATCH` | |
| FragmentMismatch = bssl_sys::SSL_R_FRAGMENT_MISMATCH as i32, | |
| /// `SSL_R_GOT_NEXT_PROTO_WITHOUT_EXTENSION` | |
| GotNextProtoWithoutExtension = bssl_sys::SSL_R_GOT_NEXT_PROTO_WITHOUT_EXTENSION as i32, | |
| /// `SSL_R_HANDSHAKE_FAILURE_ON_CLIENT_HELLO` | |
| HandshakeFailureOnClientHello = bssl_sys::SSL_R_HANDSHAKE_FAILURE_ON_CLIENT_HELLO as i32, | |
| /// `SSL_R_HTTPS_PROXY_REQUEST` | |
| HttpsProxyRequest = bssl_sys::SSL_R_HTTPS_PROXY_REQUEST as i32, | |
| /// `SSL_R_HTTP_REQUEST` | |
| HttpRequest = bssl_sys::SSL_R_HTTP_REQUEST as i32, | |
| /// `SSL_R_INAPPROPRIATE_FALLBACK` | |
| InappropriateFallback = bssl_sys::SSL_R_INAPPROPRIATE_FALLBACK as i32, | |
| /// `SSL_R_INVALID_COMMAND` | |
| InvalidCommand = bssl_sys::SSL_R_INVALID_COMMAND as i32, | |
| /// `SSL_R_INVALID_MESSAGE` | |
| InvalidMessage = bssl_sys::SSL_R_INVALID_MESSAGE as i32, | |
| /// `SSL_R_INVALID_SSL_SESSION` | |
| InvalidSslSession = bssl_sys::SSL_R_INVALID_SSL_SESSION as i32, | |
| /// `SSL_R_INVALID_TICKET_KEYS_LENGTH` | |
| InvalidTicketKeysLength = bssl_sys::SSL_R_INVALID_TICKET_KEYS_LENGTH as i32, | |
| /// `SSL_R_LENGTH_MISMATCH` | |
| LengthMismatch = bssl_sys::SSL_R_LENGTH_MISMATCH as i32, | |
| /// `SSL_R_MISSING_EXTENSION` | |
| MissingExtension = bssl_sys::SSL_R_MISSING_EXTENSION as i32, | |
| /// `SSL_R_MISSING_RSA_CERTIFICATE` | |
| MissingRsaCertificate = bssl_sys::SSL_R_MISSING_RSA_CERTIFICATE as i32, | |
| /// `SSL_R_MISSING_TMP_DH_KEY` | |
| MissingTmpDhKey = bssl_sys::SSL_R_MISSING_TMP_DH_KEY as i32, | |
| /// `SSL_R_MISSING_TMP_ECDH_KEY` | |
| MissingTmpEcdhKey = bssl_sys::SSL_R_MISSING_TMP_ECDH_KEY as i32, | |
| /// `SSL_R_MIXED_SPECIAL_OPERATOR_WITH_GROUPS` | |
| MixedSpecialOperatorWithGroups = bssl_sys::SSL_R_MIXED_SPECIAL_OPERATOR_WITH_GROUPS as i32, | |
| /// `SSL_R_MTU_TOO_SMALL` | |
| MtuTooSmall = bssl_sys::SSL_R_MTU_TOO_SMALL as i32, | |
| /// `SSL_R_NEGOTIATED_BOTH_NPN_AND_ALPN` | |
| NegotiatedBothNpnAndAlpn = bssl_sys::SSL_R_NEGOTIATED_BOTH_NPN_AND_ALPN as i32, | |
| /// `SSL_R_NESTED_GROUP` | |
| NestedGroup = bssl_sys::SSL_R_NESTED_GROUP as i32, | |
| /// `SSL_R_NO_CERTIFICATES_RETURNED` | |
| NoCertificatesReturned = bssl_sys::SSL_R_NO_CERTIFICATES_RETURNED as i32, | |
| /// `SSL_R_NO_CERTIFICATE_ASSIGNED` | |
| NoCertificateAssigned = bssl_sys::SSL_R_NO_CERTIFICATE_ASSIGNED as i32, | |
| /// `SSL_R_NO_CERTIFICATE_SET` | |
| NoCertificateSet = bssl_sys::SSL_R_NO_CERTIFICATE_SET as i32, | |
| /// `SSL_R_NO_CIPHERS_AVAILABLE` | |
| NoCiphersAvailable = bssl_sys::SSL_R_NO_CIPHERS_AVAILABLE as i32, | |
| /// `SSL_R_NO_CIPHERS_PASSED` | |
| NoCiphersPassed = bssl_sys::SSL_R_NO_CIPHERS_PASSED as i32, | |
| /// `SSL_R_NO_CIPHER_MATCH` | |
| NoCipherMatch = bssl_sys::SSL_R_NO_CIPHER_MATCH as i32, | |
| /// `SSL_R_NO_COMPRESSION_SPECIFIED` | |
| NoCompressionSpecified = bssl_sys::SSL_R_NO_COMPRESSION_SPECIFIED as i32, | |
| /// `SSL_R_NO_METHOD_SPECIFIED` | |
| NoMethodSpecified = bssl_sys::SSL_R_NO_METHOD_SPECIFIED as i32, | |
| /// `SSL_R_NO_PRIVATE_KEY_ASSIGNED` | |
| NoPrivateKeyAssigned = bssl_sys::SSL_R_NO_PRIVATE_KEY_ASSIGNED as i32, | |
| /// `SSL_R_NO_RENEGOTIATION` | |
| NoRenegotiation = bssl_sys::SSL_R_NO_RENEGOTIATION as i32, | |
| /// `SSL_R_NO_REQUIRED_DIGEST` | |
| NoRequiredDigest = bssl_sys::SSL_R_NO_REQUIRED_DIGEST as i32, | |
| /// `SSL_R_NO_SHARED_CIPHER` | |
| NoSharedCipher = bssl_sys::SSL_R_NO_SHARED_CIPHER as i32, | |
| /// `SSL_R_NULL_SSL_CTX` | |
| NullSslCtx = bssl_sys::SSL_R_NULL_SSL_CTX as i32, | |
| /// `SSL_R_NULL_SSL_METHOD_PASSED` | |
| NullSslMethodPassed = bssl_sys::SSL_R_NULL_SSL_METHOD_PASSED as i32, | |
| /// `SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED` | |
| OldSessionCipherNotReturned = bssl_sys::SSL_R_OLD_SESSION_CIPHER_NOT_RETURNED as i32, | |
| /// `SSL_R_OLD_SESSION_VERSION_NOT_RETURNED` | |
| OldSessionVersionNotReturned = bssl_sys::SSL_R_OLD_SESSION_VERSION_NOT_RETURNED as i32, | |
| /// `SSL_R_OUTPUT_ALIASES_INPUT` | |
| OutputAliasesInput = bssl_sys::SSL_R_OUTPUT_ALIASES_INPUT as i32, | |
| /// `SSL_R_PARSE_TLSEXT` | |
| ParseTlsext = bssl_sys::SSL_R_PARSE_TLSEXT as i32, | |
| /// `SSL_R_PATH_TOO_LONG` | |
| PathTooLong = bssl_sys::SSL_R_PATH_TOO_LONG as i32, | |
| /// `SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE` | |
| PeerDidNotReturnACertificate = bssl_sys::SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE as i32, | |
| /// `SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE` | |
| PeerErrorUnsupportedCertificateType = bssl_sys::SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE as i32, | |
| /// `SSL_R_PROTOCOL_IS_SHUTDOWN` | |
| ProtocolIsShutdown = bssl_sys::SSL_R_PROTOCOL_IS_SHUTDOWN as i32, | |
| /// `SSL_R_PSK_IDENTITY_NOT_FOUND` | |
| PskIdentityNotFound = bssl_sys::SSL_R_PSK_IDENTITY_NOT_FOUND as i32, | |
| /// `SSL_R_PSK_NO_CLIENT_CB` | |
| PskNoClientCb = bssl_sys::SSL_R_PSK_NO_CLIENT_CB as i32, | |
| /// `SSL_R_PSK_NO_SERVER_CB` | |
| PskNoServerCb = bssl_sys::SSL_R_PSK_NO_SERVER_CB as i32, | |
| /// `SSL_R_READ_TIMEOUT_EXPIRED` | |
| ReadTimeoutExpired = bssl_sys::SSL_R_READ_TIMEOUT_EXPIRED as i32, | |
| /// `SSL_R_RECORD_LENGTH_MISMATCH` | |
| RecordLengthMismatch = bssl_sys::SSL_R_RECORD_LENGTH_MISMATCH as i32, | |
| /// `SSL_R_RECORD_TOO_LARGE` | |
| RecordTooLarge = bssl_sys::SSL_R_RECORD_TOO_LARGE as i32, | |
| /// `SSL_R_RENEGOTIATION_ENCODING_ERR` | |
| RenegotiationEncodingErr = bssl_sys::SSL_R_RENEGOTIATION_ENCODING_ERR as i32, | |
| /// `SSL_R_RENEGOTIATION_MISMATCH` | |
| RenegotiationMismatch = bssl_sys::SSL_R_RENEGOTIATION_MISMATCH as i32, | |
| /// `SSL_R_REQUIRED_CIPHER_MISSING` | |
| RequiredCipherMissing = bssl_sys::SSL_R_REQUIRED_CIPHER_MISSING as i32, | |
| /// `SSL_R_RESUMED_EMS_SESSION_WITHOUT_EMS_EXTENSION` | |
| ResumedEmsSessionWithoutEmsExtension = bssl_sys::SSL_R_RESUMED_EMS_SESSION_WITHOUT_EMS_EXTENSION as i32, | |
| /// `SSL_R_RESUMED_NON_EMS_SESSION_WITH_EMS_EXTENSION` | |
| ResumedNonEmsSessionWithEmsExtension = bssl_sys::SSL_R_RESUMED_NON_EMS_SESSION_WITH_EMS_EXTENSION as i32, | |
| /// `SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING` | |
| ScsvReceivedWhenRenegotiating = bssl_sys::SSL_R_SCSV_RECEIVED_WHEN_RENEGOTIATING as i32, | |
| /// `SSL_R_SERVERHELLO_TLSEXT` | |
| ServerhelloTlsext = bssl_sys::SSL_R_SERVERHELLO_TLSEXT as i32, | |
| /// `SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED` | |
| SessionIdContextUninitialized = bssl_sys::SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED as i32, | |
| /// `SSL_R_SESSION_MAY_NOT_BE_CREATED` | |
| SessionMayNotBeCreated = bssl_sys::SSL_R_SESSION_MAY_NOT_BE_CREATED as i32, | |
| /// `SSL_R_SIGNATURE_ALGORITHMS_EXTENSION_SENT_BY_SERVER` | |
| SignatureAlgorithmsExtensionSentByServer = bssl_sys::SSL_R_SIGNATURE_ALGORITHMS_EXTENSION_SENT_BY_SERVER as i32, | |
| /// `SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES` | |
| SrtpCouldNotAllocateProfiles = bssl_sys::SSL_R_SRTP_COULD_NOT_ALLOCATE_PROFILES as i32, | |
| /// `SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE` | |
| SrtpUnknownProtectionProfile = bssl_sys::SSL_R_SRTP_UNKNOWN_PROTECTION_PROFILE as i32, | |
| /// `SSL_R_SSL3_EXT_INVALID_SERVERNAME` | |
| Ssl3ExtInvalidServername = bssl_sys::SSL_R_SSL3_EXT_INVALID_SERVERNAME as i32, | |
| /// `SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION` | |
| SslCtxHasNoDefaultSslVersion = bssl_sys::SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION as i32, | |
| /// `SSL_R_SSL_HANDSHAKE_FAILURE` | |
| SslHandshakeFailure = bssl_sys::SSL_R_SSL_HANDSHAKE_FAILURE as i32, | |
| /// `SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG` | |
| SslSessionIdContextTooLong = bssl_sys::SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG as i32, | |
| /// `SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST` | |
| TlsPeerDidNotRespondWithCertificateList = bssl_sys::SSL_R_TLS_PEER_DID_NOT_RESPOND_WITH_CERTIFICATE_LIST as i32, | |
| /// `SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG` | |
| TlsRsaEncryptedValueLengthIsWrong = bssl_sys::SSL_R_TLS_RSA_ENCRYPTED_VALUE_LENGTH_IS_WRONG as i32, | |
| /// `SSL_R_TOO_MANY_EMPTY_FRAGMENTS` | |
| TooManyEmptyFragments = bssl_sys::SSL_R_TOO_MANY_EMPTY_FRAGMENTS as i32, | |
| /// `SSL_R_TOO_MANY_WARNING_ALERTS` | |
| TooManyWarningAlerts = bssl_sys::SSL_R_TOO_MANY_WARNING_ALERTS as i32, | |
| /// `SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS` | |
| UnableToFindEcdhParameters = bssl_sys::SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS as i32, | |
| /// `SSL_R_UNEXPECTED_EXTENSION` | |
| UnexpectedExtension = bssl_sys::SSL_R_UNEXPECTED_EXTENSION as i32, | |
| /// `SSL_R_UNEXPECTED_MESSAGE` | |
| UnexpectedMessage = bssl_sys::SSL_R_UNEXPECTED_MESSAGE as i32, | |
| /// `SSL_R_UNEXPECTED_OPERATOR_IN_GROUP` | |
| UnexpectedOperatorInGroup = bssl_sys::SSL_R_UNEXPECTED_OPERATOR_IN_GROUP as i32, | |
| /// `SSL_R_UNEXPECTED_RECORD` | |
| UnexpectedRecord = bssl_sys::SSL_R_UNEXPECTED_RECORD as i32, | |
| /// `SSL_R_UNINITIALIZED` | |
| Uninitialized = bssl_sys::SSL_R_UNINITIALIZED as i32, | |
| /// `SSL_R_UNKNOWN_ALERT_TYPE` | |
| UnknownAlertType = bssl_sys::SSL_R_UNKNOWN_ALERT_TYPE as i32, | |
| /// `SSL_R_UNKNOWN_CERTIFICATE_TYPE` | |
| UnknownCertificateType = bssl_sys::SSL_R_UNKNOWN_CERTIFICATE_TYPE as i32, | |
| /// `SSL_R_UNKNOWN_CIPHER_RETURNED` | |
| UnknownCipherReturned = bssl_sys::SSL_R_UNKNOWN_CIPHER_RETURNED as i32, | |
| /// `SSL_R_UNKNOWN_CIPHER_TYPE` | |
| UnknownCipherType = bssl_sys::SSL_R_UNKNOWN_CIPHER_TYPE as i32, | |
| /// `SSL_R_UNKNOWN_DIGEST` | |
| UnknownDigest = bssl_sys::SSL_R_UNKNOWN_DIGEST as i32, | |
| /// `SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE` | |
| UnknownKeyExchangeType = bssl_sys::SSL_R_UNKNOWN_KEY_EXCHANGE_TYPE as i32, | |
| /// `SSL_R_UNKNOWN_PROTOCOL` | |
| UnknownProtocol = bssl_sys::SSL_R_UNKNOWN_PROTOCOL as i32, | |
| /// `SSL_R_UNKNOWN_SSL_VERSION` | |
| UnknownSslVersion = bssl_sys::SSL_R_UNKNOWN_SSL_VERSION as i32, | |
| /// `SSL_R_UNKNOWN_STATE` | |
| UnknownState = bssl_sys::SSL_R_UNKNOWN_STATE as i32, | |
| /// `SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED` | |
| UnsafeLegacyRenegotiationDisabled = bssl_sys::SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED as i32, | |
| /// `SSL_R_UNSUPPORTED_CIPHER` | |
| UnsupportedCipher = bssl_sys::SSL_R_UNSUPPORTED_CIPHER as i32, | |
| /// `SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM` | |
| UnsupportedCompressionAlgorithm = bssl_sys::SSL_R_UNSUPPORTED_COMPRESSION_ALGORITHM as i32, | |
| /// `SSL_R_UNSUPPORTED_ELLIPTIC_CURVE` | |
| UnsupportedEllipticCurve = bssl_sys::SSL_R_UNSUPPORTED_ELLIPTIC_CURVE as i32, | |
| /// `SSL_R_UNSUPPORTED_PROTOCOL` | |
| UnsupportedProtocol = bssl_sys::SSL_R_UNSUPPORTED_PROTOCOL as i32, | |
| /// `SSL_R_WRONG_CERTIFICATE_TYPE` | |
| WrongCertificateType = bssl_sys::SSL_R_WRONG_CERTIFICATE_TYPE as i32, | |
| /// `SSL_R_WRONG_CIPHER_RETURNED` | |
| WrongCipherReturned = bssl_sys::SSL_R_WRONG_CIPHER_RETURNED as i32, | |
| /// `SSL_R_WRONG_CURVE` | |
| WrongCurve = bssl_sys::SSL_R_WRONG_CURVE as i32, | |
| /// `SSL_R_WRONG_MESSAGE_TYPE` | |
| WrongMessageType = bssl_sys::SSL_R_WRONG_MESSAGE_TYPE as i32, | |
| /// `SSL_R_WRONG_SIGNATURE_TYPE` | |
| WrongSignatureType = bssl_sys::SSL_R_WRONG_SIGNATURE_TYPE as i32, | |
| /// `SSL_R_WRONG_SSL_VERSION` | |
| WrongSslVersion = bssl_sys::SSL_R_WRONG_SSL_VERSION as i32, | |
| /// `SSL_R_WRONG_VERSION_NUMBER` | |
| WrongVersionNumber = bssl_sys::SSL_R_WRONG_VERSION_NUMBER as i32, | |
| /// `SSL_R_X509_LIB` | |
| X509Lib = bssl_sys::SSL_R_X509_LIB as i32, | |
| /// `SSL_R_X509_VERIFICATION_SETUP_PROBLEMS` | |
| X509VerificationSetupProblems = bssl_sys::SSL_R_X509_VERIFICATION_SETUP_PROBLEMS as i32, | |
| /// `SSL_R_SHUTDOWN_WHILE_IN_INIT` | |
| ShutdownWhileInInit = bssl_sys::SSL_R_SHUTDOWN_WHILE_IN_INIT as i32, | |
| /// `SSL_R_INVALID_OUTER_RECORD_TYPE` | |
| InvalidOuterRecordType = bssl_sys::SSL_R_INVALID_OUTER_RECORD_TYPE as i32, | |
| /// `SSL_R_UNSUPPORTED_PROTOCOL_FOR_CUSTOM_KEY` | |
| UnsupportedProtocolForCustomKey = bssl_sys::SSL_R_UNSUPPORTED_PROTOCOL_FOR_CUSTOM_KEY as i32, | |
| /// `SSL_R_NO_COMMON_SIGNATURE_ALGORITHMS` | |
| NoCommonSignatureAlgorithms = bssl_sys::SSL_R_NO_COMMON_SIGNATURE_ALGORITHMS as i32, | |
| /// `SSL_R_DOWNGRADE_DETECTED` | |
| DowngradeDetected = bssl_sys::SSL_R_DOWNGRADE_DETECTED as i32, | |
| /// `SSL_R_EXCESS_HANDSHAKE_DATA` | |
| ExcessHandshakeData = bssl_sys::SSL_R_EXCESS_HANDSHAKE_DATA as i32, | |
| /// `SSL_R_INVALID_COMPRESSION_LIST` | |
| InvalidCompressionList = bssl_sys::SSL_R_INVALID_COMPRESSION_LIST as i32, | |
| /// `SSL_R_DUPLICATE_EXTENSION` | |
| DuplicateExtension = bssl_sys::SSL_R_DUPLICATE_EXTENSION as i32, | |
| /// `SSL_R_MISSING_KEY_SHARE` | |
| MissingKeyShare = bssl_sys::SSL_R_MISSING_KEY_SHARE as i32, | |
| /// `SSL_R_INVALID_ALPN_PROTOCOL` | |
| InvalidAlpnProtocol = bssl_sys::SSL_R_INVALID_ALPN_PROTOCOL as i32, | |
| /// `SSL_R_TOO_MANY_KEY_UPDATES` | |
| TooManyKeyUpdates = bssl_sys::SSL_R_TOO_MANY_KEY_UPDATES as i32, | |
| /// `SSL_R_BLOCK_CIPHER_PAD_IS_WRONG` | |
| BlockCipherPadIsWrong = bssl_sys::SSL_R_BLOCK_CIPHER_PAD_IS_WRONG as i32, | |
| /// `SSL_R_NO_CIPHERS_SPECIFIED` | |
| NoCiphersSpecified = bssl_sys::SSL_R_NO_CIPHERS_SPECIFIED as i32, | |
| /// `SSL_R_RENEGOTIATION_EMS_MISMATCH` | |
| RenegotiationEmsMismatch = bssl_sys::SSL_R_RENEGOTIATION_EMS_MISMATCH as i32, | |
| /// `SSL_R_DUPLICATE_KEY_SHARE` | |
| DuplicateKeyShare = bssl_sys::SSL_R_DUPLICATE_KEY_SHARE as i32, | |
| /// `SSL_R_NO_GROUPS_SPECIFIED` | |
| NoGroupsSpecified = bssl_sys::SSL_R_NO_GROUPS_SPECIFIED as i32, | |
| /// `SSL_R_NO_SHARED_GROUP` | |
| NoSharedGroup = bssl_sys::SSL_R_NO_SHARED_GROUP as i32, | |
| /// `SSL_R_PRE_SHARED_KEY_MUST_BE_LAST` | |
| PreSharedKeyMustBeLast = bssl_sys::SSL_R_PRE_SHARED_KEY_MUST_BE_LAST as i32, | |
| /// `SSL_R_OLD_SESSION_PRF_HASH_MISMATCH` | |
| OldSessionPrfHashMismatch = bssl_sys::SSL_R_OLD_SESSION_PRF_HASH_MISMATCH as i32, | |
| /// `SSL_R_INVALID_SCT_LIST` | |
| InvalidSctList = bssl_sys::SSL_R_INVALID_SCT_LIST as i32, | |
| /// `SSL_R_TOO_MUCH_SKIPPED_EARLY_DATA` | |
| TooMuchSkippedEarlyData = bssl_sys::SSL_R_TOO_MUCH_SKIPPED_EARLY_DATA as i32, | |
| /// `SSL_R_PSK_IDENTITY_BINDER_COUNT_MISMATCH` | |
| PskIdentityBinderCountMismatch = bssl_sys::SSL_R_PSK_IDENTITY_BINDER_COUNT_MISMATCH as i32, | |
| /// `SSL_R_CANNOT_PARSE_LEAF_CERT` | |
| CannotParseLeafCert = bssl_sys::SSL_R_CANNOT_PARSE_LEAF_CERT as i32, | |
| /// `SSL_R_SERVER_CERT_CHANGED` | |
| ServerCertChanged = bssl_sys::SSL_R_SERVER_CERT_CHANGED as i32, | |
| /// `SSL_R_CERTIFICATE_AND_PRIVATE_KEY_MISMATCH` | |
| CertificateAndPrivateKeyMismatch = bssl_sys::SSL_R_CERTIFICATE_AND_PRIVATE_KEY_MISMATCH as i32, | |
| /// `SSL_R_CANNOT_HAVE_BOTH_PRIVKEY_AND_METHOD` | |
| CannotHaveBothPrivkeyAndMethod = bssl_sys::SSL_R_CANNOT_HAVE_BOTH_PRIVKEY_AND_METHOD as i32, | |
| /// `SSL_R_TICKET_ENCRYPTION_FAILED` | |
| TicketEncryptionFailed = bssl_sys::SSL_R_TICKET_ENCRYPTION_FAILED as i32, | |
| /// `SSL_R_ALPN_MISMATCH_ON_EARLY_DATA` | |
| AlpnMismatchOnEarlyData = bssl_sys::SSL_R_ALPN_MISMATCH_ON_EARLY_DATA as i32, | |
| /// `SSL_R_WRONG_VERSION_ON_EARLY_DATA` | |
| WrongVersionOnEarlyData = bssl_sys::SSL_R_WRONG_VERSION_ON_EARLY_DATA as i32, | |
| /// `SSL_R_UNEXPECTED_EXTENSION_ON_EARLY_DATA` | |
| UnexpectedExtensionOnEarlyData = bssl_sys::SSL_R_UNEXPECTED_EXTENSION_ON_EARLY_DATA as i32, | |
| /// `SSL_R_NO_SUPPORTED_VERSIONS_ENABLED` | |
| NoSupportedVersionsEnabled = bssl_sys::SSL_R_NO_SUPPORTED_VERSIONS_ENABLED as i32, | |
| /// `SSL_R_EMPTY_HELLO_RETRY_REQUEST` | |
| EmptyHelloRetryRequest = bssl_sys::SSL_R_EMPTY_HELLO_RETRY_REQUEST as i32, | |
| /// `SSL_R_EARLY_DATA_NOT_IN_USE` | |
| EarlyDataNotInUse = bssl_sys::SSL_R_EARLY_DATA_NOT_IN_USE as i32, | |
| /// `SSL_R_HANDSHAKE_NOT_COMPLETE` | |
| HandshakeNotComplete = bssl_sys::SSL_R_HANDSHAKE_NOT_COMPLETE as i32, | |
| /// `SSL_R_NEGOTIATED_TB_WITHOUT_EMS_OR_RI` | |
| NegotiatedTbWithoutEmsOrRi = bssl_sys::SSL_R_NEGOTIATED_TB_WITHOUT_EMS_OR_RI as i32, | |
| /// `SSL_R_SERVER_ECHOED_INVALID_SESSION_ID` | |
| ServerEchoedInvalidSessionId = bssl_sys::SSL_R_SERVER_ECHOED_INVALID_SESSION_ID as i32, | |
| /// `SSL_R_PRIVATE_KEY_OPERATION_FAILED` | |
| PrivateKeyOperationFailed = bssl_sys::SSL_R_PRIVATE_KEY_OPERATION_FAILED as i32, | |
| /// `SSL_R_SECOND_SERVERHELLO_VERSION_MISMATCH` | |
| SecondServerhelloVersionMismatch = bssl_sys::SSL_R_SECOND_SERVERHELLO_VERSION_MISMATCH as i32, | |
| /// `SSL_R_OCSP_CB_ERROR` | |
| OcspCbError = bssl_sys::SSL_R_OCSP_CB_ERROR as i32, | |
| /// `SSL_R_SSL_SESSION_ID_TOO_LONG` | |
| SslSessionIdTooLong = bssl_sys::SSL_R_SSL_SESSION_ID_TOO_LONG as i32, | |
| /// `SSL_R_APPLICATION_DATA_ON_SHUTDOWN` | |
| ApplicationDataOnShutdown = bssl_sys::SSL_R_APPLICATION_DATA_ON_SHUTDOWN as i32, | |
| /// `SSL_R_CERT_DECOMPRESSION_FAILED` | |
| CertDecompressionFailed = bssl_sys::SSL_R_CERT_DECOMPRESSION_FAILED as i32, | |
| /// `SSL_R_UNCOMPRESSED_CERT_TOO_LARGE` | |
| UncompressedCertTooLarge = bssl_sys::SSL_R_UNCOMPRESSED_CERT_TOO_LARGE as i32, | |
| /// `SSL_R_UNKNOWN_CERT_COMPRESSION_ALG` | |
| UnknownCertCompressionAlg = bssl_sys::SSL_R_UNKNOWN_CERT_COMPRESSION_ALG as i32, | |
| /// `SSL_R_INVALID_SIGNATURE_ALGORITHM` | |
| InvalidSignatureAlgorithm = bssl_sys::SSL_R_INVALID_SIGNATURE_ALGORITHM as i32, | |
| /// `SSL_R_DUPLICATE_SIGNATURE_ALGORITHM` | |
| DuplicateSignatureAlgorithm = bssl_sys::SSL_R_DUPLICATE_SIGNATURE_ALGORITHM as i32, | |
| /// `SSL_R_TLS13_DOWNGRADE` | |
| Tls13Downgrade = bssl_sys::SSL_R_TLS13_DOWNGRADE as i32, | |
| /// `SSL_R_QUIC_INTERNAL_ERROR` | |
| QuicInternalError = bssl_sys::SSL_R_QUIC_INTERNAL_ERROR as i32, | |
| /// `SSL_R_WRONG_ENCRYPTION_LEVEL_RECEIVED` | |
| WrongEncryptionLevelReceived = bssl_sys::SSL_R_WRONG_ENCRYPTION_LEVEL_RECEIVED as i32, | |
| /// `SSL_R_TOO_MUCH_READ_EARLY_DATA` | |
| TooMuchReadEarlyData = bssl_sys::SSL_R_TOO_MUCH_READ_EARLY_DATA as i32, | |
| /// `SSL_R_INVALID_DELEGATED_CREDENTIAL` | |
| InvalidDelegatedCredential = bssl_sys::SSL_R_INVALID_DELEGATED_CREDENTIAL as i32, | |
| /// `SSL_R_KEY_USAGE_BIT_INCORRECT` | |
| KeyUsageBitIncorrect = bssl_sys::SSL_R_KEY_USAGE_BIT_INCORRECT as i32, | |
| /// `SSL_R_INCONSISTENT_CLIENT_HELLO` | |
| InconsistentClientHello = bssl_sys::SSL_R_INCONSISTENT_CLIENT_HELLO as i32, | |
| /// `SSL_R_CIPHER_MISMATCH_ON_EARLY_DATA` | |
| CipherMismatchOnEarlyData = bssl_sys::SSL_R_CIPHER_MISMATCH_ON_EARLY_DATA as i32, | |
| /// `SSL_R_QUIC_TRANSPORT_PARAMETERS_MISCONFIGURED` | |
| QuicTransportParametersMisconfigured = bssl_sys::SSL_R_QUIC_TRANSPORT_PARAMETERS_MISCONFIGURED as i32, | |
| /// `SSL_R_UNEXPECTED_COMPATIBILITY_MODE` | |
| UnexpectedCompatibilityMode = bssl_sys::SSL_R_UNEXPECTED_COMPATIBILITY_MODE as i32, | |
| /// `SSL_R_NO_APPLICATION_PROTOCOL` | |
| NoApplicationProtocol = bssl_sys::SSL_R_NO_APPLICATION_PROTOCOL as i32, | |
| /// `SSL_R_NEGOTIATED_ALPS_WITHOUT_ALPN` | |
| NegotiatedAlpsWithoutAlpn = bssl_sys::SSL_R_NEGOTIATED_ALPS_WITHOUT_ALPN as i32, | |
| /// `SSL_R_ALPS_MISMATCH_ON_EARLY_DATA` | |
| AlpsMismatchOnEarlyData = bssl_sys::SSL_R_ALPS_MISMATCH_ON_EARLY_DATA as i32, | |
| /// `SSL_R_ECH_SERVER_CONFIG_AND_PRIVATE_KEY_MISMATCH` | |
| EchServerConfigAndPrivateKeyMismatch = bssl_sys::SSL_R_ECH_SERVER_CONFIG_AND_PRIVATE_KEY_MISMATCH as i32, | |
| /// `SSL_R_ECH_SERVER_CONFIG_UNSUPPORTED_EXTENSION` | |
| EchServerConfigUnsupportedExtension = bssl_sys::SSL_R_ECH_SERVER_CONFIG_UNSUPPORTED_EXTENSION as i32, | |
| /// `SSL_R_UNSUPPORTED_ECH_SERVER_CONFIG` | |
| UnsupportedEchServerConfig = bssl_sys::SSL_R_UNSUPPORTED_ECH_SERVER_CONFIG as i32, | |
| /// `SSL_R_ECH_SERVER_WOULD_HAVE_NO_RETRY_CONFIGS` | |
| EchServerWouldHaveNoRetryConfigs = bssl_sys::SSL_R_ECH_SERVER_WOULD_HAVE_NO_RETRY_CONFIGS as i32, | |
| /// `SSL_R_INVALID_CLIENT_HELLO_INNER` | |
| InvalidClientHelloInner = bssl_sys::SSL_R_INVALID_CLIENT_HELLO_INNER as i32, | |
| /// `SSL_R_INVALID_ALPN_PROTOCOL_LIST` | |
| InvalidAlpnProtocolList = bssl_sys::SSL_R_INVALID_ALPN_PROTOCOL_LIST as i32, | |
| /// `SSL_R_COULD_NOT_PARSE_HINTS` | |
| CouldNotParseHints = bssl_sys::SSL_R_COULD_NOT_PARSE_HINTS as i32, | |
| /// `SSL_R_INVALID_ECH_PUBLIC_NAME` | |
| InvalidEchPublicName = bssl_sys::SSL_R_INVALID_ECH_PUBLIC_NAME as i32, | |
| /// `SSL_R_INVALID_ECH_CONFIG_LIST` | |
| InvalidEchConfigList = bssl_sys::SSL_R_INVALID_ECH_CONFIG_LIST as i32, | |
| /// `SSL_R_ECH_REJECTED` | |
| EchRejected = bssl_sys::SSL_R_ECH_REJECTED as i32, | |
| /// `SSL_R_INVALID_OUTER_EXTENSION` | |
| InvalidOuterExtension = bssl_sys::SSL_R_INVALID_OUTER_EXTENSION as i32, | |
| /// `SSL_R_INCONSISTENT_ECH_NEGOTIATION` | |
| InconsistentEchNegotiation = bssl_sys::SSL_R_INCONSISTENT_ECH_NEGOTIATION as i32, | |
| /// `SSL_R_INVALID_ALPS_CODEPOINT` | |
| InvalidAlpsCodepoint = bssl_sys::SSL_R_INVALID_ALPS_CODEPOINT as i32, | |
| /// `SSL_R_NO_MATCHING_ISSUER` | |
| NoMatchingIssuer = bssl_sys::SSL_R_NO_MATCHING_ISSUER as i32, | |
| /// `SSL_R_INVALID_SPAKE2PLUSV1_VALUE` | |
| InvalidSpake2plusv1Value = bssl_sys::SSL_R_INVALID_SPAKE2PLUSV1_VALUE as i32, | |
| /// `SSL_R_PAKE_EXHAUSTED` | |
| PakeExhausted = bssl_sys::SSL_R_PAKE_EXHAUSTED as i32, | |
| /// `SSL_R_PEER_PAKE_MISMATCH` | |
| PeerPakeMismatch = bssl_sys::SSL_R_PEER_PAKE_MISMATCH as i32, | |
| /// `SSL_R_UNSUPPORTED_CREDENTIAL_LIST` | |
| UnsupportedCredentialList = bssl_sys::SSL_R_UNSUPPORTED_CREDENTIAL_LIST as i32, | |
| /// `SSL_R_INVALID_TRUST_ANCHOR_LIST` | |
| InvalidTrustAnchorList = bssl_sys::SSL_R_INVALID_TRUST_ANCHOR_LIST as i32, | |
| /// `SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST` | |
| InvalidCertificatePropertyList = bssl_sys::SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST as i32, | |
| /// `SSL_R_DUPLICATE_GROUP` | |
| DuplicateGroup = bssl_sys::SSL_R_DUPLICATE_GROUP as i32, | |
| /// `SSL_R_SSLV3_ALERT_CLOSE_NOTIFY` | |
| Sslv3AlertCloseNotify = bssl_sys::SSL_R_SSLV3_ALERT_CLOSE_NOTIFY as i32, | |
| /// `SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE` | |
| Sslv3AlertUnexpectedMessage = bssl_sys::SSL_R_SSLV3_ALERT_UNEXPECTED_MESSAGE as i32, | |
| /// `SSL_R_SSLV3_ALERT_BAD_RECORD_MAC` | |
| Sslv3AlertBadRecordMac = bssl_sys::SSL_R_SSLV3_ALERT_BAD_RECORD_MAC as i32, | |
| /// `SSL_R_TLSV1_ALERT_DECRYPTION_FAILED` | |
| Tlsv1AlertDecryptionFailed = bssl_sys::SSL_R_TLSV1_ALERT_DECRYPTION_FAILED as i32, | |
| /// `SSL_R_TLSV1_ALERT_RECORD_OVERFLOW` | |
| Tlsv1AlertRecordOverflow = bssl_sys::SSL_R_TLSV1_ALERT_RECORD_OVERFLOW as i32, | |
| /// `SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE` | |
| Sslv3AlertDecompressionFailure = bssl_sys::SSL_R_SSLV3_ALERT_DECOMPRESSION_FAILURE as i32, | |
| /// `SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE` | |
| Sslv3AlertHandshakeFailure = bssl_sys::SSL_R_SSLV3_ALERT_HANDSHAKE_FAILURE as i32, | |
| /// `SSL_R_SSLV3_ALERT_NO_CERTIFICATE` | |
| Sslv3AlertNoCertificate = bssl_sys::SSL_R_SSLV3_ALERT_NO_CERTIFICATE as i32, | |
| /// `SSL_R_SSLV3_ALERT_BAD_CERTIFICATE` | |
| Sslv3AlertBadCertificate = bssl_sys::SSL_R_SSLV3_ALERT_BAD_CERTIFICATE as i32, | |
| /// `SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE` | |
| Sslv3AlertUnsupportedCertificate = bssl_sys::SSL_R_SSLV3_ALERT_UNSUPPORTED_CERTIFICATE as i32, | |
| /// `SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED` | |
| Sslv3AlertCertificateRevoked = bssl_sys::SSL_R_SSLV3_ALERT_CERTIFICATE_REVOKED as i32, | |
| /// `SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED` | |
| Sslv3AlertCertificateExpired = bssl_sys::SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED as i32, | |
| /// `SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN` | |
| Sslv3AlertCertificateUnknown = bssl_sys::SSL_R_SSLV3_ALERT_CERTIFICATE_UNKNOWN as i32, | |
| /// `SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER` | |
| Sslv3AlertIllegalParameter = bssl_sys::SSL_R_SSLV3_ALERT_ILLEGAL_PARAMETER as i32, | |
| /// `SSL_R_TLSV1_ALERT_UNKNOWN_CA` | |
| Tlsv1AlertUnknownCa = bssl_sys::SSL_R_TLSV1_ALERT_UNKNOWN_CA as i32, | |
| /// `SSL_R_TLSV1_ALERT_ACCESS_DENIED` | |
| Tlsv1AlertAccessDenied = bssl_sys::SSL_R_TLSV1_ALERT_ACCESS_DENIED as i32, | |
| /// `SSL_R_TLSV1_ALERT_DECODE_ERROR` | |
| Tlsv1AlertDecodeError = bssl_sys::SSL_R_TLSV1_ALERT_DECODE_ERROR as i32, | |
| /// `SSL_R_TLSV1_ALERT_DECRYPT_ERROR` | |
| Tlsv1AlertDecryptError = bssl_sys::SSL_R_TLSV1_ALERT_DECRYPT_ERROR as i32, | |
| /// `SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION` | |
| Tlsv1AlertExportRestriction = bssl_sys::SSL_R_TLSV1_ALERT_EXPORT_RESTRICTION as i32, | |
| /// `SSL_R_TLSV1_ALERT_PROTOCOL_VERSION` | |
| Tlsv1AlertProtocolVersion = bssl_sys::SSL_R_TLSV1_ALERT_PROTOCOL_VERSION as i32, | |
| /// `SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY` | |
| Tlsv1AlertInsufficientSecurity = bssl_sys::SSL_R_TLSV1_ALERT_INSUFFICIENT_SECURITY as i32, | |
| /// `SSL_R_TLSV1_ALERT_INTERNAL_ERROR` | |
| Tlsv1AlertInternalError = bssl_sys::SSL_R_TLSV1_ALERT_INTERNAL_ERROR as i32, | |
| /// `SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK` | |
| Tlsv1AlertInappropriateFallback = bssl_sys::SSL_R_TLSV1_ALERT_INAPPROPRIATE_FALLBACK as i32, | |
| /// `SSL_R_TLSV1_ALERT_USER_CANCELLED` | |
| Tlsv1AlertUserCancelled = bssl_sys::SSL_R_TLSV1_ALERT_USER_CANCELLED as i32, | |
| /// `SSL_R_TLSV1_ALERT_NO_RENEGOTIATION` | |
| Tlsv1AlertNoRenegotiation = bssl_sys::SSL_R_TLSV1_ALERT_NO_RENEGOTIATION as i32, | |
| /// `SSL_R_TLSV1_ALERT_UNSUPPORTED_EXTENSION` | |
| Tlsv1AlertUnsupportedExtension = bssl_sys::SSL_R_TLSV1_ALERT_UNSUPPORTED_EXTENSION as i32, | |
| /// `SSL_R_TLSV1_ALERT_CERTIFICATE_UNOBTAINABLE` | |
| Tlsv1AlertCertificateUnobtainable = bssl_sys::SSL_R_TLSV1_ALERT_CERTIFICATE_UNOBTAINABLE as i32, | |
| /// `SSL_R_TLSV1_ALERT_UNRECOGNIZED_NAME` | |
| Tlsv1AlertUnrecognizedName = bssl_sys::SSL_R_TLSV1_ALERT_UNRECOGNIZED_NAME as i32, | |
| /// `SSL_R_TLSV1_ALERT_BAD_CERTIFICATE_STATUS_RESPONSE` | |
| Tlsv1AlertBadCertificateStatusResponse = bssl_sys::SSL_R_TLSV1_ALERT_BAD_CERTIFICATE_STATUS_RESPONSE as i32, | |
| /// `SSL_R_TLSV1_ALERT_BAD_CERTIFICATE_HASH_VALUE` | |
| Tlsv1AlertBadCertificateHashValue = bssl_sys::SSL_R_TLSV1_ALERT_BAD_CERTIFICATE_HASH_VALUE as i32, | |
| /// `SSL_R_TLSV1_ALERT_UNKNOWN_PSK_IDENTITY` | |
| Tlsv1AlertUnknownPskIdentity = bssl_sys::SSL_R_TLSV1_ALERT_UNKNOWN_PSK_IDENTITY as i32, | |
| /// `SSL_R_TLSV1_ALERT_CERTIFICATE_REQUIRED` | |
| Tlsv1AlertCertificateRequired = bssl_sys::SSL_R_TLSV1_ALERT_CERTIFICATE_REQUIRED as i32, | |
| /// `SSL_R_TLSV1_ALERT_NO_APPLICATION_PROTOCOL` | |
| Tlsv1AlertNoApplicationProtocol = bssl_sys::SSL_R_TLSV1_ALERT_NO_APPLICATION_PROTOCOL as i32, | |
| /// `SSL_R_TLSV1_ALERT_ECH_REQUIRED` | |
| Tlsv1AlertEchRequired = bssl_sys::SSL_R_TLSV1_ALERT_ECH_REQUIRED as i32, | |
| } | |
| } | |
| impl Display for TlsErrorReason { | |
| fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { | |
| Debug::fmt(self, f) | |
| } | |
| } | |
| bssl_enum! { | |
| /// TLS errors | |
| #[derive(Debug, Clone, Copy)] | |
| #[must_use] | |
| pub enum TlsRetryReason: i32 { | |
| /// TLS is blocked on read. | |
| WantRead = bssl_sys::SSL_ERROR_WANT_READ as i32, | |
| /// TLS is blocked on write. | |
| WantWrite = bssl_sys::SSL_ERROR_WANT_WRITE as i32, | |
| /// Pending session. | |
| /// Caller may retry the last operation when the session lookup is ready. | |
| PendingSession = bssl_sys::SSL_ERROR_PENDING_SESSION as i32, | |
| /// Pending certificate. | |
| /// Caller may retry the last operation when the certificate lookup is ready. | |
| PendingCertificate = bssl_sys::SSL_ERROR_PENDING_CERTIFICATE as i32, | |
| /// Pending certification verification. | |
| /// Caller may retry the last operation when the certification verification is ready. | |
| PendingCertificateVerify = bssl_sys::SSL_ERROR_WANT_CERTIFICATE_VERIFY as i32, | |
| /// Pending ticket. | |
| /// Caller may retry the last operation when the ticket decryption is ready. | |
| PendingTicket = bssl_sys::SSL_ERROR_PENDING_TICKET as i32, | |
| /// End of stream, due to peer close_notify. | |
| PeerCloseNotify = bssl_sys::SSL_ERROR_ZERO_RETURN as i32, | |
| /// Want to (re)connect. | |
| /// Caller may retry the last operation when the transport becomes ready. | |
| WantConnect = bssl_sys::SSL_ERROR_WANT_CONNECT as i32, | |
| /// Want to (re)accept. | |
| /// Caller may retry the last operation when the transport becomes ready. | |
| WantAccept = bssl_sys::SSL_ERROR_WANT_ACCEPT as i32, | |
| /// Pending private key operation. | |
| /// Caller may retry the last operation when the private key operation might be ready. | |
| PendingPrivateKeyOperation = bssl_sys::SSL_ERROR_WANT_PRIVATE_KEY_OPERATION as i32, | |
| /// Early data was rejected. | |
| /// Caller may call `reset_early_data_reject` to start from a clean state. | |
| EarlyDataRejected = bssl_sys::SSL_ERROR_EARLY_DATA_REJECTED as i32, | |
| /// Handshake Hints becomes ready. | |
| HandshakeHintsReady = bssl_sys::SSL_ERROR_HANDSHAKE_HINTS_READY as i32, | |
| } | |
| } | |
| impl core::error::Error for TlsRetryReason {} | |
| impl Display for TlsRetryReason { | |
| fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { | |
| match self { | |
| TlsRetryReason::WantRead => f.write_str("want to read"), | |
| TlsRetryReason::WantWrite => f.write_str("want to write"), | |
| TlsRetryReason::PendingSession => f.write_str("pending session"), | |
| TlsRetryReason::PendingCertificate => f.write_str("pending certificate"), | |
| TlsRetryReason::PendingTicket => f.write_str("pending ticket"), | |
| TlsRetryReason::PendingCertificateVerify => f.write_str("pending certificate verify"), | |
| TlsRetryReason::WantConnect => f.write_str("want to (re)connect connection"), | |
| TlsRetryReason::WantAccept => f.write_str("want to (re)accept connection"), | |
| TlsRetryReason::PendingPrivateKeyOperation => { | |
| f.write_str("pending private key operation") | |
| } | |
| TlsRetryReason::EarlyDataRejected => f.write_str("early data rejected"), | |
| TlsRetryReason::HandshakeHintsReady => f.write_str("handshake hints ready"), | |
| TlsRetryReason::PeerCloseNotify => f.write_str("peer close notify"), | |
| } | |
| } | |
| } | |
| /// QUIC errors. | |
| #[derive(Debug)] | |
| pub enum QuicError {} | |
| impl Display for QuicError { | |
| fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { | |
| f.write_str("quic error") | |
| } | |
| } | |
| /// I/O errors | |
| #[derive(Debug)] | |
| pub enum IoError { | |
| /// Buffer sizes are too long. | |
| TooLong, | |
| /// Reached the end of stream. | |
| EndOfStream, | |
| /// Error during I/O operation in the underlying transport. | |
| Transport(Box<dyn core::error::Error + Send + Sync>), | |
| } | |
| impl Display for IoError { | |
| fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult { | |
| match self { | |
| IoError::TooLong => f.write_str("data too long"), | |
| IoError::EndOfStream => f.write_str("end of stream"), | |
| IoError::Transport(e) => write!(f, "transport: {e}"), | |
| } | |
| } | |
| } |