respond to Jeff's comments and add node pubkeys to map

Author: arik-so

lightning/src/ln/peer_handler.rs

@@ -108,15 +108,16 @@ enum InitSyncTracker{
 }
 
 enum PeerState {
-	Authenticating(PeerHandshake),
+	Handshake(PeerHandshake),
 	Connected(Conduit),
 }
 
 impl PeerState {
 	fn is_ready_for_encryption(&self) -> bool {
-		match self {
-			&PeerState::Connected(_) => true,
-			_ => false
+		if let &PeerState::Connected(_) = self {
+			true
+		} else {
+			false
 		}
 	}
 }
@@ -282,7 +283,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref> PeerManager<Descriptor, CM> where
 
 		let mut peers = self.peers.lock().unwrap();
 		if peers.peers.insert(descriptor, Peer {
-			encryptor: PeerState::Authenticating(handshake),
+			encryptor: PeerState::Handshake(handshake),
 			outbound: true,
 			their_node_id: Some(their_node_id.clone()),
 			their_features: None,
@@ -317,7 +318,7 @@ impl<Descriptor: SocketDescriptor, CM: Deref> PeerManager<Descriptor, CM> where
 
 		let mut peers = self.peers.lock().unwrap();
 		if peers.peers.insert(descriptor, Peer {
-			encryptor: PeerState::Authenticating(handshake),
+			encryptor: PeerState::Handshake(handshake),
 			outbound: false,
 			their_node_id: None,
 			their_features: None,
@@ -468,9 +469,9 @@ impl<Descriptor: SocketDescriptor, CM: Deref> PeerManager<Descriptor, CM> where
 						let mut conduit_option = None;
 						let mut remote_pubkey_option = None;
 
-						if let &mut PeerState::Authenticating(ref mut handshake) = &mut peer.encryptor {
+						if let &mut PeerState::Handshake(ref mut handshake) = &mut peer.encryptor {
 							let (response, conduit, remote_pubkey) = handshake.process_act(&peer.pending_read_buffer, None).unwrap();
-							peer.pending_read_buffer = Vec::new(); // empty the pending read buffer
+							peer.pending_read_buffer.drain(..); // we read it all
 
 							if let Some(key) = remote_pubkey {
 								remote_pubkey_option = Some(key);
@@ -489,6 +490,19 @@ impl<Descriptor: SocketDescriptor, CM: Deref> PeerManager<Descriptor, CM> where
 						if let Some(conduit) = conduit_option {
 							// Rust 1.22 does not allow assignment in a borrowed context, even if mutable
 							peer.encryptor = PeerState::Connected(conduit);
+
+							// the handshake has finished, so one way or another, we now have their node id
+							match peers.node_id_to_descriptor.entry(peer.their_node_id.unwrap()) {
+								hash_map::Entry::Occupied(_) => {
+									log_trace!(self, "Got second connection with {}, closing", log_pubkey!(peer.their_node_id.unwrap()));
+									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) => {
+									log_trace!(self, "Finished noise handshake for connection with {}", log_pubkey!(peer.their_node_id.unwrap()));
+									entry.insert(peer_descriptor.clone())
+								},
+							};
 						}
 
 						if let &mut PeerState::Connected(ref mut conduit) = &mut peer.encryptor {
@@ -530,12 +544,18 @@ impl<Descriptor: SocketDescriptor, CM: Deref> PeerManager<Descriptor, CM> where
 								}
 							}
 
-							let message_option = conduit.decrypt_single_message(Some(&peer.pending_read_buffer));
-							let msg_data = if let Some(message) = message_option {
-								message
-							} else {
+							let next_message_result = conduit.decrypt(&peer.pending_read_buffer);
+
+							let offset = next_message_result.1;
+							if offset == 0 {
+								// nothing got read
 								break;
-							};
+							}else{
+								peer.pending_read_buffer.drain(0..offset);
+							}
+
+							// something got read, so we definitely have a message
+							let msg_data = next_message_result.0.unwrap();
 
 							let mut reader = ::std::io::Cursor::new(&msg_data[..]);
 							let message_result = wire::read(&mut reader);

lightning/src/ln/peers/conduit.rs

@@ -42,7 +42,7 @@ impl Conduit {
 	}
 
 	pub(super) fn read(&mut self, data: &[u8]) {
-		let mut read_buffer = self.read_buffer.get_or_insert(Vec::new());
+		let read_buffer = self.read_buffer.get_or_insert(Vec::new());
 		read_buffer.extend_from_slice(data);
 	}