Skip to content

Commit 942942f

Browse files
committed
Drop the remaining direct uses of locked_close_channel
While most of our closure logic mostly lives in `locked_close_chan`, some important steps happen in `convert_channel_err` and `handle_error` (mostly broadcasting a channel closure `ChannelUpdate` and sending a relevant error message to our peer). In a previous commit we removed most instances of `locked_close_channel` in our closure pipeline, however it was still called in cases where we did a cooperative close. Here we remove the remaining direct references to it, always using `convert_channel_err` instead (now with a new `COOP_CLOSED` macro variant).
1 parent e3cf4b0 commit 942942f

File tree

1 file changed

+50
-54
lines changed

1 file changed

+50
-54
lines changed

lightning/src/ln/channelmanager.rs

Lines changed: 50 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -3242,6 +3242,23 @@ macro_rules! convert_channel_err {
32423242
},
32433243
}
32443244
};
3245+
($self: ident, $peer_state: expr, $shutdown_result: expr, $funded_channel: expr, $channel_id: expr, COOP_CLOSED) => { {
3246+
let reason = ChannelError::Close(("Coop Closed".to_owned(), $shutdown_result.closure_reason.clone()));
3247+
let do_close = |_| {
3248+
(
3249+
$shutdown_result,
3250+
$self.get_channel_update_for_broadcast(&$funded_channel).ok(),
3251+
)
3252+
};
3253+
let mut locked_close = |shutdown_res_mut: &mut ShutdownResult, funded_channel: &mut FundedChannel<_>| {
3254+
locked_close_channel!($self, $peer_state, funded_channel, shutdown_res_mut, FUNDED);
3255+
};
3256+
let (close, mut err) =
3257+
convert_channel_err!($self, $peer_state, reason, $funded_channel, do_close, locked_close, $channel_id, _internal);
3258+
err.dont_send_error_message();
3259+
debug_assert!(close);
3260+
(close, err)
3261+
} };
32453262
($self: ident, $peer_state: expr, $err: expr, $funded_channel: expr, $channel_id: expr, FUNDED_CHANNEL) => { {
32463263
let mut do_close = |reason| {
32473264
(
@@ -9283,13 +9300,14 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
92839300
msg.channel_id,
92849301
)
92859302
})?;
9286-
let (tx, chan_option, shutdown_result) = {
9303+
let logger;
9304+
let tx_err: Option<(_, Result<Infallible, _>)> = {
92879305
let mut peer_state_lock = peer_state_mutex.lock().unwrap();
92889306
let peer_state = &mut *peer_state_lock;
92899307
match peer_state.channel_by_id.entry(msg.channel_id.clone()) {
92909308
hash_map::Entry::Occupied(mut chan_entry) => {
92919309
if let Some(chan) = chan_entry.get_mut().as_funded_mut() {
9292-
let logger = WithChannelContext::from(&self.logger, &chan.context, None);
9310+
logger = WithChannelContext::from(&self.logger, &chan.context, None);
92939311
let res = chan.closing_signed(&self.fee_estimator, &msg, &&logger);
92949312
let (closing_signed, tx_shutdown_result) =
92959313
try_channel_entry!(self, peer_state, res, chan_entry);
@@ -9300,16 +9318,17 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
93009318
msg,
93019319
});
93029320
}
9303-
if let Some((tx, mut close_res)) = tx_shutdown_result {
9321+
if let Some((tx, close_res)) = tx_shutdown_result {
93049322
// We're done with this channel, we've got a signed closing transaction and
93059323
// will send the closing_signed back to the remote peer upon return. This
93069324
// also implies there are no pending HTLCs left on the channel, so we can
93079325
// fully delete it from tracking (the channel monitor is still around to
93089326
// watch for old state broadcasts)!
9309-
locked_close_channel!(self, peer_state, chan, close_res, FUNDED);
9310-
(Some(tx), Some(chan_entry.remove()), Some(close_res))
9327+
let (_, err) = convert_channel_err!(self, peer_state, close_res, chan, &msg.channel_id, COOP_CLOSED);
9328+
chan_entry.remove();
9329+
Some((tx, Err(err)))
93119330
} else {
9312-
(None, None, None)
9331+
None
93139332
}
93149333
} else {
93159334
return try_channel_entry!(self, peer_state, Err(ChannelError::close(
@@ -9319,26 +9338,15 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
93199338
hash_map::Entry::Vacant(_) => return Err(MsgHandleErrInternal::send_err_msg_no_close(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", counterparty_node_id), msg.channel_id))
93209339
}
93219340
};
9322-
if let Some(broadcast_tx) = tx {
9323-
let channel_id = chan_option.as_ref().map(|channel| channel.context().channel_id());
9341+
mem::drop(per_peer_state);
9342+
if let Some((broadcast_tx, err)) = tx_err {
93249343
log_info!(
9325-
WithContext::from(&self.logger, Some(*counterparty_node_id), channel_id, None),
9344+
logger,
93269345
"Broadcasting {}",
93279346
log_tx!(broadcast_tx)
93289347
);
93299348
self.tx_broadcaster.broadcast_transactions(&[&broadcast_tx]);
9330-
}
9331-
if let Some(chan) = chan_option.as_ref().and_then(Channel::as_funded) {
9332-
if let Ok(update) = self.get_channel_update_for_broadcast(chan) {
9333-
let mut pending_broadcast_messages =
9334-
self.pending_broadcast_messages.lock().unwrap();
9335-
pending_broadcast_messages
9336-
.push(MessageSendEvent::BroadcastChannelUpdate { msg: update });
9337-
}
9338-
}
9339-
mem::drop(per_peer_state);
9340-
if let Some(shutdown_result) = shutdown_result {
9341-
self.finish_close_channel(shutdown_result);
9349+
let _ = handle_error!(self, err, *counterparty_node_id);
93429350
}
93439351
Ok(())
93449352
}
@@ -10433,12 +10441,6 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
1043310441
if let Some(broadcast_tx) = msgs.signed_closing_tx {
1043410442
log_info!(logger, "Broadcasting closing tx {}", log_tx!(broadcast_tx));
1043510443
self.tx_broadcaster.broadcast_transactions(&[&broadcast_tx]);
10436-
10437-
if let Ok(update) = self.get_channel_update_for_broadcast(&funded_chan) {
10438-
pending_msg_events.push(MessageSendEvent::BroadcastChannelUpdate {
10439-
msg: update
10440-
});
10441-
}
1044210444
}
1044310445
} else {
1044410446
// We don't know how to handle a channel_ready or signed_closing_tx for a
@@ -10452,40 +10454,45 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
1045210454
}
1045310455
};
1045410456

10455-
let mut shutdown_results = Vec::new();
10457+
let mut shutdown_results: Vec<(Result<Infallible, _>, _)> = Vec::new();
1045610458
let per_peer_state = self.per_peer_state.read().unwrap();
1045710459
let per_peer_state_iter = per_peer_state.iter().filter(|(cp_id, _)| {
1045810460
if let Some((counterparty_node_id, _)) = channel_opt {
1045910461
**cp_id == counterparty_node_id
1046010462
} else { true }
1046110463
});
10462-
for (_cp_id, peer_state_mutex) in per_peer_state_iter {
10464+
for (cp_id, peer_state_mutex) in per_peer_state_iter {
1046310465
let mut peer_state_lock = peer_state_mutex.lock().unwrap();
1046410466
let peer_state = &mut *peer_state_lock;
1046510467
peer_state.channel_by_id.retain(|_, chan| {
1046610468
let shutdown_result = match channel_opt {
1046710469
Some((_, channel_id)) if chan.context().channel_id() != channel_id => None,
1046810470
_ => unblock_chan(chan, &mut peer_state.pending_msg_events),
1046910471
};
10470-
if let Some(mut shutdown_result) = shutdown_result {
10472+
if let Some(shutdown_res) = shutdown_result {
1047110473
let context = chan.context();
1047210474
let logger = WithChannelContext::from(&self.logger, context, None);
10473-
log_trace!(logger, "Removing channel {} now that the signer is unblocked", context.channel_id());
10474-
if let Some(funded_channel) = chan.as_funded_mut() {
10475-
locked_close_channel!(self, peer_state, funded_channel, shutdown_result, FUNDED);
10475+
let chan_id = context.channel_id();
10476+
log_trace!(logger, "Removing channel {} now that the signer is unblocked", chan_id);
10477+
let (remove, err) = if let Some(funded_channel) = chan.as_funded_mut() {
10478+
convert_channel_err!(self, peer_state, shutdown_res, funded_channel, &chan_id, COOP_CLOSED)
1047610479
} else {
10477-
locked_close_channel!(self, chan.context(), UNFUNDED);
10478-
}
10479-
shutdown_results.push(shutdown_result);
10480+
debug_assert!(false);
10481+
let reason = shutdown_res.closure_reason.clone();
10482+
let err = ChannelError::Close((reason.to_string(), reason));
10483+
convert_channel_err!(self, peer_state, err, chan, &chan_id, UNFUNDED_CHANNEL)
10484+
};
10485+
debug_assert!(remove);
10486+
shutdown_results.push((Err(err), *cp_id));
1048010487
false
1048110488
} else {
1048210489
true
1048310490
}
1048410491
});
1048510492
}
1048610493
drop(per_peer_state);
10487-
for shutdown_result in shutdown_results.drain(..) {
10488-
self.finish_close_channel(shutdown_result);
10494+
for (err, counterparty_node_id) in shutdown_results {
10495+
let _ = handle_error!(self, err, counterparty_node_id);
1048910496
}
1049010497
}
1049110498

@@ -10496,11 +10503,10 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
1049610503
fn maybe_generate_initial_closing_signed(&self) -> bool {
1049710504
let mut handle_errors: Vec<(PublicKey, Result<(), _>)> = Vec::new();
1049810505
let mut has_update = false;
10499-
let mut shutdown_results = Vec::new();
1050010506
{
1050110507
let per_peer_state = self.per_peer_state.read().unwrap();
1050210508

10503-
for (_cp_id, peer_state_mutex) in per_peer_state.iter() {
10509+
for (cp_id, peer_state_mutex) in per_peer_state.iter() {
1050410510
let mut peer_state_lock = peer_state_mutex.lock().unwrap();
1050510511
let peer_state = &mut *peer_state_lock;
1050610512
let pending_msg_events = &mut peer_state.pending_msg_events;
@@ -10517,17 +10523,11 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
1051710523
});
1051810524
}
1051910525
debug_assert_eq!(tx_shutdown_result_opt.is_some(), funded_chan.is_shutdown());
10520-
if let Some((tx, mut shutdown_res)) = tx_shutdown_result_opt {
10521-
locked_close_channel!(self, peer_state, funded_chan, shutdown_res, FUNDED);
10522-
shutdown_results.push(shutdown_res);
10526+
if let Some((tx, shutdown_res)) = tx_shutdown_result_opt {
1052310527
// We're done with this channel. We got a closing_signed and sent back
1052410528
// a closing_signed with a closing transaction to broadcast.
10525-
if let Ok(update) = self.get_channel_update_for_broadcast(&funded_chan) {
10526-
let mut pending_broadcast_messages = self.pending_broadcast_messages.lock().unwrap();
10527-
pending_broadcast_messages.push(MessageSendEvent::BroadcastChannelUpdate {
10528-
msg: update
10529-
});
10530-
}
10529+
let (_, err) = convert_channel_err!(self, peer_state, shutdown_res, funded_chan, channel_id, COOP_CLOSED);
10530+
handle_errors.push((*cp_id, Err(err)));
1053110531

1053210532
log_info!(logger, "Broadcasting {}", log_tx!(tx));
1053310533
self.tx_broadcaster.broadcast_transactions(&[&tx]);
@@ -10548,14 +10548,10 @@ This indicates a bug inside LDK. Please report this error at https://github.com/
1054810548
}
1054910549
}
1055010550

10551-
for (counterparty_node_id, err) in handle_errors.drain(..) {
10551+
for (counterparty_node_id, err) in handle_errors {
1055210552
let _ = handle_error!(self, err, counterparty_node_id);
1055310553
}
1055410554

10555-
for shutdown_result in shutdown_results.drain(..) {
10556-
self.finish_close_channel(shutdown_result);
10557-
}
10558-
1055910555
has_update
1056010556
}
1056110557

0 commit comments

Comments
 (0)