Make process_onion_failure iterate over Vec

In an upcoming commit, we will need to decrypt error onions constructed
from multiple session_privs. In order to simplify the code legibility,
we move from a single-iteration model to one where we first aggregate
the shared secrets, and then use them for the error decryption.

Author: arik-so

lightning/src/ln/onion_utils.rs

@@ -965,44 +965,48 @@ where
 	}
 	let mut res: Option<FailureLearnings> = None;
 	let mut htlc_msat = *first_hop_htlc_msat;
-	let mut error_code_ret = None;
-	let mut error_packet_ret = None;
+	let mut _error_code_ret = None;
+	let mut _error_packet_ret = None;
 	let mut is_from_final_node = false;
 
 	const BADONION: u16 = 0x8000;
 	const PERM: u16 = 0x4000;
 	const NODE: u16 = 0x2000;
 	const UPDATE: u16 = 0x1000;
 
-	// Handle packed channel/node updates for passing back for the route handler
-	let callback = |shared_secret: SharedSecret,
-	                _,
-	                _,
-	                route_hop_opt: Option<&RouteHop>,
-	                route_hop_idx| {
-		if res.is_some() {
-			return;
-		}
+	let num_blinded_hops = path.blinded_tail.as_ref().map_or(0, |bt| bt.hops.len());
+	let mut onion_keys = Vec::with_capacity(path.hops.len() + num_blinded_hops);
+	construct_onion_keys_generic_callback(
+		secp_ctx,
+		&path.hops,
+		path.blinded_tail.as_ref(),
+		session_priv,
+		|shared_secret, _, _, route_hop_option: Option<&RouteHop>, _| {
+			onion_keys.push((route_hop_option.cloned(), shared_secret))
+		},
+	)
+	.expect("Route we used spontaneously grew invalid keys in the middle of it?");
 
-		let route_hop = match route_hop_opt {
+	// Handle packed channel/node updates for passing back for the route handler
+	for (route_hop_idx, (route_hop_option, shared_secret)) in onion_keys.into_iter().enumerate() {
+		let route_hop = match route_hop_option.as_ref() {
 			Some(hop) => hop,
 			None => {
 				// Got an error from within a blinded route.
-				error_code_ret = Some(BADONION | PERM | 24); // invalid_onion_blinding
-				error_packet_ret = Some(vec![0; 32]);
+				_error_code_ret = Some(BADONION | PERM | 24); // invalid_onion_blinding
+				_error_packet_ret = Some(vec![0; 32]);
 				res = Some(FailureLearnings {
 					network_update: None,
 					short_channel_id: None,
 					payment_failed_permanently: false,
 					failed_within_blinded_path: true,
 				});
-				return;
+				break;
 			},
 		};
 
 		// The failing hop includes either the inbound channel to the recipient or the outbound channel
 		// from the current hop (i.e., the next hop's inbound channel).
-		let num_blinded_hops = path.blinded_tail.as_ref().map_or(0, |bt| bt.hops.len());
 		// For 1-hop blinded paths, the final `path.hops` entry is the recipient.
 		is_from_final_node = route_hop_idx + 1 == path.hops.len() && num_blinded_hops <= 1;
 		let failing_route_hop = if is_from_final_node {
@@ -1014,8 +1018,8 @@ where
 					// The failing hop is within a multi-hop blinded path.
 					#[cfg(not(test))]
 					{
-						error_code_ret = Some(BADONION | PERM | 24); // invalid_onion_blinding
-						error_packet_ret = Some(vec![0; 32]);
+						_error_code_ret = Some(BADONION | PERM | 24); // invalid_onion_blinding
+						_error_packet_ret = Some(vec![0; 32]);
 					}
 					#[cfg(test)]
 					{
@@ -1026,10 +1030,10 @@ where
 							&encrypted_packet.data,
 						))
 						.unwrap();
-						error_code_ret = Some(u16::from_be_bytes(
+						_error_code_ret = Some(u16::from_be_bytes(
 							err_packet.failuremsg.get(0..2).unwrap().try_into().unwrap(),
 						));
-						error_packet_ret = Some(err_packet.failuremsg[2..].to_vec());
+						_error_packet_ret = Some(err_packet.failuremsg[2..].to_vec());
 					}
 
 					res = Some(FailureLearnings {
@@ -1038,7 +1042,7 @@ where
 						payment_failed_permanently: false,
 						failed_within_blinded_path: true,
 					});
-					return;
+					break;
 				},
 			}
 		};
@@ -1053,7 +1057,7 @@ where
 		hmac.input(&encrypted_packet.data[32..]);
 
 		if !fixed_time_eq(&Hmac::from_engine(hmac).to_byte_array(), &encrypted_packet.data[..32]) {
-			return;
+			continue;
 		}
 
 		let err_packet =
@@ -1073,7 +1077,7 @@ where
 						payment_failed_permanently: is_from_final_node,
 						failed_within_blinded_path: false,
 					});
-					return;
+					break;
 				},
 			};
 
@@ -1095,13 +1099,13 @@ where
 					payment_failed_permanently: is_from_final_node,
 					failed_within_blinded_path: false,
 				});
-				return;
+				break;
 			},
 		};
 
 		let error_code = u16::from_be_bytes(error_code_slice.try_into().expect("len is 2"));
-		error_code_ret = Some(error_code);
-		error_packet_ret = Some(err_packet.failuremsg[2..].to_vec());
+		_error_code_ret = Some(error_code);
+		_error_packet_ret = Some(err_packet.failuremsg[2..].to_vec());
 
 		let (debug_field, debug_field_size) = errors::get_onion_debug_field(error_code);
 
@@ -1212,16 +1216,9 @@ where
 				description
 			);
 		}
-	};
 
-	construct_onion_keys_generic_callback(
-		secp_ctx,
-		&path.hops,
-		path.blinded_tail.as_ref(),
-		session_priv,
-		callback,
-	)
-	.expect("Route we used spontaneously grew invalid keys in the middle of it?");
+		break;
+	}
 
 	if let Some(FailureLearnings {
 		network_update,
@@ -1236,9 +1233,9 @@ where
 			payment_failed_permanently,
 			failed_within_blinded_path,
 			#[cfg(any(test, feature = "_test_utils"))]
-			onion_error_code: error_code_ret,
+			onion_error_code: _error_code_ret,
 			#[cfg(any(test, feature = "_test_utils"))]
-			onion_error_data: error_packet_ret,
+			onion_error_data: _error_packet_ret,
 		}
 	} else {
 		// only not set either packet unparseable or hmac does not match with any