X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=src%2Fln%2Fmsgs.rs;h=bc7c0ed98b3c38052df2fa06f8eccb9078a2bd1f;hb=aec0fa485c8e1113f0a6d24c2f18e4ba90fe568d;hp=6bb900967566149f6ae5264dc336cfc62ee585d3;hpb=9606f94caf451d9eb3a690b559e2955486a3e76a;p=rust-lightning diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs index 6bb90096..bc7c0ed9 100644 --- a/src/ln/msgs.rs +++ b/src/ln/msgs.rs @@ -2,7 +2,7 @@ use secp256k1::key::PublicKey; use secp256k1::{Secp256k1, Signature}; use bitcoin::util::uint::Uint256; use bitcoin::util::hash::Sha256dHash; -use bitcoin::network::serialize::deserialize; +use bitcoin::network::serialize::{deserialize,serialize}; use bitcoin::blockdata::script::Script; use std::error::Error; @@ -15,6 +15,14 @@ pub trait MsgEncodable { fn encode(&self) -> Vec; #[inline] fn encoded_len(&self) -> usize { self.encode().len() } + #[inline] + fn encode_with_len(&self) -> Vec { + let enc = self.encode(); + let mut res = Vec::with_capacity(enc.len() + 2); + res.extend_from_slice(&byte_utils::be16_to_array(enc.len() as u16)); + res.extend_from_slice(&enc); + res + } } #[derive(Debug)] pub enum DecodeError { @@ -53,9 +61,16 @@ impl LocalFeatures { self.flags.len() > 0 && (self.flags[0] & 1) != 0 } - pub fn supports_initial_routing_sync(&self) -> bool { + pub fn initial_routing_sync(&self) -> bool { self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0 } + pub fn set_initial_routing_sync(&mut self) { + if self.flags.len() == 0 { + self.flags.resize(1, 1 << 3); + } else { + self.flags[0] |= 1 << 3; + } + } pub fn supports_upfront_shutdown_script(&self) -> bool { self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0 @@ -124,6 +139,15 @@ pub struct Init { pub local_features: LocalFeatures, } +pub struct Ping { + pub ponglen: u16, + pub byteslen: u16, +} + +pub struct Pong { + pub byteslen: u16, +} + pub struct OpenChannel { pub chain_hash: Sha256dHash, pub temporary_channel_id: Uint256, @@ -342,22 +366,45 @@ pub struct ChannelUpdate { } /// Used to put an error message in a HandleError -pub enum ErrorMessage { +pub enum ErrorAction { + /// Indicates an inbound HTLC add resulted in a failure, and the UpdateFailHTLC provided in msg + /// should be sent back to the sender. UpdateFailHTLC { msg: UpdateFailHTLC }, - DisconnectPeer {}, + /// The peer took some action which made us think they were useless. Disconnect them. + DisconnectPeer, + /// The peer did something harmless that we weren't able to process, just log and ignore + IgnoreError, } pub struct HandleError { //TODO: rename me pub err: &'static str, - pub msg: Option, //TODO: Move into an Action enum and require it! + pub msg: Option, //TODO: Make this required and rename it +} + +/// Struct used to return values from revoke_and_ack messages, containing a bunch of commitment +/// transaction updates if they were pending. +pub struct CommitmentUpdate { + pub update_add_htlcs: Vec, + pub update_fulfill_htlcs: Vec, + pub update_fail_htlcs: Vec, + pub commitment_signed: CommitmentSigned, +} + +pub enum HTLCFailChannelUpdate { + ChannelUpdateMessage { + msg: ChannelUpdate, + }, + ChannelClosed { + short_channel_id: u64, + }, } /// A trait to describe an object which can receive channel messages. Messages MAY be called in /// paralell when they originate from different their_node_ids, however they MUST NOT be called in /// paralell when the two calls have the same their_node_id. -pub trait ChannelMessageHandler : events::EventsProvider { +pub trait ChannelMessageHandler : events::EventsProvider + Send + Sync { //Channel init: fn handle_open_channel(&self, their_node_id: &PublicKey, msg: &OpenChannel) -> Result; fn handle_accept_channel(&self, their_node_id: &PublicKey, msg: &AcceptChannel) -> Result<(), HandleError>; @@ -366,29 +413,37 @@ pub trait ChannelMessageHandler : events::EventsProvider { fn handle_funding_locked(&self, their_node_id: &PublicKey, msg: &FundingLocked) -> Result, HandleError>; // Channl close: - fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown) -> Result<(), HandleError>; - fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned) -> Result<(), HandleError>; + fn handle_shutdown(&self, their_node_id: &PublicKey, msg: &Shutdown) -> Result<(Option, Option), HandleError>; + fn handle_closing_signed(&self, their_node_id: &PublicKey, msg: &ClosingSigned) -> Result, HandleError>; // HTLC handling: fn handle_update_add_htlc(&self, their_node_id: &PublicKey, msg: &UpdateAddHTLC) -> Result<(), HandleError>; fn handle_update_fulfill_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFulfillHTLC) -> Result<(), HandleError>; - fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result<(), HandleError>; + fn handle_update_fail_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailHTLC) -> Result, HandleError>; fn handle_update_fail_malformed_htlc(&self, their_node_id: &PublicKey, msg: &UpdateFailMalformedHTLC) -> Result<(), HandleError>; - fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result; - fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result, CommitmentSigned)>, HandleError>; + fn handle_commitment_signed(&self, their_node_id: &PublicKey, msg: &CommitmentSigned) -> Result<(RevokeAndACK, Option), HandleError>; + fn handle_revoke_and_ack(&self, their_node_id: &PublicKey, msg: &RevokeAndACK) -> Result, HandleError>; fn handle_update_fee(&self, their_node_id: &PublicKey, msg: &UpdateFee) -> Result<(), HandleError>; // Channel-to-announce: fn handle_announcement_signatures(&self, their_node_id: &PublicKey, msg: &AnnouncementSignatures) -> Result<(), HandleError>; + + // Informational: + /// Indicates a connection to the peer failed/an existing connection was lost. If no connection + /// is believed to be possible in the future (eg they're sending us messages we don't + /// understand or indicate they require unknown feature bits), no_connection_possible is set + /// and any outstanding channels should be failed. + fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool); } -pub trait RoutingMessageHandler { +pub trait RoutingMessageHandler : Send + Sync { fn handle_node_announcement(&self, msg: &NodeAnnouncement) -> Result<(), HandleError>; /// Handle a channel_announcement message, returning true if it should be forwarded on, false /// or returning an Err otherwise. fn handle_channel_announcement(&self, msg: &ChannelAnnouncement) -> Result; fn handle_channel_update(&self, msg: &ChannelUpdate) -> Result<(), HandleError>; + fn handle_htlc_fail_channel_update(&self, update: &HTLCFailChannelUpdate); } pub struct OnionRealm0HopData { @@ -469,11 +524,11 @@ macro_rules! secp_signature { impl MsgDecodable for LocalFeatures { fn decode(v: &[u8]) -> Result { - if v.len() < 3 { return Err(DecodeError::WrongLength); } + if v.len() < 2 { return Err(DecodeError::WrongLength); } let len = byte_utils::slice_to_be16(&v[0..2]) as usize; if v.len() < len + 2 { return Err(DecodeError::WrongLength); } let mut flags = Vec::with_capacity(len); - flags.extend_from_slice(&v[2..]); + flags.extend_from_slice(&v[2..2 + len]); Ok(Self { flags: flags }) @@ -491,11 +546,11 @@ impl MsgEncodable for LocalFeatures { impl MsgDecodable for GlobalFeatures { fn decode(v: &[u8]) -> Result { - if v.len() < 3 { return Err(DecodeError::WrongLength); } + if v.len() < 2 { return Err(DecodeError::WrongLength); } let len = byte_utils::slice_to_be16(&v[0..2]) as usize; if v.len() < len + 2 { return Err(DecodeError::WrongLength); } let mut flags = Vec::with_capacity(len); - flags.extend_from_slice(&v[2..]); + flags.extend_from_slice(&v[2..2 + len]); Ok(Self { flags: flags }) @@ -533,6 +588,54 @@ impl MsgEncodable for Init { } } +impl MsgDecodable for Ping { + fn decode(v: &[u8]) -> Result { + if v.len() < 4 { + return Err(DecodeError::WrongLength); + } + let ponglen = byte_utils::slice_to_be16(&v[0..2]); + let byteslen = byte_utils::slice_to_be16(&v[2..4]); + if v.len() < 4 + byteslen as usize { + return Err(DecodeError::WrongLength); + } + Ok(Self { + ponglen, + byteslen, + }) + } +} +impl MsgEncodable for Ping { + fn encode(&self) -> Vec { + let mut res = Vec::with_capacity(self.byteslen as usize + 2); + res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen)); + res.resize(2 + self.byteslen as usize, 0); + res + } +} + +impl MsgDecodable for Pong { + fn decode(v: &[u8]) -> Result { + if v.len() < 2 { + return Err(DecodeError::WrongLength); + } + let byteslen = byte_utils::slice_to_be16(&v[0..2]); + if v.len() < 2 + byteslen as usize { + return Err(DecodeError::WrongLength); + } + Ok(Self { + byteslen + }) + } +} +impl MsgEncodable for Pong { + fn encode(&self) -> Vec { + let mut res = Vec::with_capacity(self.byteslen as usize + 2); + res.extend_from_slice(&byte_utils::be16_to_array(self.byteslen)); + res.resize(2 + self.byteslen as usize, 0); + res + } +} + impl MsgDecodable for OpenChannel { fn decode(v: &[u8]) -> Result { if v.len() < 2*32+6*8+4+2*2+6*33+1 { @@ -576,7 +679,33 @@ impl MsgDecodable for OpenChannel { } impl MsgEncodable for OpenChannel { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = match &self.shutdown_scriptpubkey { + &Some(ref script) => Vec::with_capacity(319 + 2 + script.len()), + &None => Vec::with_capacity(319), + }; + res.extend_from_slice(&serialize(&self.chain_hash).unwrap()); + res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.funding_satoshis)); + res.extend_from_slice(&byte_utils::be64_to_array(self.push_msat)); + res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis)); + res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat)); + res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis)); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat)); + res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw)); + res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay)); + res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs)); + res.extend_from_slice(&self.funding_pubkey.serialize()); + res.extend_from_slice(&self.revocation_basepoint.serialize()); + res.extend_from_slice(&self.payment_basepoint.serialize()); + res.extend_from_slice(&self.delayed_payment_basepoint.serialize()); + res.extend_from_slice(&self.htlc_basepoint.serialize()); + res.extend_from_slice(&self.first_per_commitment_point.serialize()); + res.push(self.channel_flags); + if let &Some(ref script) = &self.shutdown_scriptpubkey { + res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16)); + res.extend_from_slice(&script[..]); + } + res } } @@ -619,7 +748,29 @@ impl MsgDecodable for AcceptChannel { } impl MsgEncodable for AcceptChannel { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = match &self.shutdown_scriptpubkey { + &Some(ref script) => Vec::with_capacity(270 + 2 + script.len()), + &None => Vec::with_capacity(270), + }; + res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()[..]); + res.extend_from_slice(&byte_utils::be64_to_array(self.dust_limit_satoshis)); + res.extend_from_slice(&byte_utils::be64_to_array(self.max_htlc_value_in_flight_msat)); + res.extend_from_slice(&byte_utils::be64_to_array(self.channel_reserve_satoshis)); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_minimum_msat)); + res.extend_from_slice(&byte_utils::be32_to_array(self.minimum_depth)); + res.extend_from_slice(&byte_utils::be16_to_array(self.to_self_delay)); + res.extend_from_slice(&byte_utils::be16_to_array(self.max_accepted_htlcs)); + res.extend_from_slice(&self.funding_pubkey.serialize()); + res.extend_from_slice(&self.revocation_basepoint.serialize()); + res.extend_from_slice(&self.payment_basepoint.serialize()); + res.extend_from_slice(&self.delayed_payment_basepoint.serialize()); + res.extend_from_slice(&self.htlc_basepoint.serialize()); + res.extend_from_slice(&self.first_per_commitment_point.serialize()); + if let &Some(ref script) = &self.shutdown_scriptpubkey { + res.extend_from_slice(&byte_utils::be16_to_array(script.len() as u16)); + res.extend_from_slice(&script[..]); + } + res } } @@ -639,7 +790,13 @@ impl MsgDecodable for FundingCreated { } impl MsgEncodable for FundingCreated { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+32+2+64); + res.extend_from_slice(&serialize(&self.temporary_channel_id).unwrap()[..]); + res.extend_from_slice(&serialize(&self.funding_txid).unwrap()[..]); + res.extend_from_slice(&byte_utils::be16_to_array(self.funding_output_index)); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); + res } } @@ -657,7 +814,10 @@ impl MsgDecodable for FundingSigned { } impl MsgEncodable for FundingSigned { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+64); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&self.signature.serialize_compact(&Secp256k1::without_caps())); + res } } @@ -675,7 +835,10 @@ impl MsgDecodable for FundingLocked { } impl MsgEncodable for FundingLocked { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+33); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&self.next_per_commitment_point.serialize()); + res } } @@ -696,7 +859,11 @@ impl MsgDecodable for Shutdown { } impl MsgEncodable for Shutdown { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32 + 2 + self.scriptpubkey.len()); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be16_to_array(self.scriptpubkey.len() as u16)); + res.extend_from_slice(&self.scriptpubkey[..]); + res } } @@ -715,7 +882,12 @@ impl MsgDecodable for ClosingSigned { } impl MsgEncodable for ClosingSigned { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+64); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.fee_satoshis)); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); + res } } @@ -732,13 +904,20 @@ impl MsgDecodable for UpdateAddHTLC { amount_msat: byte_utils::slice_to_be64(&v[40..48]), payment_hash, cltv_expiry: byte_utils::slice_to_be32(&v[80..84]), - onion_routing_packet: OnionPacket::decode(&v[84..])?, + onion_routing_packet: OnionPacket::decode(&v[84..84+1366])?, }) } } impl MsgEncodable for UpdateAddHTLC { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+8+32+4+1+1366); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); + res.extend_from_slice(&byte_utils::be64_to_array(self.amount_msat)); + res.extend_from_slice(&self.payment_hash); + res.extend_from_slice(&byte_utils::be32_to_array(self.cltv_expiry)); + res.extend_from_slice(&self.onion_routing_packet.encode()[..]); + res } } @@ -758,7 +937,11 @@ impl MsgDecodable for UpdateFulfillHTLC { } impl MsgEncodable for UpdateFulfillHTLC { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+32); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); + res.extend_from_slice(&self.payment_preimage); + res } } @@ -776,7 +959,12 @@ impl MsgDecodable for UpdateFailHTLC { } impl MsgEncodable for UpdateFailHTLC { fn encode(&self) -> Vec { - unimplemented!(); + let reason = self.reason.encode(); + let mut res = Vec::with_capacity(32+8+reason.len()); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); + res.extend_from_slice(&reason[..]); + res } } @@ -797,7 +985,12 @@ impl MsgDecodable for UpdateFailMalformedHTLC { } impl MsgEncodable for UpdateFailMalformedHTLC { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+32+2); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.htlc_id)); + res.extend_from_slice(&self.sha256_of_onion); + res.extend_from_slice(&byte_utils::be16_to_array(self.failure_code)); + res } } @@ -824,7 +1017,15 @@ impl MsgDecodable for CommitmentSigned { } impl MsgEncodable for CommitmentSigned { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+64+2+self.htlc_signatures.len()*64); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); + res.extend_from_slice(&byte_utils::be16_to_array(self.htlc_signatures.len() as u16)); + for i in 0..self.htlc_signatures.len() { + res.extend_from_slice(&self.htlc_signatures[i].serialize_compact(&secp_ctx)); + } + res } } @@ -845,7 +1046,11 @@ impl MsgDecodable for RevokeAndACK { } impl MsgEncodable for RevokeAndACK { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+32+33); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&self.per_commitment_secret); + res.extend_from_slice(&self.next_per_commitment_point.serialize()); + res } } @@ -862,7 +1067,10 @@ impl MsgDecodable for UpdateFee { } impl MsgEncodable for UpdateFee { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+4); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be32_to_array(self.feerate_per_kw)); + res } } @@ -893,7 +1101,13 @@ impl MsgDecodable for AnnouncementSignatures { } impl MsgEncodable for AnnouncementSignatures { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(32+8+64*2); + res.extend_from_slice(&serialize(&self.channel_id).unwrap()); + res.extend_from_slice(&byte_utils::be64_to_array(self.short_channel_id)); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.node_signature.serialize_compact(&secp_ctx)); + res.extend_from_slice(&self.bitcoin_signature.serialize_compact(&secp_ctx)); + res } } @@ -1058,7 +1272,12 @@ impl MsgDecodable for NodeAnnouncement { } impl MsgEncodable for NodeAnnouncement { fn encode(&self) -> Vec { - unimplemented!(); + let contents = self.contents.encode(); + let mut res = Vec::with_capacity(64 + contents.len()); + let secp_ctx = Secp256k1::without_caps(); + res.extend_from_slice(&self.signature.serialize_compact(&secp_ctx)); + res.extend_from_slice(&contents); + res } } @@ -1113,7 +1332,15 @@ impl MsgDecodable for ChannelAnnouncement { } impl MsgEncodable for ChannelAnnouncement { fn encode(&self) -> Vec { - unimplemented!(); + let secp_ctx = Secp256k1::without_caps(); + let contents = self.contents.encode(); + let mut res = Vec::with_capacity(64 + contents.len()); + res.extend_from_slice(&self.node_signature_1.serialize_compact(&secp_ctx)); + res.extend_from_slice(&self.node_signature_2.serialize_compact(&secp_ctx)); + res.extend_from_slice(&self.bitcoin_signature_1.serialize_compact(&secp_ctx)); + res.extend_from_slice(&self.bitcoin_signature_2.serialize_compact(&secp_ctx)); + res.extend_from_slice(&contents); + res } } @@ -1251,8 +1478,26 @@ impl MsgEncodable for OnionPacket { } impl MsgDecodable for DecodedOnionErrorPacket { - fn decode(_v: &[u8]) -> Result { - unimplemented!(); + fn decode(v: &[u8]) -> Result { + if v.len() < 32 + 4 { + return Err(DecodeError::WrongLength); + } + let failuremsg_len = byte_utils::slice_to_be16(&v[32..34]) as usize; + if v.len() < 32 + 4 + failuremsg_len { + return Err(DecodeError::WrongLength); + } + let padding_len = byte_utils::slice_to_be16(&v[34 + failuremsg_len..]) as usize; + if v.len() < 32 + 4 + failuremsg_len + padding_len { + return Err(DecodeError::WrongLength); + } + + let mut hmac = [0; 32]; + hmac.copy_from_slice(&v[0..32]); + Ok(Self { + hmac, + failuremsg: v[34..34 + failuremsg_len].to_vec(), + pad: v[36 + failuremsg_len..36 + failuremsg_len + padding_len].to_vec(), + }) } } impl MsgEncodable for DecodedOnionErrorPacket { @@ -1283,7 +1528,9 @@ impl MsgDecodable for OnionErrorPacket { } impl MsgEncodable for OnionErrorPacket { fn encode(&self) -> Vec { - unimplemented!(); + let mut res = Vec::with_capacity(2 + self.data.len()); + res.extend_from_slice(&byte_utils::be16_to_array(self.data.len() as u16)); + res.extend_from_slice(&self.data); + res } } -