X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fpeer_handler.rs;h=aec3a32e945b3f773c0519e46aec957696d1f50c;hb=d8474c9d3c422dddf6cf4b5a4f52157a0277203a;hp=01081845ae8630f9c6540fe30f706f6dbe4238c0;hpb=69eb59b24d502f3df6f4dd3990aad99cc727385c;p=rust-lightning diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs index 01081845..aec3a32e 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, @@ -48,6 +49,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 +87,7 @@ pub struct PeerManager { peers: Mutex>, pending_events: Mutex>, our_node_secret: SecretKey, + initial_syncs_sent: AtomicUsize, } @@ -91,6 +103,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,6 +115,7 @@ 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), } } @@ -262,16 +278,19 @@ impl PeerManager { match $thing { Ok(x) => x, Err(e) => { - // TODO: Log e.err + println!("Got error handling message: {}!", e.err); if let Some(action) = e.msg { match action { msgs::ErrorAction::UpdateFailHTLC { msg } => { encode_and_send_msg!(msg, 131); continue; }, - msgs::ErrorAction::DisconnectPeer {} => { + msgs::ErrorAction::DisconnectPeer => { return Err(PeerHandleError{ no_connection_possible: false }); }, + msgs::ErrorAction::IgnoreError => { + continue; + }, } } else { return Err(PeerHandleError{ no_connection_possible: false }); @@ -286,6 +305,7 @@ impl PeerManager { match $thing { Ok(x) => x, Err(_e) => { + println!("Error decoding message"); //TODO: Handle e? return Err(PeerHandleError{ no_connection_possible: false }); } @@ -293,6 +313,18 @@ impl PeerManager { } } + 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 => { @@ -307,9 +339,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 => { @@ -355,17 +392,29 @@ impl PeerManager { 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..])); + 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 => { @@ -424,7 +473,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..])); @@ -433,18 +485,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 => {}, } @@ -469,7 +530,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 => { @@ -581,41 +642,59 @@ 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::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; },