X-Git-Url: http://git.bitcoin.ninja/index.cgi?p=ldk-c-bindings;a=blobdiff_plain;f=lightning-c-bindings%2Fsrc%2Fc_types%2Fmod.rs;h=f31d55bd1b2c7d9ec67f30552f0036d27e5b28a6;hp=5db6dda00b908375df6a5b02accae57d2f21a89a;hb=5f6a53d54a93ba52f9f06f1a43f615facad6f471;hpb=f160848382e6a1bc43dc100d77b96c4b4ecb3beb

diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs
index 5db6dda..f31d55b 100644
--- a/lightning-c-bindings/src/c_types/mod.rs
+++ b/lightning-c-bindings/src/c_types/mod.rs
@@ -13,9 +13,25 @@ use bitcoin::secp256k1::recovery::RecoveryId;
 use bitcoin::secp256k1::recovery::RecoverableSignature as SecpRecoverableSignature;
 use bitcoin::bech32;
 
-use std::convert::TryInto; // Bindings need at least rustc 1.34
+use core::convert::TryInto; // Bindings need at least rustc 1.34
+use core::ffi::c_void;
 
-use std::io::{Cursor, Read}; // TODO: We should use core2 here when we support no_std
+#[cfg(feature = "std")]
+pub(crate) use std::io::{self, Cursor, Read};
+#[cfg(feature = "no-std")]
+pub(crate) use core2::io::{self, Cursor, Read};
+#[cfg(feature = "no-std")]
+use alloc::{boxed::Box, vec::Vec, string::String};
+
+#[repr(C)]
+/// A dummy struct of which an instance must never exist.
+/// This corresponds to the Rust type `Infallible`, or, in unstable rust, `!`
+pub struct NotConstructable {
+	_priv_thing: core::convert::Infallible,
+}
+impl From<core::convert::Infallible> for NotConstructable {
+	fn from(_: core::convert::Infallible) -> Self { unreachable!(); }
+}
 
 /// Integer in the range `0..32`
 #[derive(PartialEq, Eq, Copy, Clone)]
@@ -51,6 +67,7 @@ impl PublicKey {
 }
 
 #[repr(C)]
