Add a few WouldBlock cases

Author: ghedo

boring/src/ssl/error.rs

@@ -27,6 +27,17 @@ impl ErrorCode {
     /// Wait for write readiness and retry the operation.
     pub const WANT_WRITE: ErrorCode = ErrorCode(ffi::SSL_ERROR_WANT_WRITE);
 
+    pub const WANT_X509_LOOKUP: ErrorCode = ErrorCode(ffi::SSL_ERROR_WANT_X509_LOOKUP);
+
+    pub const PENDING_SESSION: ErrorCode = ErrorCode(ffi::SSL_ERROR_PENDING_SESSION);
+
+    pub const PENDING_CERTIFICATE: ErrorCode = ErrorCode(ffi::SSL_ERROR_PENDING_CERTIFICATE);
+
+    pub const WANT_PRIVATE_KEY_OPERATION: ErrorCode =
+        ErrorCode(ffi::SSL_ERROR_WANT_PRIVATE_KEY_OPERATION);
+
+    pub const PENDING_TICKET: ErrorCode = ErrorCode(ffi::SSL_ERROR_PENDING_TICKET);
+
     /// A non-recoverable IO error occurred.
     pub const SYSCALL: ErrorCode = ErrorCode(ffi::SSL_ERROR_SYSCALL);
 
@@ -81,6 +92,19 @@ impl Error {
             _ => None,
         }
     }
+
+    pub fn would_block(&self) -> bool {
+        matches!(
+            self.code,
+            ErrorCode::WANT_READ
+                | ErrorCode::WANT_WRITE
+                | ErrorCode::WANT_X509_LOOKUP
+                | ErrorCode::PENDING_SESSION
+                | ErrorCode::PENDING_CERTIFICATE
+                | ErrorCode::WANT_PRIVATE_KEY_OPERATION
+                | ErrorCode::PENDING_TICKET
+        )
+    }
 }
 
 impl From<ErrorStack> for Error {

boring/src/ssl/mod.rs

@@ -3163,11 +3163,9 @@ impl<S> MidHandshakeSslStream<S> {
             Ok(self.stream)
         } else {
             self.error = self.stream.make_error(ret);
-            match self.error.code() {
-                ErrorCode::WANT_READ | ErrorCode::WANT_WRITE => {
-                    Err(HandshakeError::WouldBlock(self))
-                }
-                _ => Err(HandshakeError::Failure(self)),
+            match self.error.would_block() {
+                true => Err(HandshakeError::WouldBlock(self)),
+                false => Err(HandshakeError::Failure(self)),
             }
         }
     }
@@ -3472,14 +3470,12 @@ where
             Ok(stream)
         } else {
             let error = stream.make_error(ret);
-            match error.code() {
-                ErrorCode::WANT_READ | ErrorCode::WANT_WRITE => {
-                    Err(HandshakeError::WouldBlock(MidHandshakeSslStream {
-                        stream,
-                        error,
-                    }))
-                }
-                _ => Err(HandshakeError::Failure(MidHandshakeSslStream {
+            match error.would_block() {
+                true => Err(HandshakeError::WouldBlock(MidHandshakeSslStream {
+                    stream,
+                    error,
+                })),
+                false => Err(HandshakeError::Failure(MidHandshakeSslStream {
                     stream,
                     error,
                 })),
@@ -3495,14 +3491,12 @@ where
             Ok(stream)
         } else {
             let error = stream.make_error(ret);
-            match error.code() {
-                ErrorCode::WANT_READ | ErrorCode::WANT_WRITE => {
-                    Err(HandshakeError::WouldBlock(MidHandshakeSslStream {
-                        stream,
-                        error,
-                    }))
-                }
-                _ => Err(HandshakeError::Failure(MidHandshakeSslStream {
+            match error.would_block() {
+                true => Err(HandshakeError::WouldBlock(MidHandshakeSslStream {
+                    stream,
+                    error,
+                })),
+                false => Err(HandshakeError::Failure(MidHandshakeSslStream {
                     stream,
                     error,
                 })),
@@ -3524,14 +3518,12 @@ where
             Ok(stream)
         } else {
             let error = stream.make_error(ret);
-            match error.code() {
-                ErrorCode::WANT_READ | ErrorCode::WANT_WRITE => {
-                    Err(HandshakeError::WouldBlock(MidHandshakeSslStream {
-                        stream,
-                        error,
-                    }))
-                }
-                _ => Err(HandshakeError::Failure(MidHandshakeSslStream {
+            match error.would_block() {
+                true => Err(HandshakeError::WouldBlock(MidHandshakeSslStream {
+                    stream,
+                    error,
+                })),
+                false => Err(HandshakeError::Failure(MidHandshakeSslStream {
                     stream,
                     error,
                 })),