X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Fpeer_handler.rs;h=d851d29d46cd80e9d608fb951bc535e0c231649b;hb=9e7c02cd125cba991e1b757a5a59c6d4a230280e;hp=d38afcbacb304620851d92de9eb54f4de813e5c0;hpb=8886d1dc76ce7bd815634c738d114e7d3572c4fe;p=rust-lightning

diff --git a/lightning/src/ln/peer_handler.rs b/lightning/src/ln/peer_handler.rs
index d38afcba..d851d29d 100644
--- a/lightning/src/ln/peer_handler.rs
+++ b/lightning/src/ln/peer_handler.rs
@@ -17,26 +17,26 @@
 
 use bitcoin::secp256k1::{self, Secp256k1, SecretKey, PublicKey};
 
-use ln::features::{InitFeatures, NodeFeatures};
-use ln::msgs;
-use ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
-use ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
-use util::ser::{VecWriter, Writeable, Writer};
-use ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
-use ln::wire;
-use ln::wire::Encode;
-use onion_message::{SimpleArcOnionMessenger, SimpleRefOnionMessenger};
-use routing::gossip::{NetworkGraph, P2PGossipSync};
-use util::atomic_counter::AtomicCounter;
-use util::crypto::sign;
-use util::events::{MessageSendEvent, MessageSendEventsProvider, OnionMessageProvider};
-use util::logger::Logger;
-
-use prelude::*;
-use io;
+use crate::ln::features::{InitFeatures, NodeFeatures};
+use crate::ln::msgs;
+use crate::ln::msgs::{ChannelMessageHandler, LightningError, NetAddress, OnionMessageHandler, RoutingMessageHandler};
+use crate::ln::channelmanager::{SimpleArcChannelManager, SimpleRefChannelManager};
+use crate::util::ser::{VecWriter, Writeable, Writer};
+use crate::ln::peer_channel_encryptor::{PeerChannelEncryptor,NextNoiseStep};
+use crate::ln::wire;
+use crate::ln::wire::Encode;
+use crate::onion_message::{CustomOnionMessageContents, CustomOnionMessageHandler, SimpleArcOnionMessenger, SimpleRefOnionMessenger};
+use crate::routing::gossip::{NetworkGraph, P2PGossipSync};
+use crate::util::atomic_counter::AtomicCounter;
+use crate::util::crypto::sign;
+use crate::util::events::{MessageSendEvent, MessageSendEventsProvider, OnionMessageProvider};
+use crate::util::logger::Logger;
+
+use crate::prelude::*;
+use crate::io;
 use alloc::collections::LinkedList;
-use sync::{Arc, Mutex, MutexGuard, FairRwLock};
-use core::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use crate::sync::{Arc, Mutex, MutexGuard, FairRwLock};
+use core::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use core::{cmp, hash, fmt, mem};
 use core::ops::Deref;
 use core::convert::Infallible;
@@ -95,6 +95,21 @@ impl OnionMessageHandler for IgnoringMessageHandler {
 		InitFeatures::empty()
 	}
 }
