_ Git - ldk-c-bindings/blob - lightning-c-bindings/src/c_types/mod.rs

   1 //! This module contains standard C-mapped types for types not in the original crate.
   2
   3 /// Auto-generated C-mapped types for templated containers
   4 pub mod derived;
   5
   6 use bitcoin::Transaction as BitcoinTransaction;
   7 use bitcoin::hashes::Hash;
   8 use bitcoin::secp256k1::PublicKey as SecpPublicKey;
   9 use bitcoin::secp256k1::SecretKey as SecpSecretKey;
  10 use bitcoin::secp256k1::ecdsa::Signature as SecpSignature;
  11 use bitcoin::secp256k1::Error as SecpError;
  12 use bitcoin::secp256k1::ecdsa::RecoveryId;
  13 use bitcoin::secp256k1::ecdsa::RecoverableSignature as SecpRecoverableSignature;
  14 use bitcoin::bech32;
  15 use bitcoin::util::address;
  16
  17 use core::convert::TryInto; // Bindings need at least rustc 1.34
  18 use core::ffi::c_void;
  19
  20 #[cfg(feature = "std")]
  21 pub(crate) use std::io::{self, Cursor, Read};
  22 #[cfg(feature = "no-std")]
  23 pub(crate) use core2::io::{self, Cursor, Read};
  24 #[cfg(feature = "no-std")]
  25 use alloc::{boxed::Box, vec::Vec, string::String};
  26
  27 #[repr(C)]
  28 /// A dummy struct of which an instance must never exist.
  29 /// This corresponds to the Rust type `Infallible`, or, in unstable rust, `!`
  30 pub struct NotConstructable {
  31         _priv_thing: core::convert::Infallible,
  32 }
  33 impl From<core::convert::Infallible> for NotConstructable {
  34         fn from(_: core::convert::Infallible) -> Self { unreachable!(); }
  35 }
  36
  37 /// Integer in the range `0..32`
  38 #[derive(PartialEq, Eq, Copy, Clone)]
  39 #[allow(non_camel_case_types)]
  40 #[repr(C)]
  41 pub struct u5(u8);
  42
  43 impl From<bech32::u5> for u5 {
  44         fn from(o: bech32::u5) -> Self { Self(o.to_u8()) }
  45 }
  46 impl Into<bech32::u5> for u5 {
  47         fn into(self) -> bech32::u5 { bech32::u5::try_from_u8(self.0).expect("u5 objects must be in the range 0..32") }
  48 }
  49
  50 /// Integer in the range `0..=16`
  51 #[derive(PartialEq, Eq, Copy, Clone)]
  52 #[repr(C)]
  53 pub struct WitnessVersion(u8);
  54
  55 impl From<address::WitnessVersion> for WitnessVersion {
  56         fn from(o: address::WitnessVersion) -> Self { Self(o.into_num()) }
  57 }
  58 impl Into<address::WitnessVersion> for WitnessVersion {
  59         fn into(self) -> address::WitnessVersion { address::WitnessVersion::from_num(self.0).expect("WitnessVersion objects must be in the range 0..=16") }
  60 }
  61
  62 #[derive(Clone)]
  63 #[repr(C)]
  64 /// Represents a valid secp256k1 public key serialized in "compressed form" as a 33 byte array.
  65 pub struct PublicKey {
  66         /// The bytes of the public key
  67         pub compressed_form: [u8; 33],
  68 }
  69 impl PublicKey {
  70         pub(crate) fn from_rust(pk: &SecpPublicKey) -> Self {
  71                 Self {
  72                         compressed_form: pk.serialize(),
  73                 }
  74         }
  75         pub(crate) fn into_rust(&self) -> SecpPublicKey {
  76                 SecpPublicKey::from_slice(&self.compressed_form).unwrap()
  77         }
  78         pub(crate) fn is_null(&self) -> bool { self.compressed_form[..] == [0; 33][..] }
  79         pub(crate) fn null() -> Self { Self { compressed_form: [0; 33] } }
  80 }
  81
  82 #[repr(C)]
  83 #[derive(Clone)]
  84 /// Represents a valid secp256k1 secret key serialized as a 32 byte array.
  85 pub struct SecretKey {
  86         /// The bytes of the secret key
  87         pub bytes: [u8; 32],
  88 }
  89 impl SecretKey {
  90         // from_rust isn't implemented for a ref since we just return byte array refs directly
  91         pub(crate) fn from_rust(sk: SecpSecretKey) -> Self {
  92                 let mut bytes = [0; 32];
  93                 bytes.copy_from_slice(&sk[..]);
  94                 Self { bytes }
  95         }
  96         pub(crate) fn into_rust(&self) -> SecpSecretKey {
  97                 SecpSecretKey::from_slice(&self.bytes).unwrap()
  98         }
  99 }
 100
 101 #[repr(C)]
 102 #[derive(Clone)]
 103 /// Represents a secp256k1 signature serialized as two 32-byte numbers
 104 pub struct Signature {
 105         /// The bytes of the signature in "compact" form
 106         pub compact_form: [u8; 64],
 107 }
 108 impl Signature {
 109         pub(crate) fn from_rust(pk: &SecpSignature) -> Self {
 110                 Self {
 111                         compact_form: pk.serialize_compact(),
 112                 }
 113         }
 114         pub(crate) fn into_rust(&self) -> SecpSignature {
 115                 SecpSignature::from_compact(&self.compact_form).unwrap()
 116         }
 117         // The following are used for Option<Signature> which we support, but don't use anymore
 118         #[allow(unused)] pub(crate) fn is_null(&self) -> bool { self.compact_form[..] == [0; 64][..] }
 119         #[allow(unused)] pub(crate) fn null() -> Self { Self { compact_form: [0; 64] } }
 120 }
 121
 122 #[repr(C)]
 123 #[derive(Clone)]
 124 /// Represents a secp256k1 signature serialized as two 32-byte numbers as well as a tag which
 125 /// allows recovering the exact public key which created the signature given the message.
 126 pub struct RecoverableSignature {
 127         /// The bytes of the signature in "compact" form plus a "Recovery ID" which allows for
 128         /// recovery.
 129         pub serialized_form: [u8; 68],
 130 }
 131 impl RecoverableSignature {
 132         pub(crate) fn from_rust(pk: &SecpRecoverableSignature) -> Self {
 133                 let (id, compact_form) = pk.serialize_compact();
 134                 let mut serialized_form = [0; 68];
 135                 serialized_form[0..64].copy_from_slice(&compact_form[..]);
 136                 serialized_form[64..].copy_from_slice(&id.to_i32().to_le_bytes());
 137                 Self { serialized_form }
 138         }
 139         pub(crate) fn into_rust(&self) -> SecpRecoverableSignature {
 140                 let mut id = [0; 4];
 141                 id.copy_from_slice(&self.serialized_form[64..]);
 142                 SecpRecoverableSignature::from_compact(&self.serialized_form[0..64],
 143                                 RecoveryId::from_i32(i32::from_le_bytes(id)).expect("Invalid Recovery ID"))
 144                         .unwrap()
 145         }
 146 }
 147
 148 #[repr(C)]
 149 #[derive(Copy, Clone)]
 150 /// Represents an error returned from libsecp256k1 during validation of some secp256k1 data
 151 pub enum Secp256k1Error {
 152         /// Signature failed verification
 153         IncorrectSignature,
 154         /// Badly sized message ("messages" are actually fixed-sized digests; see the MESSAGE_SIZE constant)
 155         InvalidMessage,
 156         /// Bad public key
 157         InvalidPublicKey,
 158         /// Bad signature
 159         InvalidSignature,
 160         /// Bad secret key
 161         InvalidSecretKey,
 162         /// Bad shared secret.
 163         InvalidSharedSecret,
 164         /// Bad recovery id
 165         InvalidRecoveryId,
 166         /// Invalid tweak for add_assign or mul_assign
 167         InvalidTweak,
 168         /// Didn't pass enough memory to context creation with preallocated memory
 169         NotEnoughMemory,
 170         /// Bad set of public keys.
 171         InvalidPublicKeySum,
 172         /// The only valid parity values are 0 or 1.
 173         InvalidParityValue,
 174 }
 175 impl Secp256k1Error {
 176         pub(crate) fn from_rust(err: SecpError) -> Self {
 177                 match err {
 178                         SecpError::IncorrectSignature => Secp256k1Error::IncorrectSignature,
 179                         SecpError::InvalidMessage => Secp256k1Error::InvalidMessage,
 180                         SecpError::InvalidPublicKey => Secp256k1Error::InvalidPublicKey,
 181                         SecpError::InvalidSignature => Secp256k1Error::InvalidSignature,
 182                         SecpError::InvalidSecretKey => Secp256k1Error::InvalidSecretKey,
 183                         SecpError::InvalidSharedSecret => Secp256k1Error::InvalidSharedSecret,
 184                         SecpError::InvalidRecoveryId => Secp256k1Error::InvalidRecoveryId,
 185                         SecpError::InvalidTweak => Secp256k1Error::InvalidTweak,
 186                         SecpError::NotEnoughMemory => Secp256k1Error::NotEnoughMemory,
 187                         SecpError::InvalidPublicKeySum => Secp256k1Error::InvalidPublicKeySum,
 188                         SecpError::InvalidParityValue(_) => Secp256k1Error::InvalidParityValue,
 189                 }
 190         }
 191         pub(crate) fn into_rust(self) -> SecpError {
 192                 let invalid_parity = secp256k1::Parity::from_i32(42).unwrap_err();
 193                 match self {
 194                         Secp256k1Error::IncorrectSignature => SecpError::IncorrectSignature,
 195                         Secp256k1Error::InvalidMessage => SecpError::InvalidMessage,
 196                         Secp256k1Error::InvalidPublicKey => SecpError::InvalidPublicKey,
 197                         Secp256k1Error::InvalidSignature => SecpError::InvalidSignature,
 198                         Secp256k1Error::InvalidSecretKey => SecpError::InvalidSecretKey,
 199                         Secp256k1Error::InvalidSharedSecret => SecpError::InvalidSharedSecret,
 200                         Secp256k1Error::InvalidRecoveryId => SecpError::InvalidRecoveryId,
 201                         Secp256k1Error::InvalidTweak => SecpError::InvalidTweak,
 202                         Secp256k1Error::NotEnoughMemory => SecpError::NotEnoughMemory,
 203                         Secp256k1Error::InvalidPublicKeySum => SecpError::InvalidPublicKeySum,
 204                         Secp256k1Error::InvalidParityValue => SecpError::InvalidParityValue(invalid_parity),
 205                 }
 206         }
 207 }
 208
 209 #[repr(C)]
 210 #[derive(Copy, Clone)]
 211 /// Represents an error returned from the bech32 library during validation of some bech32 data
 212 pub enum Bech32Error {
 213         /// String does not contain the separator character
 214         MissingSeparator,
 215         /// The checksum does not match the rest of the data
 216         InvalidChecksum,
 217         /// The data or human-readable part is too long or too short
 218         InvalidLength,
 219         /// Some part of the string contains an invalid character
 220         InvalidChar(u32),
 221         /// Some part of the data has an invalid value
 222         InvalidData(u8),
 223         /// The bit conversion failed due to a padding issue
 224         InvalidPadding,
 225         /// The whole string must be of one case
 226         MixedCase,
 227 }
 228 impl Bech32Error {
 229         pub(crate) fn from_rust(err: bech32::Error) -> Self {
 230                 match err {
 231                         bech32::Error::MissingSeparator => Self::MissingSeparator,
 232                         bech32::Error::InvalidChecksum => Self::InvalidChecksum,
 233                         bech32::Error::InvalidLength => Self::InvalidLength,
 234                         bech32::Error::InvalidChar(c) => Self::InvalidChar(c as u32),
 235                         bech32::Error::InvalidData(d) => Self::InvalidData(d),
 236                         bech32::Error::InvalidPadding => Self::InvalidPadding,
 237                         bech32::Error::MixedCase => Self::MixedCase,
 238                 }
 239         }
 240         pub(crate) fn into_rust(self) -> bech32::Error {
 241                 match self {
 242                         Self::MissingSeparator => bech32::Error::MissingSeparator,
 243                         Self::InvalidChecksum => bech32::Error::InvalidChecksum,
 244                         Self::InvalidLength => bech32::Error::InvalidLength,
 245                         Self::InvalidChar(c) => bech32::Error::InvalidChar(core::char::from_u32(c).expect("Invalid UTF-8 character in Bech32Error::InvalidChar")),
 246                         Self::InvalidData(d) => bech32::Error::InvalidData(d),
 247                         Self::InvalidPadding => bech32::Error::InvalidPadding,
 248                         Self::MixedCase => bech32::Error::MixedCase,
 249                 }
 250         }
 251 }
 252 #[no_mangle]
 253 /// Creates a new Bech32Error which has the same data as `orig`
 254 pub extern "C" fn Bech32Error_clone(orig: &Bech32Error) -> Bech32Error { orig.clone() }
 255 #[no_mangle]
 256 /// Releases any memory held by the given `Bech32Error` (which is currently none)
 257 pub extern "C" fn Bech32Error_free(o: Bech32Error) { }
 258
 259 #[repr(C)]
 260 #[derive(Clone, Copy, PartialEq)]
 261 /// Sub-errors which don't have specific information in them use this type.
 262 pub struct Error {
 263         /// Zero-Sized_types aren't consistent across Rust/C/C++, so we add some size here
 264         pub _dummy: u8,
 265 }
 266
 267 #[repr(C)]
 268 #[allow(missing_docs)] // If there's no docs upstream, that's good enough for us
 269 #[derive(Clone, Copy, PartialEq)]
 270 /// Represents an IO Error. Note that some information is lost in the conversion from Rust.
 271 pub enum IOError {
 272         NotFound,
 273         PermissionDenied,
 274         ConnectionRefused,
 275         ConnectionReset,
 276         ConnectionAborted,
 277         NotConnected,
 278         AddrInUse,
 279         AddrNotAvailable,
 280         BrokenPipe,
 281         AlreadyExists,
 282         WouldBlock,
 283         InvalidInput,
 284         InvalidData,
 285         TimedOut,
 286         WriteZero,
 287         Interrupted,
 288         Other,
 289         UnexpectedEof,
 290 }
 291 impl IOError {
 292         pub(crate) fn from_rust(err: io::Error) -> Self {
 293                 match err.kind() {
 294                         io::ErrorKind::NotFound => IOError::NotFound,
 295                         io::ErrorKind::PermissionDenied => IOError::PermissionDenied,
 296                         io::ErrorKind::ConnectionRefused => IOError::ConnectionRefused,
 297                         io::ErrorKind::ConnectionReset => IOError::ConnectionReset,
 298                         io::ErrorKind::ConnectionAborted => IOError::ConnectionAborted,
 299                         io::ErrorKind::NotConnected => IOError::NotConnected,
 300                         io::ErrorKind::AddrInUse => IOError::AddrInUse,
 301                         io::ErrorKind::AddrNotAvailable => IOError::AddrNotAvailable,
 302                         io::ErrorKind::BrokenPipe => IOError::BrokenPipe,
 303                         io::ErrorKind::AlreadyExists => IOError::AlreadyExists,
 304                         io::ErrorKind::WouldBlock => IOError::WouldBlock,
 305                         io::ErrorKind::InvalidInput => IOError::InvalidInput,
 306                         io::ErrorKind::InvalidData => IOError::InvalidData,
 307                         io::ErrorKind::TimedOut => IOError::TimedOut,
 308                         io::ErrorKind::WriteZero => IOError::WriteZero,
 309                         io::ErrorKind::Interrupted => IOError::Interrupted,
 310                         io::ErrorKind::Other => IOError::Other,
 311                         io::ErrorKind::UnexpectedEof => IOError::UnexpectedEof,
 312                         _ => IOError::Other,
 313                 }
 314         }
 315         pub(crate) fn to_rust(&self) -> io::Error {
 316                 io::Error::new(match self {
 317                         IOError::NotFound => io::ErrorKind::NotFound,
 318                         IOError::PermissionDenied => io::ErrorKind::PermissionDenied,
 319                         IOError::ConnectionRefused => io::ErrorKind::ConnectionRefused,
 320                         IOError::ConnectionReset => io::ErrorKind::ConnectionReset,
 321                         IOError::ConnectionAborted => io::ErrorKind::ConnectionAborted,
 322                         IOError::NotConnected => io::ErrorKind::NotConnected,
 323                         IOError::AddrInUse => io::ErrorKind::AddrInUse,
 324                         IOError::AddrNotAvailable => io::ErrorKind::AddrNotAvailable,
 325                         IOError::BrokenPipe => io::ErrorKind::BrokenPipe,
 326                         IOError::AlreadyExists => io::ErrorKind::AlreadyExists,
 327                         IOError::WouldBlock => io::ErrorKind::WouldBlock,
 328                         IOError::InvalidInput => io::ErrorKind::InvalidInput,
 329                         IOError::InvalidData => io::ErrorKind::InvalidData,
 330                         IOError::TimedOut => io::ErrorKind::TimedOut,
 331                         IOError::WriteZero => io::ErrorKind::WriteZero,
 332                         IOError::Interrupted => io::ErrorKind::Interrupted,
 333                         IOError::Other => io::ErrorKind::Other,
 334                         IOError::UnexpectedEof => io::ErrorKind::UnexpectedEof,
 335                 }, "")
 336         }
 337 }
 338
 339 #[repr(C)]
 340 /// A serialized transaction, in (pointer, length) form.
 341 ///
 342 /// This type optionally owns its own memory, and thus the semantics around access change based on
 343 /// the `data_is_owned` flag. If `data_is_owned` is set, you must call `Transaction_free` to free
 344 /// the underlying buffer before the object goes out of scope. If `data_is_owned` is not set, any
 345 /// access to the buffer after the scope in which the object was provided to you is invalid. eg,
 346 /// access after you return from the call in which a `!data_is_owned` `Transaction` is provided to
 347 /// you would be invalid.
 348 ///
 349 /// Note that, while it may change in the future, because transactions on the Rust side are stored
 350 /// in a deserialized form, all `Transaction`s generated on the Rust side will have `data_is_owned`
 351 /// set. Similarly, while it may change in the future, all `Transaction`s you pass to Rust may have
 352 /// `data_is_owned` either set or unset at your discretion.
 353 pub struct Transaction {
 354         /// The serialized transaction data.
 355         ///
 356         /// This is non-const for your convenience, an object passed to Rust is never written to.
 357         pub data: *mut u8,
 358         /// The length of the serialized transaction
 359         pub datalen: usize,
 360         /// Whether the data pointed to by `data` should be freed or not.
 361         pub data_is_owned: bool,
 362 }
 363 impl Transaction {
 364         fn from_vec(vec: Vec<u8>) -> Self {
 365                 let datalen = vec.len();
 366                 let data = Box::into_raw(vec.into_boxed_slice());
 367                 Self {
 368                         data: unsafe { (*data).as_mut_ptr() },
 369                         datalen,
 370                         data_is_owned: true,
 371                 }
 372         }
 373         pub(crate) fn into_bitcoin(&self) -> BitcoinTransaction {
 374                 if self.datalen == 0 { panic!("0-length buffer can never represent a valid Transaction"); }
 375                 ::bitcoin::consensus::encode::deserialize(unsafe { core::slice::from_raw_parts(self.data, self.datalen) }).unwrap()
 376         }
 377         pub(crate) fn from_bitcoin(btc: &BitcoinTransaction) -> Self {
 378                 let vec = ::bitcoin::consensus::encode::serialize(btc);
 379                 Self::from_vec(vec)
 380         }
 381 }
 382 impl Drop for Transaction {
 383         fn drop(&mut self) {
 384                 if self.data_is_owned && self.datalen != 0 {
 385                         let _ = derived::CVec_u8Z { data: self.data as *mut u8, datalen: self.datalen };
 386                 }
 387         }
 388 }
 389 impl Clone for Transaction {
 390         fn clone(&self) -> Self {
 391                 let sl = unsafe { core::slice::from_raw_parts(self.data, self.datalen) };
 392                 let mut v = Vec::new();
 393                 v.extend_from_slice(&sl);
 394                 Self::from_vec(v)
 395         }
 396 }
 397 #[no_mangle]
 398 /// Frees the data buffer, if data_is_owned is set and datalen > 0.
 399 pub extern "C" fn Transaction_free(_res: Transaction) { }
 400
 401 pub(crate) fn bitcoin_to_C_outpoint(outpoint: ::bitcoin::blockdata::transaction::OutPoint) -> crate::lightning::chain::transaction::OutPoint {
 402         crate::lightning::chain::transaction::OutPoint_new(ThirtyTwoBytes { data: outpoint.txid.into_inner() }, outpoint.vout.try_into().unwrap())
 403 }
 404 pub(crate) fn C_to_bitcoin_outpoint(outpoint: crate::lightning::chain::transaction::OutPoint) -> ::bitcoin::blockdata::transaction::OutPoint {
 405         unsafe {
 406                 ::bitcoin::blockdata::transaction::OutPoint {
 407                         txid: (*outpoint.inner).txid, vout: (*outpoint.inner).index as u32
 408                 }
 409         }
 410 }
 411
 412 #[repr(C)]
 413 #[derive(Clone)]
 414 /// A transaction output including a scriptPubKey and value.
 415 /// This type *does* own its own memory, so must be free'd appropriately.
 416 pub struct TxOut {
 417         /// The script_pubkey in this output
 418         pub script_pubkey: derived::CVec_u8Z,
 419         /// The value, in satoshis, of this output
 420         pub value: u64,
 421 }
 422
 423 impl TxOut {
 424         pub(crate) fn into_rust(mut self) -> ::bitcoin::blockdata::transaction::TxOut {
 425                 ::bitcoin::blockdata::transaction::TxOut {
 426                         script_pubkey: self.script_pubkey.into_rust().into(),
 427                         value: self.value,
 428                 }
 429         }
 430         pub(crate) fn from_rust(txout: ::bitcoin::blockdata::transaction::TxOut) -> Self {
 431                 Self {
 432                         script_pubkey: derived::CVec_u8Z::from(txout.script_pubkey.into_bytes()),
 433                         value: txout.value
 434                 }
 435         }
 436 }
 437
 438 #[no_mangle]
 439 /// Convenience function for constructing a new TxOut
 440 pub extern "C" fn TxOut_new(script_pubkey: derived::CVec_u8Z, value: u64) -> TxOut {
 441         TxOut { script_pubkey, value }
 442 }
 443 #[no_mangle]
 444 /// Frees the data pointed to by script_pubkey.
 445 pub extern "C" fn TxOut_free(_res: TxOut) { }
 446 #[no_mangle]
 447 /// Creates a new TxOut which has the same data as `orig` but with a new script buffer.
 448 pub extern "C" fn TxOut_clone(orig: &TxOut) -> TxOut { orig.clone() }
 449
 450 #[repr(C)]
 451 /// A "slice" referencing some byte array. This is simply a length-tagged pointer which does not
 452 /// own the memory pointed to by data.
 453 pub struct u8slice {
 454         /// A pointer to the byte buffer
 455         pub data: *const u8,
 456         /// The number of bytes pointed to by `data`.
 457         pub datalen: usize
 458 }
 459 impl u8slice {
 460         pub(crate) fn from_slice(s: &[u8]) -> Self {
 461                 Self {
 462                         data: s.as_ptr(),
 463                         datalen: s.len(),
 464                 }
 465         }
 466         pub(crate) fn to_slice(&self) -> &[u8] {
 467                 if self.datalen == 0 { return &[]; }
 468                 unsafe { core::slice::from_raw_parts(self.data, self.datalen) }
 469         }
 470         pub(crate) fn to_reader<'a>(&'a self) -> Cursor<&'a [u8]> {
 471                 let sl = self.to_slice();
 472                 Cursor::new(sl)
 473         }
 474         pub(crate) fn from_vec(v: &derived::CVec_u8Z) -> u8slice {
 475                 Self::from_slice(v.as_slice())
 476         }
 477 }
 478 pub(crate) fn reader_to_vec<R: Read>(r: &mut R) -> derived::CVec_u8Z {
 479         let mut res = Vec::new();
 480         r.read_to_end(&mut res).unwrap();
 481         derived::CVec_u8Z::from(res)
 482 }
 483
 484 #[repr(C)]
 485 #[derive(Copy, Clone)]
 486 /// Arbitrary 32 bytes, which could represent one of a few different things. You probably want to
 487 /// look up the corresponding function in rust-lightning's docs.
 488 pub struct ThirtyTwoBytes {
 489         /// The thirty-two bytes
 490         pub data: [u8; 32],
 491 }
 492 impl ThirtyTwoBytes {
 493         pub(crate) fn null() -> Self {
 494                 Self { data: [0; 32] }
 495         }
 496 }
 497
 498 #[repr(C)]
 499 /// A 3-byte byte array.
 500 pub struct ThreeBytes { /** The three bytes */ pub data: [u8; 3], }
 501 #[derive(Clone)]
 502 #[repr(C)]
 503 /// A 4-byte byte array.
 504 pub struct FourBytes { /** The four bytes */ pub data: [u8; 4], }
 505 #[derive(Clone)]
 506 #[repr(C)]
 507 /// A 12-byte byte array.
 508 pub struct TwelveBytes { /** The twelve bytes */ pub data: [u8; 12], }
 509 #[derive(Clone)]
 510 #[repr(C)]
 511 /// A 16-byte byte array.
 512 pub struct SixteenBytes { /** The sixteen bytes */ pub data: [u8; 16], }
 513 #[derive(Clone)]
 514 #[repr(C)]
 515 /// A 20-byte byte array.
 516 pub struct TwentyBytes { /** The twenty bytes */ pub data: [u8; 20], }
 517
 518 pub(crate) struct VecWriter(pub Vec<u8>);
 519 impl lightning::util::ser::Writer for VecWriter {
 520         fn write_all(&mut self, buf: &[u8]) -> Result<(), io::Error> {
 521                 self.0.extend_from_slice(buf);
 522                 Ok(())
 523         }
 524 }
 525 pub(crate) fn serialize_obj<I: lightning::util::ser::Writeable>(i: &I) -> derived::CVec_u8Z {
 526         let mut out = VecWriter(Vec::new());
 527         i.write(&mut out).unwrap();
 528         derived::CVec_u8Z::from(out.0)
 529 }
 530 pub(crate) fn deserialize_obj<I: lightning::util::ser::Readable>(s: u8slice) -> Result<I, lightning::ln::msgs::DecodeError> {
 531         I::read(&mut s.to_slice())
 532 }
 533 pub(crate) fn maybe_deserialize_obj<I: lightning::util::ser::MaybeReadable>(s: u8slice) -> Result<Option<I>, lightning::ln::msgs::DecodeError> {
 534         I::read(&mut s.to_slice())
 535 }
 536 pub(crate) fn deserialize_obj_arg<A, I: lightning::util::ser::ReadableArgs<A>>(s: u8slice, args: A) -> Result<I, lightning::ln::msgs::DecodeError> {
 537         I::read(&mut s.to_slice(), args)
 538 }
 539
 540 #[repr(C)]
 541 /// A Rust str object, ie a reference to a UTF8-valid string.
 542 /// This is *not* null-terminated so cannot be used directly as a C string!
 543 pub struct Str {
 544         /// A pointer to the string's bytes, in UTF8 encoding
 545         pub chars: *const u8,
 546         /// The number of bytes (not characters!) pointed to by `chars`
 547         pub len: usize,
 548         /// Whether the data pointed to by `chars` should be freed or not.
 549         pub chars_is_owned: bool,
 550 }
 551 impl Into<Str> for &'static str {
 552         fn into(self) -> Str {
 553                 Str { chars: self.as_ptr(), len: self.len(), chars_is_owned: false }
 554         }
 555 }
 556 impl Into<Str> for &mut &'static str {
 557         fn into(self) -> Str {
 558                 let us: &'static str = *self;
 559                 us.into()
 560         }
 561 }
 562
 563 impl Str {
 564         pub(crate) fn into_str(&self) -> &'static str {
 565                 if self.len == 0 { return ""; }
 566                 core::str::from_utf8(unsafe { core::slice::from_raw_parts(self.chars, self.len) }).unwrap()
 567         }
 568         pub(crate) fn into_string(mut self) -> String {
 569                 let bytes = if self.len == 0 {
 570                         Vec::new()
 571                 } else if self.chars_is_owned {
 572                         let ret = unsafe {
 573                                 Box::from_raw(core::slice::from_raw_parts_mut(unsafe { self.chars as *mut u8 }, self.len))
 574                         }.into();
 575                         self.chars_is_owned = false;
 576                         ret
 577                 } else {
 578                         let mut ret = Vec::with_capacity(self.len);
 579                         ret.extend_from_slice(unsafe { core::slice::from_raw_parts(self.chars, self.len) });
 580                         ret
 581                 };
 582                 String::from_utf8(bytes).unwrap()
 583         }
 584 }
 585 impl Into<Str> for String {
 586         fn into(self) -> Str {
 587                 let s = Box::leak(self.into_boxed_str());
 588                 Str { chars: s.as_ptr(), len: s.len(), chars_is_owned: true }
 589         }
 590 }
 591 impl Clone for Str {
 592         fn clone(&self) -> Self {
 593                 String::from(self.into_str()).into()
 594         }
 595 }
 596
 597 impl Drop for Str {
 598         fn drop(&mut self) {
 599                 if self.chars_is_owned && self.len != 0 {
 600                         let _ = derived::CVec_u8Z { data: self.chars as *mut u8, datalen: self.len };
 601                 }
 602         }
 603 }
 604 #[no_mangle]
 605 /// Frees the data buffer, if chars_is_owned is set and len > 0.
 606 pub extern "C" fn Str_free(_res: Str) { }
 607
 608 // Note that the C++ headers memset(0) all the Templ types to avoid deallocation!
 609 // Thus, they must gracefully handle being completely null in _free.
 610
 611 // TODO: Integer/bool primitives should avoid the pointer indirection for underlying types
 612 // everywhere in the containers.
 613
 614 #[repr(C)]
 615 pub(crate) union CResultPtr<O, E> {
 616         pub(crate) result: *mut O,
 617         pub(crate) err: *mut E,
 618 }
 619 #[repr(C)]
 620 pub(crate) struct CResultTempl<O, E> {
 621         pub(crate) contents: CResultPtr<O, E>,
 622         pub(crate) result_ok: bool,
 623 }
 624 impl<O, E> CResultTempl<O, E> {
 625         pub(crate) extern "C" fn ok(o: O) -> Self {
 626                 CResultTempl {
 627                         contents: CResultPtr {
 628                                 result: Box::into_raw(Box::new(o)),
 629                         },
 630                         result_ok: true,
 631                 }
 632         }
 633         pub(crate) extern "C" fn err(e: E) -> Self {
 634                 CResultTempl {
 635                         contents: CResultPtr {
 636                                 err: Box::into_raw(Box::new(e)),
 637                         },
 638                         result_ok: false,
 639                 }
 640         }
 641 }
 642 impl<O, E> Drop for CResultTempl<O, E> {
 643         fn drop(&mut self) {
 644                 if self.result_ok {
 645                         if unsafe { !self.contents.result.is_null() } {
 646                                 unsafe { Box::from_raw(self.contents.result) };
 647                         }
 648                 } else if unsafe { !self.contents.err.is_null() } {
 649                         unsafe { Box::from_raw(self.contents.err) };
 650                 }
 651         }
 652 }
 653
 654 /// Utility to make it easy to set a pointer to null and get its original value in line.
 655 pub(crate) trait TakePointer<T> {
 656         fn take_ptr(&mut self) -> T;
 657 }
 658 impl<T> TakePointer<*const T> for *const T {
 659         fn take_ptr(&mut self) -> *const T {
 660                 let ret = *self;
 661                 *self = core::ptr::null();
 662                 ret
 663         }
 664 }
 665 impl<T> TakePointer<*mut T> for *mut T {
 666         fn take_ptr(&mut self) -> *mut T {
 667                 let ret = *self;
 668                 *self = core::ptr::null_mut();
 669                 ret
 670         }
 671 }
 672
 673
 674 pub(crate) mod ObjOps {
 675         #[cfg(feature = "no-std")]
 676         use alloc::boxed::Box;
 677
 678         #[inline]
 679         #[must_use = "returns new dangling pointer"]
 680         pub(crate) fn heap_alloc<T>(obj: T) -> *mut T {
 681                 let ptr = Box::into_raw(Box::new(obj));
 682                 nonnull_ptr_to_inner(ptr)
 683         }
 684         #[inline]
 685         pub(crate) fn nonnull_ptr_to_inner<T>(ptr: *const T) -> *mut T {
 686                 if core::mem::size_of::<T>() == 0 {
 687                         // We map `None::<T>` as `T { inner: null, .. }` which works great for all
 688                         // non-Zero-Sized-Types `T`.
 689                         // For ZSTs, we need to differentiate between null implying `None` and null implying
 690                         // `Some` with no allocation.
 691                         // Thus, for ZSTs, we add one (usually) page here, which should always be aligned.
 692                         // Note that this relies on undefined behavior! A pointer to NULL may be valid, but a
 693                         // pointer to NULL + 4096 is almost certainly not. That said, Rust's existing use of
 694                         // `(*mut T)1` for the pointer we're adding to is also not defined, so we should be
 695                         // fine.
 696                         // Note that we add 4095 here as at least the Java client assumes that the low bit on
 697                         // any heap pointer is 0, which is generally provided by malloc, but which is not true
 698                         // for ZSTs "allocated" by `Box::new`.
 699                         debug_assert_eq!(ptr as usize, 1);
 700                         unsafe { (ptr as *mut T).cast::<u8>().add(4096 - 1).cast::<T>() }
 701                 } else {
 702                         // In order to get better test coverage, also increment non-ZST pointers with
 703                         // --cfg=test_mod_pointers, which is set in genbindings.sh for debug builds.
 704                         #[cfg(test_mod_pointers)]
 705                         unsafe { (ptr as *mut T).cast::<u8>().add(4096).cast::<T>() }
 706                         #[cfg(not(test_mod_pointers))]
 707                         unsafe { ptr as *mut T }
 708                 }
 709         }
 710         #[inline]
 711         /// Invert nonnull_ptr_to_inner
 712         pub(crate) fn untweak_ptr<T>(ptr: *mut T) -> *mut T {
 713                 if core::mem::size_of::<T>() == 0 {
 714                         unsafe { ptr.cast::<u8>().sub(4096 - 1).cast::<T>() }
 715                 } else {
 716                         #[cfg(test_mod_pointers)]
 717                         unsafe { ptr.cast::<u8>().sub(4096).cast::<T>() }
 718                         #[cfg(not(test_mod_pointers))]
 719                         ptr
 720                 }
 721         }
 722 }
 723
 724 #[cfg(test_mod_pointers)]
 725 #[no_mangle]
 726 /// This function exists for memory safety testing purposes. It should never be used in production
 727 /// code
 728 pub extern "C" fn __unmangle_inner_ptr(ptr: *const c_void) -> *const c_void {
 729         if ptr as usize == 1 {
 730                 core::ptr::null()
 731         } else {
 732                 unsafe { ptr.cast::<u8>().sub(4096).cast::<c_void>() }
 733         }
 734 }
 735
 736 pub(crate) struct SmartPtr<T> {
 737         ptr: *mut T,
 738 }
 739 impl<T> SmartPtr<T> {
 740         pub(crate) fn from_obj(o: T) -> Self {
 741                 Self { ptr: Box::into_raw(Box::new(o)) }
 742         }
 743         pub(crate) fn null() -> Self {
 744                 Self { ptr: core::ptr::null_mut() }
 745         }
 746 }
 747 impl<T> Drop for SmartPtr<T> {
 748         fn drop(&mut self) {
 749                 if self.ptr != core::ptr::null_mut() {
 750                         unsafe { Box::from_raw(self.ptr); }
 751                 }
 752         }
 753 }
 754 impl<T> core::ops::Deref for SmartPtr<T> {
 755         type Target = *mut T;
 756         fn deref(&self) -> &*mut T {
 757                 &self.ptr
 758         }
 759 }