Skip to content

Commit 122727a

Browse files
TheBlueMattTheBlueMatt
committed
Rewrite monitor_update_failed as it didn't capture all the options
Primarily this fixes the case where we receive an RAA which does not require a response, allowing us to call monitor_update_failed without generating pending messages.
1 parent 70b0506 commit 122727a

File tree

3 files changed

+57
-29
lines changed

3 files changed

+57
-29
lines changed

‎src/ln/channel.rs

Lines changed: 4 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -2196,23 +2196,15 @@ impl Channel {
21962196
/// commitment update or a revoke_and_ack generation). The messages which were generated from
21972197
/// that original call must *not* have been sent to the remote end, and must instead have been
21982198
/// dropped. They will be regenerated when monitor_updating_restored is called.
2199-
pub fn monitor_update_failed(&mut self, order: RAACommitmentOrder, mut pending_forwards: Vec<(PendingForwardHTLCInfo, u64)>, mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>, raa_first_dropped_cs: bool) {
2199+
pub fn monitor_update_failed(&mut self, order: RAACommitmentOrder, resend_raa: bool, resend_commitment: bool, mut pending_forwards: Vec<(PendingForwardHTLCInfo, u64)>, mut pending_fails: Vec<(HTLCSource, PaymentHash, HTLCFailReason)>) {
22002200
assert_eq!(self.channel_state & ChannelState::MonitorUpdateFailed as u32, 0);
2201-
match order {
2202-
RAACommitmentOrder::CommitmentFirst => {
2203-
self.monitor_pending_revoke_and_ack = false;
2204-
self.monitor_pending_commitment_signed = true;
2205-
},
2206-
RAACommitmentOrder::RevokeAndACKFirst => {
2207-
self.monitor_pending_revoke_and_ack = true;
2208-
self.monitor_pending_commitment_signed = raa_first_dropped_cs;
2209-
},
2210-
}
2201+
self.monitor_pending_revoke_and_ack = resend_raa;
2202+
self.monitor_pending_commitment_signed = resend_commitment;
2203+
self.monitor_pending_order = Some(order);
22112204
assert!(self.monitor_pending_forwards.is_empty());
22122205
mem::swap(&mut pending_forwards, &mut self.monitor_pending_forwards);
22132206
assert!(self.monitor_pending_failures.is_empty());
22142207
mem::swap(&mut pending_fails, &mut self.monitor_pending_failures);
2215-
self.monitor_pending_order = Some(order);
22162208
self.channel_state |= ChannelState::MonitorUpdateFailed as u32;
22172209
}
22182210

‎src/ln/channelmanager.rs

Lines changed: 10 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -439,17 +439,10 @@ macro_rules! try_chan_entry {
439439
}
440440

441441
macro_rules! return_monitor_err {
442-
($self: expr, $err: expr, $channel_state: expr, $entry: expr, $action_type: path) => {
443-
return_monitor_err!($self, $err, $channel_state, $entry, $action_type, Vec::new(), Vec::new())
442+
($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $resend_raa: expr, $resend_commitment: expr) => {
443+
return_monitor_err!($self, $err, $channel_state, $entry, $action_type, $resend_raa, $resend_commitment, Vec::new(), Vec::new())
444444
};
445-
($self: expr, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $raa_first_dropped_cs: expr) => {
446-
if $action_type != RAACommitmentOrder::RevokeAndACKFirst { panic!("Bad return_monitor_err call!"); }
447-
return_monitor_err!($self, $err, $channel_state, $entry, $action_type, Vec::new(), Vec::new(), $raa_first_dropped_cs)
448-
};
449-
($self: expr, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $failed_forwards: expr, $failed_fails: expr) => {
450-
return_monitor_err!($self, $err, $channel_state, $entry, $action_type, $failed_forwards, $failed_fails, false)
451-
};
452-
($self: expr, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $failed_forwards: expr, $failed_fails: expr, $raa_first_dropped_cs: expr) => {
445+
($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $resend_raa: expr, $resend_commitment: expr, $failed_forwards: expr, $failed_fails: expr) => {
453446
match $err {
454447
ChannelMonitorUpdateErr::PermanentFailure => {
455448
let (channel_id, mut chan) = $entry.remove_entry();
@@ -468,7 +461,7 @@ macro_rules! return_monitor_err {
468461
return Err(MsgHandleErrInternal::from_finish_shutdown("ChannelMonitor storage failure", channel_id, chan.force_shutdown(), $self.get_channel_update(&chan).ok()))
469462
},
470463
ChannelMonitorUpdateErr::TemporaryFailure => {
471-
$entry.get_mut().monitor_update_failed($action_type, $failed_forwards, $failed_fails, $raa_first_dropped_cs);
464+
$entry.get_mut().monitor_update_failed($action_type, $resend_raa, $resend_commitment, $failed_forwards, $failed_fails);
472465
return Err(MsgHandleErrInternal::from_chan_no_close(ChannelError::Ignore("Failed to update ChannelMonitor"), *$entry.key()));
473466
},
474467
}
@@ -477,7 +470,7 @@ macro_rules! return_monitor_err {
477470

478471
// Does not break in case of TemporaryFailure!
479472
macro_rules! maybe_break_monitor_err {
480-
($self: expr, $err: expr, $channel_state: expr, $entry: expr, $action_type: path) => {
473+
($self: ident, $err: expr, $channel_state: expr, $entry: expr, $action_type: path, $resend_raa: expr, $resend_commitment: expr) => {
481474
match $err {
482475
ChannelMonitorUpdateErr::PermanentFailure => {
483476
let (channel_id, mut chan) = $entry.remove_entry();
@@ -487,7 +480,7 @@ macro_rules! maybe_break_monitor_err {
487480
break Err(MsgHandleErrInternal::from_finish_shutdown("ChannelMonitor storage failure", channel_id, chan.force_shutdown(), $self.get_channel_update(&chan).ok()))
488481
},
489482
ChannelMonitorUpdateErr::TemporaryFailure => {
490-
$entry.get_mut().monitor_update_failed($action_type, Vec::new(), Vec::new(), false);
483+
$entry.get_mut().monitor_update_failed($action_type, $resend_raa, $resend_commitment, Vec::new(), Vec::new());
491484
},
492485
}
493486
}
@@ -1018,7 +1011,7 @@ impl ChannelManager {
10181011
} {
10191012
Some((update_add, commitment_signed, chan_monitor)) => {
10201013
if let Err(e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) {
1021-
maybe_break_monitor_err!(self, e, channel_state, chan, RAACommitmentOrder::CommitmentFirst);
1014+
maybe_break_monitor_err!(self, e, channel_state, chan, RAACommitmentOrder::CommitmentFirst, false, true);
10221015
// Note that MonitorUpdateFailed here indicates (per function docs)
10231016
// that we will resent the commitment update once we unfree monitor
10241017
// updating, so we have to take special care that we don't return
@@ -1962,7 +1955,7 @@ impl ChannelManager {
19621955
let (revoke_and_ack, commitment_signed, closing_signed, chan_monitor) =
19631956
try_chan_entry!(self, chan.get_mut().commitment_signed(&msg, &*self.fee_estimator), channel_state, chan);
19641957
if let Err(e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) {
1965-
return_monitor_err!(self, e, channel_state, chan, RAACommitmentOrder::RevokeAndACKFirst, commitment_signed.is_some());
1958+
return_monitor_err!(self, e, channel_state, chan, RAACommitmentOrder::RevokeAndACKFirst, true, commitment_signed.is_some());
19661959
//TODO: Rebroadcast closing_signed if present on monitor update restoration
19671960
}
19681961
channel_state.pending_msg_events.push(events::MessageSendEvent::SendRevokeAndACK {
@@ -2040,7 +2033,7 @@ impl ChannelManager {
20402033
let (commitment_update, pending_forwards, pending_failures, closing_signed, chan_monitor) =
20412034
try_chan_entry!(self, chan.get_mut().revoke_and_ack(&msg, &*self.fee_estimator), channel_state, chan);
20422035
if let Err(e) = self.monitor.add_update_monitor(chan_monitor.get_funding_txo().unwrap(), chan_monitor) {
2043-
return_monitor_err!(self, e, channel_state, chan, RAACommitmentOrder::CommitmentFirst, pending_forwards, pending_failures);
2036+
return_monitor_err!(self, e, channel_state, chan, RAACommitmentOrder::CommitmentFirst, false, commitment_update.is_some(), pending_forwards, pending_failures);
20442037
}
20452038
if let Some(updates) = commitment_update {
20462039
channel_state.pending_msg_events.push(events::MessageSendEvent::UpdateHTLCs {
@@ -2147,7 +2140,7 @@ impl ChannelManager {
21472140
if commitment_update.is_none() {
21482141
order = RAACommitmentOrder::RevokeAndACKFirst;
21492142
}
2150-
return_monitor_err!(self, e, channel_state, chan, order);
2143+
return_monitor_err!(self, e, channel_state, chan, order, revoke_and_ack.is_some(), commitment_update.is_some());
21512144
//TODO: Resend the funding_locked if needed once we get the monitor running again
21522145
}
21532146
}

‎src/ln/functional_tests.rs

Lines changed: 43 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4677,6 +4677,49 @@ fn test_monitor_update_fail_cs() {
46774677
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
46784678
}
46794679

4680+
#[test]
4681+
fn test_monitor_update_fail_no_rebroadcast() {
4682+
// Tests handling of a monitor update failure when no message rebroadcasting on
4683+
// test_restore_channel_monitor() is required. Backported from
4684+
// chanmon_fail_consistency fuzz tests.
4685+
let mut nodes = create_network(2);
4686+
create_announced_chan_between_nodes(&nodes, 0, 1);
4687+
4688+
let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
4689+
let (payment_preimage_1, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4690+
nodes[0].node.send_payment(route, our_payment_hash).unwrap();
4691+
check_added_monitors!(nodes[0], 1);
4692+
4693+
let send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
4694+
nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
4695+
let bs_raa = commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false, true, false, true);
4696+
4697+
*nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
4698+
if let msgs::HandleError { err, action: Some(msgs::ErrorAction::IgnoreError) } = nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &bs_raa).unwrap_err() {
4699+
assert_eq!(err, "Failed to update ChannelMonitor");
4700+
} else { panic!(); }
4701+
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4702+
assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
4703+
check_added_monitors!(nodes[1], 1);
4704+
4705+
*nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
4706+
nodes[1].node.test_restore_channel_monitor();
4707+
assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4708+
check_added_monitors!(nodes[1], 1);
4709+
expect_pending_htlcs_forwardable!(nodes[1]);
4710+
4711+
let events = nodes[1].node.get_and_clear_pending_events();
4712+
assert_eq!(events.len(), 1);
4713+
match events[0] {
4714+
Event::PaymentReceived { payment_hash, .. } => {
4715+
assert_eq!(payment_hash, our_payment_hash);
4716+
},
4717+
_ => panic!("Unexpected event"),
4718+
}
4719+
4720+
claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
4721+
}
4722+
46804723
fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
46814724
// Tests handling of a monitor update failure when processing an incoming RAA
46824725
let mut nodes = create_network(3);

0 commit comments

Comments
 (0)