X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fonion_message%2Fpacket.rs;h=2fb2407dbdd093bdbe4ae260e31f12fbe4722d8a;hb=0ecb4b093ac1134cbf06275cc48dd79ef7524774;hp=da8dd561072edd516182b377229788518d431e77;hpb=f4f1093edc506314484c8d52a40dd155e692394b;p=rust-lightning diff --git a/lightning/src/onion_message/packet.rs b/lightning/src/onion_message/packet.rs index da8dd561..2fb2407d 100644 --- a/lightning/src/onion_message/packet.rs +++ b/lightning/src/onion_message/packet.rs @@ -12,11 +12,12 @@ use bitcoin::secp256k1::PublicKey; use bitcoin::secp256k1::ecdh::SharedSecret; +use crate::blinded_path::{BlindedPath, ForwardTlvs, ReceiveTlvs}; use crate::ln::msgs::DecodeError; use crate::ln::onion_utils; -use super::blinded_route::{BlindedRoute, ForwardTlvs, ReceiveTlvs}; +use super::messenger::CustomOnionMessageHandler; use crate::util::chacha20poly1305rfc::{ChaChaPolyReadAdapter, ChaChaPolyWriteAdapter}; -use crate::util::ser::{BigSize, FixedLengthReader, LengthRead, LengthReadable, LengthReadableArgs, MaybeReadableArgs, Readable, ReadableArgs, Writeable, Writer}; +use crate::util::ser::{BigSize, FixedLengthReader, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer}; use core::cmp; use crate::io::{self, Read}; @@ -98,7 +99,7 @@ pub(super) enum Payload { /// This payload is for the final hop. Receive { control_tlvs: ReceiveControlTlvs, - reply_path: Option, + reply_path: Option, message: OnionMessageContents, } } @@ -106,7 +107,7 @@ pub(super) enum Payload { #[derive(Debug)] /// The contents of an onion message. In the context of offers, this would be the invoice, invoice /// request, or invoice error. -pub enum OnionMessageContents where T: CustomOnionMessageContents { +pub enum OnionMessageContents { // Coming soon: // Invoice, // InvoiceRequest, @@ -115,8 +116,10 @@ pub enum OnionMessageContents where T: CustomOnionMessageContents { Custom(T), } -impl OnionMessageContents where T: CustomOnionMessageContents { +impl OnionMessageContents { /// Returns the type that was used to decode the message payload. + /// + /// This is not exported to bindings users as methods on non-cloneable enums are not currently exportable pub fn tlv_type(&self) -> u64 { match self { &OnionMessageContents::Custom(ref msg) => msg.tlv_type(), @@ -124,6 +127,7 @@ impl OnionMessageContents where T: CustomOnionMessageContents { } } +/// This is not exported to bindings users as methods on non-cloneable enums are not currently exportable impl Writeable for OnionMessageContents { fn write(&self, w: &mut W) -> Result<(), io::Error> { match self { @@ -132,21 +136,20 @@ impl Writeable for OnionMessageContents { } } -/// The contents of a custom onion message. Must implement `MaybeReadableArgs` where the `u64` -/// is the custom TLV type attempting to be read, and return `Ok(None)` if the TLV type is unknown. -pub trait CustomOnionMessageContents: Writeable + MaybeReadableArgs { +/// The contents of a custom onion message. +pub trait CustomOnionMessageContents: Writeable { /// Returns the TLV type identifying the message contents. MUST be >= 64. fn tlv_type(&self) -> u64; } /// Forward control TLVs in their blinded and unblinded form. pub(super) enum ForwardControlTlvs { - /// If we're sending to a blinded route, the node that constructed the blinded route has provided + /// If we're sending to a blinded path, the node that constructed the blinded path has provided /// this hop's control TLVs, already encrypted into bytes. Blinded(Vec), /// If we're constructing an onion message hop through an intermediate unblinded node, we'll need /// to construct the intermediate hop's control TLVs in their unblinded state to avoid encoding - /// them into an intermediate Vec. See [`super::blinded_route::ForwardTlvs`] for more info. + /// them into an intermediate Vec. See [`crate::blinded_path::ForwardTlvs`] for more info. Unblinded(ForwardTlvs), } @@ -154,7 +157,7 @@ pub(super) enum ForwardControlTlvs { pub(super) enum ReceiveControlTlvs { /// See [`ForwardControlTlvs::Blinded`]. Blinded(Vec), - /// See [`ForwardControlTlvs::Unblinded`] and [`super::blinded_route::ReceiveTlvs`]. + /// See [`ForwardControlTlvs::Unblinded`] and [`crate::blinded_path::ReceiveTlvs`]. Unblinded(ReceiveTlvs), } @@ -163,22 +166,22 @@ impl Writeable for (Payload, [u8; 32]) { fn write(&self, w: &mut W) -> Result<(), io::Error> { match &self.0 { Payload::Forward(ForwardControlTlvs::Blinded(encrypted_bytes)) => { - encode_varint_length_prefixed_tlv!(w, { - (4, encrypted_bytes, vec_type) + _encode_varint_length_prefixed_tlv!(w, { + (4, *encrypted_bytes, vec_type) }) }, Payload::Receive { control_tlvs: ReceiveControlTlvs::Blinded(encrypted_bytes), reply_path, message, } => { - encode_varint_length_prefixed_tlv!(w, { + _encode_varint_length_prefixed_tlv!(w, { (2, reply_path, option), - (4, encrypted_bytes, vec_type), + (4, *encrypted_bytes, vec_type), (message.tlv_type(), message, required) }) }, Payload::Forward(ForwardControlTlvs::Unblinded(control_tlvs)) => { let write_adapter = ChaChaPolyWriteAdapter::new(self.1, &control_tlvs); - encode_varint_length_prefixed_tlv!(w, { + _encode_varint_length_prefixed_tlv!(w, { (4, write_adapter, required) }) }, @@ -186,7 +189,7 @@ impl Writeable for (Payload, [u8; 32]) { control_tlvs: ReceiveControlTlvs::Unblinded(control_tlvs), reply_path, message, } => { let write_adapter = ChaChaPolyWriteAdapter::new(self.1, &control_tlvs); - encode_varint_length_prefixed_tlv!(w, { + _encode_varint_length_prefixed_tlv!(w, { (2, reply_path, option), (4, write_adapter, required), (message.tlv_type(), message, required) @@ -198,16 +201,18 @@ impl Writeable for (Payload, [u8; 32]) { } // Uses the provided secret to simultaneously decode and decrypt the control TLVs and data TLV. -impl ReadableArgs for Payload { - fn read(r: &mut R, encrypted_tlvs_ss: SharedSecret) -> Result { +impl ReadableArgs<(SharedSecret, &H)> for Payload<::CustomMessage> { + fn read(r: &mut R, args: (SharedSecret, &H)) -> Result { + let (encrypted_tlvs_ss, handler) = args; + let v: BigSize = Readable::read(r)?; let mut rd = FixedLengthReader::new(r, v.0); - let mut reply_path: Option = None; + let mut reply_path: Option = None; let mut read_adapter: Option> = None; let rho = onion_utils::gen_rho_from_shared_secret(&encrypted_tlvs_ss.secret_bytes()); let mut message_type: Option = None; let mut message = None; - decode_tlv_stream!(&mut rd, { + decode_tlv_stream_with_custom_tlv_decode!(&mut rd, { (2, reply_path, option), (4, read_adapter, (option: LengthReadableArgs, rho)), }, |msg_type, msg_reader| { @@ -216,7 +221,7 @@ impl ReadableArgs for Payload { if message_type.is_some() { return Err(DecodeError::InvalidValue) } message_type = Some(msg_type); - match T::read(msg_reader, msg_type) { + match handler.read_custom_message(msg_type, msg_reader) { Ok(Some(msg)) => { message = Some(msg); Ok(true) @@ -250,7 +255,7 @@ impl ReadableArgs for Payload { /// When reading a packet off the wire, we don't know a priori whether the packet is to be forwarded /// or received. Thus we read a ControlTlvs rather than reading a ForwardControlTlvs or /// ReceiveControlTlvs directly. -pub(super) enum ControlTlvs { +pub(crate) enum ControlTlvs { /// This onion message is intended to be forwarded. Forward(ForwardTlvs), /// This onion message is intended to be received.