X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fchannelmanager.rs;h=60c7a6a2bef70801fe08949c623dd18aab599dbe;hb=a0f8c2519b522e7d600946cf5d90f97c2188bc19;hp=12ac136af0a7c7aa468904cb7cfd6da8c0f559a5;hpb=aee06996d97de6012ae7c56a4188587654ecee57;p=rust-lightning

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 12ac136a..60c7a6a2 100644
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -30,7 +30,7 @@ use chain::transaction::OutPoint;
 use ln::channel::{Channel, ChannelError};
 use ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, ManyChannelMonitor, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ANTI_REORG_DELAY};
 use ln::router::Route;
-use ln::features::InitFeatures;
+use ln::features::{InitFeatures, NodeFeatures};
 use ln::msgs;
 use ln::onion_utils;
 use ln::msgs::{ChannelMessageHandler, DecodeError, LightningError};
@@ -355,6 +355,8 @@ pub struct ChannelManager<ChanSigner: ChannelKeys, M: Deref> where M::Target: Ma
 	channel_state: Mutex<ChannelHolder<ChanSigner>>,
 	our_network_key: SecretKey,
 
+	last_node_announcement_serial: AtomicUsize,
+
 	/// The bulk of our storage will eventually be here (channels and message queues and the like).
 	/// If we are connected to a peer we always at least have an entry here, even if no channels
 	/// are currently open with that peer.
@@ -649,6 +651,8 @@ impl<ChanSigner: ChannelKeys, M: Deref> ChannelManager<ChanSigner, M> where M::T
 			}),
 			our_network_key: keys_manager.get_node_secret(),
 
+			last_node_announcement_serial: AtomicUsize::new(0),
+
 			per_peer_state: RwLock::new(HashMap::new()),
 
 			pending_events: Mutex::new(Vec::new()),
@@ -1163,6 +1167,9 @@ impl<ChanSigner: ChannelKeys, M: Deref> ChannelManager<ChanSigner, M> where M::T
 		let onion_keys = secp_call!(onion_utils::construct_onion_keys(&self.secp_ctx, &route, &session_priv),
 				APIError::RouteError{err: "Pubkey along hop was maliciously selected"});
 		let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route, cur_height)?;
+		if onion_utils::route_size_insane(&onion_payloads) {
+			return Err(APIError::RouteError{err: "Route had too large size once"});
+		}
 		let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, prng_seed, &payment_hash);
 
 		let _ = self.total_consistency_lock.read().unwrap();
@@ -1311,6 +1318,37 @@ impl<ChanSigner: ChannelKeys, M: Deref> ChannelManager<ChanSigner, M> where M::T
 		})
 	}
 
+	/// Generates a signed node_announcement from the given arguments and creates a
+	/// BroadcastNodeAnnouncement event.
+	///
+	/// RGB is a node "color" and alias a printable human-readable string to describe this node to
+	/// humans. They carry no in-protocol meaning.
+	///
+	/// addresses represent the set (possibly empty) of socket addresses on which this node accepts
+	/// incoming connections.
+	pub fn broadcast_node_announcement(&self, rgb: [u8; 3], alias: [u8; 32], addresses: msgs::NetAddressSet) {
+		let _ = self.total_consistency_lock.read().unwrap();
+
+		let announcement = msgs::UnsignedNodeAnnouncement {
+			features: NodeFeatures::supported(),
+			timestamp: self.last_node_announcement_serial.fetch_add(1, Ordering::AcqRel) as u32,
+			node_id: self.get_our_node_id(),
+			rgb, alias,
+			addresses: addresses.to_vec(),
+			excess_address_data: Vec::new(),
+			excess_data: Vec::new(),
+		};
+		let msghash = hash_to_message!(&Sha256dHash::hash(&announcement.encode()[..])[..]);
+
+		let mut channel_state = self.channel_state.lock().unwrap();
+		channel_state.pending_msg_events.push(events::MessageSendEvent::BroadcastNodeAnnouncement {
+			msg: msgs::NodeAnnouncement {
+				signature: self.secp_ctx.sign(&msghash, &self.our_network_key),
+				contents: announcement
+			},
+		});
+	}
+
 	/// Processes HTLCs which are pending waiting on random forward delay.
 	///
 	/// Should only really ever be called in response to a PendingHTLCsForwardable event.
@@ -2906,6 +2944,7 @@ impl<ChanSigner: ChannelKeys, M: Deref + Sync + Send> ChannelMessageHandler for
 					&events::MessageSendEvent::SendShutdown { ref node_id, .. } => node_id != their_node_id,
 					&events::MessageSendEvent::SendChannelReestablish { ref node_id, .. } => node_id != their_node_id,
 					&events::MessageSendEvent::BroadcastChannelAnnouncement { .. } => true,
+					&events::MessageSendEvent::BroadcastNodeAnnouncement { .. } => true,
 					&events::MessageSendEvent::BroadcastChannelUpdate { .. } => true,
 					&events::MessageSendEvent::HandleError { ref node_id, .. } => node_id != their_node_id,
 					&events::MessageSendEvent::PaymentFailureNetworkUpdate { .. } => true,
@@ -3219,6 +3258,8 @@ impl<ChanSigner: ChannelKeys + Writeable, M: Deref> Writeable for ChannelManager
 			peer_state.latest_features.write(writer)?;
 		}
 
+		(self.last_node_announcement_serial.load(Ordering::Acquire) as u32).write(writer)?;
+
 		Ok(())
 	}
 }
@@ -3362,6 +3403,8 @@ impl<'a, R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>, M: Deref> R
 			per_peer_state.insert(peer_pubkey, Mutex::new(peer_state));
 		}
 
+		let last_node_announcement_serial: u32 = Readable::read(reader)?;
+
 		let channel_manager = ChannelManager {
 			genesis_hash,
 			fee_estimator: args.fee_estimator,
@@ -3381,6 +3424,8 @@ impl<'a, R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>, M: Deref> R
 			}),
 			our_network_key: args.keys_manager.get_node_secret(),
 
+			last_node_announcement_serial: AtomicUsize::new(last_node_announcement_serial as usize),
+
 			per_peer_state: RwLock::new(per_peer_state),
 
 			pending_events: Mutex::new(Vec::new()),