+impl CustomOnionMessageHandler for IgnoringMessageHandler {
+	type CustomMessage = Infallible;
+	fn handle_custom_message(&self, _msg: Infallible) {
+		// Since we always return `None` in the read the handle method should never be called.
+		unreachable!();
+	}
+	fn read_custom_message<R: io::Read>(&self, _msg_type: u64, _buffer: &mut R) -> Result<Option<Infallible>, msgs::DecodeError> where Self: Sized {
+		Ok(None)
+	}
+}
+
+impl CustomOnionMessageContents for Infallible {
+	fn tlv_type(&self) -> u64 { unreachable!(); }
+}
+
 impl Deref for IgnoringMessageHandler {
 	type Target = IgnoringMessageHandler;
 	fn deref(&self) -> &Self { self }
@@ -486,7 +501,7 @@ pub type SimpleArcPeerManager<SD, M, T, F, C, L> = PeerManager<SD, Arc<SimpleArc
 /// helps with issues such as long function definitions.
 ///
 /// (C-not exported) as general type aliases don't make sense in bindings.
-pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, SD, M, T, F, C, L> = PeerManager<SD, SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, M, T, F, L>, &'e P2PGossipSync<&'g NetworkGraph<&'f L>, &'h C, &'f L>, &'i SimpleRefOnionMessenger<'j, 'k, L>, &'f L, IgnoringMessageHandler>;
+pub type SimpleRefPeerManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, 'j, 'k, 'l, 'm, SD, M, T, F, C, L> = PeerManager<SD, SimpleRefChannelManager<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'm, M, T, F, L>, &'f P2PGossipSync<&'g NetworkGraph<&'f L>, &'h C, &'f L>, &'i SimpleRefOnionMessenger<'j, 'k, L>, &'f L, IgnoringMessageHandler>;
 
 /// A PeerManager manages a set of peers, described by their [`SocketDescriptor`] and marshalls
 /// socket events into messages which it passes on to its [`MessageHandler`].
@@ -540,7 +555,7 @@ pub struct PeerManager<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: D
 
 	/// Used to track the last value sent in a node_announcement "timestamp" field. We ensure this
 	/// value increases strictly since we don't assume access to a time source.
-	last_node_announcement_serial: AtomicU64,
+	last_node_announcement_serial: AtomicU32,
 
 	our_node_secret: SecretKey,
 	ephemeral_key_midstate: Sha256Engine,
@@ -594,7 +609,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, OM: Deref, L: Deref> PeerManager<D
 	/// minute should suffice.
 	///
 	/// (C-not exported) as we can't export a PeerManager with a dummy route handler
-	pub fn new_channel_only(channel_message_handler: CM, onion_message_handler: OM, our_node_secret: SecretKey, current_time: u64, ephemeral_random_data: &[u8; 32], logger: L) -> Self {
+	pub fn new_channel_only(channel_message_handler: CM, onion_message_handler: OM, our_node_secret: SecretKey, current_time: u32, ephemeral_random_data: &[u8; 32], logger: L) -> Self {
 		Self::new(MessageHandler {
 			chan_handler: channel_message_handler,
 			route_handler: IgnoringMessageHandler{},
@@ -620,7 +635,7 @@ impl<Descriptor: SocketDescriptor, RM: Deref, L: Deref> PeerManager<Descriptor,
 	/// cryptographically secure random bytes.
 	///
 	/// (C-not exported) as we can't export a PeerManager with a dummy channel handler
-	pub fn new_routing_only(routing_message_handler: RM, our_node_secret: SecretKey, current_time: u64, ephemeral_random_data: &[u8; 32], logger: L) -> Self {
+	pub fn new_routing_only(routing_message_handler: RM, our_node_secret: SecretKey, current_time: u32, ephemeral_random_data: &[u8; 32], logger: L) -> Self {
 		Self::new(MessageHandler {
 			chan_handler: ErroringMessageHandler::new(),
 			route_handler: routing_message_handler,
@@ -684,7 +699,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 	/// incremented irregularly internally. In general it is best to simply use the current UNIX
 	/// timestamp, however if it is not available a persistent counter that increases once per
 	/// minute should suffice.
-	pub fn new(message_handler: MessageHandler<CM, RM, OM>, our_node_secret: SecretKey, current_time: u64, ephemeral_random_data: &[u8; 32], logger: L, custom_message_handler: CMH) -> Self {
+	pub fn new(message_handler: MessageHandler<CM, RM, OM>, our_node_secret: SecretKey, current_time: u32, ephemeral_random_data: &[u8; 32], logger: L, custom_message_handler: CMH) -> Self {
 		let mut ephemeral_key_midstate = Sha256::engine();
 		ephemeral_key_midstate.input(ephemeral_random_data);
 
@@ -701,7 +716,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 			our_node_secret,
 			ephemeral_key_midstate,
 			peer_counter: AtomicCounter::new(),
-			last_node_announcement_serial: AtomicU64::new(current_time),
+			last_node_announcement_serial: AtomicU32::new(current_time),
 			logger,
 			custom_message_handler,
 			secp_ctx,
@@ -2001,7 +2016,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 			.or(self.message_handler.onion_message_handler.provided_node_features());
 		let announcement = msgs::UnsignedNodeAnnouncement {
 			features,
-			timestamp: self.last_node_announcement_serial.fetch_add(1, Ordering::AcqRel) as u32,
+			timestamp: self.last_node_announcement_serial.fetch_add(1, Ordering::AcqRel),
 			node_id: PublicKey::from_secret_key(&self.secp_ctx, &self.our_node_secret),
 			rgb, alias, addresses,
 			excess_address_data: Vec::new(),
@@ -2036,17 +2051,17 @@ fn is_gossip_msg(type_id: u16) -> bool {
 
 #[cfg(test)]
 mod tests {
-	use ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler, filter_addresses};
-	use ln::{msgs, wire};
-	use ln::msgs::NetAddress;
-	use util::events;
-	use util::test_utils;
+	use crate::ln::peer_handler::{PeerManager, MessageHandler, SocketDescriptor, IgnoringMessageHandler, filter_addresses};
+	use crate::ln::{msgs, wire};
+	use crate::ln::msgs::NetAddress;
+	use crate::util::events;
+	use crate::util::test_utils;
 
 	use bitcoin::secp256k1::Secp256k1;
 	use bitcoin::secp256k1::{SecretKey, PublicKey};
 
-	use prelude::*;
-	use sync::{Arc, Mutex};
+	use crate::prelude::*;
+	use crate::sync::{Arc, Mutex};
 	use core::sync::atomic::Ordering;
 
 	#[derive(Clone)]