fixup

Author: adi2011

lightning/src/ln/channelmanager.rs

@@ -8230,74 +8230,50 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
 		}
 	}
 
-	fn internal_peer_storage_retrieval(&self, counterparty_node_id: PublicKey, _msg: msgs::PeerStorageRetrieval) {
+	fn internal_peer_storage_retrieval(&self, counterparty_node_id: PublicKey, _msg: msgs::PeerStorageRetrieval) -> Result<(), MsgHandleErrInternal> {
 		// TODO: Decrypt and check if have any stale or missing ChannelMonitor.
-		let per_peer_state = self.per_peer_state.read().unwrap();
-		let peer_state_mutex = match per_peer_state.get(&counterparty_node_id) {
-			Some(peer_state_mutex) => peer_state_mutex,
-			None => return,
-		};
-		let mut peer_state_lock = peer_state_mutex.lock().unwrap();
-		let peer_state = &mut *peer_state_lock;
 		let logger = WithContext::from(&self.logger, Some(counterparty_node_id), None, None);
 
 		log_debug!(logger, "Received unexpected peer_storage_retrieval from {}. This is unusual since we do not yet distribute peer storage. Sending a warning.", log_pubkey!(counterparty_node_id));
-		peer_state.pending_msg_events.push(events::MessageSendEvent::HandleError {
-			node_id: counterparty_node_id.clone(),
-			action: msgs::ErrorAction::SendWarningMessage {
-				msg: msgs::WarningMessage {
-					channel_id: ChannelId([0; 32]),
-					data: "Invalid peer_storage_retrieval message received.".to_owned()
-				},
-				log_level: Level::Trace,
-			}
-		});
+
+		Err(MsgHandleErrInternal::from_chan_no_close(ChannelError::Warn(
+			format!("Invalid peer_storage_retrieval message received.")
+		), ChannelId([0; 32])))
 	}
 
-	fn internal_peer_storage(&self, counterparty_node_id: PublicKey, msg: msgs::PeerStorage) {
+	fn internal_peer_storage(&self, counterparty_node_id: PublicKey, msg: msgs::PeerStorage) -> Result<(), MsgHandleErrInternal> {
 		let per_peer_state = self.per_peer_state.read().unwrap();
-		let peer_state_mutex = match per_peer_state.get(&counterparty_node_id) {
-			Some(peer_state_mutex) => peer_state_mutex,
-			None => return,
-		};
+		let peer_state_mutex = per_peer_state.get(&counterparty_node_id)
+			.ok_or_else(|| {
+				debug_assert!(false);
+				MsgHandleErrInternal::send_err_msg_no_close(format!("Can't find a peer matching the passed counterparty node_id {}", counterparty_node_id), ChannelId([0; 32]))
+			})?;
+
 		let mut peer_state_lock = peer_state_mutex.lock().unwrap();
 		let peer_state = &mut *peer_state_lock;
 		let logger = WithContext::from(&self.logger, Some(counterparty_node_id), None, None);
 
 		// Check if we have any channels with the peer (Currently we only provide the service to peers we have a channel with).
 		if !peer_state.channel_by_id.values().any(|phase| phase.is_funded()) {
 			log_debug!(logger, "Ignoring peer storage request from {} as we don't have any funded channels with them.", log_pubkey!(counterparty_node_id));
-			peer_state.pending_msg_events.push(events::MessageSendEvent::HandleError {
-				node_id: counterparty_node_id.clone(),
-				action: msgs::ErrorAction::SendWarningMessage {
-					msg: msgs::WarningMessage {
-						channel_id: ChannelId([0; 32]),
-						data: "Ignoring peer_storage message, as peer storage is currently supported only for peers with an active funded channel.".to_owned()
-					},
-					log_level: Level::Trace,
-				}
-			});
-			return;
+			return Err(MsgHandleErrInternal::from_chan_no_close(ChannelError::Warn(
+				format!("Ignoring peer_storage message, as peer storage is currently supported only for peers with an active funded channel.")
+			), ChannelId([0; 32])));
 		}
 
 		#[cfg(not(test))]
 		if msg.data.len() > MAX_PEER_STORAGE_SIZE {
 			log_debug!(logger, "Sending warning to peer and ignoring peer storage request from {} as its over 1KiB", log_pubkey!(counterparty_node_id));
-			peer_state.pending_msg_events.push(events::MessageSendEvent::HandleError {
-				node_id: counterparty_node_id.clone(),
-				action: msgs::ErrorAction::SendWarningMessage {
-					msg: msgs::WarningMessage {
-						channel_id: ChannelId([0; 32]),
-						data: format!("Supports only data up to {} bytes in peer storage.", MAX_PEER_STORAGE_SIZE)
-					},
-					log_level: Level::Trace,
-				}
-			});
-			return;
+
+			return Err(MsgHandleErrInternal::from_chan_no_close(ChannelError::Warn(
+				format!("Supports only data up to {} bytes in peer storage.", MAX_PEER_STORAGE_SIZE)
+			), ChannelId([0; 32])));
 		}
 
 		log_trace!(logger, "Received peer_storage from {}", log_pubkey!(counterparty_node_id));
 		peer_state.peer_storage = msg.data;
+
+		Ok(())
 	}
 
 	fn internal_funding_signed(&self, counterparty_node_id: &PublicKey, msg: &msgs::FundingSigned) -> Result<(), MsgHandleErrInternal> {
@@ -11498,12 +11474,12 @@ where
 
 	fn handle_peer_storage(&self, counterparty_node_id: PublicKey, msg: msgs::PeerStorage) {
 		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || NotifyOption::SkipPersistNoEvents);
-		self.internal_peer_storage(counterparty_node_id, msg);
+		let _ = handle_error!(self, self.internal_peer_storage(counterparty_node_id, msg), counterparty_node_id);
 	}
 
 	fn handle_peer_storage_retrieval(&self, counterparty_node_id: PublicKey, msg: msgs::PeerStorageRetrieval) {
 		let _persistence_guard = PersistenceNotifierGuard::optionally_notify(self, || NotifyOption::SkipPersistNoEvents);
-		self.internal_peer_storage_retrieval(counterparty_node_id, msg);
+		let _ = handle_error!(self, self.internal_peer_storage_retrieval(counterparty_node_id, msg), counterparty_node_id);
 	}
 
 	fn handle_channel_ready(&self, counterparty_node_id: PublicKey, msg: &msgs::ChannelReady) {