X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fchannel.rs;h=b59379aa74fdbab50589ad9ba424a17fab916ab4;hb=d2b44ca7a64161186c3a42f8186097a5f1bd3d4e;hp=a54be7722384fd2da84ed7de9c801d48e7a527be;hpb=4330ae5d4f1fefeb7f211360354fb04eb8480351;p=rust-lightning

diff --git a/src/ln/channel.rs b/src/ln/channel.rs
index a54be772..b59379aa 100644
--- a/src/ln/channel.rs
+++ b/src/ln/channel.rs
@@ -16,7 +16,7 @@ use crypto::hkdf::{hkdf_extract,hkdf_expand};
 use ln::msgs;
 use ln::msgs::{ErrorAction, HandleError, MsgEncodable};
 use ln::channelmonitor::ChannelMonitor;
-use ln::channelmanager::{PendingForwardHTLCInfo, HTLCFailReason};
+use ln::channelmanager::{PendingHTLCStatus, PendingForwardHTLCInfo, HTLCFailReason, HTLCFailureMsg};
 use ln::chan_utils::{TxCreationKeys,HTLCOutputInCommitment,HTLC_SUCCESS_TX_WEIGHT,HTLC_TIMEOUT_TX_WEIGHT};
 use ln::chan_utils;
 use chain::chaininterface::{FeeEstimator,ConfirmationTarget};
