X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=a4e0042414f8996f95c08deb72d7a578322fff97;hb=c92db69183143a58b3017ec450bdbf15a035bd9f;hp=2fcf1b33047c4dadd9d6e2c0394cc0b1d5f4e4a7;hpb=cfaa7f3617947d25e74fb4fcaad20c442ffd602e;p=rust-lightning

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index 2fcf1b33..a4e00424 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -684,6 +684,8 @@ pub trait APeerManager {
 	type NS: Deref<Target=Self::NST>;
 	/// Gets a reference to the underlying [`PeerManager`].
 	fn as_ref(&self) -> &PeerManager<Self::Descriptor, Self::CM, Self::RM, Self::OM, Self::L, Self::CMH, Self::NS>;
+	/// Returns the peer manager's [`OnionMessageHandler`].
+	fn onion_message_handler(&self) -> &Self::OMT;
 }
 
 impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CMH: Deref, NS: Deref>
@@ -709,6 +711,9 @@ APeerManager for PeerManager<Descriptor, CM, RM, OM, L, CMH, NS> where
 	type NST = <NS as Deref>::Target;
 	type NS = NS;
 	fn as_ref(&self) -> &PeerManager<Descriptor, CM, RM, OM, L, CMH, NS> { self }
+	fn onion_message_handler(&self) -> &Self::OMT {
+		self.message_handler.onion_message_handler.deref()
+	}
 }
 
 /// A PeerManager manages a set of peers, described by their [`SocketDescriptor`] and marshalls
@@ -1290,8 +1295,10 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 				let mut read_pos = 0;
 				while read_pos < data.len() {
 					macro_rules! try_potential_handleerror {
-						($peer: expr, $thing: expr) => {
-							match $thing {
+						($peer: expr, $thing: expr) => {{
+							let res = $thing;
+							let logger = WithContext::from(&self.logger, peer_node_id.map(|(id, _)| id), None);
+							match res {
 								Ok(x) => x,
 								Err(e) => {
 									match e.action {
@@ -1301,7 +1308,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 											// re-entrant code and possibly unexpected behavior. The
 											// message send is optimistic anyway, and in this case
 											// we immediately disconnect the peer.
-											log_debug!(self.logger, "Error handling message{}; disconnecting peer with: {}", OptionalFromDebugger(&peer_node_id), e.err);
+											log_debug!(logger, "Error handling message{}; disconnecting peer with: {}", OptionalFromDebugger(&peer_node_id), e.err);
 											return Err(PeerHandleError { });
 										},
 										msgs::ErrorAction::DisconnectPeerWithWarning { .. } => {
@@ -1310,32 +1317,32 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 											// re-entrant code and possibly unexpected behavior. The
 											// message send is optimistic anyway, and in this case
 											// we immediately disconnect the peer.
-											log_debug!(self.logger, "Error handling message{}; disconnecting peer with: {}", OptionalFromDebugger(&peer_node_id), e.err);
+											log_debug!(logger, "Error handling message{}; disconnecting peer with: {}", OptionalFromDebugger(&peer_node_id), e.err);
 											return Err(PeerHandleError { });
 										},
 										msgs::ErrorAction::IgnoreAndLog(level) => {
-											log_given_level!(self.logger, level, "Error handling message{}; ignoring: {}", OptionalFromDebugger(&peer_node_id), e.err);
+											log_given_level!(logger, level, "Error handling message{}; ignoring: {}", OptionalFromDebugger(&peer_node_id), e.err);
 											continue
 										},
 										msgs::ErrorAction::IgnoreDuplicateGossip => continue, // Don't even bother logging these
 										msgs::ErrorAction::IgnoreError => {
-											log_debug!(self.logger, "Error handling message{}; ignoring: {}", OptionalFromDebugger(&peer_node_id), e.err);
+											log_debug!(logger, "Error handling message{}; ignoring: {}", OptionalFromDebugger(&peer_node_id), e.err);
 											continue;
 										},
 										msgs::ErrorAction::SendErrorMessage { msg } => {
-											log_debug!(self.logger, "Error handling message{}; sending error message with: {}", OptionalFromDebugger(&peer_node_id), e.err);
+											log_debug!(logger, "Error handling message{}; sending error message with: {}", OptionalFromDebugger(&peer_node_id), e.err);
 											self.enqueue_message($peer, &msg);
 											continue;
 										},
 										msgs::ErrorAction::SendWarningMessage { msg, log_level } => {
-											log_given_level!(self.logger, log_level, "Error handling message{}; sending warning message with: {}", OptionalFromDebugger(&peer_node_id), e.err);
+											log_given_level!(logger, log_level, "Error handling message{}; sending warning message with: {}", OptionalFromDebugger(&peer_node_id), e.err);
 											self.enqueue_message($peer, &msg);
 											continue;
 										},
 									}
 								}
 							}
-						}
+						}}
 					}
 
 					let mut peer_lock = peer_mutex.lock().unwrap();
@@ -2009,25 +2016,29 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 							self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
 						},
 						MessageSendEvent::SendStfu { ref node_id, ref msg} => {
-							log_debug!(self.logger, "Handling SendStfu event in peer_handler for node {} for channel {}",
+							let logger = WithContext::from(&self.logger, Some(*node_id), Some(msg.channel_id));
+							log_debug!(logger, "Handling SendStfu event in peer_handler for node {} for channel {}",
 									log_pubkey!(node_id),
 									&msg.channel_id);
 							self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
 						}
 						MessageSendEvent::SendSplice { ref node_id, ref msg} => {
-							log_debug!(self.logger, "Handling SendSplice event in peer_handler for node {} for channel {}",
+							let logger = WithContext::from(&self.logger, Some(*node_id), Some(msg.channel_id));
+							log_debug!(logger, "Handling SendSplice event in peer_handler for node {} for channel {}",
 									log_pubkey!(node_id),
 									&msg.channel_id);
 							self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
 						}
 						MessageSendEvent::SendSpliceAck { ref node_id, ref msg} => {
-							log_debug!(self.logger, "Handling SendSpliceAck event in peer_handler for node {} for channel {}",
+							let logger = WithContext::from(&self.logger, Some(*node_id), Some(msg.channel_id));
+							log_debug!(logger, "Handling SendSpliceAck event in peer_handler for node {} for channel {}",
 									log_pubkey!(node_id),
 									&msg.channel_id);
 							self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
 						}
 						MessageSendEvent::SendSpliceLocked { ref node_id, ref msg} => {
-							log_debug!(self.logger, "Handling SendSpliceLocked event in peer_handler for node {} for channel {}",
+							let logger = WithContext::from(&self.logger, Some(*node_id), Some(msg.channel_id));
+							log_debug!(logger, "Handling SendSpliceLocked event in peer_handler for node {} for channel {}",
 									log_pubkey!(node_id),
 									&msg.channel_id);
 							self.enqueue_message(&mut *get_peer_for_forwarding!(node_id), msg);
@@ -2477,7 +2488,6 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 	// broadcast_node_announcement panics) of the maximum-length addresses would fit in a 64KB
 	// message...
 	const HALF_MESSAGE_IS_ADDRS: u32 = ::core::u16::MAX as u32 / (SocketAddress::MAX_LEN as u32 + 1) / 2;
-	#[deny(const_err)]
 	#[allow(dead_code)]
 	// ...by failing to compile if the number of addresses that would be half of a message is
 	// smaller than 100: