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=6267b80bc2dd007ba9476f76d01127d2b9a74937;hp=0a96f3e7d6789d0ad0be381022db26bb78b727ed;hb=d3d51441b4cd98389308d4cfaba6548f25598c4c;hpb=1495575b517c90da925698da14f627bf0d5b313f diff --git a/lightning-c-bindings/src/c_types/mod.rs b/lightning-c-bindings/src/c_types/mod.rs index 0a96f3e..6267b80 100644 --- a/lightning-c-bindings/src/c_types/mod.rs +++ b/lightning-c-bindings/src/c_types/mod.rs @@ -1,18 +1,38 @@ +//! This module contains standard C-mapped types for types not in the original crate. + +/// Auto-generated C-mapped types for templated containers pub mod derived; -use bitcoin::Script as BitcoinScript; use bitcoin::Transaction as BitcoinTransaction; use bitcoin::hashes::Hash; use bitcoin::secp256k1::key::PublicKey as SecpPublicKey; use bitcoin::secp256k1::key::SecretKey as SecpSecretKey; use bitcoin::secp256k1::Signature as SecpSignature; use bitcoin::secp256k1::Error as SecpError; +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 +/// Integer in the range `0..32` +#[derive(PartialEq, Eq, Copy, Clone)] +#[allow(non_camel_case_types)] +#[repr(C)] +pub struct u5(u8); + +impl From for u5 { + fn from(o: bech32::u5) -> Self { Self(o.to_u8()) } +} +impl Into for u5 { + fn into(self) -> bech32::u5 { bech32::u5::try_from_u8(self.0).expect("u5 objects must be in the range 0..32") } +} + #[derive(Clone)] #[repr(C)] +/// Represents a valid secp256k1 public key serialized in "compressed form" as a 33 byte array. pub struct PublicKey { + /// The bytes of the public key pub compressed_form: [u8; 33], } impl PublicKey { @@ -29,7 +49,9 @@ impl PublicKey { } #[repr(C)] +/// Represents a valid secp256k1 secret key serialized as a 32 byte array. pub struct SecretKey { + /// The bytes of the secret key pub bytes: [u8; 32], } impl SecretKey { @@ -46,7 +68,9 @@ impl SecretKey { #[repr(C)] #[derive(Clone)] +/// Represents a secp256k1 signature serialized as two 32-byte numbers pub struct Signature { + /// The bytes of the signature in "compact" form pub compact_form: [u8; 64], } impl Signature { @@ -64,15 +88,51 @@ impl Signature { } #[repr(C)] +#[derive(Clone)] +/// Represents a secp256k1 signature serialized as two 32-byte numbers as well as a tag which +/// allows recovering the exact public key which created the signature given the message. +pub struct RecoverableSignature { + /// The bytes of the signature in "compact" form plus a "Recovery ID" which allows for + /// recovery. + pub serialized_form: [u8; 68], +} +impl RecoverableSignature { + pub(crate) fn from_rust(pk: &SecpRecoverableSignature) -> Self { + let (id, compact_form) = pk.serialize_compact(); + let mut serialized_form = [0; 68]; + serialized_form[0..64].copy_from_slice(&compact_form[..]); + serialized_form[64..].copy_from_slice(&id.to_i32().to_le_bytes()); + Self { serialized_form } + } + pub(crate) fn into_rust(&self) -> SecpRecoverableSignature { + let mut id = [0; 4]; + id.copy_from_slice(&self.serialized_form[64..]); + SecpRecoverableSignature::from_compact(&self.serialized_form[0..64], + RecoveryId::from_i32(i32::from_le_bytes(id)).expect("Invalid Recovery ID")) + .unwrap() + } +} + +#[repr(C)] +/// Represents an error returned from libsecp256k1 during validation of some secp256k1 data pub enum Secp256k1Error { + /// Signature failed verification IncorrectSignature, + /// Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant) InvalidMessage, + /// Bad public key InvalidPublicKey, + /// Bad signature InvalidSignature, + /// Bad secret key InvalidSecretKey, + /// Bad recovery id InvalidRecoveryId, + /// Invalid tweak for add_assign or mul_assign InvalidTweak, + /// tweak_add_check failed on an xonly public key TweakCheckFailed, + /// Didn't pass enough memory to context creation with preallocated memory NotEnoughMemory, } impl Secp256k1Error { @@ -91,6 +151,55 @@ impl Secp256k1Error { } } +#[repr(C)] +#[allow(missing_docs)] // If there's no docs upstream, that's good enough for us +/// Represents an IO Error. Note that some information is lost in the conversion from Rust. +pub enum IOError { + NotFound, + PermissionDenied, + ConnectionRefused, + ConnectionReset, + ConnectionAborted, + NotConnected, + AddrInUse, + AddrNotAvailable, + BrokenPipe, + AlreadyExists, + WouldBlock, + InvalidInput, + InvalidData, + TimedOut, + WriteZero, + Interrupted, + Other, + UnexpectedEof, +} +impl IOError { + pub(crate) fn from_rust(err: std::io::Error) -> Self { + match err.kind() { + std::io::ErrorKind::NotFound => IOError::NotFound, + std::io::ErrorKind::PermissionDenied => IOError::PermissionDenied, + std::io::ErrorKind::ConnectionRefused => IOError::ConnectionRefused, + std::io::ErrorKind::ConnectionReset => IOError::ConnectionReset, + std::io::ErrorKind::ConnectionAborted => IOError::ConnectionAborted, + std::io::ErrorKind::NotConnected => IOError::NotConnected, + std::io::ErrorKind::AddrInUse => IOError::AddrInUse, + std::io::ErrorKind::AddrNotAvailable => IOError::AddrNotAvailable, + std::io::ErrorKind::BrokenPipe => IOError::BrokenPipe, + std::io::ErrorKind::AlreadyExists => IOError::AlreadyExists, + std::io::ErrorKind::WouldBlock => IOError::WouldBlock, + std::io::ErrorKind::InvalidInput => IOError::InvalidInput, + std::io::ErrorKind::InvalidData => IOError::InvalidData, + std::io::ErrorKind::TimedOut => IOError::TimedOut, + std::io::ErrorKind::WriteZero => IOError::WriteZero, + std::io::ErrorKind::Interrupted => IOError::Interrupted, + std::io::ErrorKind::Other => IOError::Other, + std::io::ErrorKind::UnexpectedEof => IOError::UnexpectedEof, + _ => IOError::Other, + } + } +} + #[repr(C)] /// A serialized transaction, in (pointer, length) form. /// @@ -106,9 +215,13 @@ impl Secp256k1Error { /// set. Similarly, while it may change in the future, all `Transaction`s you pass to Rust may have /// `data_is_owned` either set or unset at your discretion. pub struct Transaction { + /// The serialized transaction data. + /// /// This is non-const for your convenience, an object passed to Rust is never written to. pub data: *mut u8, + /// The length of the serialized transaction pub datalen: usize, + /// Whether the data pointed to by `data` should be freed or not. pub data_is_owned: bool, } impl Transaction { @@ -116,9 +229,10 @@ impl Transaction { 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() } - pub(crate) fn from_vec(v: Vec) -> Self { - let datalen = v.len(); - let data = Box::into_raw(v.into_boxed_slice()); + pub(crate) fn from_bitcoin(btc: &BitcoinTransaction) -> Self { + let vec = ::bitcoin::consensus::encode::serialize(btc); + let datalen = vec.len(); + let data = Box::into_raw(vec.into_boxed_slice()); Self { data: unsafe { (*data).as_mut_ptr() }, datalen, @@ -134,10 +248,11 @@ impl Drop for Transaction { } } #[no_mangle] +/// Frees the data buffer, if data_is_owned is set and datalen > 0. pub extern "C" fn Transaction_free(_res: Transaction) { } -pub(crate) fn bitcoin_to_C_outpoint(outpoint: ::bitcoin::blockdata::transaction::OutPoint) -> crate::chain::transaction::OutPoint { - crate::chain::transaction::OutPoint_new(ThirtyTwoBytes { data: outpoint.txid.into_inner() }, outpoint.vout.try_into().unwrap()) +pub(crate) fn bitcoin_to_C_outpoint(outpoint: ::bitcoin::blockdata::transaction::OutPoint) -> crate::lightning::chain::transaction::OutPoint { + crate::lightning::chain::transaction::OutPoint_new(ThirtyTwoBytes { data: outpoint.txid.into_inner() }, outpoint.vout.try_into().unwrap()) } #[repr(C)] @@ -145,7 +260,9 @@ pub(crate) fn bitcoin_to_C_outpoint(outpoint: ::bitcoin::blockdata::transaction: /// A transaction output including a scriptPubKey and value. /// This type *does* own its own memory, so must be free'd appropriately. pub struct TxOut { + /// The script_pubkey in this output pub script_pubkey: derived::CVec_u8Z, + /// The value, in satoshis, of this output pub value: u64, } @@ -164,13 +281,19 @@ impl TxOut { } } #[no_mangle] +/// Frees the data pointed to by script_pubkey. pub extern "C" fn TxOut_free(_res: TxOut) { } #[no_mangle] +/// Creates a new TxOut which has the same data as `orig` but with a new script buffer. pub extern "C" fn TxOut_clone(orig: &TxOut) -> TxOut { orig.clone() } #[repr(C)] +/// A "slice" referencing some byte array. This is simply a length-tagged pointer which does not +/// own the memory pointed to by data. pub struct u8slice { + /// A pointer to the byte buffer pub data: *const u8, + /// The number of bytes pointed to by `data`. pub datalen: usize } impl u8slice { @@ -191,6 +314,7 @@ impl u8slice { /// Arbitrary 32 bytes, which could represent one of a few different things. You probably want to /// look up the corresponding function in rust-lightning's docs. pub struct ThirtyTwoBytes { + /// The thirty-two bytes pub data: [u8; 32], } impl ThirtyTwoBytes { @@ -200,16 +324,24 @@ impl ThirtyTwoBytes { } #[repr(C)] -pub struct ThreeBytes { pub data: [u8; 3], } +/// A 3-byte byte array. +pub struct ThreeBytes { /** The three bytes */ pub data: [u8; 3], } +#[derive(Clone)] +#[repr(C)] +/// A 4-byte byte array. +pub struct FourBytes { /** The four bytes */ pub data: [u8; 4], } #[derive(Clone)] #[repr(C)] -pub struct FourBytes { pub data: [u8; 4], } +/// A 10-byte byte array. +pub struct TenBytes { /** The ten bytes */ pub data: [u8; 10], } #[derive(Clone)] #[repr(C)] -pub struct TenBytes { pub data: [u8; 10], } +/// A 16-byte byte array. +pub struct SixteenBytes { /** The sixteen bytes */ pub data: [u8; 16], } #[derive(Clone)] #[repr(C)] -pub struct SixteenBytes { pub data: [u8; 16], } +/// A 20-byte byte array. +pub struct TwentyBytes { /** The twenty bytes */ pub data: [u8; 20], } pub(crate) struct VecWriter(pub Vec); impl lightning::util::ser::Writer for VecWriter { @@ -234,24 +366,61 @@ pub(crate) fn deserialize_obj_arg>(s } #[repr(C)] -#[derive(Copy, Clone)] +#[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 { + /// A pointer to the string's bytes, in UTF8 encoding pub chars: *const u8, - pub len: usize + /// The number of bytes (not characters!) pointed to by `chars` + pub len: usize, + /// Whether the data pointed to by `chars` should be freed or not. + pub chars_is_owned: bool, } impl Into for &'static str { fn into(self) -> Str { - Str { chars: self.as_ptr(), len: self.len() } + Str { chars: self.as_ptr(), len: self.len(), chars_is_owned: false } } } -impl Into<&'static str> for Str { - fn into(self) -> &'static str { +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() } + 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)) + }.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 + }; + String::from_utf8(bytes).unwrap() + } } +impl Into for String { + fn into(self) -> Str { + let s = Box::leak(self.into_boxed_str()); + Str { chars: s.as_ptr(), len: s.len(), chars_is_owned: true } + } +} + +impl Drop for Str { + fn drop(&mut self) { + if self.chars_is_owned && self.len != 0 { + let _ = derived::CVec_u8Z { data: self.chars as *mut u8, datalen: self.len }; + } + } +} +#[no_mangle] +/// Frees the data buffer, if chars_is_owned is set and len > 0. +pub extern "C" fn Str_free(_res: Str) { } // Note that the C++ headers memset(0) all the Templ types to avoid deallocation! // Thus, they must gracefully handle being completely null in _free.