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};
/// 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<u8>, 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
pending_events: Mutex<Vec<Event>>,
our_node_secret: SecretKey,
initial_syncs_sent: AtomicUsize,
+ logger: Arc<Logger>,
}
/// 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<Descriptor: SocketDescriptor> PeerManager<Descriptor> {
- pub fn new(message_handler: MessageHandler, our_node_secret: SecretKey) -> PeerManager<Descriptor> {
+ pub fn new(message_handler: MessageHandler, our_node_secret: SecretKey, logger: Arc<Logger>) -> PeerManager<Descriptor> {
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<PublicKey> {
+ 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.
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)[..]));
+ }
}
}
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 => {
+ msgs::ErrorAction::DisconnectPeer { msg: _ } => {
+ //TODO: Try to push msg
+ log_trace!(self, "Got Err handling message, disconnecting peer because {}", e.err);
return Err(PeerHandleError{ no_connection_possible: false });
},
msgs::ErrorAction::IgnoreError => {
+ log_trace!(self, "Got Err handling message, ignoring because {}", e.err);
+ continue;
+ },
+ msgs::ErrorAction::SendErrorMessage { msg } => {
+ log_trace!(self, "Got Err handling message, sending Error message because {}", e.err);
+ encode_and_send_msg!(msg, 17);
continue;
},
}
} else {
+ log_debug!(self, "Got Err handling message, action not yet filled in: {}", e.err);
return Err(PeerHandleError{ no_connection_possible: false });
}
}
match $thing {
Ok(x) => x,
Err(_e) => {
- println!("Error decoding message");
//TODO: Handle e?
return Err(PeerHandleError{ no_connection_possible: false });
}
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;
}
};
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 });
}
},
17 => {
- // Error msg
+ let msg = try_potential_decodeerror!(msgs::ErrorMessage::decode(&msg_data[2..]));
+ let mut data_is_printable = true;
+ for b in msg.data.bytes() {
+ if b < 32 || b > 126 {
+ data_is_printable = false;
+ break;
+ }
+ }
+
+ if data_is_printable {
+ log_debug!(self, "Got Err message from {}: {}", log_pubkey!(peer.their_node_id.unwrap()), msg.data);
+ } else {
+ log_debug!(self, "Got Err message from {} with non-ASCII error message", log_pubkey!(peer.their_node_id.unwrap()));
+ }
+ self.message_handler.chan_handler.handle_error(&peer.their_node_id.unwrap(), &msg);
+ if msg.channel_id == [0; 32] {
+ return Err(PeerHandleError{ no_connection_possible: true });
+ }
},
18 => {
};
match peers.peers.get_mut(&descriptor) {
Some(peer) => {
+ if peer.their_global_features.is_none() {
+ $handle_no_such_peer;
+ continue;
+ }
(descriptor, peer)
},
None => panic!("Inconsistent peers set state!"),
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)
});
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
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
});
Self::do_attempt_write_data(&mut descriptor, peer);
continue;
},
- Event::SendHTLCs { ref node_id, ref msgs, ref commitment_msg } => {
+ Event::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref commitment_signed } } => {
+ log_trace!(self, "Handling UpdateHTLCs event in peer_handler for node {} with {} adds, {} fulfills, {} fails for channel {}",
+ log_pubkey!(node_id),
+ update_add_htlcs.len(),
+ update_fulfill_htlcs.len(),
+ update_fail_htlcs.len(),
+ log_bytes!(commitment_signed.channel_id));
let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {
//TODO: Do whatever we're gonna do for handling dropped messages
});
- for msg in msgs {
+ for msg in update_add_htlcs {
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 128)));
}
- 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::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)));
+ for msg in update_fulfill_htlcs {
+ peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg, 130)));
+ }
+ for msg in update_fail_htlcs {
+ 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_signed, 132)));
Self::do_attempt_write_data(&mut descriptor, peer);
continue;
},
- Event::SendFailHTLC { ref node_id, ref msg, ref commitment_msg } => {
+ 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, 131)));
- peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(commitment_msg, 132)));
+ 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);
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
- if !peer.channel_encryptor.is_ready_for_encryption() {
+ if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_global_features.is_none() {
continue
}
match peer.their_node_id {
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);
for (ref descriptor, ref mut peer) in peers.peers.iter_mut() {
- if !peer.channel_encryptor.is_ready_for_encryption() {
+ if !peer.channel_encryptor.is_ready_for_encryption() || peer.their_global_features.is_none() {
continue
}
peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encoded_msg[..]));
}
continue;
},
+ Event::HandleError { ref node_id, ref action } => {
+ if let Some(ref action) = *action {
+ match *action {
+ 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);
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<u8>, 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<PeerManager<FileDescriptor>> {
+ let secp_ctx = Secp256k1::new();
+ let mut peers = Vec::new();
+ let mut rng = thread_rng();
+ let logger : Arc<Logger> = 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<FileDescriptor>, peer_b: &PeerManager<FileDescriptor>) {
+ 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);
+ }
+}