f - use Features::requires_unknown_bits_from

Author: jkczyz

lightning/src/ln/peer_handler.rs

@@ -1346,11 +1346,17 @@ impl<Descriptor: SocketDescriptor, CM: Deref, RM: Deref, OM: Deref, L: Deref, CM
 
 		// Need an Init as first message
 		if let wire::Message::Init(msg) = message {
-			let additional_features = msg.features.clone() - self.init_features(&their_node_id);
-			if additional_features.requires_unknown_bits() {
-				log_debug!(self.logger, "Peer features required unknown version bits");
+			let our_features = self.init_features(&their_node_id);
+			if msg.features.requires_unknown_bits_from(&our_features) {
+				log_debug!(self.logger, "Peer requires features unknown to us");
 				return Err(PeerHandleError { }.into());
 			}
+
+			if our_features.requires_unknown_bits_from(&msg.features) {
+				log_debug!(self.logger, "We require features unknown to our peer");
+				return Err(PeerHandleError { }.into());
+			}
+
 			if peer_lock.their_features.is_some() {
 				return Err(PeerHandleError { }.into());
 			}
@@ -2325,8 +2331,8 @@ mod tests {
 		for i in 0..peer_count {
 			let node_secret = SecretKey::from_slice(&[42 + i as u8; 32]).unwrap();
 			let features = {
-				let mut feature_bits = vec![0u8; 32 + i + 1];
-				feature_bits[32 + i] = 0b00000001;
+				let mut feature_bits = vec![0u8; 33 + i + 1];
+				feature_bits[33 + i] = 0b00000001;
 				InitFeatures::from_le_bytes(feature_bits)
 			};
 			cfgs.push(
@@ -2472,35 +2478,38 @@ mod tests {
 
 	#[test]
 	fn test_incompatible_peers() {
-		let cfgs = create_incompatible_peermgr_cfgs(2);
-		let peers = create_network(2, &cfgs);
-		let peer_a = &peers[0];
-		let peer_b = &peers[1];
+		let cfgs = create_peermgr_cfgs(2);
+		let incompatible_cfgs = create_incompatible_peermgr_cfgs(2);
 
-		let id_a = peer_a.node_signer.get_node_id(Recipient::Node).unwrap();
-		let mut fd_a = FileDescriptor {
-			fd: 1, outbound_data: Arc::new(Mutex::new(Vec::new())),
-			disconnect: Arc::new(AtomicBool::new(false)),
-		};
-		let addr_a = NetAddress::IPv4{addr: [127, 0, 0, 1], port: 1000};
-		let mut fd_b = FileDescriptor {
-			fd: 1, outbound_data: Arc::new(Mutex::new(Vec::new())),
-			disconnect: Arc::new(AtomicBool::new(false)),
-		};
-		let addr_b = NetAddress::IPv4{addr: [127, 0, 0, 1], port: 1001};
-		let initial_data = peer_b.new_outbound_connection(id_a, fd_b.clone(), Some(addr_a.clone())).unwrap();
-		peer_a.new_inbound_connection(fd_a.clone(), Some(addr_b.clone())).unwrap();
-		assert_eq!(peer_a.read_event(&mut fd_a, &initial_data).unwrap(), false);
-		peer_a.process_events();
+		let peers = create_network(2, &cfgs);
+		let incompatible_peers = create_network(2, &incompatible_cfgs);
+		let peer_pairs = [(&peers[0], &incompatible_peers[0]), (&incompatible_peers[1], &peers[1])];
+		for (peer_a, peer_b) in peer_pairs {
+			let id_a = peer_a.node_signer.get_node_id(Recipient::Node).unwrap();
+			let mut fd_a = FileDescriptor {
+				fd: 1, outbound_data: Arc::new(Mutex::new(Vec::new())),
+				disconnect: Arc::new(AtomicBool::new(false)),
+			};
+			let addr_a = NetAddress::IPv4{addr: [127, 0, 0, 1], port: 1000};
+			let mut fd_b = FileDescriptor {
+				fd: 1, outbound_data: Arc::new(Mutex::new(Vec::new())),
+				disconnect: Arc::new(AtomicBool::new(false)),
+			};
+			let addr_b = NetAddress::IPv4{addr: [127, 0, 0, 1], port: 1001};
+			let initial_data = peer_b.new_outbound_connection(id_a, fd_b.clone(), Some(addr_a.clone())).unwrap();
+			peer_a.new_inbound_connection(fd_a.clone(), Some(addr_b.clone())).unwrap();
+			assert_eq!(peer_a.read_event(&mut fd_a, &initial_data).unwrap(), false);
+			peer_a.process_events();
 
-		let a_data = fd_a.outbound_data.lock().unwrap().split_off(0);
-		assert_eq!(peer_b.read_event(&mut fd_b, &a_data).unwrap(), false);
+			let a_data = fd_a.outbound_data.lock().unwrap().split_off(0);
+			assert_eq!(peer_b.read_event(&mut fd_b, &a_data).unwrap(), false);
 
-		peer_b.process_events();
-		let b_data = fd_b.outbound_data.lock().unwrap().split_off(0);
+			peer_b.process_events();
+			let b_data = fd_b.outbound_data.lock().unwrap().split_off(0);
 
-		// Should fail because of unknown required features
-		assert!(peer_a.read_event(&mut fd_a, &b_data).is_err());
+			// Should fail because of unknown required features
+			assert!(peer_a.read_event(&mut fd_a, &b_data).is_err());
+		}
 	}
 
 	#[test]