@@ -164,7 +164,7 @@ struct HTLCOutput { //TODO: Refactor into Outbound/InboundHTLCOutput (will save
 	/// If we're in LocalRemoved*, set to true if we fulfilled the HTLC, and can claim money
 	local_removed_fulfilled: bool,
 	/// state pre-committed Remote* implies pending_forward_state, otherwise it must be None
-	pending_forward_state: Option<PendingForwardHTLCInfo>,
+	pending_forward_state: Option<PendingHTLCStatus>,
 }
 
 impl HTLCOutput {
@@ -373,6 +373,8 @@ impl Channel {
 	}
 
 	fn derive_minimum_depth(_channel_value_satoshis_msat: u64, _value_to_self_msat: u64) -> u32 {
+		// Note that in order to comply with BOLT 7 announcement_signatures requirements this must
+		// be at least 6.
 		const CONF_TARGET: u32 = 12; //TODO: Should be much higher
 		CONF_TARGET
 	}
@@ -1018,10 +1020,13 @@ impl Channel {
 		for (idx, htlc) in self.pending_htlcs.iter().enumerate() {
 			if !htlc.outbound && htlc.payment_hash == payment_hash_calc &&
 					htlc.state != HTLCState::LocalRemoved && htlc.state != HTLCState::LocalRemovedAwaitingCommitment {
-				if pending_idx != std::usize::MAX {
-					panic!("Duplicate HTLC payment_hash, ChannelManager should have prevented this!");
+				if let Some(PendingHTLCStatus::Fail(_)) = htlc.pending_forward_state {
+				} else {
+					if pending_idx != std::usize::MAX {
+						panic!("Duplicate HTLC payment_hash, ChannelManager should have prevented this!");
+					}
+					pending_idx = idx;
 				}
-				pending_idx = idx;
 			}
 		}
 		if pending_idx == std::usize::MAX {
@@ -1131,17 +1136,24 @@ impl Channel {
 				if htlc_id != 0 {
 					panic!("Duplicate HTLC payment_hash, you probably re-used payment preimages, NEVER DO THIS!");
 				}
-				htlc_id = htlc.htlc_id;
-				htlc_amount_msat += htlc.amount_msat;
 				if htlc.state == HTLCState::Committed {
 					htlc.state = HTLCState::LocalRemoved;
 				} else if htlc.state == HTLCState::RemoteAnnounced {
-					panic!("Somehow forwarded HTLC prior to remote revocation!");
+					if let Some(PendingHTLCStatus::Forward(_)) = htlc.pending_forward_state {
+						panic!("Somehow forwarded HTLC prior to remote revocation!");
+					} else {
+						// We have to pretend this isn't here - we're probably a duplicate with the
+						// same payment_hash as some other HTLC, and the other is getting failed,
+						// we'll fail this one as soon as remote commits to it.
+						continue;
+					}
 				} else if htlc.state == HTLCState::LocalRemoved || htlc.state == HTLCState::LocalRemovedAwaitingCommitment {
 					return Err(HandleError{err: "Unable to find a pending HTLC which matched the given payment preimage", action: None});
 				} else {
 					panic!("Have an inbound HTLC when not awaiting remote revoke that had a garbage state");
 				}
+				htlc_id = htlc.htlc_id;
+				htlc_amount_msat += htlc.amount_msat;
 			}
 		}
 		if htlc_amount_msat == 0 {
@@ -1381,7 +1393,7 @@ impl Channel {
 		(inbound_htlc_count, outbound_htlc_count, htlc_outbound_value_msat, htlc_inbound_value_msat)
 	}
 
-	pub fn update_add_htlc(&mut self, msg: &msgs::UpdateAddHTLC, pending_forward_state: PendingForwardHTLCInfo) -> Result<(), HandleError> {
+	pub fn update_add_htlc(&mut self, msg: &msgs::UpdateAddHTLC, pending_forward_state: PendingHTLCStatus) -> Result<(), HandleError> {
 		if (self.channel_state & (ChannelState::ChannelFunded as u32 | ChannelState::RemoteShutdownSent as u32)) != (ChannelState::ChannelFunded as u32) {
 			return Err(HandleError{err: "Got add HTLC message when channel was not in an operational state", action: None});
 		}
@@ -1633,6 +1645,7 @@ impl Channel {
 						update_add_htlcs,
 						update_fulfill_htlcs,
 						update_fail_htlcs,
+						update_fail_malformed_htlcs: Vec::new(),
 						commitment_signed,
 					}, monitor_update)))
 				},
@@ -1670,6 +1683,8 @@ impl Channel {
 
 		let mut to_forward_infos = Vec::new();
 		let mut revoked_htlcs = Vec::new();
+		let mut update_fail_htlcs = Vec::new();
+		let mut update_fail_malformed_htlcs = Vec::new();
 		let mut require_commitment = false;
 		let mut value_to_self_msat_diff: i64 = 0;
 		// We really shouldnt have two passes here, but retain gives a non-mutable ref (Rust bug)
@@ -1693,8 +1708,20 @@ impl Channel {
 				htlc.state = HTLCState::AwaitingAnnouncedRemoteRevoke;
 				require_commitment = true;
 			} else if htlc.state == HTLCState::AwaitingAnnouncedRemoteRevoke {
-				htlc.state = HTLCState::Committed;
-				to_forward_infos.push(htlc.pending_forward_state.take().unwrap());
+				match htlc.pending_forward_state.take().unwrap() {
+					PendingHTLCStatus::Fail(fail_msg) => {
+						htlc.state = HTLCState::LocalRemoved;
+						require_commitment = true;
+						match fail_msg {
+							HTLCFailureMsg::Relay(msg) => update_fail_htlcs.push(msg),
+							HTLCFailureMsg::Malformed(msg) => update_fail_malformed_htlcs.push(msg),
+						}
+					},
+					PendingHTLCStatus::Forward(forward_info) => {
+						to_forward_infos.push(forward_info);
+						htlc.state = HTLCState::Committed;
+					}
+				}
 			} else if htlc.state == HTLCState::AwaitingRemoteRevokeToRemove {
 				htlc.state = HTLCState::AwaitingRemovedRemoteRevoke;
 				require_commitment = true;
@@ -1706,7 +1733,15 @@ impl Channel {
 		self.value_to_self_msat = (self.value_to_self_msat as i64 + value_to_self_msat_diff) as u64;
 
 		match self.free_holding_cell_htlcs()? {
-			Some(commitment_update) => {
+			Some(mut commitment_update) => {
+				commitment_update.0.update_fail_htlcs.reserve(update_fail_htlcs.len());
+				for fail_msg in update_fail_htlcs.drain(..) {
+					commitment_update.0.update_fail_htlcs.push(fail_msg);
+				}
+				commitment_update.0.update_fail_malformed_htlcs.reserve(update_fail_malformed_htlcs.len());
+				for fail_msg in update_fail_malformed_htlcs.drain(..) {
+					commitment_update.0.update_fail_malformed_htlcs.push(fail_msg);
+				}
 				Ok((Some(commitment_update.0), to_forward_infos, revoked_htlcs, commitment_update.1))
 			},
 			None => {
@@ -1715,7 +1750,8 @@ impl Channel {
 					Ok((Some(msgs::CommitmentUpdate {
 						update_add_htlcs: Vec::new(),
 						update_fulfill_htlcs: Vec::new(),
-						update_fail_htlcs: Vec::new(),
+						update_fail_htlcs,
+						update_fail_malformed_htlcs,
 						commitment_signed
 					}), to_forward_infos, revoked_htlcs, monitor_update))
 				} else {
@@ -2239,18 +2275,22 @@ impl Channel {
 
 	/// Gets an UnsignedChannelAnnouncement, as well as a signature covering it using our
 	/// bitcoin_key, if available, for this channel. The channel must be publicly announceable and
-	/// available for use (have exchanged FundingLocked messages in both directions. Should be used
+	/// available for use (have exchanged FundingLocked messages in both directions). Should be used
 	/// for both loose and in response to an AnnouncementSignatures message from the remote peer.
-	/// Note that you can get an announcement for a channel which is closing, though you should
-	/// likely not announce such a thing. In case its already been announced, a channel_update
-	/// message can mark the channel disabled.
+	/// Will only fail if we're not in a state where channel_announcement may be sent (including
+	/// closing).
+	/// Note that the "channel must be funded" requirement is stricter than BOLT 7 requires - see
+	/// https://github.com/lightningnetwork/lightning-rfc/issues/468
 	pub fn get_channel_announcement(&self, our_node_id: PublicKey, chain_hash: Sha256dHash) -> Result<(msgs::UnsignedChannelAnnouncement, Signature), HandleError> {
 		if !self.announce_publicly {
 			return Err(HandleError{err: "Channel is not available for public announcements", action: None});
 		}
-		if self.channel_state & (ChannelState::ChannelFunded as u32) != (ChannelState::ChannelFunded as u32) {
+		if self.channel_state & (ChannelState::ChannelFunded as u32) == 0 {
 			return Err(HandleError{err: "Cannot get a ChannelAnnouncement until the channel funding has been locked", action: None});
 		}
+		if (self.channel_state & (ChannelState::LocalShutdownSent as u32 | ChannelState::ShutdownComplete as u32)) != 0 {
+			return Err(HandleError{err: "Cannot get a ChannelAnnouncement once the channel is closing", action: None});
+		}
 
 		let were_node_one = our_node_id.serialize()[..] < self.their_node_id.serialize()[..];
 		let our_bitcoin_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key);