X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fpeer_handler.rs;h=5e9424243008e19768300475757bf07b17affbf8;hb=11e5975523147ae7024b03f05445c78c9b695752;hp=86e2553623d2405232c97c735f548e7fb84bb04b;hpb=f9ec0a76d4a1bb6a1eee62b8775b2c239b4672e8;p=rust-lightning diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs index 86e25536..5e942424 100644 --- a/src/ln/peer_handler.rs +++ b/src/ln/peer_handler.rs @@ -5,6 +5,7 @@ use ln::msgs::{MsgEncodable,MsgDecodable}; use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep}; use util::byte_utils; use util::events::{EventsProvider,Event}; +use util::logger::Logger; use std::collections::{HashMap,LinkedList}; use std::sync::{Arc, Mutex}; @@ -21,7 +22,9 @@ pub struct MessageHandler { /// implement Hash to meet the PeerManager API. /// For efficiency, Clone should be relatively cheap for this type. /// You probably want to just extend an int and put a file descriptor in a struct and implement -/// send_data. +/// send_data. Note that if you are using a higher-level net library that may close() itself, be +/// careful to ensure you don't have races whereby you might register a new connection with an fd +/// the same as a yet-to-be-disconnect_event()-ed. pub trait SocketDescriptor : cmp::Eq + hash::Hash + Clone { /// Attempts to send some data from the given Vec starting at the given offset to the peer. /// Returns the amount of data which was sent, possibly 0 if the socket has since disconnected. @@ -35,6 +38,12 @@ pub trait SocketDescriptor : cmp::Eq + hash::Hash + Clone { /// indicating that read events on this descriptor should resume. A resume_read of false does /// *not* imply that further read events should be paused. fn send_data(&mut self, data: &Vec, write_offset: usize, resume_read: bool) -> usize; + /// Disconnect the socket pointed to by this SocketDescriptor. Once this function returns, no + /// more calls to write_event, read_event or disconnect_event may be made with this descriptor. + /// No disconnect_event should be generated as a result of this call, though obviously races + /// may occur whereby disconnect_socket is called after a call to disconnect_event but prior to + /// that event completing. + fn disconnect_socket(&mut self); } /// Error for PeerManager errors. If you get one of these, you must disconnect the socket and @@ -88,6 +97,7 @@ pub struct PeerManager { pending_events: Mutex>, our_node_secret: SecretKey, initial_syncs_sent: AtomicUsize, + logger: Arc, } @@ -109,16 +119,26 @@ const INITIAL_SYNCS_TO_SEND: usize = 5; /// Manages and reacts to connection events. You probably want to use file descriptors as PeerIds. /// PeerIds may repeat, but only after disconnect_event() has been called. impl PeerManager { - pub fn new(message_handler: MessageHandler, our_node_secret: SecretKey) -> PeerManager { + pub fn new(message_handler: MessageHandler, our_node_secret: SecretKey, logger: Arc) -> PeerManager { PeerManager { message_handler: message_handler, peers: Mutex::new(PeerHolder { peers: HashMap::new(), node_id_to_descriptor: HashMap::new() }), pending_events: Mutex::new(Vec::new()), our_node_secret: our_node_secret, initial_syncs_sent: AtomicUsize::new(0), + logger, } } + /// Get the list of node ids for peers which have completed the initial handshake. + /// For outbound connections, this will be the same as the their_node_id parameter passed in to + /// new_outbound_connection, however entries will only appear once the initial handshake has + /// completed and we are sure the remote peer has the private key for the given node_id. + pub fn get_peer_node_ids(&self) -> Vec { + let peers = self.peers.lock().unwrap(); + peers.peers.values().filter_map(|p| p.their_node_id).collect() + } + /// Indicates a new outbound connection has been established to a node with the given node_id. /// Note that if an Err is returned here you MUST NOT call disconnect_event for the new /// descriptor but must disconnect the connection immediately. @@ -269,7 +289,10 @@ impl PeerManager { macro_rules! encode_and_send_msg { ($msg: expr, $msg_code: expr) => { - peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!($msg, $msg_code)[..])); + { + log_trace!(self, "Encoding and sending message of type {} to {}", $msg_code, log_pubkey!(peer.their_node_id.unwrap())); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!($msg, $msg_code)[..])); + } } } @@ -278,19 +301,22 @@ impl PeerManager { match $thing { Ok(x) => x, Err(e) => { - println!("Got error handling message: {}!", e.err); - if let Some(action) = e.msg { + if let Some(action) = e.action { match action { msgs::ErrorAction::UpdateFailHTLC { msg } => { encode_and_send_msg!(msg, 131); continue; }, - msgs::ErrorAction::DisconnectPeer => { + msgs::ErrorAction::DisconnectPeer { msg: _ } => { return Err(PeerHandleError{ no_connection_possible: false }); }, msgs::ErrorAction::IgnoreError => { continue; }, + msgs::ErrorAction::SendErrorMessage { msg } => { + encode_and_send_msg!(msg, 17); + continue; + }, } } else { return Err(PeerHandleError{ no_connection_possible: false }); @@ -305,7 +331,6 @@ impl PeerManager { match $thing { Ok(x) => x, Err(_e) => { - println!("Error decoding message"); //TODO: Handle e? return Err(PeerHandleError{ no_connection_possible: false }); } @@ -318,7 +343,7 @@ impl PeerManager { match $thing { Ok(x) => x, Err(_e) => { - println!("Error decoding message, ignoring due to lnd spec incompatibility. See https://github.com/lightningnetwork/lnd/issues/1407"); + log_debug!(self, "Error decoding message, ignoring due to lnd spec incompatibility. See https://github.com/lightningnetwork/lnd/issues/1407"); continue; } }; @@ -374,6 +399,7 @@ impl PeerManager { peer.pending_read_is_header = true; let msg_type = byte_utils::slice_to_be16(&msg_data[0..2]); + log_trace!(self, "Received message of type {} from {}", msg_type, log_pubkey!(peer.their_node_id.unwrap())); if msg_type != 16 && peer.their_global_features.is_none() { // Need an init message as first message return Err(PeerHandleError{ no_connection_possible: false }); @@ -607,12 +633,24 @@ impl PeerManager { Event::PaymentReceived {..} => { /* Hand upstream */ }, Event::PaymentSent {..} => { /* Hand upstream */ }, Event::PaymentFailed {..} => { /* Hand upstream */ }, + Event::PendingHTLCsForwardable {..} => { /* Hand upstream */ }, - Event::PendingHTLCsForwardable {..} => { - //TODO: Handle upstream in some confused form so that upstream just knows - //to call us somehow? + Event::SendOpenChannel { ref node_id, ref msg } => { + log_trace!(self, "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, { + //TODO: Drop the pending channel? (or just let it timeout, but that sucks) + }); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 32))); + Self::do_attempt_write_data(&mut descriptor, peer); + continue; }, Event::SendFundingCreated { ref node_id, ref msg } => { + log_trace!(self, "Handling SendFundingCreated event in peer_handler for node {} for channel {} (which becomes {})", + log_pubkey!(node_id), + log_bytes!(msg.temporary_channel_id), + log_funding_channel_id!(msg.funding_txid, msg.funding_output_index)); let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, { //TODO: generate a DiscardFunding event indicating to the wallet that //they should just throw away this funding transaction @@ -622,6 +660,10 @@ impl PeerManager { continue; }, Event::SendFundingLocked { ref node_id, ref msg, ref announcement_sigs } => { + log_trace!(self, "Handling SendFundingLocked event in peer_handler for node {}{} for channel {}", + log_pubkey!(node_id), + if announcement_sigs.is_some() { " with announcement sigs" } else { "" }, + log_bytes!(msg.channel_id)); let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, { //TODO: Do whatever we're gonna do for handling dropped messages }); @@ -634,6 +676,10 @@ impl PeerManager { continue; }, Event::SendHTLCs { ref node_id, ref msgs, ref commitment_msg } => { + log_trace!(self, "Handling SendHTLCs event in peer_handler for node {} with {} HTLCs for channel {}", + log_pubkey!(node_id), + msgs.len(), + log_bytes!(commitment_msg.channel_id)); let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, { //TODO: Do whatever we're gonna do for handling dropped messages }); @@ -645,6 +691,10 @@ impl PeerManager { continue; }, Event::SendFulfillHTLC { ref node_id, ref msg, ref commitment_msg } => { + log_trace!(self, "Handling SendFulfillHTLCs event in peer_handler for node {} with payment_preimage {} for channel {}", + log_pubkey!(node_id), + log_bytes!(msg.payment_preimage), + log_bytes!(msg.channel_id)); let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, { //TODO: Do whatever we're gonna do for handling dropped messages }); @@ -654,6 +704,10 @@ impl PeerManager { continue; }, Event::SendFailHTLC { ref node_id, ref msg, ref commitment_msg } => { + log_trace!(self, "Handling SendFailHTLCs event in peer_handler for node {} for HTLC ID {} for channel {}", + log_pubkey!(node_id), + msg.htlc_id, + log_bytes!(msg.channel_id)); let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, { //TODO: Do whatever we're gonna do for handling dropped messages }); @@ -662,7 +716,19 @@ impl PeerManager { Self::do_attempt_write_data(&mut descriptor, peer); continue; }, + Event::SendShutdown { ref node_id, ref msg } => { + log_trace!(self, "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, { + //TODO: Do whatever we're gonna do for handling dropped messages + }); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 38))); + Self::do_attempt_write_data(&mut descriptor, peer); + continue; + }, Event::BroadcastChannelAnnouncement { ref msg, ref update_msg } => { + log_trace!(self, "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, 256); let encoded_update_msg = encode_msg!(update_msg, 258); @@ -687,6 +753,7 @@ impl PeerManager { continue; }, Event::BroadcastChannelUpdate { ref msg } => { + log_trace!(self, "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, 258); @@ -700,6 +767,59 @@ impl PeerManager { } continue; }, + Event::HandleError { ref node_id, ref action } => { + if let Some(ref action) = *action { + match *action { + msgs::ErrorAction::UpdateFailHTLC { ref msg } => { + log_trace!(self, "Handling UpdateFailHTLC HandleError event in peer_handler for node {} for HTLC ID {} for channel {}", + log_pubkey!(node_id), + msg.htlc_id, + log_bytes!(msg.channel_id)); + let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, { + //TODO: Do whatever we're gonna do for handling dropped messages + }); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 131))); + Self::do_attempt_write_data(&mut descriptor, peer); + + }, + msgs::ErrorAction::DisconnectPeer { ref msg } => { + if let Some(mut descriptor) = peers.node_id_to_descriptor.remove(node_id) { + if let Some(mut peer) = peers.peers.remove(&descriptor) { + if let Some(ref msg) = *msg { + log_trace!(self, "Handling DisconnectPeer HandleError event in peer_handler for node {} with message {}", + log_pubkey!(node_id), + msg.data); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 17))); + // This isn't guaranteed to work, but if there is enough free + // room in the send buffer, put the error message there... + Self::do_attempt_write_data(&mut descriptor, &mut peer); + } else { + log_trace!(self, "Handling DisconnectPeer HandleError event in peer_handler for node {} with no message", log_pubkey!(node_id)); + } + } + descriptor.disconnect_socket(); + self.message_handler.chan_handler.peer_disconnected(&node_id, false); + } + }, + msgs::ErrorAction::IgnoreError => { + continue; + }, + msgs::ErrorAction::SendErrorMessage { ref msg } => { + log_trace!(self, "Handling SendErrorMessage HandleError event in peer_handler for node {} with message {}", + log_pubkey!(node_id), + msg.data); + let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, { + //TODO: Do whatever we're gonna do for handling dropped messages + }); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 17))); + Self::do_attempt_write_data(&mut descriptor, peer); + }, + } + } else { + log_error!(self, "Got no-action HandleError Event in peer_handler for node {}, no such events should ever be generated!", log_pubkey!(node_id)); + } + continue; + } } upstream_events.push(event); @@ -746,3 +866,86 @@ impl EventsProvider for PeerManager { ret } } + +#[cfg(test)] +mod tests { + use ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor}; + use ln::msgs; + use util::events; + use util::test_utils; + use util::logger::Logger; + + use secp256k1::Secp256k1; + use secp256k1::key::{SecretKey, PublicKey}; + + use rand::{thread_rng, Rng}; + + use std::sync::{Arc}; + + #[derive(PartialEq, Eq, Clone, Hash)] + struct FileDescriptor { + fd: u16, + } + + impl SocketDescriptor for FileDescriptor { + fn send_data(&mut self, data: &Vec, write_offset: usize, _resume_read: bool) -> usize { + assert!(write_offset < data.len()); + data.len() - write_offset + } + + fn disconnect_socket(&mut self) {} + } + + fn create_network(peer_count: usize) -> Vec> { + let secp_ctx = Secp256k1::new(); + let mut peers = Vec::new(); + let mut rng = thread_rng(); + let logger : Arc = Arc::new(test_utils::TestLogger::new()); + + for _ in 0..peer_count { + let chan_handler = test_utils::TestChannelMessageHandler::new(); + let router = test_utils::TestRoutingMessageHandler::new(); + let node_id = { + let mut key_slice = [0;32]; + rng.fill_bytes(&mut key_slice); + SecretKey::from_slice(&secp_ctx, &key_slice).unwrap() + }; + let msg_handler = MessageHandler { chan_handler: Arc::new(chan_handler), route_handler: Arc::new(router) }; + let peer = PeerManager::new(msg_handler, node_id, Arc::clone(&logger)); + peers.push(peer); + } + + peers + } + + fn establish_connection(peer_a: &PeerManager, peer_b: &PeerManager) { + let secp_ctx = Secp256k1::new(); + let their_id = PublicKey::from_secret_key(&secp_ctx, &peer_b.our_node_secret); + let fd = FileDescriptor { fd: 1}; + peer_a.new_inbound_connection(fd.clone()).unwrap(); + peer_a.peers.lock().unwrap().node_id_to_descriptor.insert(their_id, fd.clone()); + } + + #[test] + fn test_disconnect_peer() { + // Simple test which builds a network of PeerManager, connects and brings them to NoiseState::Finished and + // push an DisconnectPeer event to remove the node flagged by id + let mut peers = create_network(2); + establish_connection(&peers[0], &peers[1]); + assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1); + + let secp_ctx = Secp256k1::new(); + let their_id = PublicKey::from_secret_key(&secp_ctx, &peers[1].our_node_secret); + + let chan_handler = test_utils::TestChannelMessageHandler::new(); + chan_handler.pending_events.lock().unwrap().push(events::Event::HandleError { + node_id: their_id, + action: Some(msgs::ErrorAction::DisconnectPeer { msg: None }), + }); + assert_eq!(chan_handler.pending_events.lock().unwrap().len(), 1); + peers[0].message_handler.chan_handler = Arc::new(chan_handler); + + peers[0].process_events(); + assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 0); + } +}