fix unwrap

youknowone · youknowone · commit c054bdab9d67 · 2025-10-29T17:53:41.000+09:00
diff --git a/stdlib/src/ssl.rs b/stdlib/src/ssl.rs
@@ -2020,25 +2020,24 @@ mod _ssl {
             }
 
             let peer_cert = stream.ssl().peer_certificate();
-            match peer_cert {
-                None => Ok(None),
-                Some(cert) => {
-                    if binary {
-                        // Return DER-encoded certificate
-                        cert_to_py(vm, &cert, true).map(Some)
+            let Some(cert) = peer_cert else {
+                return Ok(None);
+            };
+
+            if binary {
+                // Return DER-encoded certificate
+                cert_to_py(vm, &cert, true).map(Some)
+            } else {
+                // Check verify_mode
+                unsafe {
+                    let ssl_ctx = sys::SSL_get_SSL_CTX(stream.ssl().as_ptr());
+                    let verify_mode = sys::SSL_CTX_get_verify_mode(ssl_ctx);
+                    if (verify_mode & sys::SSL_VERIFY_PEER as libc::c_int) == 0 {
+                        // Return empty dict when SSL_VERIFY_PEER is not set
+                        Ok(Some(vm.ctx.new_dict().into()))
                     } else {
-                        // Check verify_mode
-                        unsafe {
-                            let ssl_ctx = sys::SSL_get_SSL_CTX(stream.ssl().as_ptr());
-                            let verify_mode = sys::SSL_CTX_get_verify_mode(ssl_ctx);
-                            if (verify_mode & sys::SSL_VERIFY_PEER as libc::c_int) == 0 {
-                                // Return empty dict when SSL_VERIFY_PEER is not set
-                                Ok(Some(vm.ctx.new_dict().into()))
-                            } else {
-                                // Return decoded certificate
-                                cert_to_py(vm, &cert, false).map(Some)
-                            }
-                        }
+                        // Return decoded certificate
+                        cert_to_py(vm, &cert, false).map(Some)
                     }
                 }
             }
@@ -2295,7 +2294,9 @@ mod _ssl {
 
             // Return the underlying socket
             // Get the socket from the stream (SocketStream wraps PyRef<PySocket>)
-            let socket = stream.get_ref().unwrap();
+            let socket = stream
+                .get_ref()
+                .expect("unwrap() called on bio mode; should only be called in socket mode");
             Ok(socket.0.clone())
         }
 
@@ -2338,13 +2339,19 @@ mod _ssl {
             }
 
             // Socket mode: handle timeout and blocking
-            let timeout = stream.get_ref().unwrap().timeout_deadline();
+            let timeout = stream
+                .get_ref()
+                .expect("handshake called in bio mode; should only be called in socket mode")
+                .timeout_deadline();
             loop {
                 let err = match stream.do_handshake() {
                     Ok(()) => return Ok(()),
                     Err(e) => e,
                 };
-                let (needs, state) = stream.get_ref().unwrap().socket_needs(&err, &timeout);
+                let (needs, state) = stream
+                    .get_ref()
+                    .expect("handshake called in bio mode; should only be called in socket mode")
+                    .socket_needs(&err, &timeout);
                 match state {
                     SelectRet::TimedOut => {
                         return Err(socket::timeout_error_msg(
@@ -2381,8 +2388,11 @@ mod _ssl {
             }
 
             // Socket mode: handle timeout and blocking
-            let timeout = stream.get_ref().unwrap().timeout_deadline();
-            let state = stream.get_ref().unwrap().select(SslNeeds::Write, &timeout);
+            let socket_ref = stream
+                .get_ref()
+                .expect("write called in bio mode; should only be called in socket mode");
+            let timeout = socket_ref.timeout_deadline();
+            let state = socket_ref.select(SslNeeds::Write, &timeout);
             match state {
                 SelectRet::TimedOut => {
                     return Err(socket::timeout_error_msg(
@@ -2398,7 +2408,10 @@ mod _ssl {
                     Ok(len) => return Ok(len),
                     Err(e) => e,
                 };
-                let (needs, state) = stream.get_ref().unwrap().socket_needs(&err, &timeout);
+                let (needs, state) = stream
+                    .get_ref()
+                    .expect("write called in bio mode; should only be called in socket mode")
+                    .socket_needs(&err, &timeout);
                 match state {
                     SelectRet::TimedOut => {
                         return Err(socket::timeout_error_msg(
@@ -2524,7 +2537,10 @@ mod _ssl {
                 }
             } else {
                 // Socket mode: handle timeout and blocking
-                let timeout = stream.get_ref().unwrap().timeout_deadline();
+                let timeout = stream
+                    .get_ref()
+                    .expect("read called in bio mode; should only be called in socket mode")
+                    .timeout_deadline();
                 loop {
                     let err = match stream.ssl_read(buf) {
                         Ok(count) => break count,
@@ -2535,7 +2551,10 @@ mod _ssl {
                     {
                         break 0;
                     }
-                    let (needs, state) = stream.get_ref().unwrap().socket_needs(&err, &timeout);
+                    let (needs, state) = stream
+                        .get_ref()
+                        .expect("read called in bio mode; should only be called in socket mode")
+                        .socket_needs(&err, &timeout);
                     match state {
                         SelectRet::TimedOut => {
                             return Err(socket::timeout_error_msg(
@@ -3124,7 +3143,9 @@ mod _ssl {
                 }
 
                 // Convert back to PyBaseExceptionRef
-                exc_obj.downcast().unwrap()
+                exc_obj.downcast().expect(
+                    "exc_obj is created as PyBaseExceptionRef and must downcast successfully",
+                )
             }
             None => {
                 let cls = PySslError::class(&vm.ctx).to_owned();
