From 90421e583020a5a3806749f5f4624ed01ff1a04a Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Mon, 6 Jan 2020 18:30:03 -0500 Subject: [PATCH] Seal the features contexts --- lightning/src/ln/features.rs | 182 +++++++++++++++++------------------ 1 file changed, 89 insertions(+), 93 deletions(-) diff --git a/lightning/src/ln/features.rs b/lightning/src/ln/features.rs index 34fee6befd2..2e2a5398ae0 100644 --- a/lightning/src/ln/features.rs +++ b/lightning/src/ln/features.rs @@ -8,57 +8,32 @@ use std::marker::PhantomData; use ln::msgs::DecodeError; use util::ser::{Readable, Writeable, Writer}; -/// The context in which a Feature object appears determines which bits of features the node -/// supports will be set. We use this when creating our own Feature objects to select which bits to -/// set and when passing around Feature objects to ensure the bits we're checking for are -/// available. -/// -/// This Context represents when the Feature appears in the init message, sent between peers and not -/// rumored around the P2P network. -pub struct FeatureContextInit {} -/// The context in which a Feature object appears determines which bits of features the node -/// supports will be set. We use this when creating our own Feature objects to select which bits to -/// set and when passing around Feature objects to ensure the bits we're checking for are -/// available. -/// -/// This Context represents when the Feature appears in the node_announcement message, as it is -/// rumored around the P2P network. -pub struct FeatureContextNode {} -/// The context in which a Feature object appears determines which bits of features the node -/// supports will be set. We use this when creating our own Feature objects to select which bits to -/// set and when passing around Feature objects to ensure the bits we're checking for are -/// available. -/// -/// This Context represents when the Feature appears in the ChannelAnnouncement message, as it is -/// rumored around the P2P network. -pub struct FeatureContextChannel {} -/// The context in which a Feature object appears determines which bits of features the node -/// supports will be set. We use this when creating our own Feature objects to select which bits to -/// set and when passing around Feature objects to ensure the bits we're checking for are -/// available. -/// -/// This Context represents when the Feature appears in an invoice, used to determine the different -/// options available for routing a payment. -/// -/// Note that this is currently unused as invoices come to us via a different crate and are not -/// native to rust-lightning directly. -pub struct FeatureContextInvoice {} - -/// An internal trait capturing the various future context types -pub trait FeatureContext {} -impl FeatureContext for FeatureContextInit {} -impl FeatureContext for FeatureContextNode {} -impl FeatureContext for FeatureContextChannel {} -impl FeatureContext for FeatureContextInvoice {} - -/// An internal trait capturing FeatureContextInit and FeatureContextNode -pub trait FeatureContextInitNode : FeatureContext {} -impl FeatureContextInitNode for FeatureContextInit {} -impl FeatureContextInitNode for FeatureContextNode {} +mod sealed { // You should just use the type aliases instead. + pub struct InitContext {} + pub struct NodeContext {} + pub struct ChannelContext {} + + /// An internal trait capturing the various feature context types + pub trait Context {} + impl Context for InitContext {} + impl Context for NodeContext {} + impl Context for ChannelContext {} + + pub trait DataLossProtect: Context {} + impl DataLossProtect for InitContext {} + impl DataLossProtect for NodeContext {} + + pub trait InitialRoutingSync: Context {} + impl InitialRoutingSync for InitContext {} + + pub trait UpfrontShutdownScript: Context {} + impl UpfrontShutdownScript for InitContext {} + impl UpfrontShutdownScript for NodeContext {} +} /// Tracks the set of features which a node implements, templated by the context in which it /// appears. -pub struct Features { +pub struct Features { #[cfg(not(test))] /// Note that, for convinience, flags is LITTLE endian (despite being big-endian on the wire) flags: Vec, @@ -72,7 +47,7 @@ pub struct Features { pub mark: PhantomData, } -impl Clone for Features { +impl Clone for Features { fn clone(&self) -> Self { Self { flags: self.flags.clone(), @@ -80,61 +55,104 @@ impl Clone for Features { } } } -impl PartialEq for Features { +impl PartialEq for Features { fn eq(&self, o: &Self) -> bool { self.flags.eq(&o.flags) } } -impl fmt::Debug for Features { +impl fmt::Debug for Features { fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> { self.flags.fmt(fmt) } } /// A feature message as it appears in an init message -pub type InitFeatures = Features; +pub type InitFeatures = Features; /// A feature message as it appears in a node_announcement message -pub type NodeFeatures = Features; +pub type NodeFeatures = Features; /// A feature message as it appears in a channel_announcement message -pub type ChannelFeatures = Features; +pub type ChannelFeatures = Features; -impl Features { +impl InitFeatures { /// Create a Features with the features we support #[cfg(not(feature = "fuzztarget"))] - pub(crate) fn our_features() -> Features { - Features { + pub(crate) fn our_features() -> InitFeatures { + InitFeatures { flags: vec![2 | 1 << 5], mark: PhantomData, } } #[cfg(feature = "fuzztarget")] - pub fn our_features() -> Features { - Features { + pub fn our_features() -> InitFeatures { + InitFeatures { flags: vec![2 | 1 << 5], mark: PhantomData, } } + + /// Writes all features present up to, and including, 13. + pub(crate) fn write_up_to_13(&self, w: &mut W) -> Result<(), ::std::io::Error> { + let len = cmp::min(2, self.flags.len()); + w.size_hint(len + 2); + (len as u16).write(w)?; + for i in (0..len).rev() { + if i == 0 { + self.flags[i].write(w)?; + } else { + // On byte 1, check (1 << 14) - 1 up all bits-up-to-but-not-including-bit-14. + (self.flags[i] & ((1 << (14 - 8)) - 1)).write(w)?; + } + } + Ok(()) + } + + /// or's another InitFeatures into this one. + pub(crate) fn or(&mut self, o: &InitFeatures) { + let total_feature_len = cmp::max(self.flags.len(), o.flags.len()); + self.flags.resize(total_feature_len, 0u8); + for (byte, o_byte) in self.flags.iter_mut().zip(o.flags.iter()) { + *byte |= *o_byte; + } + } } -impl Features { +impl ChannelFeatures { /// Create a Features with the features we support #[cfg(not(feature = "fuzztarget"))] - pub(crate) fn our_features() -> Features { - Features { + pub(crate) fn our_features() -> ChannelFeatures { + ChannelFeatures { flags: Vec::new(), mark: PhantomData, } } #[cfg(feature = "fuzztarget")] - pub fn our_features() -> Features { - Features { + pub fn our_features() -> ChannelFeatures { + ChannelFeatures { flags: Vec::new(), mark: PhantomData, } } } -impl Features { +impl NodeFeatures { + /// Create a Features with the features we support + #[cfg(not(feature = "fuzztarget"))] + pub(crate) fn our_features() -> NodeFeatures { + NodeFeatures { + flags: vec![2 | 1 << 5], + mark: PhantomData, + } + } + #[cfg(feature = "fuzztarget")] + pub fn our_features() -> NodeFeatures { + NodeFeatures { + flags: vec![2 | 1 << 5], + mark: PhantomData, + } + } +} + +impl Features { /// Create a blank Features with no fetures set pub fn empty() -> Features { Features { @@ -179,11 +197,13 @@ impl Features { } } -impl Features { +impl Features { pub(crate) fn supports_data_loss_protect(&self) -> bool { self.flags.len() > 0 && (self.flags[0] & 3) != 0 } +} +impl Features { pub(crate) fn supports_upfront_shutdown_script(&self) -> bool { self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0 } @@ -193,7 +213,7 @@ impl Features { } } -impl Features { +impl Features { pub(crate) fn initial_routing_sync(&self) -> bool { self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0 } @@ -204,33 +224,9 @@ impl Features { self.flags[0] |= 1 << 3; } } - - /// Writes all features present up to, and including, 13. - pub(crate) fn write_up_to_13(&self, w: &mut W) -> Result<(), ::std::io::Error> { - let len = cmp::min(2, self.flags.len()); - w.size_hint(len + 2); - (len as u16).write(w)?; - for i in (0..len).rev() { - if i == 0 { - self.flags[i].write(w)?; - } else { - (self.flags[i] & ((1 << (14 - 8)) - 1)).write(w)?; - } - } - Ok(()) - } - - /// or's another InitFeatures into this one. - pub(crate) fn or(&mut self, o: &InitFeatures) { - let total_feature_len = cmp::max(self.flags.len(), o.flags.len()); - self.flags.resize(total_feature_len, 0u8); - for (feature, o_feature) in self.flags.iter_mut().zip(o.flags.iter()) { - *feature |= *o_feature; - } - } } -impl Writeable for Features { +impl Writeable for Features { fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> { w.size_hint(self.flags.len() + 2); (self.flags.len() as u16).write(w)?; @@ -241,7 +237,7 @@ impl Writeable for Features { } } -impl Readable for Features { +impl Readable for Features { fn read(r: &mut R) -> Result { let mut flags: Vec = Readable::read(r)?; flags.reverse(); // Swap to little-endian