+#[derive(Clone)]
 /// Represents a valid secp256k1 secret key serialized as a 32 byte array.
 pub struct SecretKey {
 	/// The bytes of the secret key
@@ -178,6 +195,7 @@ pub enum IOError {
 	Other,
 	UnexpectedEof,
 }
+#[cfg(feature = "std")]
 impl IOError {
 	pub(crate) fn from_rust(err: std::io::Error) -> Self {
 		match err.kind() {
@@ -262,7 +280,7 @@ impl Transaction {
 	}
 	pub(crate) fn into_bitcoin(&self) -> BitcoinTransaction {
 		if self.datalen == 0 { panic!("0-length buffer can never represent a valid Transaction"); }
-		::bitcoin::consensus::encode::deserialize(unsafe { std::slice::from_raw_parts(self.data, self.datalen) }).unwrap()
+		::bitcoin::consensus::encode::deserialize(unsafe { core::slice::from_raw_parts(self.data, self.datalen) }).unwrap()
 	}
 	pub(crate) fn from_bitcoin(btc: &BitcoinTransaction) -> Self {
 		let vec = ::bitcoin::consensus::encode::serialize(btc);
@@ -278,7 +296,7 @@ impl Drop for Transaction {
 }
 impl Clone for Transaction {
 	fn clone(&self) -> Self {
-		let sl = unsafe { std::slice::from_raw_parts(self.data, self.datalen) };
+		let sl = unsafe { core::slice::from_raw_parts(self.data, self.datalen) };
 		let mut v = Vec::new();
 		v.extend_from_slice(&sl);
 		Self::from_vec(v)
@@ -355,7 +373,7 @@ impl u8slice {
 	}
 	pub(crate) fn to_slice(&self) -> &[u8] {
 		if self.datalen == 0 { return &[]; }
-		unsafe { std::slice::from_raw_parts(self.data, self.datalen) }
+		unsafe { core::slice::from_raw_parts(self.data, self.datalen) }
 	}
 	pub(crate) fn to_reader<'a>(&'a self) -> Cursor<&'a [u8]> {
 		let sl = self.to_slice();
@@ -394,8 +412,8 @@ pub struct ThreeBytes { /** The three bytes */ pub data: [u8; 3], }
 pub struct FourBytes { /** The four bytes */ pub data: [u8; 4], }
 #[derive(Clone)]
 #[repr(C)]
-/// A 10-byte byte array.
-pub struct TenBytes { /** The ten bytes */ pub data: [u8; 10], }
+/// A 12-byte byte array.
+pub struct TwelveBytes { /** The twelve bytes */ pub data: [u8; 12], }
 #[derive(Clone)]
 #[repr(C)]
 /// A 16-byte byte array.
@@ -407,7 +425,7 @@ pub struct TwentyBytes { /** The twenty bytes */ pub data: [u8; 20], }
 
 pub(crate) struct VecWriter(pub Vec<u8>);
 impl lightning::util::ser::Writer for VecWriter {
-	fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
+	fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error> {
 		self.0.extend_from_slice(buf);
 		Ok(())
 	}
@@ -420,12 +438,14 @@ pub(crate) fn serialize_obj<I: lightning::util::ser::Writeable>(i: &I) -> derive
 pub(crate) fn deserialize_obj<I: lightning::util::ser::Readable>(s: u8slice) -> Result<I, lightning::ln::msgs::DecodeError> {
 	I::read(&mut s.to_slice())
 }
+pub(crate) fn maybe_deserialize_obj<I: lightning::util::ser::MaybeReadable>(s: u8slice) -> Result<Option<I>, lightning::ln::msgs::DecodeError> {
+	I::read(&mut s.to_slice())
+}
 pub(crate) fn deserialize_obj_arg<A, I: lightning::util::ser::ReadableArgs<A>>(s: u8slice, args: A) -> Result<I, lightning::ln::msgs::DecodeError> {
 	I::read(&mut s.to_slice(), args)
 }
 
 #[repr(C)]
-#[derive(Clone)]
 /// A Rust str object, ie a reference to a UTF8-valid string.
 /// This is *not* null-terminated so cannot be used directly as a C string!
 pub struct Str {
@@ -441,23 +461,30 @@ impl Into<Str> for &'static str {
 		Str { chars: self.as_ptr(), len: self.len(), chars_is_owned: false }
 	}
 }
+impl Into<Str> for &mut &'static str {
+	fn into(self) -> Str {
+		let us: &'static str = *self;
+		us.into()
+	}
+}
+
 impl Str {
 	pub(crate) fn into_str(&self) -> &'static str {
 		if self.len == 0 { return ""; }
-		std::str::from_utf8(unsafe { std::slice::from_raw_parts(self.chars, self.len) }).unwrap()
+		core::str::from_utf8(unsafe { core::slice::from_raw_parts(self.chars, self.len) }).unwrap()
 	}
 	pub(crate) fn into_string(mut self) -> String {
 		let bytes = if self.len == 0 {
 			Vec::new()
 		} else if self.chars_is_owned {
 			let ret = unsafe {
-				Box::from_raw(std::slice::from_raw_parts_mut(unsafe { self.chars as *mut u8 }, self.len))
+				Box::from_raw(core::slice::from_raw_parts_mut(unsafe { self.chars as *mut u8 }, self.len))
 			}.into();
 			self.chars_is_owned = false;
 			ret
 		} else {
 			let mut ret = Vec::with_capacity(self.len);
-			ret.extend_from_slice(unsafe { std::slice::from_raw_parts(self.chars, self.len) });
+			ret.extend_from_slice(unsafe { core::slice::from_raw_parts(self.chars, self.len) });
 			ret
 		};
 		String::from_utf8(bytes).unwrap()
@@ -469,6 +496,11 @@ impl Into<Str> for String {
 		Str { chars: s.as_ptr(), len: s.len(), chars_is_owned: true }
 	}
 }
+impl Clone for Str {
+	fn clone(&self) -> Self {
+		self.into_str().clone().into()
+	}
+}
 
 impl Drop for Str {
 	fn drop(&mut self) {
@@ -534,20 +566,23 @@ pub(crate) trait TakePointer<T> {
 impl<T> TakePointer<*const T> for *const T {
 	fn take_ptr(&mut self) -> *const T {
 		let ret = *self;
-		*self = std::ptr::null();
+		*self = core::ptr::null();
 		ret
 	}
 }
 impl<T> TakePointer<*mut T> for *mut T {
 	fn take_ptr(&mut self) -> *mut T {
 		let ret = *self;
-		*self = std::ptr::null_mut();
+		*self = core::ptr::null_mut();
 		ret
 	}
 }
 
 
 pub(crate) mod ObjOps {
+	#[cfg(feature = "no-std")]
+	use alloc::boxed::Box;
+
 	#[inline]
 	#[must_use = "returns new dangling pointer"]
 	pub(crate) fn heap_alloc<T>(obj: T) -> *mut T {
@@ -593,3 +628,40 @@ pub(crate) mod ObjOps {
 		}
 	}
 }
+
+#[cfg(test_mod_pointers)]
+#[no_mangle]
+/// This function exists for memory safety testing purposes. It should never be used in production
+/// code
+pub extern "C" fn __unmangle_inner_ptr(ptr: *const c_void) -> *const c_void {
+	if ptr as usize == 1 {
+		core::ptr::null()
+	} else {
+		unsafe { ptr.cast::<u8>().sub(4096).cast::<c_void>() }
+	}
+}
+
+pub(crate) struct SmartPtr<T> {
+	ptr: *mut T,
+}
+impl<T> SmartPtr<T> {
+	pub(crate) fn from_obj(o: T) -> Self {
+		Self { ptr: Box::into_raw(Box::new(o)) }
+	}
+	pub(crate) fn null() -> Self {
+		Self { ptr: core::ptr::null_mut() }
+	}
+}
+impl<T> Drop for SmartPtr<T> {
+	fn drop(&mut self) {
+		if self.ptr != core::ptr::null_mut() {
+			unsafe { Box::from_raw(self.ptr); }
+		}
+	}
+}
+impl<T> core::ops::Deref for SmartPtr<T> {
+	type Target = *mut T;
+	fn deref(&self) -> &*mut T {
+		&self.ptr
+	}
+}