use bitcoin::network::constants::Network;
use crate::events::{MessageSendEvent, MessageSendEventsProvider};
-use crate::ln::ChannelId;
+use crate::ln::types::ChannelId;
use crate::ln::features::{ChannelFeatures, NodeFeatures, InitFeatures};
use crate::ln::msgs::{DecodeError, ErrorAction, Init, LightningError, RoutingMessageHandler, SocketAddress, MAX_VALUE_MSAT};
use crate::ln::msgs::{ChannelAnnouncement, ChannelUpdate, NodeAnnouncement, GossipTimestampFilter};
use crate::io_extras::{copy, sink};
use crate::prelude::*;
use core::{cmp, fmt};
-use core::convert::TryFrom;
use crate::sync::{RwLock, RwLockReadGuard, LockTestExt};
#[cfg(feature = "std")]
use core::sync::atomic::{AtomicUsize, Ordering};
NodeId(pubkey.serialize())
}
+ /// Create a new NodeId from a slice of bytes
+ pub fn from_slice(bytes: &[u8]) -> Result<Self, DecodeError> {
+ if bytes.len() != PUBLIC_KEY_SIZE {
+ return Err(DecodeError::InvalidValue);
+ }
+ let mut data = [0; PUBLIC_KEY_SIZE];
+ data.copy_from_slice(bytes);
+ Ok(NodeId(data))
+ }
+
/// Get the public key slice from this NodeId
pub fn as_slice(&self) -> &[u8] {
&self.0
};
for (_, ref node) in iter {
if let Some(node_info) = node.announcement_info.as_ref() {
- if let Some(msg) = node_info.announcement_message.clone() {
- return Some(msg);
+ if let NodeAnnouncementInfo::Relayed(announcement) = node_info {
+ return Some(announcement.clone());
}
}
}
// Prior replies should use the number of blocks that fit into the reply. Overflow
// safe since first_blocknum is always <= last SCID's block.
else {
- (false, block_from_scid(batch.last().unwrap()) - first_blocknum)
+ (false, block_from_scid(*batch.last().unwrap()) - first_blocknum)
};
prev_batch_endblock = first_blocknum + number_of_blocks;
///
/// Refers to the `node_id` forwarding the payment to the next hop.
#[inline]
- pub(super) fn source(&self) -> &'a NodeId { if self.from_node_one { &self.channel.node_one } else { &self.channel.node_two } }
+ pub fn source(&self) -> &'a NodeId { if self.from_node_one { &self.channel.node_one } else { &self.channel.node_two } }
/// Returns the `node_id` of the target hop.
///
/// Refers to the `node_id` receiving the payment from the previous hop.
#[inline]
- pub(super) fn target(&self) -> &'a NodeId { if self.from_node_one { &self.channel.node_two } else { &self.channel.node_one } }
+ pub fn target(&self) -> &'a NodeId { if self.from_node_one { &self.channel.node_two } else { &self.channel.node_one } }
}
impl<'a> fmt::Debug for DirectedChannelInfo<'a> {
});
#[derive(Clone, Debug, PartialEq, Eq)]
-/// Information received in the latest node_announcement from this node.
-pub struct NodeAnnouncementInfo {
+/// Non-relayable information received in the latest node_announcement from this node.
+pub struct NodeAnnouncementDetails {
/// Protocol features the node announced support for
pub features: NodeFeatures,
+
/// When the last known update to the node state was issued.
/// Value is opaque, as set in the announcement.
pub last_update: u32,
+
/// Color assigned to the node
pub rgb: [u8; 3],
+
/// Moniker assigned to the node.
/// May be invalid or malicious (eg control chars),
/// should not be exposed to the user.
pub alias: NodeAlias,
+
+ /// Internet-level addresses via which one can connect to the node
+ pub addresses: Vec<SocketAddress>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+/// Information received in the latest node_announcement from this node.
+pub enum NodeAnnouncementInfo {
/// An initial announcement of the node
- /// Mostly redundant with the data we store in fields explicitly.
/// Everything else is useful only for sending out for initial routing sync.
/// Not stored if contains excess data to prevent DoS.
- pub announcement_message: Option<NodeAnnouncement>
+ Relayed(NodeAnnouncement),
+
+ /// Non-relayable information received in the latest node_announcement from this node.
+ Local(NodeAnnouncementDetails),
}
impl NodeAnnouncementInfo {
+
+ /// Protocol features the node announced support for
+ pub fn features(&self) -> &NodeFeatures {
+ match self {
+ NodeAnnouncementInfo::Relayed(relayed) => {
+ &relayed.contents.features
+ }
+ NodeAnnouncementInfo::Local(local) => {
+ &local.features
+ }
+ }
+ }
+
+ /// When the last known update to the node state was issued.
+ ///
+ /// Value may or may not be a timestamp, depending on the policy of the origin node.
+ pub fn last_update(&self) -> u32 {
+ match self {
+ NodeAnnouncementInfo::Relayed(relayed) => {
+ relayed.contents.timestamp
+ }
+ NodeAnnouncementInfo::Local(local) => {
+ local.last_update
+ }
+ }
+ }
+
+ /// Color assigned to the node
+ pub fn rgb(&self) -> [u8; 3] {
+ match self {
+ NodeAnnouncementInfo::Relayed(relayed) => {
+ relayed.contents.rgb
+ }
+ NodeAnnouncementInfo::Local(local) => {
+ local.rgb
+ }
+ }
+ }
+
+ /// Moniker assigned to the node.
+ ///
+ /// May be invalid or malicious (eg control chars), should not be exposed to the user.
+ pub fn alias(&self) -> &NodeAlias {
+ match self {
+ NodeAnnouncementInfo::Relayed(relayed) => {
+ &relayed.contents.alias
+ }
+ NodeAnnouncementInfo::Local(local) => {
+ &local.alias
+ }
+ }
+ }
+
/// Internet-level addresses via which one can connect to the node
- pub fn addresses(&self) -> &[SocketAddress] {
- self.announcement_message.as_ref()
- .map(|msg| msg.contents.addresses.as_slice())
- .unwrap_or_default()
+ pub fn addresses(&self) -> &Vec<SocketAddress> {
+ match self {
+ NodeAnnouncementInfo::Relayed(relayed) => {
+ &relayed.contents.addresses
+ }
+ NodeAnnouncementInfo::Local(local) => {
+ &local.addresses
+ }
+ }
+ }
+
+ /// An initial announcement of the node
+ ///
+ /// Not stored if contains excess data to prevent DoS.
+ pub fn announcement_message(&self) -> Option<&NodeAnnouncement> {
+ match self {
+ NodeAnnouncementInfo::Relayed(announcement) => {
+ Some(announcement)
+ }
+ NodeAnnouncementInfo::Local(_) => {
+ None
+ }
+ }
}
}
impl Writeable for NodeAnnouncementInfo {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
- let empty_addresses = Vec::<SocketAddress>::new();
+ let features = self.features();
+ let last_update = self.last_update();
+ let rgb = self.rgb();
+ let alias = self.alias();
+ let addresses = self.addresses();
+ let announcement_message = self.announcement_message();
+
write_tlv_fields!(writer, {
- (0, self.features, required),
- (2, self.last_update, required),
- (4, self.rgb, required),
- (6, self.alias, required),
- (8, self.announcement_message, option),
- (10, empty_addresses, required_vec), // Versions prior to 0.0.115 require this field
+ (0, features, required),
+ (2, last_update, required),
+ (4, rgb, required),
+ (6, alias, required),
+ (8, announcement_message, option),
+ (10, *addresses, required_vec), // Versions 0.0.115 through 0.0.123 only serialized an empty vec
});
Ok(())
}
(4, rgb, required),
(6, alias, required),
(8, announcement_message, option),
- (10, _addresses, optional_vec), // deprecated, not used anymore
+ (10, addresses, required_vec),
});
- let _: Option<Vec<SocketAddress>> = _addresses;
- Ok(Self { features: features.0.unwrap(), last_update: last_update.0.unwrap(), rgb: rgb.0.unwrap(),
- alias: alias.0.unwrap(), announcement_message })
+ if let Some(announcement) = announcement_message {
+ Ok(Self::Relayed(announcement))
+ } else {
+ Ok(Self::Local(NodeAnnouncementDetails {
+ features: features.0.unwrap(),
+ last_update: last_update.0.unwrap(),
+ rgb: rgb.0.unwrap(),
+ alias: alias.0.unwrap(),
+ addresses,
+ }))
+ }
}
}
pub announcement_info: Option<NodeAnnouncementInfo>
}
+impl NodeInfo {
+ /// Returns whether the node has only announced Tor addresses.
+ pub fn is_tor_only(&self) -> bool {
+ self.announcement_info
+ .as_ref()
+ .map(|info| info.addresses())
+ .and_then(|addresses| (!addresses.is_empty()).then(|| addresses))
+ .map(|addresses| addresses.iter().all(|address| address.is_tor()))
+ .unwrap_or(false)
+ }
+}
+
impl fmt::Display for NodeInfo {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
write!(f, " channels: {:?}, announcement_info: {:?}",
channels: RwLock::new(channels),
nodes: RwLock::new(nodes),
last_rapid_gossip_sync_timestamp: Mutex::new(last_rapid_gossip_sync_timestamp),
- removed_nodes: Mutex::new(HashMap::new()),
- removed_channels: Mutex::new(HashMap::new()),
+ removed_nodes: Mutex::new(new_hash_map()),
+ removed_channels: Mutex::new(new_hash_map()),
pending_checks: utxo::PendingChecks::new(),
})
}
channels: RwLock::new(IndexedMap::new()),
nodes: RwLock::new(IndexedMap::new()),
last_rapid_gossip_sync_timestamp: Mutex::new(None),
- removed_channels: Mutex::new(HashMap::new()),
- removed_nodes: Mutex::new(HashMap::new()),
+ removed_channels: Mutex::new(new_hash_map()),
+ removed_nodes: Mutex::new(new_hash_map()),
pending_checks: utxo::PendingChecks::new(),
}
}
// The timestamp field is somewhat of a misnomer - the BOLTs use it to order
// updates to ensure you always have the latest one, only vaguely suggesting
// that it be at least the current time.
- if node_info.last_update > msg.timestamp {
+ if node_info.last_update() > msg.timestamp {
return Err(LightningError{err: "Update older than last processed update".to_owned(), action: ErrorAction::IgnoreDuplicateGossip});
- } else if node_info.last_update == msg.timestamp {
+ } else if node_info.last_update() == msg.timestamp {
return Err(LightningError{err: "Update had the same timestamp as last processed update".to_owned(), action: ErrorAction::IgnoreDuplicateGossip});
}
}
let should_relay =
msg.excess_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY &&
- msg.excess_address_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY &&
- msg.excess_data.len() + msg.excess_address_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY;
- node.announcement_info = Some(NodeAnnouncementInfo {
- features: msg.features.clone(),
- last_update: msg.timestamp,
- rgb: msg.rgb,
- alias: msg.alias,
- announcement_message: if should_relay { full_msg.cloned() } else { None },
- });
+ msg.excess_address_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY &&
+ msg.excess_data.len() + msg.excess_address_data.len() <= MAX_EXCESS_BYTES_FOR_RELAY;
+
+ node.announcement_info = if let (Some(signed_announcement), true) = (full_msg, should_relay) {
+ Some(NodeAnnouncementInfo::Relayed(signed_announcement.clone()))
+ } else {
+ Some(NodeAnnouncementInfo::Local(NodeAnnouncementDetails {
+ features: msg.features.clone(),
+ last_update: msg.timestamp,
+ rgb: msg.rgb,
+ alias: msg.alias,
+ addresses: msg.addresses.clone(),
+ }))
+ };
Ok(())
}
None => {
core::mem::drop(channels);
self.pending_checks.check_hold_pending_channel_update(msg, full_msg)?;
- return Err(LightningError{err: "Couldn't find channel for update".to_owned(), action: ErrorAction::IgnoreError});
+ return Err(LightningError {
+ err: "Couldn't find channel for update".to_owned(),
+ action: ErrorAction::IgnoreAndLog(Level::Gossip),
+ });
},
Some(channel) => {
if msg.htlc_maximum_msat > MAX_VALUE_MSAT {
use crate::ln::chan_utils::make_funding_redeemscript;
#[cfg(feature = "std")]
use crate::ln::features::InitFeatures;
+ use crate::ln::msgs::SocketAddress;
use crate::routing::gossip::{P2PGossipSync, NetworkGraph, NetworkUpdate, NodeAlias, MAX_EXCESS_BYTES_FOR_RELAY, NodeId, RoutingFees, ChannelUpdateInfo, ChannelInfo, NodeAnnouncementInfo, NodeInfo};
use crate::routing::utxo::{UtxoLookupError, UtxoResult};
use crate::ln::msgs::{RoutingMessageHandler, UnsignedNodeAnnouncement, NodeAnnouncement,
ReplyChannelRange, QueryChannelRange, QueryShortChannelIds, MAX_VALUE_MSAT};
use crate::util::config::UserConfig;
use crate::util::test_utils;
- use crate::util::ser::{ReadableArgs, Readable, Writeable};
+ use crate::util::ser::{Hostname, ReadableArgs, Readable, Writeable};
use crate::util::scid_utils::scid_from_parts;
use crate::routing::gossip::REMOVED_ENTRIES_TRACKING_AGE_LIMIT_SECS;
// 1. Check we can read a valid NodeAnnouncementInfo and fail on an invalid one
let announcement_message = <Vec<u8>>::from_hex("d977cb9b53d93a6ff64bb5f1e158b4094b66e798fb12911168a3ccdf80a83096340a6a95da0ae8d9f776528eecdbb747eb6b545495a4319ed5378e35b21e073a000122013413a7031b84c5567b126440995d3ed5aaba0565d71e1834604819ff9c17f5e9d5dd078f2020201010101010101010101010101010101010101010101010101010101010101010000701fffefdfc2607").unwrap();
let announcement_message = NodeAnnouncement::read(&mut announcement_message.as_slice()).unwrap();
- let valid_node_ann_info = NodeAnnouncementInfo {
- features: channelmanager::provided_node_features(&UserConfig::default()),
- last_update: 0,
- rgb: [0u8; 3],
- alias: NodeAlias([0u8; 32]),
- announcement_message: Some(announcement_message)
- };
+ let valid_node_ann_info = NodeAnnouncementInfo::Relayed(announcement_message);
let mut encoded_valid_node_ann_info = Vec::new();
assert!(valid_node_ann_info.write(&mut encoded_valid_node_ann_info).is_ok());
let old_ann_info_with_addresses = <Vec<u8>>::from_hex("3f0009000708a000080a51220204000000000403000000062000000000000000000000000000000000000000000000000000000000000000000a0505014104d2").unwrap();
let ann_info_with_addresses = NodeAnnouncementInfo::read(&mut old_ann_info_with_addresses.as_slice())
.expect("to be able to read an old NodeAnnouncementInfo with addresses");
- // This serialized info has an address field but no announcement_message, therefore the addresses returned by our function will still be empty
- assert!(ann_info_with_addresses.addresses().is_empty());
+ // This serialized info has no announcement_message but its address field should still be considered
+ assert!(!ann_info_with_addresses.addresses().is_empty());
}
#[test]
let node_id = NodeId([42; 33]);
assert_eq!(format!("{}", &node_id), "2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a");
}
+
+ #[test]
+ fn is_tor_only_node() {
+ let network_graph = create_network_graph();
+ let (secp_ctx, gossip_sync) = create_gossip_sync(&network_graph);
+
+ let node_1_privkey = &SecretKey::from_slice(&[42; 32]).unwrap();
+ let node_2_privkey = &SecretKey::from_slice(&[41; 32]).unwrap();
+ let node_1_id = NodeId::from_pubkey(&PublicKey::from_secret_key(&secp_ctx, node_1_privkey));
+
+ let announcement = get_signed_channel_announcement(|_| {}, node_1_privkey, node_2_privkey, &secp_ctx);
+ gossip_sync.handle_channel_announcement(&announcement).unwrap();
+
+ let tcp_ip_v4 = SocketAddress::TcpIpV4 {
+ addr: [255, 254, 253, 252],
+ port: 9735
+ };
+ let tcp_ip_v6 = SocketAddress::TcpIpV6 {
+ addr: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240],
+ port: 9735
+ };
+ let onion_v2 = SocketAddress::OnionV2([255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 38, 7]);
+ let onion_v3 = SocketAddress::OnionV3 {
+ ed25519_pubkey: [255, 254, 253, 252, 251, 250, 249, 248, 247, 246, 245, 244, 243, 242, 241, 240, 239, 238, 237, 236, 235, 234, 233, 232, 231, 230, 229, 228, 227, 226, 225, 224],
+ checksum: 32,
+ version: 16,
+ port: 9735
+ };
+ let hostname = SocketAddress::Hostname {
+ hostname: Hostname::try_from(String::from("host")).unwrap(),
+ port: 9735,
+ };
+
+ assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only());
+
+ let announcement = get_signed_node_announcement(|_| {}, node_1_privkey, &secp_ctx);
+ gossip_sync.handle_node_announcement(&announcement).unwrap();
+ assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only());
+
+ let announcement = get_signed_node_announcement(
+ |announcement| {
+ announcement.addresses = vec![
+ tcp_ip_v4.clone(), tcp_ip_v6.clone(), onion_v2.clone(), onion_v3.clone(),
+ hostname.clone()
+ ];
+ announcement.timestamp += 1000;
+ },
+ node_1_privkey, &secp_ctx
+ );
+ gossip_sync.handle_node_announcement(&announcement).unwrap();
+ assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only());
+
+ let announcement = get_signed_node_announcement(
+ |announcement| {
+ announcement.addresses = vec![
+ tcp_ip_v4.clone(), tcp_ip_v6.clone(), onion_v2.clone(), onion_v3.clone()
+ ];
+ announcement.timestamp += 2000;
+ },
+ node_1_privkey, &secp_ctx
+ );
+ gossip_sync.handle_node_announcement(&announcement).unwrap();
+ assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only());
+
+ let announcement = get_signed_node_announcement(
+ |announcement| {
+ announcement.addresses = vec![
+ tcp_ip_v6.clone(), onion_v2.clone(), onion_v3.clone()
+ ];
+ announcement.timestamp += 3000;
+ },
+ node_1_privkey, &secp_ctx
+ );
+ gossip_sync.handle_node_announcement(&announcement).unwrap();
+ assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only());
+
+ let announcement = get_signed_node_announcement(
+ |announcement| {
+ announcement.addresses = vec![onion_v2.clone(), onion_v3.clone()];
+ announcement.timestamp += 4000;
+ },
+ node_1_privkey, &secp_ctx
+ );
+ gossip_sync.handle_node_announcement(&announcement).unwrap();
+ assert!(network_graph.read_only().node(&node_1_id).unwrap().is_tor_only());
+
+ let announcement = get_signed_node_announcement(
+ |announcement| {
+ announcement.addresses = vec![onion_v2.clone()];
+ announcement.timestamp += 5000;
+ },
+ node_1_privkey, &secp_ctx
+ );
+ gossip_sync.handle_node_announcement(&announcement).unwrap();
+ assert!(network_graph.read_only().node(&node_1_id).unwrap().is_tor_only());
+
+ let announcement = get_signed_node_announcement(
+ |announcement| {
+ announcement.addresses = vec![tcp_ip_v4.clone()];
+ announcement.timestamp += 6000;
+ },
+ node_1_privkey, &secp_ctx
+ );
+ gossip_sync.handle_node_announcement(&announcement).unwrap();
+ assert!(!network_graph.read_only().node(&node_1_id).unwrap().is_tor_only());
+ }
}
#[cfg(ldk_bench)]