X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fpeer_handler.rs;h=20faf2500b8ed40e911f018edba75b34828c28a4;hb=fe90e13f841548f2be0594854216c85889e71584;hp=3122e572e57fafcbd90e1c08c6c10b146d152c29;hpb=a1aaea5dc295df82fb73a4c1a998331f9e7ede4d;p=rust-lightning diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs index 3122e572..20faf250 100644 --- a/src/ln/peer_handler.rs +++ b/src/ln/peer_handler.rs @@ -1,13 +1,13 @@ use secp256k1::key::{SecretKey,PublicKey}; use ln::msgs; -use ln::msgs::{MsgEncodable,MsgDecodable}; +use util::ser::{Writeable, Writer, Readable}; 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::collections::{HashMap,hash_map,LinkedList}; use std::sync::{Arc, Mutex}; use std::sync::atomic::{AtomicUsize, Ordering}; use std::{cmp,error,mem,hash,fmt}; @@ -90,6 +90,18 @@ struct PeerHolder { /// Only add to this set when noise completes: node_id_to_descriptor: HashMap, } +struct MutPeerHolder<'a, Descriptor: SocketDescriptor + 'a> { + peers: &'a mut HashMap, + node_id_to_descriptor: &'a mut HashMap, +} +impl PeerHolder { + fn borrow_parts(&mut self) -> MutPeerHolder { + MutPeerHolder { + peers: &mut self.peers, + node_id_to_descriptor: &mut self.node_id_to_descriptor, + } + } +} pub struct PeerManager { message_handler: MessageHandler, @@ -100,17 +112,24 @@ pub struct PeerManager { logger: Arc, } +struct VecWriter(Vec); +impl Writer for VecWriter { + fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> { + self.0.extend_from_slice(buf); + Ok(()) + } + fn size_hint(&mut self, size: usize) { + self.0.reserve_exact(size); + } +} macro_rules! encode_msg { - ($msg: expr, $msg_code: expr) => { - { - let just_msg = $msg.encode(); - let mut encoded_msg = Vec::with_capacity(just_msg.len() + 2); - encoded_msg.extend_from_slice(&byte_utils::be16_to_array($msg_code)); - encoded_msg.extend_from_slice(&just_msg[..]); - encoded_msg - } - } + ($msg: expr, $msg_code: expr) => {{ + let mut msg = VecWriter(Vec::new()); + ($msg_code as u16).write(&mut msg).unwrap(); + $msg.write(&mut msg).unwrap(); + msg.0 + }} } //TODO: Really should do something smarter for this @@ -136,7 +155,12 @@ impl PeerManager { /// 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() + peers.peers.values().filter_map(|p| { + if !p.channel_encryptor.is_ready_for_encryption() || p.their_global_features.is_none() { + return None; + } + p.their_node_id + }).collect() } /// Indicates a new outbound connection has been established to a node with the given node_id. @@ -267,14 +291,14 @@ impl PeerManager { fn do_read_event(&self, peer_descriptor: &mut Descriptor, data: Vec) -> Result { let pause_read = { - let mut peers = self.peers.lock().unwrap(); - let (should_insert_node_id, pause_read) = match peers.peers.get_mut(peer_descriptor) { + let mut peers_lock = self.peers.lock().unwrap(); + let peers = peers_lock.borrow_parts(); + let pause_read = match peers.peers.get_mut(peer_descriptor) { None => panic!("Descriptor for read_event is not already known to PeerManager"), Some(peer) => { assert!(peer.pending_read_buffer.len() > 0); assert!(peer.pending_read_buffer.len() > peer.pending_read_buffer_pos); - let mut insert_node_id = None; let mut read_pos = 0; while read_pos < data.len() { { @@ -347,12 +371,26 @@ impl PeerManager { continue; }, msgs::DecodeError::BadLengthDescriptor => return Err(PeerHandleError{ no_connection_possible: false }), + msgs::DecodeError::Io(_) => return Err(PeerHandleError{ no_connection_possible: false }), + msgs::DecodeError::InvalidValue => panic!("should not happen with message decoding"), } } }; } } + macro_rules! insert_node_id { + () => { + match peers.node_id_to_descriptor.entry(peer.their_node_id.unwrap()) { + hash_map::Entry::Occupied(_) => { + 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) => entry.insert(peer_descriptor.clone()), + }; + } + } + let next_step = peer.channel_encryptor.get_noise_step(); match next_step { NextNoiseStep::ActOne => { @@ -366,7 +404,7 @@ impl PeerManager { peer.pending_read_buffer = [0; 18].to_vec(); // Message length header is 18 bytes peer.pending_read_is_header = true; - insert_node_id = Some(peer.their_node_id.unwrap()); + insert_node_id!(); 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); @@ -382,7 +420,7 @@ impl PeerManager { 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 = Some(peer.their_node_id.unwrap()); + insert_node_id!(); }, NextNoiseStep::NoiseComplete => { if peer.pending_read_is_header { @@ -407,16 +445,38 @@ impl PeerManager { // Need an init message as first message return Err(PeerHandleError{ no_connection_possible: false }); } + let mut reader = ::std::io::Cursor::new(&msg_data[2..]); match msg_type { // Connection control: 16 => { - let msg = try_potential_decodeerror!(msgs::Init::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::Init::read(&mut reader)); if msg.global_features.requires_unknown_bits() { + log_info!(self, "Peer global features required unknown version bits"); return Err(PeerHandleError{ no_connection_possible: true }); } if msg.local_features.requires_unknown_bits() { + log_info!(self, "Peer local features required unknown version bits"); return Err(PeerHandleError{ no_connection_possible: true }); } + if msg.local_features.requires_data_loss_protect() { + log_info!(self, "Peer local features required data_loss_protect"); + return Err(PeerHandleError{ no_connection_possible: true }); + } + if msg.local_features.requires_upfront_shutdown_script() { + log_info!(self, "Peer local features required upfront_shutdown_script"); + return Err(PeerHandleError{ no_connection_possible: true }); + } + if peer.their_global_features.is_some() { + return Err(PeerHandleError{ no_connection_possible: false }); + } + + log_info!(self, "Received peer Init message: data_loss_protect: {}, initial_routing_sync: {}, upfront_shutdown_script: {}, unkown local flags: {}, unknown global flags: {}", + if msg.local_features.supports_data_loss_protect() { "supported" } else { "not supported"}, + if msg.local_features.initial_routing_sync() { "requested" } else { "not requested" }, + if msg.local_features.supports_upfront_shutdown_script() { "supported" } else { "not supported"}, + if msg.local_features.supports_unknown_bits() { "present" } else { "none" }, + if msg.global_features.supports_unknown_bits() { "present" } else { "none" }); + peer.their_global_features = Some(msg.global_features); peer.their_local_features = Some(msg.local_features); @@ -431,9 +491,13 @@ impl PeerManager { local_features, }, 16); } + + for msg in self.message_handler.chan_handler.peer_connected(&peer.their_node_id.unwrap()) { + encode_and_send_msg!(msg, 136); + } }, 17 => { - let msg = try_potential_decodeerror!(msgs::ErrorMessage::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::ErrorMessage::read(&mut reader)); let mut data_is_printable = true; for b in msg.data.bytes() { if b < 32 || b > 126 { @@ -454,38 +518,38 @@ impl PeerManager { }, 18 => { - let msg = try_potential_decodeerror!(msgs::Ping::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::Ping::read(&mut reader)); 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..])); + try_potential_decodeerror!(msgs::Pong::read(&mut reader)); }, // Channel control: 32 => { - let msg = try_potential_decodeerror!(msgs::OpenChannel::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::OpenChannel::read(&mut reader)); let resp = try_potential_handleerror!(self.message_handler.chan_handler.handle_open_channel(&peer.their_node_id.unwrap(), &msg)); encode_and_send_msg!(resp, 33); }, 33 => { - let msg = try_potential_decodeerror!(msgs::AcceptChannel::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::AcceptChannel::read(&mut reader)); try_potential_handleerror!(self.message_handler.chan_handler.handle_accept_channel(&peer.their_node_id.unwrap(), &msg)); }, 34 => { - let msg = try_potential_decodeerror!(msgs::FundingCreated::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::FundingCreated::read(&mut reader)); let resp = try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_created(&peer.their_node_id.unwrap(), &msg)); encode_and_send_msg!(resp, 35); }, 35 => { - let msg = try_potential_decodeerror!(msgs::FundingSigned::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::FundingSigned::read(&mut reader)); try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_signed(&peer.their_node_id.unwrap(), &msg)); }, 36 => { - let msg = try_potential_decodeerror!(msgs::FundingLocked::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::FundingLocked::read(&mut reader)); let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_funding_locked(&peer.their_node_id.unwrap(), &msg)); match resp_option { Some(resp) => encode_and_send_msg!(resp, 259), @@ -494,7 +558,7 @@ impl PeerManager { }, 38 => { - let msg = try_potential_decodeerror!(msgs::Shutdown::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::Shutdown::read(&mut reader)); let resp_options = try_potential_handleerror!(self.message_handler.chan_handler.handle_shutdown(&peer.their_node_id.unwrap(), &msg)); if let Some(resp) = resp_options.0 { encode_and_send_msg!(resp, 38); @@ -504,7 +568,7 @@ impl PeerManager { } }, 39 => { - let msg = try_potential_decodeerror!(msgs::ClosingSigned::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::ClosingSigned::read(&mut reader)); let resp_option = try_potential_handleerror!(self.message_handler.chan_handler.handle_closing_signed(&peer.their_node_id.unwrap(), &msg)); if let Some(resp) = resp_option { encode_and_send_msg!(resp, 39); @@ -512,27 +576,27 @@ impl PeerManager { }, 128 => { - let msg = try_potential_decodeerror!(msgs::UpdateAddHTLC::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::UpdateAddHTLC::read(&mut reader)); try_potential_handleerror!(self.message_handler.chan_handler.handle_update_add_htlc(&peer.their_node_id.unwrap(), &msg)); }, 130 => { - let msg = try_potential_decodeerror!(msgs::UpdateFulfillHTLC::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::UpdateFulfillHTLC::read(&mut reader)); try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fulfill_htlc(&peer.their_node_id.unwrap(), &msg)); }, 131 => { - let msg = try_potential_decodeerror!(msgs::UpdateFailHTLC::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::UpdateFailHTLC::read(&mut reader)); 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..])); + let msg = try_potential_decodeerror!(msgs::UpdateFailMalformedHTLC::read(&mut reader)); try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fail_malformed_htlc(&peer.their_node_id.unwrap(), &msg)); }, 132 => { - let msg = try_potential_decodeerror!(msgs::CommitmentSigned::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::CommitmentSigned::read(&mut reader)); 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 { @@ -540,7 +604,7 @@ impl PeerManager { } }, 133 => { - let msg = try_potential_decodeerror!(msgs::RevokeAndACK::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::RevokeAndACK::read(&mut reader)); 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) => { @@ -559,18 +623,42 @@ impl PeerManager { } }, 134 => { - let msg = try_potential_decodeerror!(msgs::UpdateFee::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::UpdateFee::read(&mut reader)); try_potential_handleerror!(self.message_handler.chan_handler.handle_update_fee(&peer.their_node_id.unwrap(), &msg)); }, - 136 => { }, // TODO: channel_reestablish + 136 => { + let msg = try_potential_decodeerror!(msgs::ChannelReestablish::read(&mut reader)); + let (funding_locked, revoke_and_ack, commitment_update) = try_potential_handleerror!(self.message_handler.chan_handler.handle_channel_reestablish(&peer.their_node_id.unwrap(), &msg)); + if let Some(lock_msg) = funding_locked { + encode_and_send_msg!(lock_msg, 36); + } + if let Some(revoke_msg) = revoke_and_ack { + encode_and_send_msg!(revoke_msg, 133); + } + match commitment_update { + Some(resps) => { + for resp in resps.update_add_htlcs { + encode_and_send_msg!(resp, 128); + } + 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 => {}, + } + }, // Routing control: 259 => { - let msg = try_potential_decodeerror!(msgs::AnnouncementSignatures::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::AnnouncementSignatures::read(&mut reader)); try_potential_handleerror!(self.message_handler.chan_handler.handle_announcement_signatures(&peer.their_node_id.unwrap(), &msg)); }, 256 => { - let msg = try_potential_decodeerror!(msgs::ChannelAnnouncement::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::ChannelAnnouncement::read(&mut reader)); let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_announcement(&msg)); if should_forward { @@ -578,7 +666,7 @@ impl PeerManager { } }, 257 => { - let msg = try_potential_decodeerror!(msgs::NodeAnnouncement::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::NodeAnnouncement::read(&mut reader)); let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_node_announcement(&msg)); if should_forward { @@ -586,7 +674,7 @@ impl PeerManager { } }, 258 => { - let msg = try_potential_decodeerror!(msgs::ChannelUpdate::decode(&msg_data[2..])); + let msg = try_potential_decodeerror!(msgs::ChannelUpdate::read(&mut reader)); let should_forward = try_potential_handleerror!(self.message_handler.route_handler.handle_channel_update(&msg)); if should_forward { @@ -607,15 +695,10 @@ impl PeerManager { Self::do_attempt_write_data(peer_descriptor, peer); - (insert_node_id /* should_insert_node_id */, peer.pending_outbound_buffer.len() > 10) // pause_read + peer.pending_outbound_buffer.len() > 10 // pause_read } }; - match should_insert_node_id { - Some(node_id) => { peers.node_id_to_descriptor.insert(node_id, peer_descriptor.clone()); }, - None => {} - }; - pause_read };