Unify nul errors

Part of #8245 to reduce the amount of work needed to review. I
simplified the embedded nul errors by forwarding to the implementations
in `vm::exceptions`.

Author: joshuamegnauth54

crates/stdlib/src/grp.rs

@@ -63,7 +63,7 @@ mod grp {
     fn getgrnam(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<GroupData> {
         let gr_name = name.as_str();
         if gr_name.contains('\0') {
-            return Err(exceptions::cstring_error(vm));
+            return Err(exceptions::nul_char_error(vm));
         }
         let group = host_grp::getgrnam(gr_name).map_err(|err| err.into_pyexception(vm))?;
         let group = group.ok_or_else(|| {

crates/stdlib/src/multiprocessing.rs

@@ -359,6 +359,7 @@ mod _multiprocessing {
     use rustpython_host_env::multiprocessing::{
         self as host_multiprocessing, SemError, TryAcquireStatus, WaitStatus,
     };
+    use rustpython_vm::exceptions;
 
     /// Error type for sem_timedwait operations
     #[cfg(target_vendor = "apple")]
@@ -811,7 +812,7 @@ mod _multiprocessing {
             let (handle, name) =
                 SemHandle::create(&args.name, value, args.unlink).map_err(|err| {
                     if err == SemError::InvalidInput && args.name.contains('\0') {
-                        vm.new_value_error("embedded null character")
+                        exceptions::nul_char_error(vm)
                     } else {
                         os_error(vm, err)
                     }
@@ -835,7 +836,7 @@ mod _multiprocessing {
     fn sem_unlink(name: String, vm: &VirtualMachine) -> PyResult<()> {
         host_multiprocessing::sem_unlink(&name).map_err(|err| {
             if err == SemError::InvalidInput && name.contains('\0') {
-                vm.new_value_error("embedded null character")
+                exceptions::nul_char_error(vm)
             } else {
                 os_error(vm, err)
             }

crates/stdlib/src/openssl.rs

@@ -1041,7 +1041,7 @@ mod _ssl {
         fn set_ciphers(&self, cipherlist: PyStrRef, vm: &VirtualMachine) -> PyResult<()> {
             let ciphers: &str = cipherlist.as_ref();
             if ciphers.contains('\0') {
-                return Err(exceptions::cstring_error(vm));
+                return Err(exceptions::nul_char_error(vm));
             }
             self.builder()
                 .set_cipher_list(ciphers)
@@ -1097,12 +1097,12 @@ mod _ssl {
                 Either::A(s) => {
                     let s: &str = s.as_ref();
                     if s.contains('\0') {
-                        return Err(exceptions::cstring_error(vm));
+                        return Err(exceptions::nul_char_error(vm));
                     }
                     s.to_cstring(vm)?
                 }
                 Either::B(b) => std::ffi::CString::new(b.borrow_buf().to_vec())
-                    .map_err(|_| exceptions::cstring_error(vm))?,
+                    .map_err(|_| exceptions::nul_char_error(vm))?,
             };
 
             // Find the NID for the curve name using OBJ_sn2nid
@@ -2038,7 +2038,7 @@ mod _ssl {
                     ));
                 }
                 if hostname_str.contains('\0') {
-                    return Err(vm.new_type_error("embedded null character"));
+                    return Err(exceptions::nul_char_type_error(vm));
                 }
                 let ip = hostname_str.parse::<core::net::IpAddr>();
                 if ip.is_err() {

crates/stdlib/src/ssl.rs

@@ -70,6 +70,7 @@ mod _ssl {
         sync::atomic::{AtomicUsize, Ordering},
         time::Duration,
     };
+    use rustpython_vm::exceptions;
     use std::{
         collections::{HashMap, hash_map::DefaultHasher},
         io::BufRead,
@@ -392,7 +393,7 @@ mod _ssl {
         // SNI will not be sent for IP addresses
 
         if hostname.contains('\0') {
-            return Err(vm.new_type_error("embedded null character"));
+            return Err(exceptions::nul_char_type_error(vm));
         }
 
         if hostname.len() > 253 {
@@ -1869,7 +1870,7 @@ mod _ssl {
 
                     // Check for NULL bytes
                     if hostname.contains('\0') {
-                        return Err(vm.new_type_error("embedded null character"));
+                        return Err(exceptions::nul_char_error(vm));
                     }
 
                     Some(hostname.to_string())

crates/vm/src/buffer.rs

@@ -3,6 +3,7 @@ use crate::{
     builtins::{PyBaseExceptionRef, PyBytesRef, PyTuple, PyTupleRef, PyTypeRef},
     common::{static_cell, str::wchar_t},
     convert::ToPyObject,
+    exceptions,
     function::{ArgBytesLike, ArgIntoBool, ArgIntoFloat},
 };
 
@@ -282,7 +283,7 @@ impl FormatCode {
 
             // Check for embedded null character
             if c == 0 {
-                return Err("embedded null character".to_owned());
+                return Err(exceptions::NulError.to_string());
             }
 
             // PEP3118: Handle extended format specifiers

crates/vm/src/exceptions.rs

@@ -15,6 +15,7 @@ use crate::{
     suggestion::offer_suggestions,
     types::{Callable, Constructor, Initializer, Representable},
 };
+use core::fmt::{self, Display, Formatter};
 use crossbeam_utils::atomic::AtomicCell;
 use itertools::Itertools;
 #[cfg(feature = "host_env")]
@@ -1188,20 +1189,62 @@ impl serde::Serialize for SerializeException<'_, '_> {
     }
 }
 
-pub fn cstring_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
+#[derive(Debug)]
+pub struct NulError;
+
+impl Display for NulError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "embedded null character")
+    }
+}
+
+pub fn nul_char_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
     vm.new_value_error("embedded null character")
 }
 
+pub fn nul_char_type_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
+    vm.new_type_error("embedded null character")
+}
+
+pub fn nul_byte_error(vm: &VirtualMachine) -> PyBaseExceptionRef {
+    vm.new_value_error("embedded null byte")
+}
+
 impl ToPyException for alloc::ffi::NulError {
     fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        cstring_error(vm)
+        nul_char_error(vm)
+    }
+}
+
+impl ToPyException for alloc::ffi::FromVecWithNulError {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        nul_char_error(vm)
+    }
+}
+
+impl ToPyException for core::ffi::FromBytesWithNulError {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        nul_char_error(vm)
+    }
+}
+
+impl ToPyException for NulError {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        nul_char_error(vm)
     }
 }
 
 #[cfg(windows)]
 impl<C> ToPyException for widestring::error::ContainsNul<C> {
     fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
-        cstring_error(vm)
+        nul_char_error(vm)
+    }
+}
+
+#[cfg(windows)]
+impl ToPyException for widestring::error::MissingNulTerminator {
+    fn to_pyexception(&self, vm: &VirtualMachine) -> PyBaseExceptionRef {
+        vm.new_value_error(self.to_string())
     }
 }
 

crates/vm/src/function/fspath.rs

@@ -40,7 +40,7 @@ impl FsPath {
             if !check_for_nul || memchr::memchr(b'\0', b).is_none() {
                 Ok(())
             } else {
-                Err(crate::exceptions::cstring_error(vm))
+                Err(crate::exceptions::nul_char_error(vm))
             }
         };
         let match1 = |obj: PyObjectRef| {

crates/vm/src/stdlib/_codecs.rs

@@ -13,7 +13,7 @@ mod _codecs {
         AsObject, PyObjectRef, PyResult, VirtualMachine,
         builtins::{PyStrRef, PyUtf8StrRef},
         codecs,
-        exceptions::cstring_error,
+        exceptions::nul_char_error,
         function::{ArgBytesLike, FuncArgs},
     };
 
@@ -30,7 +30,7 @@ mod _codecs {
     #[pyfunction]
     fn lookup(encoding: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
         if encoding.as_str().contains('\0') {
-            return Err(cstring_error(vm));
+            return Err(nul_char_error(vm));
         }
         vm.state
             .codec_registry
@@ -106,15 +106,15 @@ mod _codecs {
     #[pyfunction]
     fn lookup_error(name: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult {
         if name.as_str().contains('\0') {
-            return Err(cstring_error(vm));
+            return Err(nul_char_error(vm));
         }
         vm.state.codec_registry.lookup_error(name.as_str(), vm)
     }
 
     #[pyfunction]
     fn _unregister_error(errors: PyUtf8StrRef, vm: &VirtualMachine) -> PyResult<bool> {
         if errors.as_str().contains('\0') {
-            return Err(cstring_error(vm));
+            return Err(nul_char_error(vm));
         }
         vm.state
             .codec_registry

crates/vm/src/stdlib/_io.rs

@@ -132,7 +132,7 @@ mod _io {
         },
         common::wtf8::{Wtf8, Wtf8Buf},
         convert::ToPyObject,
-        exceptions::cstring_error,
+        exceptions::nul_char_error,
         function::{
             ArgBytesLike, ArgIterable, ArgMemoryBuffer, ArgSize, Either, FsPath, FuncArgs,
             IntoFuncArgs, OptionalArg, OptionalOption, PySetterValue,
@@ -2855,7 +2855,7 @@ mod _io {
 
         fn validate_errors(errors: &PyRef<PyUtf8Str>, vm: &VirtualMachine) -> PyResult<()> {
             if errors.as_str().contains('\0') {
-                return Err(cstring_error(vm));
+                return Err(nul_char_error(vm));
             }
             vm.state
                 .codec_registry
@@ -2896,7 +2896,7 @@ mod _io {
                 },
                 Some(enc) => {
                     if enc.as_str().contains('\0') {
-                        return Err(cstring_error(vm));
+                        return Err(nul_char_error(vm));
                     }
                     enc
                 }
@@ -2915,7 +2915,7 @@ mod _io {
                 },
             };
             if encoding.as_str().contains('\0') {
-                return Err(cstring_error(vm));
+                return Err(nul_char_error(vm));
             }
             Ok(encoding)
         }

crates/vm/src/stdlib/nt.rs

@@ -552,7 +552,7 @@ pub(crate) mod module {
 
             // Validate: no null characters in key or value
             if key_str.contains('\0') || value_str.contains('\0') {
-                return Err(vm.new_value_error("embedded null character"));
+                return Err(exceptions::nul_char_error(vm));
             }
             // Validate: empty key or '=' in key after position 0
             // (search from index 1 because on Windows starting '=' is allowed