Consistent allocation failure for windows-registry

crates/libs/registry/src/bindings.rs

@@ -21,7 +21,6 @@ windows_targets::link!("kernel32.dll" "system" fn HeapFree(hheap : HANDLE, dwfla
 pub type BOOL = i32;
 pub const ERROR_INVALID_DATA: WIN32_ERROR = 13u32;
 pub const ERROR_NO_MORE_ITEMS: WIN32_ERROR = 259u32;
-pub const ERROR_OUTOFMEMORY: WIN32_ERROR = 14u32;
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct FILETIME {

crates/libs/registry/src/data.rs

@@ -8,15 +8,15 @@ pub struct Data {
 
 impl Data {
  // Creates a buffer with the specified length of zero bytes.
- pub fn new(len: usize) -> Result<Self> {
+ pub fn new(len: usize) -> Self {
  unsafe {
- let bytes = Self::alloc(len)?;
+ let bytes = Self::alloc(len);
 
  if len > 0 {
  core::ptr::write_bytes(bytes.ptr, 0, len);
  }
 
- Ok(bytes)
+ bytes
  }
  }
 
@@ -30,34 +30,34 @@ impl Data {
  }
 
  // Creates a buffer by copying the bytes from the slice.
- pub fn from_slice(slice: &[u8]) -> Result<Self> {
+ pub fn from_slice(slice: &[u8]) -> Self {
  unsafe {
- let bytes = Self::alloc(slice.len())?;
+ let bytes = Self::alloc(slice.len());
 
  if !slice.is_empty() {
  core::ptr::copy_nonoverlapping(slice.as_ptr(), bytes.ptr, slice.len());
  }
 
- Ok(bytes)
+ bytes
  }
  }
 
  // Allocates an uninitialized buffer.
- unsafe fn alloc(len: usize) -> Result<Self> {
+ unsafe fn alloc(len: usize) -> Self {
  if len == 0 {
- Ok(Self {
+ Self {
  ptr: null_mut(),
  len: 0,
- })
+ }
  } else {
  // This pointer will have at least 8 byte alignment.
  let ptr = HeapAlloc(GetProcessHeap(), 0, len) as *mut u8;
 
  if ptr.is_null() {
- Err(Error::from_hresult(HRESULT::from_win32(ERROR_OUTOFMEMORY)))
- } else {
- Ok(Self { ptr, len })
+ panic!("allocation failed");
  }
+
+ Self { ptr, len }
  }
  }
 }
@@ -96,7 +96,7 @@ impl core::ops::DerefMut for Data {
 
 impl Clone for Data {
  fn clone(&self) -> Self {
- Self::from_slice(self).unwrap()
+ Self::from_slice(self)
  }
 }
 
@@ -114,9 +114,8 @@ impl core::fmt::Debug for Data {
  }
 }
 
-impl<const N: usize> TryFrom<[u8; N]> for Data {
- type Error = Error;
- fn try_from(from: [u8; N]) -> Result<Self> {
+impl<const N: usize> From<[u8; N]> for Data {
+ fn from(from: [u8; N]) -> Self {
  Self::from_slice(&from)
  }
 }

crates/libs/registry/src/key.rs

@@ -144,7 +144,7 @@ impl Key {
  pub fn get_value<T: AsRef<str>>(&self, name: T) -> Result<Value> {
  let name = pcwstr(name);
  let (ty, len) = unsafe { self.raw_get_info(name.as_raw())? };
- let mut data = Data::new(len)?;
+ let mut data = Data::new(len);
  unsafe { self.raw_get_bytes(name.as_raw(), &mut data)? };
  Ok(Value { data, ty })
  }

crates/libs/registry/src/value.rs

@@ -38,13 +38,12 @@ impl AsRef<[u8]> for Value {
  }
 }
 
-impl TryFrom<u32> for Value {
- type Error = Error;
- fn try_from(from: u32) -> Result<Self> {
- Ok(Self {
- data: from.to_le_bytes().try_into()?,
+impl From<u32> for Value {
+ fn from(from: u32) -> Self {
+ Self {
+ data: from.to_le_bytes().into(),
  ty: Type::U32,
- })
+ }
  }
 }
 
@@ -55,13 +54,12 @@ impl TryFrom<Value> for u32 {
  }
 }
 
-impl TryFrom<u64> for Value {
- type Error = Error;
- fn try_from(from: u64) -> Result<Self> {
- Ok(Self {
- data: from.to_le_bytes().try_into()?,
+impl From<u64> for Value {
+ fn from(from: u64) -> Self {
+ Self {
+ data: from.to_le_bytes().into(),
  ty: Type::U64,
- })
+ }
  }
 }
 
@@ -82,13 +80,12 @@ impl TryFrom<Value> for String {
  }
 }
 
-impl TryFrom<&str> for Value {
- type Error = Error;
- fn try_from(from: &str) -> Result<Self> {
- Ok(Self {
- data: Data::from_slice(pcwstr(from).as_bytes())?,
+impl From<&str> for Value {
+ fn from(from: &str) -> Self {
+ Self {
+ data: Data::from_slice(pcwstr(from).as_bytes()),
  ty: Type::String,
- })
+ }
  }
 }
 
@@ -117,33 +114,30 @@ impl TryFrom<Value> for HSTRING {
  }
 }
 
-impl TryFrom<&HSTRING> for Value {
- type Error = Error;
- fn try_from(from: &HSTRING) -> Result<Self> {
- Ok(Self {
- data: Data::from_slice(as_bytes(from))?,
+impl From<&HSTRING> for Value {
+ fn from(from: &HSTRING) -> Self {
+ Self {
+ data: Data::from_slice(as_bytes(from)),
  ty: Type::String,
- })
+ }
  }
 }
 
-impl TryFrom<&[u8]> for Value {
- type Error = Error;
- fn try_from(from: &[u8]) -> Result<Self> {
- Ok(Self {
- data: Data::from_slice(from)?,
+impl From<&[u8]> for Value {
+ fn from(from: &[u8]) -> Self {
+ Self {
+ data: Data::from_slice(from),
  ty: Type::Bytes,
- })
+ }
  }
 }
 
-impl<const N: usize> TryFrom<[u8; N]> for Value {
- type Error = Error;
- fn try_from(from: [u8; N]) -> Result<Self> {
- Ok(Self {
- data: Data::from_slice(&from)?,
+impl<const N: usize> From<[u8; N]> for Value {
+ fn from(from: [u8; N]) -> Self {
+ Self {
+ data: Data::from_slice(&from),
  ty: Type::Bytes,
- })
+ }
  }
 }
 

crates/libs/registry/src/value_iterator.rs

@@ -37,7 +37,7 @@ impl<'a> ValueIterator<'a> {
  key,
  range: 0..count as usize,
  name: vec![0; name_max_len as usize + 1],
- data: Data::new(value_max_len as usize)?,
+ data: Data::new(value_max_len as usize),
  })
  }
 }
@@ -72,7 +72,7 @@ impl<'a> Iterator for ValueIterator<'a> {
  Some((
  name,
  Value {
- data: Data::from_slice(&self.data[0..data_len as usize]).unwrap(),
+ data: Data::from_slice(&self.data[0..data_len as usize]),
  ty: ty.into(),
  },
  ))

crates/tests/registry/tests/value.rs

@@ -7,27 +7,27 @@ fn value() -> Result<()> {
  _ = CURRENT_USER.remove_tree(test_key);
  let key = CURRENT_USER.create(test_key)?;
 
- key.set_value("u32", &Value::try_from(123u32)?)?;
+ key.set_value("u32", &Value::from(123u32))?;
  assert_eq!(key.get_type("u32")?, Type::U32);
- assert_eq!(key.get_value("u32")?, Value::try_from(123u32)?);
+ assert_eq!(key.get_value("u32")?, Value::from(123u32));
  assert_eq!(key.get_u32("u32")?, 123u32);
  assert_eq!(key.get_u64("u32")?, 123u64);
  assert_eq!(u32::try_from(key.get_value("u32")?)?, 123u32);
 
  assert_eq!(unsafe { key.raw_get_info(w!("u32"))? }, (Type::U32, 4));
 
- key.set_value("u64", &Value::try_from(123u64)?)?;
+ key.set_value("u64", &Value::from(123u64))?;
  assert_eq!(key.get_type("u64")?, Type::U64);
- assert_eq!(key.get_value("u64")?, Value::try_from(123u64)?);
+ assert_eq!(key.get_value("u64")?, Value::from(123u64));
  assert_eq!(key.get_u32("u64")?, 123u32);
  assert_eq!(key.get_u64("u64")?, 123u64);
  assert_eq!(u64::try_from(key.get_value("u64")?)?, 123u64);
 
  assert_eq!(unsafe { key.raw_get_info(w!("u64"))? }, (Type::U64, 8));
 
- key.set_value("string", &Value::try_from("string")?)?;
+ key.set_value("string", &Value::from("string"))?;
  assert_eq!(key.get_type("string")?, Type::String);
- assert_eq!(key.get_value("string")?, Value::try_from("string")?);
+ assert_eq!(key.get_value("string")?, Value::from("string"));
  assert_eq!(key.get_string("string")?, "string");
  assert_eq!(String::try_from(key.get_value("string")?)?, "string");
 
@@ -36,7 +36,7 @@ fn value() -> Result<()> {
  (Type::String, 14)
  );
 
- let mut value = Value::try_from("expand")?;
+ let mut value = Value::from("expand");
  value.set_ty(Type::ExpandString);
  assert_eq!(value.ty(), Type::ExpandString);
  key.set_value("expand", &value)?;
@@ -49,13 +49,13 @@ fn value() -> Result<()> {
  (Type::ExpandString, 14)
  );
 
- key.set_value("bytes", &Value::try_from([1u8, 2u8, 3u8])?)?;
+ key.set_value("bytes", &Value::from([1u8, 2u8, 3u8]))?;
  assert_eq!(key.get_type("bytes")?, Type::Bytes);
- assert_eq!(key.get_value("bytes")?, Value::try_from([1, 2, 3])?);
+ assert_eq!(key.get_value("bytes")?, Value::from([1, 2, 3]));
 
  assert_eq!(unsafe { key.raw_get_info(w!("bytes"))? }, (Type::Bytes, 3));
 
- let mut value = Value::try_from([1u8, 2u8, 3u8, 4u8].as_slice())?;
+ let mut value = Value::from([1u8, 2u8, 3u8, 4u8].as_slice());
  value.set_ty(Type::Other(1234));
  key.set_value("slice", &value)?;
  assert_eq!(key.get_type("slice")?, Type::Other(1234));
@@ -66,9 +66,9 @@ fn value() -> Result<()> {
  (Type::Other(1234), 4)
  );
 
- key.set_value("hstring", &Value::try_from(h!("HSTRING"))?)?;
+ key.set_value("hstring", &Value::from(h!("HSTRING")))?;
  assert_eq!(key.get_type("hstring")?, Type::String);
- assert_eq!(key.get_value("hstring")?, Value::try_from(h!("HSTRING"))?);
+ assert_eq!(key.get_value("hstring")?, Value::from(h!("HSTRING")));
  assert_eq!(key.get_string("hstring")?, "HSTRING");
  assert_eq!(HSTRING::try_from(key.get_value("hstring")?)?, "HSTRING");
 
@@ -77,9 +77,9 @@ fn value() -> Result<()> {
  (Type::String, 16)
  );
 
- let abc = Value::try_from("abc")?;
+ let abc = Value::from("abc");
  assert_eq!(abc.as_wide(), &[97, 98, 99, 0]);
- let abc = Value::try_from(h!("abcd"))?;
+ let abc = Value::from(h!("abcd"));
  assert_eq!(abc.as_wide(), &[97, 98, 99, 100, 0]);
 
  Ok(())

crates/tests/registry/tests/values.rs

@@ -16,9 +16,9 @@ fn values() -> Result<()> {
  assert_eq!(
  names,
  [
- ("u32".to_string(), Value::try_from(123u32)?),
- ("u64".to_string(), Value::try_from(456u64)?),
- ("string".to_string(), Value::try_from("hello world")?),
+ ("u32".to_string(), Value::from(123u32)),
+ ("u64".to_string(), Value::from(456u64)),
+ ("string".to_string(), Value::from("hello world")),
  ]
  );
 

crates/tools/bindings/src/registry.txt

@@ -4,7 +4,6 @@
 --filter
  Windows.Win32.Foundation.ERROR_INVALID_DATA
  Windows.Win32.Foundation.ERROR_NO_MORE_ITEMS
- Windows.Win32.Foundation.ERROR_OUTOFMEMORY
  Windows.Win32.System.Memory.GetProcessHeap
  Windows.Win32.System.Memory.HeapAlloc
  Windows.Win32.System.Memory.HeapFree