X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fpeer_handler.rs;h=7e213c037dc6be81ac550cd5b383d75b714d94be;hb=af5c6e8186d1e8297f4a828901fae589d5cfcc76;hp=e01d2c9b89c4494d68b8720062de63147538a1fc;hpb=4fbc0b37688411a7270fce20b44fb43944669823;p=rust-lightning diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs index e01d2c9b..7e213c03 100644 --- a/src/ln/peer_handler.rs +++ b/src/ln/peer_handler.rs @@ -8,7 +8,8 @@ use util::events::{EventsProvider,Event}; use std::collections::{HashMap,LinkedList}; use std::sync::{Arc, Mutex}; -use std::{cmp,mem,hash,fmt}; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::{cmp,error,mem,hash,fmt}; pub struct MessageHandler { pub chan_handler: Arc, @@ -20,7 +21,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. @@ -34,6 +37,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 @@ -48,6 +57,16 @@ impl fmt::Debug for PeerHandleError { formatter.write_str("Peer Sent Invalid Data") } } +impl fmt::Display for PeerHandleError { + fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { + formatter.write_str("Peer Sent Invalid Data") + } +} +impl error::Error for PeerHandleError { + fn description(&self) -> &str { + "Peer Sent Invalid Data" + } +} struct Peer { channel_encryptor: PeerChannelEncryptor, @@ -76,6 +95,7 @@ pub struct PeerManager { peers: Mutex>, pending_events: Mutex>, our_node_secret: SecretKey, + initial_syncs_sent: AtomicUsize, } @@ -91,6 +111,9 @@ macro_rules! encode_msg { } } +//TODO: Really should do something smarter for this +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 { @@ -100,9 +123,19 @@ impl PeerManager { 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), } } + /// 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. @@ -223,7 +256,7 @@ impl PeerManager { match self.do_read_event(peer_descriptor, data) { Ok(res) => Ok(res), Err(e) => { - self.disconnect_event(peer_descriptor); + self.disconnect_event_internal(peer_descriptor, e.no_connection_possible); Err(e) } } @@ -238,38 +271,7 @@ impl PeerManager { assert!(peer.pending_read_buffer.len() > 0); assert!(peer.pending_read_buffer.len() > peer.pending_read_buffer_pos); - macro_rules! try_potential_handleerror { - ($thing: expr) => { - match $thing { - Ok(x) => x, - Err(_e) => { - //TODO: Handle e appropriately! - return Err(PeerHandleError{}); - } - }; - } - } - - macro_rules! try_potential_decodeerror { - ($thing: expr) => { - match $thing { - Ok(x) => x, - Err(_e) => { - //TODO: Handle e? - return Err(PeerHandleError{}); - } - }; - } - } - - 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)[..])); - } - } - let mut insert_node_id = None; - let mut read_pos = 0; while read_pos < data.len() { { @@ -278,7 +280,72 @@ impl PeerManager { 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! 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)[..])); + } + } + + macro_rules! try_potential_handleerror { + ($thing: expr) => { + match $thing { + Ok(x) => x, + Err(e) => { + println!("Got error handling message: {}!", e.err); + if let Some(action) = e.action { + match action { + msgs::ErrorAction::UpdateFailHTLC { msg } => { + encode_and_send_msg!(msg, 131); + continue; + }, + 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 }); + } + } + }; + } + } + + macro_rules! try_potential_decodeerror { + ($thing: expr) => { + match $thing { + Ok(x) => x, + Err(_e) => { + println!("Error decoding message"); + //TODO: Handle e? + return Err(PeerHandleError{ no_connection_possible: false }); + } + }; + } + } + + macro_rules! try_ignore_potential_decodeerror { + ($thing: expr) => { + 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"); + continue; + } + }; + } + } + let next_step = peer.channel_encryptor.get_noise_step(); match next_step { NextNoiseStep::ActOne => { @@ -293,9 +360,14 @@ impl PeerManager { peer.pending_read_is_header = true; insert_node_id = Some(peer.their_node_id.unwrap()); + let mut local_features = msgs::LocalFeatures::new(); + if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND { + self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel); + local_features.set_initial_routing_sync(); + } encode_and_send_msg!(msgs::Init { global_features: msgs::GlobalFeatures::new(), - local_features: msgs::LocalFeatures::new(), + local_features, }, 16); }, NextNoiseStep::ActThree => { @@ -311,43 +383,61 @@ impl PeerManager { 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{}); + 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 msg_type = byte_utils::slice_to_be16(&msg_data[0..2]); if msg_type != 16 && peer.their_global_features.is_none() { // Need an init message as first message - return Err(PeerHandleError{}); + return Err(PeerHandleError{ no_connection_possible: false }); } match msg_type { // Connection control: 16 => { let msg = try_potential_decodeerror!(msgs::Init::decode(&msg_data[2..])); if msg.global_features.requires_unknown_bits() { - return Err(PeerHandleError{}); + return Err(PeerHandleError{ no_connection_possible: true }); } if msg.local_features.requires_unknown_bits() { - return Err(PeerHandleError{}); + return Err(PeerHandleError{ no_connection_possible: true }); } peer.their_global_features = Some(msg.global_features); peer.their_local_features = Some(msg.local_features); if !peer.outbound { + let mut local_features = msgs::LocalFeatures::new(); + if self.initial_syncs_sent.load(Ordering::Acquire) < INITIAL_SYNCS_TO_SEND { + self.initial_syncs_sent.fetch_add(1, Ordering::AcqRel); + local_features.set_initial_routing_sync(); + } encode_and_send_msg!(msgs::Init { global_features: msgs::GlobalFeatures::new(), - local_features: msgs::LocalFeatures::new(), + local_features, }, 16); } }, 17 => { // Error msg }, - 18 => { }, // ping - 19 => { }, // pong + + 18 => { + let msg = try_potential_decodeerror!(msgs::Ping::decode(&msg_data[2..])); + if msg.ponglen < 65532 { + let resp = msgs::Pong { byteslen: msg.ponglen }; + encode_and_send_msg!(resp, 19); + } + }, + 19 => { + try_potential_decodeerror!(msgs::Pong::decode(&msg_data[2..])); + }, // Channel control: 32 => { @@ -406,7 +496,10 @@ impl PeerManager { }, 131 => { let msg = try_potential_decodeerror!(msgs::UpdateFailHTLC::decode(&msg_data[2..])); - try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_htlc(&peer.their_node_id.unwrap(), &msg)); + let chan_update = try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_htlc(&peer.their_node_id.unwrap(), &msg)); + if let Some(update) = chan_update { + self.message_handler.route_handler.handle_htlc_fail_channel_update(&update); + } }, 135 => { let msg = try_potential_decodeerror!(msgs::UpdateFailMalformedHTLC::decode(&msg_data[2..])); @@ -415,18 +508,27 @@ impl PeerManager { 132 => { let msg = try_potential_decodeerror!(msgs::CommitmentSigned::decode(&msg_data[2..])); - let resp = try_potential_handleerror!(self.message_handler.chan_handler.handle_commitment_signed(&peer.their_node_id.unwrap(), &msg)); - encode_and_send_msg!(resp, 133); + let resps = try_potential_handleerror!(self.message_handler.chan_handler.handle_commitment_signed(&peer.their_node_id.unwrap(), &msg)); + encode_and_send_msg!(resps.0, 133); + if let Some(resp) = resps.1 { + encode_and_send_msg!(resp, 132); + } }, 133 => { let msg = try_potential_decodeerror!(msgs::RevokeAndACK::decode(&msg_data[2..])); let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_revoke_and_ack(&peer.their_node_id.unwrap(), &msg)); match resp_option { Some(resps) => { - for resp in resps.0 { + for resp in resps.update_add_htlcs { encode_and_send_msg!(resp, 128); } - encode_and_send_msg!(resps.1, 132); + for resp in resps.update_fulfill_htlcs { + encode_and_send_msg!(resp, 130); + } + for resp in resps.update_fail_htlcs { + encode_and_send_msg!(resp, 131); + } + encode_and_send_msg!(resps.commitment_signed, 132); }, None => {}, } @@ -451,7 +553,7 @@ impl PeerManager { } }, 257 => { - let msg = try_potential_decodeerror!(msgs::NodeAnnouncement::decode(&msg_data[2..])); + let msg = try_ignore_potential_decodeerror!(msgs::NodeAnnouncement::decode(&msg_data[2..])); try_potential_handleerror!(self.message_handler.route_handler.handle_node_announcement(&msg)); }, 258 => { @@ -460,18 +562,13 @@ impl PeerManager { }, _ => { if (msg_type & 1) == 0 { - //TODO: Fail all channels. Kill the peer! - return Err(PeerHandleError{}); + return Err(PeerHandleError{ no_connection_possible: true }); } }, } - - peer.pending_read_buffer = [0; 18].to_vec(); - peer.pending_read_is_header = true; } } } - peer.pending_read_buffer_pos = 0; } } @@ -531,10 +628,15 @@ 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 } => { + 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 } => { let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, { @@ -568,44 +670,84 @@ impl PeerManager { Self::do_attempt_write_data(&mut descriptor, peer); continue; }, - Event::SendFulfillHTLC { ref node_id, ref msg } => { + Event::SendFulfillHTLC { ref node_id, ref msg, ref commitment_msg } => { 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, 130))); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(commitment_msg, 132))); Self::do_attempt_write_data(&mut descriptor, peer); continue; }, - Event::SendFailHTLC { ref node_id, ref msg } => { + Event::SendFailHTLC { ref node_id, ref msg, ref commitment_msg } => { 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))); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(commitment_msg, 132))); + Self::do_attempt_write_data(&mut descriptor, peer); + continue; + }, + Event::SendShutdown { ref node_id, ref msg } => { + 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 } => { - let encoded_msg = encode_msg!(msg, 256); - let encoded_update_msg = encode_msg!(update_msg, 258); + 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); - for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { - if !peer.channel_encryptor.is_ready_for_encryption() { - 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 + for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { + if !peer.channel_encryptor.is_ready_for_encryption() { + 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); + } + } + continue; + }, + Event::BroadcastChannelUpdate { ref msg } => { + if self.message_handler.route_handler.handle_channel_update(msg).is_ok() { + let encoded_msg = encode_msg!(msg, 258); + + for (ref descriptor, ref mut peer) in peers.peers.iter_mut() { + if !peer.channel_encryptor.is_ready_for_encryption() { + continue + } + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..])); + Self::do_attempt_write_data(&mut (*descriptor).clone(), peer); } - 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); } continue; }, + Event::DisconnectPeer { ref node_id, 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 { + 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); + } + } + descriptor.disconnect_socket(); + self.message_handler.chan_handler.peer_disconnected(&node_id, false); + } + }, } upstream_events.push(event); @@ -623,18 +765,22 @@ impl PeerManager { /// but must NOT be called if a PeerHandleError was provided out of a new_*_connection event! /// Panics if the descriptor was not previously registered in a successful new_*_connection event. pub fn disconnect_event(&self, descriptor: &Descriptor) { + self.disconnect_event_internal(descriptor, false); + } + + fn disconnect_event_internal(&self, descriptor: &Descriptor, no_connection_possible: bool) { let mut peers = self.peers.lock().unwrap(); let peer_option = peers.peers.remove(descriptor); match peer_option { None => panic!("Descriptor for disconnect_event is not already known to PeerManager"), Some(peer) => { match peer.their_node_id { - Some(node_id) => { peers.node_id_to_descriptor.remove(&node_id); }, + Some(node_id) => { + peers.node_id_to_descriptor.remove(&node_id); + self.message_handler.chan_handler.peer_disconnected(&node_id, no_connection_possible); + }, None => {} } - //TODO: Notify the chan_handler that this node disconnected, and do something about - //handling response messages that were queued for sending (maybe the send buffer - //needs to be unencrypted?) } }; } @@ -648,3 +794,83 @@ impl EventsProvider for PeerManager { ret } } + +#[cfg(test)] +mod tests { + use ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor}; + use util::events; + use util::test_utils; + + 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(); + + 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); + 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).unwrap(); + 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).unwrap(); + + let chan_handler = test_utils::TestChannelMessageHandler::new(); + chan_handler.pending_events.lock().unwrap().push(events::Event::DisconnectPeer { + node_id: their_id, + 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); + } +}