From: Matt Corallo Date: Wed, 6 Oct 2021 06:58:15 +0000 (+0000) Subject: Process messages with only the top-level read lock held X-Git-Tag: v0.0.107~31^2~13 X-Git-Url: http://git.bitcoin.ninja/?a=commitdiff_plain;h=a731efcb6822609b400170bce54d59addc5821c3;p=rust-lightning Process messages with only the top-level read lock held Users are required to only ever call `read_event` serially per-peer, thus we actually don't need any locks while we're processing messages - we can only be processing messages in one thread per-peer. That said, we do need to ensure that another thread doesn't disconnect the peer we're processing messages for, as that could result in a peer_disconencted call while we're processing a message for the same peer - somewhat nonsensical. This significantly improves parallelism especially during gossip processing as it avoids waiting on the entire set of individual peer locks to forward a gossip message while several other threads are validating gossip messages with their individual peer locks held. --- diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index dd6eda63f..2226e9574 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -33,7 +33,7 @@ use routing::network_graph::{NetworkGraph, NetGraphMsgHandler}; use prelude::*; use io; use alloc::collections::LinkedList; -use sync::{Arc, Mutex, RwLock}; +use sync::{Arc, Mutex, MutexGuard, RwLock}; use core::{cmp, hash, fmt, mem}; use core::ops::Deref; use core::convert::Infallible; @@ -376,6 +376,10 @@ impl Peer { } struct PeerHolder { + /// Peer is under its own mutex for sending and receiving bytes, but note that we do *not* hold + /// this mutex while we're processing a message. This is fine as [`PeerManager::read_event`] + /// requires that there be no parallel calls for a given peer, so mutual exclusion of messages + /// handed to the `MessageHandler`s for a given peer is already guaranteed. peers: HashMap>, } @@ -832,209 +836,217 @@ impl P } fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: &[u8]) -> Result { - let pause_read = { - let peers = self.peers.read().unwrap(); - let mut msgs_to_forward = Vec::new(); - let mut peer_node_id = None; - let pause_read = match peers.peers.get(peer_descriptor) { - None => { - // This is most likely a simple race condition where the user read some bytes - // from the socket, then we told the user to `disconnect_socket()`, then they - // called this method. Return an error to make sure we get disconnected. - return Err(PeerHandleError { no_connection_possible: false }); - }, - Some(peer_mutex) => { + let mut pause_read = false; + let peers = self.peers.read().unwrap(); + let mut msgs_to_forward = Vec::new(); + let mut peer_node_id = None; + match peers.peers.get(peer_descriptor) { + None => { + // This is most likely a simple race condition where the user read some bytes + // from the socket, then we told the user to `disconnect_socket()`, then they + // called this method. Return an error to make sure we get disconnected. + return Err(PeerHandleError { no_connection_possible: false }); + }, + Some(peer_mutex) => { + let mut read_pos = 0; + while read_pos < data.len() { + macro_rules! try_potential_handleerror { + ($peer: expr, $thing: expr) => { + match $thing { + Ok(x) => x, + Err(e) => { + match e.action { + msgs::ErrorAction::DisconnectPeer { msg: _ } => { + //TODO: Try to push msg + log_debug!(self.logger, "Error handling message{}; disconnecting peer with: {}", OptionalFromDebugger(&peer_node_id), e.err); + return Err(PeerHandleError{ no_connection_possible: false }); + }, + msgs::ErrorAction::IgnoreAndLog(level) => { + log_given_level!(self.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); + continue; + }, + msgs::ErrorAction::SendErrorMessage { msg } => { + log_debug!(self.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); + self.enqueue_message($peer, &msg); + continue; + }, + } + } + } + } + } + let mut peer_lock = peer_mutex.lock().unwrap(); let peer = &mut *peer_lock; + let mut msg_to_handle = None; + if peer_node_id.is_none() { + peer_node_id = peer.their_node_id.clone(); + } assert!(peer.pending_read_buffer.len() > 0); assert!(peer.pending_read_buffer.len() > peer.pending_read_buffer_pos); - let mut read_pos = 0; - while read_pos < data.len() { - { - let data_to_copy = cmp::min(peer.pending_read_buffer.len() - peer.pending_read_buffer_pos, data.len() - read_pos); - peer.pending_read_buffer[peer.pending_read_buffer_pos..peer.pending_read_buffer_pos + data_to_copy].copy_from_slice(&data[read_pos..read_pos + data_to_copy]); - read_pos += data_to_copy; - peer.pending_read_buffer_pos += data_to_copy; + { + let data_to_copy = cmp::min(peer.pending_read_buffer.len() - peer.pending_read_buffer_pos, data.len() - read_pos); + peer.pending_read_buffer[peer.pending_read_buffer_pos..peer.pending_read_buffer_pos + data_to_copy].copy_from_slice(&data[read_pos..read_pos + data_to_copy]); + read_pos += data_to_copy; + peer.pending_read_buffer_pos += data_to_copy; + } + + if peer.pending_read_buffer_pos == peer.pending_read_buffer.len() { + peer.pending_read_buffer_pos = 0; + + macro_rules! insert_node_id { + () => { + match self.node_id_to_descriptor.lock().unwrap().entry(peer.their_node_id.unwrap()) { + hash_map::Entry::Occupied(_) => { + log_trace!(self.logger, "Got second connection with {}, closing", log_pubkey!(peer.their_node_id.unwrap())); + peer.their_node_id = None; // Unset so that we don't generate a peer_disconnected event + return Err(PeerHandleError{ no_connection_possible: false }) + }, + hash_map::Entry::Vacant(entry) => { + log_debug!(self.logger, "Finished noise handshake for connection with {}", log_pubkey!(peer.their_node_id.unwrap())); + entry.insert(peer_descriptor.clone()) + }, + }; + } } - if peer.pending_read_buffer_pos == peer.pending_read_buffer.len() { - peer.pending_read_buffer_pos = 0; + let next_step = peer.channel_encryptor.get_noise_step(); + match next_step { + NextNoiseStep::ActOne => { + let act_two = try_potential_handleerror!(peer, + peer.channel_encryptor.process_act_one_with_keys(&peer.pending_read_buffer[..], &self.our_node_secret, self.get_ephemeral_key())).to_vec(); + peer.pending_outbound_buffer.push_back(act_two); + peer.pending_read_buffer = [0; 66].to_vec(); // act three is 66 bytes long + }, + NextNoiseStep::ActTwo => { + let (act_three, their_node_id) = try_potential_handleerror!(peer, + peer.channel_encryptor.process_act_two(&peer.pending_read_buffer[..], &self.our_node_secret)); + peer.pending_outbound_buffer.push_back(act_three.to_vec()); + peer.pending_read_buffer = [0; 18].to_vec(); // Message length header is 18 bytes + peer.pending_read_is_header = true; + + peer.their_node_id = Some(their_node_id); + insert_node_id!(); + let features = InitFeatures::known(); + let resp = msgs::Init { features, remote_network_address: filter_addresses(peer.their_net_address.clone()) }; + self.enqueue_message(peer, &resp); + peer.awaiting_pong_timer_tick_intervals = 0; + }, + NextNoiseStep::ActThree => { + let their_node_id = try_potential_handleerror!(peer, + peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..])); + peer.pending_read_buffer = [0; 18].to_vec(); // Message length header is 18 bytes + peer.pending_read_is_header = true; + peer.their_node_id = Some(their_node_id); + insert_node_id!(); + let features = InitFeatures::known(); + let resp = msgs::Init { features, remote_network_address: filter_addresses(peer.their_net_address.clone()) }; + self.enqueue_message(peer, &resp); + peer.awaiting_pong_timer_tick_intervals = 0; + }, + NextNoiseStep::NoiseComplete => { + if peer.pending_read_is_header { + let msg_len = try_potential_handleerror!(peer, + peer.channel_encryptor.decrypt_length_header(&peer.pending_read_buffer[..])); + peer.pending_read_buffer = Vec::with_capacity(msg_len as usize + 16); + peer.pending_read_buffer.resize(msg_len as usize + 16, 0); + if msg_len < 2 { // Need at least the message type tag + return Err(PeerHandleError{ no_connection_possible: false }); + } + peer.pending_read_is_header = false; + } else { + let msg_data = try_potential_handleerror!(peer, + peer.channel_encryptor.decrypt_message(&peer.pending_read_buffer[..])); + assert!(msg_data.len() >= 2); + + // Reset read buffer + peer.pending_read_buffer = [0; 18].to_vec(); + peer.pending_read_is_header = true; - macro_rules! try_potential_handleerror { - ($thing: expr) => { - match $thing { + let mut reader = io::Cursor::new(&msg_data[..]); + let message_result = wire::read(&mut reader, &*self.custom_message_handler); + let message = match message_result { Ok(x) => x, Err(e) => { - match e.action { - msgs::ErrorAction::DisconnectPeer { msg: _ } => { - //TODO: Try to push msg - log_debug!(self.logger, "Error handling message{}; disconnecting peer with: {}", OptionalFromDebugger(&peer.their_node_id), e.err); - return Err(PeerHandleError{ no_connection_possible: false }); - }, - msgs::ErrorAction::IgnoreAndLog(level) => { - log_given_level!(self.logger, level, "Error handling message{}; ignoring: {}", OptionalFromDebugger(&peer.their_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.their_node_id), e.err); + match e { + // Note that to avoid recursion we never call + // `do_attempt_write_data` from here, causing + // the messages enqueued here to not actually + // be sent before the peer is disconnected. + (msgs::DecodeError::UnknownRequiredFeature, Some(ty)) if is_gossip_msg(ty) => { + log_gossip!(self.logger, "Got a channel/node announcement with an unknown required feature flag, you may want to update!"); continue; - }, - msgs::ErrorAction::SendErrorMessage { msg } => { - log_debug!(self.logger, "Error handling message{}; sending error message with: {}", OptionalFromDebugger(&peer.their_node_id), e.err); - self.enqueue_message(peer, &msg); + } + (msgs::DecodeError::UnsupportedCompression, _) => { + log_gossip!(self.logger, "We don't support zlib-compressed message fields, sending a warning and ignoring message"); + self.enqueue_message(peer, &msgs::WarningMessage { channel_id: [0; 32], data: "Unsupported message compression: zlib".to_owned() }); continue; - }, - msgs::ErrorAction::SendWarningMessage { msg, log_level } => { - log_given_level!(self.logger, log_level, "Error handling message{}; sending warning message with: {}", OptionalFromDebugger(&peer.their_node_id), e.err); - self.enqueue_message(peer, &msg); + } + (_, Some(ty)) if is_gossip_msg(ty) => { + log_gossip!(self.logger, "Got an invalid value while deserializing a gossip message"); + self.enqueue_message(peer, &msgs::WarningMessage { channel_id: [0; 32], data: "Unreadable/bogus gossip message".to_owned() }); continue; - }, + } + (msgs::DecodeError::UnknownRequiredFeature, ty) => { + log_gossip!(self.logger, "Received a message with an unknown required feature flag or TLV, you may want to update!"); + self.enqueue_message(peer, &msgs::WarningMessage { channel_id: [0; 32], data: format!("Received an unknown required feature/TLV in message type {:?}", ty) }); + return Err(PeerHandleError { no_connection_possible: false }); + } + (msgs::DecodeError::UnknownVersion, _) => return Err(PeerHandleError { no_connection_possible: false }), + (msgs::DecodeError::InvalidValue, _) => { + log_debug!(self.logger, "Got an invalid value while deserializing message"); + return Err(PeerHandleError { no_connection_possible: false }); + } + (msgs::DecodeError::ShortRead, _) => { + log_debug!(self.logger, "Deserialization failed due to shortness of message"); + return Err(PeerHandleError { no_connection_possible: false }); + } + (msgs::DecodeError::BadLengthDescriptor, _) => return Err(PeerHandleError { no_connection_possible: false }), + (msgs::DecodeError::Io(_), _) => return Err(PeerHandleError { no_connection_possible: false }), } } - } - } - } - - macro_rules! insert_node_id { - () => { - match self.node_id_to_descriptor.lock().unwrap().entry(peer.their_node_id.unwrap()) { - hash_map::Entry::Occupied(_) => { - log_trace!(self.logger, "Got second connection with {}, closing", log_pubkey!(peer.their_node_id.unwrap())); - peer.their_node_id = None; // Unset so that we don't generate a peer_disconnected event - return Err(PeerHandleError{ no_connection_possible: false }) - }, - hash_map::Entry::Vacant(entry) => { - log_debug!(self.logger, "Finished noise handshake for connection with {}", log_pubkey!(peer.their_node_id.unwrap())); - entry.insert(peer_descriptor.clone()) - }, }; - } - } - - let next_step = peer.channel_encryptor.get_noise_step(); - match next_step { - NextNoiseStep::ActOne => { - let act_two = try_potential_handleerror!(peer.channel_encryptor.process_act_one_with_keys(&peer.pending_read_buffer[..], &self.our_node_secret, self.get_ephemeral_key())).to_vec(); - peer.pending_outbound_buffer.push_back(act_two); - peer.pending_read_buffer = [0; 66].to_vec(); // act three is 66 bytes long - }, - NextNoiseStep::ActTwo => { - let (act_three, their_node_id) = try_potential_handleerror!(peer.channel_encryptor.process_act_two(&peer.pending_read_buffer[..], &self.our_node_secret)); - peer.pending_outbound_buffer.push_back(act_three.to_vec()); - peer.pending_read_buffer = [0; 18].to_vec(); // Message length header is 18 bytes - peer.pending_read_is_header = true; - peer.their_node_id = Some(their_node_id); - insert_node_id!(); - let features = InitFeatures::known(); - let resp = msgs::Init { features, remote_network_address: filter_addresses(peer.their_net_address.clone())}; - self.enqueue_message(peer, &resp); - peer.awaiting_pong_timer_tick_intervals = 0; - }, - NextNoiseStep::ActThree => { - let their_node_id = try_potential_handleerror!(peer.channel_encryptor.process_act_three(&peer.pending_read_buffer[..])); - peer.pending_read_buffer = [0; 18].to_vec(); // Message length header is 18 bytes - peer.pending_read_is_header = true; - peer.their_node_id = Some(their_node_id); - insert_node_id!(); - let features = InitFeatures::known(); - let resp = msgs::Init { features, remote_network_address: filter_addresses(peer.their_net_address.clone())}; - self.enqueue_message(peer, &resp); - peer.awaiting_pong_timer_tick_intervals = 0; - }, - NextNoiseStep::NoiseComplete => { - if peer.pending_read_is_header { - let msg_len = try_potential_handleerror!(peer.channel_encryptor.decrypt_length_header(&peer.pending_read_buffer[..])); - peer.pending_read_buffer = Vec::with_capacity(msg_len as usize + 16); - peer.pending_read_buffer.resize(msg_len as usize + 16, 0); - if msg_len < 2 { // Need at least the message type tag - return Err(PeerHandleError{ no_connection_possible: false }); - } - peer.pending_read_is_header = false; - } else { - let msg_data = try_potential_handleerror!(peer.channel_encryptor.decrypt_message(&peer.pending_read_buffer[..])); - assert!(msg_data.len() >= 2); - - // Reset read buffer - peer.pending_read_buffer = [0; 18].to_vec(); - peer.pending_read_is_header = true; - - let mut reader = io::Cursor::new(&msg_data[..]); - let message_result = wire::read(&mut reader, &*self.custom_message_handler); - let message = match message_result { - Ok(x) => x, - Err(e) => { - match e { - // Note that to avoid recursion we never call - // `do_attempt_write_data` from here, causing - // the messages enqueued here to not actually - // be sent before the peer is disconnected. - (msgs::DecodeError::UnknownRequiredFeature, Some(ty)) if is_gossip_msg(ty) => { - log_gossip!(self.logger, "Got a channel/node announcement with an unknown required feature flag, you may want to update!"); - continue; - } - (msgs::DecodeError::UnsupportedCompression, _) => { - log_gossip!(self.logger, "We don't support zlib-compressed message fields, sending a warning and ignoring message"); - self.enqueue_message(peer, &msgs::WarningMessage { channel_id: [0; 32], data: "Unsupported message compression: zlib".to_owned() }); - continue; - } - (_, Some(ty)) if is_gossip_msg(ty) => { - log_gossip!(self.logger, "Got an invalid value while deserializing a gossip message"); - self.enqueue_message(peer, &msgs::WarningMessage { channel_id: [0; 32], data: "Unreadable/bogus gossip message".to_owned() }); - continue; - } - (msgs::DecodeError::UnknownRequiredFeature, ty) => { - log_gossip!(self.logger, "Received a message with an unknown required feature flag or TLV, you may want to update!"); - self.enqueue_message(peer, &msgs::WarningMessage { channel_id: [0; 32], data: format!("Received an unknown required feature/TLV in message type {:?}", ty) }); - return Err(PeerHandleError { no_connection_possible: false }); - } - (msgs::DecodeError::UnknownVersion, _) => return Err(PeerHandleError { no_connection_possible: false }), - (msgs::DecodeError::InvalidValue, _) => { - log_debug!(self.logger, "Got an invalid value while deserializing message"); - return Err(PeerHandleError { no_connection_possible: false }); - } - (msgs::DecodeError::ShortRead, _) => { - log_debug!(self.logger, "Deserialization failed due to shortness of message"); - return Err(PeerHandleError { no_connection_possible: false }); - } - (msgs::DecodeError::BadLengthDescriptor, _) => return Err(PeerHandleError { no_connection_possible: false }), - (msgs::DecodeError::Io(_), _) => return Err(PeerHandleError { no_connection_possible: false }), - } - } - }; - - match self.handle_message(peer, message) { - Err(handling_error) => 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) => {}, - } - } + msg_to_handle = Some(message); } } } } - - peer.pending_outbound_buffer.len() > OUTBOUND_BUFFER_LIMIT_READ_PAUSE // pause_read + pause_read = peer.pending_outbound_buffer.len() > OUTBOUND_BUFFER_LIMIT_READ_PAUSE; + + if let Some(message) = msg_to_handle { + match self.handle_message(&peer_mutex, peer_lock, message) { + Err(handling_error) => match handling_error { + MessageHandlingError::PeerHandleError(e) => { return Err(e) }, + MessageHandlingError::LightningError(e) => { + try_potential_handleerror!(&mut peer_mutex.lock().unwrap(), Err(e)); + }, + }, + Ok(Some(msg)) => { + msgs_to_forward.push(msg); + }, + Ok(None) => {}, + } + } } - }; - - for msg in msgs_to_forward.drain(..) { - self.forward_broadcast_msg(&*peers, &msg, peer_node_id.as_ref()); } + } - pause_read - }; + for msg in msgs_to_forward.drain(..) { + self.forward_broadcast_msg(&*peers, &msg, peer_node_id.as_ref()); + } Ok(pause_read) } @@ -1043,52 +1055,74 @@ impl P /// Returns the message back if it needs to be broadcasted to all other peers. fn handle_message( &self, - peer: &mut Peer, + peer_mutex: &Mutex, + mut peer_lock: MutexGuard, message: wire::Message<<::Target as wire::CustomMessageReader>::CustomMessage> ) -> Result::Target as wire::CustomMessageReader>::CustomMessage>>, MessageHandlingError> { - if is_gossip_msg(message.type_id()) { - log_gossip!(self.logger, "Received message {:?} from {}", message, log_pubkey!(peer.their_node_id.unwrap())); - } else { - log_trace!(self.logger, "Received message {:?} from {}", message, log_pubkey!(peer.their_node_id.unwrap())); - } - - peer.received_message_since_timer_tick = true; + let their_node_id = peer_lock.their_node_id.clone().expect("We know the peer's public key by the time we receive messages"); + peer_lock.received_message_since_timer_tick = true; // Need an Init as first message - if let wire::Message::Init(_) = message { - } else if peer.their_features.is_none() { - log_debug!(self.logger, "Peer {} sent non-Init first message", log_pubkey!(peer.their_node_id.unwrap())); + if let wire::Message::Init(msg) = message { + if msg.features.requires_unknown_bits() { + log_debug!(self.logger, "Peer features required unknown version bits"); + return Err(PeerHandleError{ no_connection_possible: true }.into()); + } + if peer_lock.their_features.is_some() { + return Err(PeerHandleError{ no_connection_possible: false }.into()); + } + + log_info!(self.logger, "Received peer Init message from {}: {}", log_pubkey!(their_node_id), msg.features); + + // For peers not supporting gossip queries start sync now, otherwise wait until we receive a filter. + if msg.features.initial_routing_sync() && !msg.features.supports_gossip_queries() { + peer_lock.sync_status = InitSyncTracker::ChannelsSyncing(0); + } + + if !msg.features.supports_static_remote_key() { + log_debug!(self.logger, "Peer {} does not support static remote key, disconnecting with no_connection_possible", log_pubkey!(their_node_id)); + return Err(PeerHandleError{ no_connection_possible: true }.into()); + } + + self.message_handler.route_handler.peer_connected(&their_node_id, &msg); + + self.message_handler.chan_handler.peer_connected(&their_node_id, &msg); + peer_lock.their_features = Some(msg.features); + return Ok(None); + } else if peer_lock.their_features.is_none() { + log_debug!(self.logger, "Peer {} sent non-Init first message", log_pubkey!(their_node_id)); return Err(PeerHandleError{ no_connection_possible: false }.into()); } - let mut should_forward = None; - - match message { - // Setup and Control messages: - wire::Message::Init(msg) => { - if msg.features.requires_unknown_bits() { - log_debug!(self.logger, "Peer features required unknown version bits"); - return Err(PeerHandleError{ no_connection_possible: true }.into()); - } - if peer.their_features.is_some() { - return Err(PeerHandleError{ no_connection_possible: false }.into()); - } + if let wire::Message::GossipTimestampFilter(_msg) = message { + // When supporting gossip messages, start inital gossip sync only after we receive + // a GossipTimestampFilter + if peer_lock.their_features.as_ref().unwrap().supports_gossip_queries() && + !peer_lock.sent_gossip_timestamp_filter { + peer_lock.sent_gossip_timestamp_filter = true; + peer_lock.sync_status = InitSyncTracker::ChannelsSyncing(0); + } + return Ok(None); + } - log_info!(self.logger, "Received peer Init message from {}: {}", log_pubkey!(peer.their_node_id.unwrap()), msg.features); + let their_features = peer_lock.their_features.clone(); + mem::drop(peer_lock); - // For peers not supporting gossip queries start sync now, otherwise wait until we receive a filter. - if msg.features.initial_routing_sync() && !msg.features.supports_gossip_queries() { - peer.sync_status = InitSyncTracker::ChannelsSyncing(0); - } - if !msg.features.supports_static_remote_key() { - log_debug!(self.logger, "Peer {} does not support static remote key, disconnecting with no_connection_possible", log_pubkey!(peer.their_node_id.unwrap())); - return Err(PeerHandleError{ no_connection_possible: true }.into()); - } + if is_gossip_msg(message.type_id()) { + log_gossip!(self.logger, "Received message {:?} from {}", message, log_pubkey!(their_node_id)); + } else { + log_trace!(self.logger, "Received message {:?} from {}", message, log_pubkey!(their_node_id)); + } - self.message_handler.route_handler.peer_connected(&peer.their_node_id.unwrap(), &msg); + let mut should_forward = None; - self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap(), &msg); - peer.their_features = Some(msg.features); + match message { + // Setup and Control messages: + wire::Message::Init(_) => { + // Handled above + }, + wire::Message::GossipTimestampFilter(_) => { + // Handled above }, wire::Message::Error(msg) => { let mut data_is_printable = true; @@ -1100,11 +1134,11 @@ impl P } if data_is_printable { - log_debug!(self.logger, "Got Err message from {}: {}", log_pubkey!(peer.their_node_id.unwrap()), msg.data); + log_debug!(self.logger, "Got Err message from {}: {}", log_pubkey!(their_node_id), msg.data); } else { - log_debug!(self.logger, "Got Err message from {} with non-ASCII error message", log_pubkey!(peer.their_node_id.unwrap())); + log_debug!(self.logger, "Got Err message from {} with non-ASCII error message", log_pubkey!(their_node_id)); } - self.message_handler.chan_handler.handle_error(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_error(&their_node_id, &msg); if msg.channel_id == [0; 32] { return Err(PeerHandleError{ no_connection_possible: true }.into()); } @@ -1119,78 +1153,79 @@ impl P } if data_is_printable { - log_debug!(self.logger, "Got warning message from {}: {}", log_pubkey!(peer.their_node_id.unwrap()), msg.data); + log_debug!(self.logger, "Got warning message from {}: {}", log_pubkey!(their_node_id), msg.data); } else { - log_debug!(self.logger, "Got warning message from {} with non-ASCII error message", log_pubkey!(peer.their_node_id.unwrap())); + log_debug!(self.logger, "Got warning message from {} with non-ASCII error message", log_pubkey!(their_node_id)); } }, wire::Message::Ping(msg) => { if msg.ponglen < 65532 { let resp = msgs::Pong { byteslen: msg.ponglen }; - self.enqueue_message(peer, &resp); + self.enqueue_message(&mut *peer_mutex.lock().unwrap(), &resp); } }, wire::Message::Pong(_msg) => { - peer.awaiting_pong_timer_tick_intervals = 0; - peer.msgs_sent_since_pong = 0; + let mut peer_lock = peer_mutex.lock().unwrap(); + peer_lock.awaiting_pong_timer_tick_intervals = 0; + peer_lock.msgs_sent_since_pong = 0; }, // Channel messages: wire::Message::OpenChannel(msg) => { - self.message_handler.chan_handler.handle_open_channel(&peer.their_node_id.unwrap(), peer.their_features.clone().unwrap(), &msg); + self.message_handler.chan_handler.handle_open_channel(&their_node_id, their_features.clone().unwrap(), &msg); }, wire::Message::AcceptChannel(msg) => { - self.message_handler.chan_handler.handle_accept_channel(&peer.their_node_id.unwrap(), peer.their_features.clone().unwrap(), &msg); + self.message_handler.chan_handler.handle_accept_channel(&their_node_id, their_features.clone().unwrap(), &msg); }, wire::Message::FundingCreated(msg) => { - self.message_handler.chan_handler.handle_funding_created(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_funding_created(&their_node_id, &msg); }, wire::Message::FundingSigned(msg) => { - self.message_handler.chan_handler.handle_funding_signed(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_funding_signed(&their_node_id, &msg); }, wire::Message::FundingLocked(msg) => { - self.message_handler.chan_handler.handle_funding_locked(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_funding_locked(&their_node_id, &msg); }, wire::Message::Shutdown(msg) => { - self.message_handler.chan_handler.handle_shutdown(&peer.their_node_id.unwrap(), peer.their_features.as_ref().unwrap(), &msg); + self.message_handler.chan_handler.handle_shutdown(&their_node_id, their_features.as_ref().unwrap(), &msg); }, wire::Message::ClosingSigned(msg) => { - self.message_handler.chan_handler.handle_closing_signed(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_closing_signed(&their_node_id, &msg); }, // Commitment messages: wire::Message::UpdateAddHTLC(msg) => { - self.message_handler.chan_handler.handle_update_add_htlc(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_update_add_htlc(&their_node_id, &msg); }, wire::Message::UpdateFulfillHTLC(msg) => { - self.message_handler.chan_handler.handle_update_fulfill_htlc(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_update_fulfill_htlc(&their_node_id, &msg); }, wire::Message::UpdateFailHTLC(msg) => { - self.message_handler.chan_handler.handle_update_fail_htlc(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_update_fail_htlc(&their_node_id, &msg); }, wire::Message::UpdateFailMalformedHTLC(msg) => { - self.message_handler.chan_handler.handle_update_fail_malformed_htlc(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_update_fail_malformed_htlc(&their_node_id, &msg); }, wire::Message::CommitmentSigned(msg) => { - self.message_handler.chan_handler.handle_commitment_signed(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_commitment_signed(&their_node_id, &msg); }, wire::Message::RevokeAndACK(msg) => { - self.message_handler.chan_handler.handle_revoke_and_ack(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_revoke_and_ack(&their_node_id, &msg); }, wire::Message::UpdateFee(msg) => { - self.message_handler.chan_handler.handle_update_fee(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_update_fee(&their_node_id, &msg); }, wire::Message::ChannelReestablish(msg) => { - self.message_handler.chan_handler.handle_channel_reestablish(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_channel_reestablish(&their_node_id, &msg); }, // Routing messages: wire::Message::AnnouncementSignatures(msg) => { - self.message_handler.chan_handler.handle_announcement_signatures(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_announcement_signatures(&their_node_id, &msg); }, wire::Message::ChannelAnnouncement(msg) => { if self.message_handler.route_handler.handle_channel_announcement(&msg) @@ -1205,32 +1240,23 @@ impl P } }, wire::Message::ChannelUpdate(msg) => { - self.message_handler.chan_handler.handle_channel_update(&peer.their_node_id.unwrap(), &msg); + self.message_handler.chan_handler.handle_channel_update(&their_node_id, &msg); if self.message_handler.route_handler.handle_channel_update(&msg) .map_err(|e| -> MessageHandlingError { e.into() })? { should_forward = Some(wire::Message::ChannelUpdate(msg)); } }, wire::Message::QueryShortChannelIds(msg) => { - self.message_handler.route_handler.handle_query_short_channel_ids(&peer.their_node_id.unwrap(), msg)?; + self.message_handler.route_handler.handle_query_short_channel_ids(&their_node_id, msg)?; }, wire::Message::ReplyShortChannelIdsEnd(msg) => { - self.message_handler.route_handler.handle_reply_short_channel_ids_end(&peer.their_node_id.unwrap(), msg)?; + self.message_handler.route_handler.handle_reply_short_channel_ids_end(&their_node_id, msg)?; }, wire::Message::QueryChannelRange(msg) => { - self.message_handler.route_handler.handle_query_channel_range(&peer.their_node_id.unwrap(), msg)?; + self.message_handler.route_handler.handle_query_channel_range(&their_node_id, msg)?; }, wire::Message::ReplyChannelRange(msg) => { - self.message_handler.route_handler.handle_reply_channel_range(&peer.their_node_id.unwrap(), msg)?; - }, - wire::Message::GossipTimestampFilter(_msg) => { - // When supporting gossip messages, start inital gossip sync only after we receive - // a GossipTimestampFilter - if peer.their_features.as_ref().unwrap().supports_gossip_queries() && - !peer.sent_gossip_timestamp_filter { - peer.sent_gossip_timestamp_filter = true; - peer.sync_status = InitSyncTracker::ChannelsSyncing(0); - } + self.message_handler.route_handler.handle_reply_channel_range(&their_node_id, msg)?; }, // Unknown messages: @@ -1243,7 +1269,7 @@ impl P log_trace!(self.logger, "Received unknown odd message of type {}, ignoring", type_id); }, wire::Message::Custom(custom) => { - self.custom_message_handler.handle_custom_message(custom, &peer.their_node_id.unwrap())?; + self.custom_message_handler.handle_custom_message(custom, &their_node_id)?; }, }; Ok(should_forward)