From f4323d98b87cb1a6458c788dfea540d51c0c4130 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 10 Jun 2021 16:26:33 +0000 Subject: [PATCH 1/8] Drop unused "peer gone" handling in get_peer_for_forwarding!() We can never assume that messages were reliably delivered whether we placed them in the socket or not, so there isn't a lot of use in explicitly handling the case that a peer was not connected when we went to send it a message. Two TODOs are left for the generation of a `FundingAbandoned` (or similar) event, though it ultimately belongs in `ChannelManager`. --- lightning/src/ln/peer_handler.rs | 63 +++++++++----------------------- 1 file changed, 18 insertions(+), 45 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index 6e05b5498cf..2003efc8f7a 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -1026,19 +1026,17 @@ impl PeerManager { + ($node_id: expr) => { { let descriptor = match peers.node_id_to_descriptor.get($node_id) { Some(descriptor) => descriptor.clone(), None => { - $handle_no_such_peer; continue; }, }; match peers.peers.get_mut(&descriptor) { Some(peer) => { if peer.their_features.is_none() { - $handle_no_such_peer; continue; } (descriptor, peer) @@ -1053,9 +1051,7 @@ impl PeerManager PeerManager PeerManager PeerManager PeerManager PeerManager PeerManager PeerManager PeerManager PeerManager PeerManager PeerManager { - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {}); + let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::SendShortIdsQuery { ref node_id, ref msg } => { - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {}); + let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); self.do_attempt_write_data(&mut descriptor, peer); } @@ -1291,7 +1264,7 @@ impl PeerManager Date: Wed, 16 Jun 2021 18:57:21 +0000 Subject: [PATCH 2/8] Fix bogus reentrancy from read_event -> do_attempt_write_data `Julian Knutsen ` pointed out in a previous discussion that `read_event` can reenter user code despite the documentation stating explicitly that it will not. This was addressed in #456 by simply codifying the reentrancy, but its somewhat simpler to just drop the `do_attempt_write_data` call. Ideally we could land most of Julian's work, but its still in need of substantial git history cleanup to get it in a reviewable state and this solves the immediate issue. --- lightning/src/ln/peer_handler.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index 2003efc8f7a..cc15d26d5f6 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -807,8 +807,6 @@ impl PeerManager 10 // pause_read } }; @@ -1467,7 +1465,9 @@ mod tests { let initial_data = peer_b.new_outbound_connection(a_id, fd_b.clone()).unwrap(); peer_a.new_inbound_connection(fd_a.clone()).unwrap(); assert_eq!(peer_a.read_event(&mut fd_a, &initial_data).unwrap(), false); + peer_a.process_events(); assert_eq!(peer_b.read_event(&mut fd_b, &fd_a.outbound_data.lock().unwrap().split_off(0)).unwrap(), false); + peer_b.process_events(); assert_eq!(peer_a.read_event(&mut fd_a, &fd_b.outbound_data.lock().unwrap().split_off(0)).unwrap(), false); (fd_a.clone(), fd_b.clone()) } @@ -1506,10 +1506,12 @@ mod tests { // peers[0] awaiting_pong is set to true, but the Peer is still connected peers[0].timer_tick_occurred(); + peers[0].process_events(); assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1); // Since timer_tick_occurred() is called again when awaiting_pong is true, all Peers are disconnected peers[0].timer_tick_occurred(); + peers[0].process_events(); assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 0); } @@ -1530,7 +1532,9 @@ mod tests { let (mut fd_a, mut fd_b) = establish_connection(&peers[0], &peers[1]); // Make each peer to read the messages that the other peer just wrote to them. + peers[0].process_events(); peers[1].read_event(&mut fd_b, &fd_a.outbound_data.lock().unwrap().split_off(0)).unwrap(); + peers[1].process_events(); peers[0].read_event(&mut fd_a, &fd_b.outbound_data.lock().unwrap().split_off(0)).unwrap(); // Check that each peer has received the expected number of channel updates and channel From 9de22ae6fc634993c7f8ff226e24f1165ba3ca92 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 10 Jun 2021 18:48:59 +0000 Subject: [PATCH 3/8] Refactor message broadcasting out into a utility method This will allow us to broadcast messages received in the next commit. --- lightning/src/ln/peer_handler.rs | 114 ++++++++++++++++++------------- 1 file changed, 68 insertions(+), 46 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index cc15d26d5f6..0497fae158b 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -1009,6 +1009,64 @@ impl PeerManager, msg: &wire::Message, except_node: Option<&PublicKey>) { + match msg { + wire::Message::ChannelAnnouncement(ref msg) => { + let encoded_msg = encode_msg!(msg); + + for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { + if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || + !peer.should_forward_channel_announcement(msg.contents.short_channel_id) { + continue + } + if peer.their_node_id.as_ref() == Some(&msg.contents.node_id_1) || + peer.their_node_id.as_ref() == Some(&msg.contents.node_id_2) { + continue; + } + if except_node.is_some() && peer.their_node_id.as_ref() == except_node { + continue; + } + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); + peers.peers_needing_send.insert((*descriptor).clone()); + } + }, + wire::Message::NodeAnnouncement(ref msg) => { + let encoded_msg = encode_msg!(msg); + + for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { + if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || + !peer.should_forward_node_announcement(msg.contents.node_id) { + continue + } + if peer.their_node_id.as_ref() == Some(&msg.contents.node_id) { + continue; + } + if except_node.is_some() && peer.their_node_id.as_ref() == except_node { + continue; + } + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); + peers.peers_needing_send.insert((*descriptor).clone()); + } + }, + wire::Message::ChannelUpdate(ref msg) => { + let encoded_msg = encode_msg!(msg); + + for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { + if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || + !peer.should_forward_channel_announcement(msg.contents.short_channel_id) { + continue + } + if except_node.is_some() && peer.their_node_id.as_ref() == except_node { + continue; + } + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); + peers.peers_needing_send.insert((*descriptor).clone()); + } + }, + _ => debug_assert!(false, "We shouldn't attempt to forward anything but gossip messages"), + } + } + /// Checks for any events generated by our handlers and processes them. Includes sending most /// response messages as well as messages generated by calls to handler functions directly (eg /// functions like ChannelManager::process_pending_htlc_forward or send_payment). @@ -1154,59 +1212,23 @@ impl PeerManager { + MessageSendEvent::BroadcastChannelAnnouncement { msg, update_msg } => { log_trace!(self.logger, "Handling BroadcastChannelAnnouncement event in peer_handler for short channel id {}", msg.contents.short_channel_id); - if self.message_handler.route_handler.handle_channel_announcement(msg).is_ok() && self.message_handler.route_handler.handle_channel_update(update_msg).is_ok() { - let encoded_msg = encode_msg!(msg); - let encoded_update_msg = encode_msg!(update_msg); - - for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { - if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || - !peer.should_forward_channel_announcement(msg.contents.short_channel_id) { - continue - } - match peer.their_node_id { - None => continue, - Some(their_node_id) => { - if their_node_id == msg.contents.node_id_1 || their_node_id == msg.contents.node_id_2 { - continue - } - } - } - peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); - peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_update_msg[..])); - self.do_attempt_write_data(&mut (*descriptor).clone(), peer); - } + if self.message_handler.route_handler.handle_channel_announcement(&msg).is_ok() && self.message_handler.route_handler.handle_channel_update(&update_msg).is_ok() { + self.forward_broadcast_msg(peers, &wire::Message::ChannelAnnouncement(msg), None); + self.forward_broadcast_msg(peers, &wire::Message::ChannelUpdate(update_msg), None); } }, - MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => { + MessageSendEvent::BroadcastNodeAnnouncement { msg } => { log_trace!(self.logger, "Handling BroadcastNodeAnnouncement event in peer_handler"); - if self.message_handler.route_handler.handle_node_announcement(msg).is_ok() { - let encoded_msg = encode_msg!(msg); - - for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { - if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || - !peer.should_forward_node_announcement(msg.contents.node_id) { - continue - } - peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); - self.do_attempt_write_data(&mut (*descriptor).clone(), peer); - } + if self.message_handler.route_handler.handle_node_announcement(&msg).is_ok() { + self.forward_broadcast_msg(peers, &wire::Message::NodeAnnouncement(msg), None); } }, - MessageSendEvent::BroadcastChannelUpdate { ref msg } => { + MessageSendEvent::BroadcastChannelUpdate { msg } => { log_trace!(self.logger, "Handling BroadcastChannelUpdate event in peer_handler for short channel id {}", msg.contents.short_channel_id); - if self.message_handler.route_handler.handle_channel_update(msg).is_ok() { - let encoded_msg = encode_msg!(msg); - - for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { - if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || - !peer.should_forward_channel_announcement(msg.contents.short_channel_id) { - continue - } - peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); - self.do_attempt_write_data(&mut (*descriptor).clone(), peer); - } + if self.message_handler.route_handler.handle_channel_update(&msg).is_ok() { + self.forward_broadcast_msg(peers, &wire::Message::ChannelUpdate(msg), None); } }, MessageSendEvent::PaymentFailureNetworkUpdate { ref update } => { From c56cd1ef3a6e9dc586ac6eb60d438e6b2e88ee7c Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 10 Jun 2021 18:20:16 +0000 Subject: [PATCH 4/8] Forward gossip msgs --- lightning/src/ln/peer_handler.rs | 48 +++++++++++++++++++------------- 1 file changed, 28 insertions(+), 20 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index 0497fae158b..d7d52a05845 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -658,6 +658,8 @@ impl PeerManager panic!("Descriptor for read_event is not already known to PeerManager"), Some(peer) => { @@ -793,13 +795,18 @@ impl PeerManager match handling_error { MessageHandlingError::PeerHandleError(e) => { return Err(e) }, MessageHandlingError::LightningError(e) => { try_potential_handleerror!(Err(e)); }, - } + }, + Ok(Some(msg)) => { + peer_node_id = Some(peer.their_node_id.expect("After noise is complete, their_node_id is always set")); + msgs_to_forward.push(msg); + }, + Ok(None) => {}, } } } @@ -811,6 +818,10 @@ impl PeerManager PeerManager, peer: &mut Peer, peer_descriptor: Descriptor, message: wire::Message) -> Result<(), MessageHandlingError> { + /// Returns the message back if it needs to be broadcasted to all other peers. + fn handle_message(&self, peers_needing_send: &mut HashSet, peer: &mut Peer, peer_descriptor: Descriptor, message: wire::Message) -> Result, MessageHandlingError> { log_trace!(self.logger, "Received message of type {} from {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap())); // Need an Init as first message @@ -828,6 +840,8 @@ impl PeerManager { @@ -950,34 +964,28 @@ impl PeerManager { - let should_forward = match self.message_handler.route_handler.handle_channel_announcement(&msg) { + if match self.message_handler.route_handler.handle_channel_announcement(&msg) { Ok(v) => v, Err(e) => { return Err(e.into()); }, - }; - - if should_forward { - // TODO: forward msg along to all our other peers! + } { + should_forward = Some(wire::Message::ChannelAnnouncement(msg)); } }, wire::Message::NodeAnnouncement(msg) => { - let should_forward = match self.message_handler.route_handler.handle_node_announcement(&msg) { + if match self.message_handler.route_handler.handle_node_announcement(&msg) { Ok(v) => v, Err(e) => { return Err(e.into()); }, - }; - - if should_forward { - // TODO: forward msg along to all our other peers! + } { + should_forward = Some(wire::Message::NodeAnnouncement(msg)); } }, wire::Message::ChannelUpdate(msg) => { self.message_handler.chan_handler.handle_channel_update(&peer.their_node_id.unwrap(), &msg); - let should_forward = match self.message_handler.route_handler.handle_channel_update(&msg) { + if match self.message_handler.route_handler.handle_channel_update(&msg) { Ok(v) => v, Err(e) => { return Err(e.into()); }, - }; - - if should_forward { - // TODO: forward msg along to all our other peers! + } { + should_forward = Some(wire::Message::ChannelUpdate(msg)); } }, wire::Message::QueryShortChannelIds(msg) => { @@ -1006,7 +1014,7 @@ impl PeerManager, msg: &wire::Message, except_node: Option<&PublicKey>) { From 0426d6e7a9580d3f22605210498c35814e2fc7fb Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 10 Jun 2021 18:26:57 +0000 Subject: [PATCH 5/8] Skip forwarding gossip messages to peers if their buffer is over-full --- lightning/src/ln/peer_handler.rs | 31 ++++++++++++++++++++++++------- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index d7d52a05845..14d2d7de622 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -233,6 +233,15 @@ enum InitSyncTracker{ NodesSyncing(PublicKey), } +/// When the outbound buffer has this many messages, we'll stop reading bytes from the peer until +/// we have fewer than this many messages in the outbound buffer again. +/// We also use this as the target number of outbound gossip messages to keep in the write buffer, +/// refilled as we send bytes. +const OUTBOUND_BUFFER_LIMIT_READ_PAUSE: usize = 10; +/// When the outbound buffer has this many messages, we'll simply skip relaying gossip messages to +/// the peer. +const OUTBOUND_BUFFER_LIMIT_DROP_GOSSIP: usize = 20; + struct Peer { channel_encryptor: PeerChannelEncryptor, their_node_id: Option, @@ -531,13 +540,12 @@ impl PeerManager {}, InitSyncTracker::ChannelsSyncing(c) if c < 0xffff_ffff_ffff_ffff => { - let steps = ((MSG_BUFF_SIZE - peer.pending_outbound_buffer.len() + 2) / 3) as u8; + let steps = ((OUTBOUND_BUFFER_LIMIT_READ_PAUSE - peer.pending_outbound_buffer.len() + 2) / 3) as u8; let all_messages = self.message_handler.route_handler.get_next_channel_announcements(c, steps); for &(ref announce, ref update_a_option, ref update_b_option) in all_messages.iter() { encode_and_send_msg!(announce); @@ -554,7 +562,7 @@ impl PeerManager { - let steps = (MSG_BUFF_SIZE - peer.pending_outbound_buffer.len()) as u8; + let steps = (OUTBOUND_BUFFER_LIMIT_READ_PAUSE - peer.pending_outbound_buffer.len()) as u8; let all_messages = self.message_handler.route_handler.get_next_node_announcements(None, steps); for msg in all_messages.iter() { encode_and_send_msg!(msg); @@ -566,7 +574,7 @@ impl PeerManager unreachable!(), InitSyncTracker::NodesSyncing(key) => { - let steps = (MSG_BUFF_SIZE - peer.pending_outbound_buffer.len()) as u8; + let steps = (OUTBOUND_BUFFER_LIMIT_READ_PAUSE - peer.pending_outbound_buffer.len()) as u8; let all_messages = self.message_handler.route_handler.get_next_node_announcements(Some(&key), steps); for msg in all_messages.iter() { encode_and_send_msg!(msg); @@ -585,7 +593,7 @@ impl PeerManager buff, }; - let should_be_reading = peer.pending_outbound_buffer.len() < MSG_BUFF_SIZE; + let should_be_reading = peer.pending_outbound_buffer.len() < OUTBOUND_BUFFER_LIMIT_READ_PAUSE; let pending = &next_buff[peer.pending_outbound_buffer_first_msg_offset..]; let data_sent = descriptor.send_data(pending, should_be_reading); peer.pending_outbound_buffer_first_msg_offset += data_sent; @@ -814,7 +822,7 @@ impl PeerManager 10 // pause_read + peer.pending_outbound_buffer.len() > OUTBOUND_BUFFER_LIMIT_READ_PAUSE // pause_read } }; @@ -1027,6 +1035,9 @@ impl PeerManager OUTBOUND_BUFFER_LIMIT_DROP_GOSSIP { + continue; + } if peer.their_node_id.as_ref() == Some(&msg.contents.node_id_1) || peer.their_node_id.as_ref() == Some(&msg.contents.node_id_2) { continue; @@ -1046,6 +1057,9 @@ impl PeerManager OUTBOUND_BUFFER_LIMIT_DROP_GOSSIP { + continue; + } if peer.their_node_id.as_ref() == Some(&msg.contents.node_id) { continue; } @@ -1064,6 +1078,9 @@ impl PeerManager OUTBOUND_BUFFER_LIMIT_DROP_GOSSIP { + continue; + } if except_node.is_some() && peer.their_node_id.as_ref() == except_node { continue; } From ae39b2ce19a5f35a31228cfb7996197c3e3eb4fd Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 10 Jun 2021 18:46:24 +0000 Subject: [PATCH 6/8] Drop peers_needing_send tracking and try to write for each peer We do a lot of work to track which peers have buffers which need to be flushed, when we could instead just try to flush ever peer's buffer. --- lightning/src/ln/peer_handler.rs | 86 ++++++++++---------------------- 1 file changed, 27 insertions(+), 59 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index 14d2d7de622..c5128e25b05 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -287,9 +287,6 @@ impl Peer { struct PeerHolder { peers: HashMap, - /// Added to by do_read_event for cases where we pushed a message onto the send buffer but - /// didn't call do_attempt_write_data to avoid reentrancy. Cleared in process_events() - peers_needing_send: HashSet, /// Only add to this set when noise completes: node_id_to_descriptor: HashMap, } @@ -420,7 +417,6 @@ impl PeerManager PeerManager(&self, peers_needing_send: &mut HashSet, peer: &mut Peer, descriptor: Descriptor, message: &M) { + fn enqueue_message(&self, peer: &mut Peer, message: &M) { let mut buffer = VecWriter(Vec::new()); wire::write(message, &mut buffer).unwrap(); // crash if the write failed let encoded_message = buffer.0; log_trace!(self.logger, "Enqueueing message of type {} to {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap())); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_message[..])); - peers_needing_send.insert(descriptor); } fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: &[u8]) -> Result { @@ -703,7 +698,7 @@ impl PeerManager { log_trace!(self.logger, "Got Err handling message, sending Error message because {}", e.err); - self.enqueue_message(&mut peers.peers_needing_send, peer, peer_descriptor.clone(), &msg); + self.enqueue_message(peer, &msg); continue; }, } @@ -745,7 +740,7 @@ impl PeerManager { let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..])); @@ -755,7 +750,7 @@ impl PeerManager { if peer.pending_read_is_header { @@ -803,7 +798,7 @@ impl PeerManager match handling_error { MessageHandlingError::PeerHandleError(e) => { return Err(e) }, MessageHandlingError::LightningError(e) => { @@ -838,7 +833,7 @@ impl PeerManager, peer: &mut Peer, peer_descriptor: Descriptor, message: wire::Message) -> Result, MessageHandlingError> { + fn handle_message(&self, peer: &mut Peer, message: wire::Message) -> Result, MessageHandlingError> { log_trace!(self.logger, "Received message of type {} from {}", message.type_id(), log_pubkey!(peer.their_node_id.unwrap())); // Need an Init as first message @@ -873,7 +868,6 @@ impl PeerManager PeerManager { if msg.ponglen < 65532 { let resp = msgs::Pong { byteslen: msg.ponglen }; - self.enqueue_message(peers_needing_send, peer, peer_descriptor.clone(), &resp); + self.enqueue_message(peer, &resp); } }, wire::Message::Pong(_msg) => { @@ -1030,7 +1024,7 @@ impl PeerManager { let encoded_msg = encode_msg!(msg); - for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { + for (_, peer) in peers.peers.iter_mut() { if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || !peer.should_forward_channel_announcement(msg.contents.short_channel_id) { continue @@ -1046,13 +1040,12 @@ impl PeerManager { let encoded_msg = encode_msg!(msg); - for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { + for (_, peer) in peers.peers.iter_mut() { if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || !peer.should_forward_node_announcement(msg.contents.node_id) { continue @@ -1067,13 +1060,12 @@ impl PeerManager { let encoded_msg = encode_msg!(msg); - for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { + for (_, peer) in peers.peers.iter_mut() { if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_features.is_none() || !peer.should_forward_channel_announcement(msg.contents.short_channel_id) { continue @@ -1085,7 +1077,6 @@ impl PeerManager debug_assert!(false, "We shouldn't attempt to forward anything but gossip messages"), @@ -1132,17 +1123,15 @@ impl PeerManager { log_trace!(self.logger, "Handling SendOpenChannel event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.temporary_channel_id)); - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::SendFundingCreated { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendFundingCreated event in peer_handler for node {} for channel {} (which becomes {})", @@ -1151,33 +1140,29 @@ impl PeerManager { log_trace!(self.logger, "Handling SendFundingSigned event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendFundingLocked event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendAnnouncementSignatures event in peer_handler for node {} for channel {})", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => { log_trace!(self.logger, "Handling UpdateHTLCs event in peer_handler for node {} with {} adds, {} fulfills, {} fails for channel {}", @@ -1186,7 +1171,7 @@ impl PeerManager PeerManager { log_trace!(self.logger, "Handling SendRevokeAndACK event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendClosingSigned event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::SendShutdown { ref node_id, ref msg } => { log_trace!(self.logger, "Handling Shutdown event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendChannelReestablish event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::BroadcastChannelAnnouncement { msg, update_msg } => { log_trace!(self.logger, "Handling BroadcastChannelAnnouncement event in peer_handler for short channel id {}", msg.contents.short_channel_id); @@ -1263,7 +1243,6 @@ impl PeerManager { if let Some(mut descriptor) = peers.node_id_to_descriptor.remove(node_id) { - peers.peers_needing_send.remove(&descriptor); if let Some(mut peer) = peers.peers.remove(&descriptor) { if let Some(ref msg) = *msg { log_trace!(self.logger, "Handling DisconnectPeer HandleError event in peer_handler for node {} with message {}", @@ -1286,21 +1265,18 @@ impl PeerManager { - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); }, MessageSendEvent::SendShortIdsQuery { ref node_id, ref msg } => { - let (mut descriptor, peer) = get_peer_for_forwarding!(node_id); + let (_, peer) = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); - self.do_attempt_write_data(&mut descriptor, peer); } MessageSendEvent::SendReplyChannelRange { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendReplyChannelRange event in peer_handler for node {} with num_scids={} first_blocknum={} number_of_blocks={}, sync_complete={}", @@ -1309,18 +1285,14 @@ impl PeerManager self.do_attempt_write_data(&mut descriptor, peer), - None => panic!("Inconsistent peers set state!"), - } + for (descriptor, peer) in peers.peers.iter_mut() { + self.do_attempt_write_data(&mut (*descriptor).clone(), peer); } } } @@ -1339,7 +1311,6 @@ impl PeerManager panic!("Descriptor for disconnect_event is not already known to PeerManager"), @@ -1367,7 +1338,6 @@ impl PeerManager PeerManager { From f76e14c4256550f39421ec0ed14bbe796d072f13 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Thu, 17 Jun 2021 15:31:05 +0000 Subject: [PATCH 7/8] Somewhat simplify message handling error mapping in peer_handler --- lightning/src/ln/peer_handler.rs | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index c5128e25b05..ac6cef2926e 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -966,27 +966,21 @@ impl PeerManager { - if match self.message_handler.route_handler.handle_channel_announcement(&msg) { - Ok(v) => v, - Err(e) => { return Err(e.into()); }, - } { + if self.message_handler.route_handler.handle_channel_announcement(&msg) + .map_err(|e| -> MessageHandlingError { e.into() })? { should_forward = Some(wire::Message::ChannelAnnouncement(msg)); } }, wire::Message::NodeAnnouncement(msg) => { - if match self.message_handler.route_handler.handle_node_announcement(&msg) { - Ok(v) => v, - Err(e) => { return Err(e.into()); }, - } { + if self.message_handler.route_handler.handle_node_announcement(&msg) + .map_err(|e| -> MessageHandlingError { e.into() })? { should_forward = Some(wire::Message::NodeAnnouncement(msg)); } }, wire::Message::ChannelUpdate(msg) => { self.message_handler.chan_handler.handle_channel_update(&peer.their_node_id.unwrap(), &msg); - if match self.message_handler.route_handler.handle_channel_update(&msg) { - Ok(v) => v, - Err(e) => { return Err(e.into()); }, - } { + if self.message_handler.route_handler.handle_channel_update(&msg) + .map_err(|e| -> MessageHandlingError { e.into() })? { should_forward = Some(wire::Message::ChannelUpdate(msg)); } }, From 895d1a8504a436904ac3f06b009137e480c21a09 Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Mon, 21 Jun 2021 18:48:51 +0000 Subject: [PATCH 8/8] [peer_handler] Drop unused return from get_peer_for_forwarding!() This avoids a now-unnecessary SocketDescriptor clone() call in addition to cleaning up the callsite code somewhat. --- lightning/src/ln/peer_handler.rs | 51 ++++++++++++++++---------------- 1 file changed, 25 insertions(+), 26 deletions(-) diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index ac6cef2926e..2eb9b2e78f0 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -1094,20 +1094,19 @@ impl PeerManager { { - let descriptor = match peers.node_id_to_descriptor.get($node_id) { - Some(descriptor) => descriptor.clone(), + match peers.node_id_to_descriptor.get($node_id) { + Some(descriptor) => match peers.peers.get_mut(&descriptor) { + Some(peer) => { + if peer.their_features.is_none() { + continue; + } + peer + }, + None => panic!("Inconsistent peers set state!"), + }, None => { continue; }, - }; - match peers.peers.get_mut(&descriptor) { - Some(peer) => { - if peer.their_features.is_none() { - continue; - } - (descriptor, peer) - }, - None => panic!("Inconsistent peers set state!"), } } } @@ -1117,14 +1116,14 @@ impl PeerManager { log_trace!(self.logger, "Handling SendOpenChannel event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.temporary_channel_id)); - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); }, MessageSendEvent::SendFundingCreated { ref node_id, ref msg } => { @@ -1134,28 +1133,28 @@ impl PeerManager { log_trace!(self.logger, "Handling SendFundingSigned event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); }, MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendFundingLocked event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); }, MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendAnnouncementSignatures event in peer_handler for node {} for channel {})", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); }, MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => { @@ -1165,7 +1164,7 @@ impl PeerManager PeerManager { log_trace!(self.logger, "Handling SendClosingSigned event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); }, MessageSendEvent::SendShutdown { ref node_id, ref msg } => { log_trace!(self.logger, "Handling Shutdown event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); }, MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } => { log_trace!(self.logger, "Handling SendChannelReestablish event in peer_handler for node {} for channel {}", log_pubkey!(node_id), log_bytes!(msg.channel_id)); - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); }, MessageSendEvent::BroadcastChannelAnnouncement { msg, update_msg } => { @@ -1259,17 +1258,17 @@ impl PeerManager { - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); }, MessageSendEvent::SendShortIdsQuery { ref node_id, ref msg } => { - let (_, peer) = get_peer_for_forwarding!(node_id); + let peer = get_peer_for_forwarding!(node_id); peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); } MessageSendEvent::SendReplyChannelRange { ref node_id, ref msg } => { @@ -1279,7 +1278,7 @@ impl PeerManager