X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=33c4050b374dd21fa4eeb3486bb179ae91c85f4e;hb=29bad58ff4fc4c9801761e3e5f71f146fb894b63;hp=b977f791389f2eadade27b0d739539f441341290;hpb=d95f14568b6efbc4722f3d7ee78477328678c052;p=rust-lightning diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs index b977f791..33c4050b 100644 --- a/lightning/src/ln/peer_handler.rs +++ b/lightning/src/ln/peer_handler.rs @@ -30,11 +30,14 @@ use util::events::{MessageSendEvent, MessageSendEventsProvider}; use util::logger::Logger; use routing::network_graph::NetGraphMsgHandler; -use std::collections::{HashMap,hash_map,HashSet,LinkedList}; +use prelude::*; +use alloc::collections::LinkedList; +use std::collections::{HashMap,hash_map,HashSet}; use std::sync::{Arc, Mutex}; -use std::sync::atomic::{AtomicUsize, Ordering}; -use std::{cmp, error, hash, fmt, mem}; -use std::ops::Deref; +use core::sync::atomic::{AtomicUsize, Ordering}; +use core::{cmp, hash, fmt, mem}; +use core::ops::Deref; +use std::error; use bitcoin::hashes::sha256::Hash as Sha256; use bitcoin::hashes::sha256::HashEngine as Sha256Engine; @@ -42,7 +45,7 @@ use bitcoin::hashes::{HashEngine, Hash}; /// A dummy struct which implements `RoutingMessageHandler` without storing any routing information /// or doing any processing. You can provide one of these as the route_handler in a MessageHandler. -struct IgnoringMessageHandler{} +pub struct IgnoringMessageHandler{} impl MessageSendEventsProvider for IgnoringMessageHandler { fn get_and_clear_pending_msg_events(&self) -> Vec { Vec::new() } } @@ -67,7 +70,7 @@ impl Deref for IgnoringMessageHandler { /// A dummy struct which implements `ChannelMessageHandler` without having any channels. /// You can provide one of these as the route_handler in a MessageHandler. -struct ErroringMessageHandler { +pub struct ErroringMessageHandler { message_queue: Mutex> } impl ErroringMessageHandler { @@ -142,6 +145,8 @@ impl ChannelMessageHandler for ErroringMessageHandler { fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &msgs::ChannelReestablish) { ErroringMessageHandler::push_error(self, their_node_id, msg.channel_id); } + // msgs::ChannelUpdate does not contain the channel_id field, so we just drop them. + fn handle_channel_update(&self, _their_node_id: &PublicKey, _msg: &msgs::ChannelUpdate) {} fn peer_disconnected(&self, _their_node_id: &PublicKey, _no_connection_possible: bool) {} fn peer_connected(&self, _their_node_id: &PublicKey, _msg: &msgs::Init) {} fn handle_error(&self, _their_node_id: &PublicKey, _msg: &msgs::ErrorMessage) {} @@ -231,7 +236,6 @@ enum InitSyncTracker{ struct Peer { channel_encryptor: PeerChannelEncryptor, - outbound: bool, their_node_id: Option, their_features: Option, @@ -293,7 +297,7 @@ fn _check_usize_is_32_or_64() { /// lifetimes). Other times you can afford a reference, which is more efficient, in which case /// SimpleRefPeerManager is the more appropriate type. Defining these type aliases prevents /// issues such as overly long function definitions. -pub type SimpleArcPeerManager = Arc, Arc, Arc>>, Arc>>; +pub type SimpleArcPeerManager = PeerManager>, Arc, Arc>>, Arc>; /// SimpleRefPeerManager is a type alias for a PeerManager reference, and is the reference /// counterpart to the SimpleArcPeerManager type alias. Use this type by default when you don't @@ -463,7 +467,6 @@ impl PeerManager PeerManager PeerManager { if peer.pending_read_is_header { @@ -781,6 +786,10 @@ impl PeerManager return Err(PeerHandleError { no_connection_possible: false }), msgs::DecodeError::Io(_) => return Err(PeerHandleError { no_connection_possible: false }), + msgs::DecodeError::UnsupportedCompression => { + log_debug!(self.logger, "We don't support zlib-compressed message fields, ignoring message"); + continue; + } } } }; @@ -852,12 +861,6 @@ impl PeerManager PeerManager { + self.message_handler.chan_handler.handle_channel_update(&peer.their_node_id.unwrap(), &msg); let should_forward = match self.message_handler.route_handler.handle_channel_update(&msg) { Ok(v) => v, Err(e) => { return Err(e.into()); }, @@ -1017,9 +1021,9 @@ impl PeerManager PeerManager { + log_trace!(self.logger, "Handling SendReplyChannelRange event in peer_handler for node {} with num_scids={} first_blocknum={} number_of_blocks={}, sync_complete={}", + log_pubkey!(node_id), + msg.short_channel_ids.len(), + msg.first_blocknum, + msg.number_of_blocks, + msg.sync_complete); + let (mut descriptor, peer) = get_peer_for_forwarding!(node_id, {}); + peer.pending_outbound_buffer.push_back(peer.channel_encryptor.encrypt_message(&encode_msg!(msg))); + self.do_attempt_write_data(&mut descriptor, peer); + } } } @@ -1345,7 +1360,7 @@ impl PeerManager(&self, hasher: &mut H) { + impl core::hash::Hash for FileDescriptor { + fn hash(&self, hasher: &mut H) { self.fd.hash(hasher) } } @@ -1518,11 +1533,11 @@ mod tests { assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1); // peers[0] awaiting_pong is set to true, but the Peer is still connected - peers[0].timer_tick_occured(); + peers[0].timer_tick_occurred(); assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1); - // Since timer_tick_occured() is called again when awaiting_pong is true, all Peers are disconnected - peers[0].timer_tick_occured(); + // Since timer_tick_occurred() is called again when awaiting_pong is true, all Peers are disconnected + peers[0].timer_tick_occurred(); assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 0); }