Merge pull request #1692 from TheBlueMatt/2022-08-time-goes-backwards

[rust-lightning] / lightning / src / onion_message / packet.rs

diff --git a/lightning/src/onion_message/packet.rs b/lightning/src/onion_message/packet.rs
index 5afe578121ba1440c1a66f40a0c2995b4fadb7de..1337bdb14d5d6c3bf83fcadc5beebcea8b6d70d8 100644 (file)
--- a/lightning/src/onion_message/packet.rs
+++ b/lightning/src/onion_message/packet.rs
@@ -14,7 +14,7 @@ use bitcoin::secp256k1::ecdh::SharedSecret;
 
 use ln::msgs::DecodeError;
 use ln::onion_utils;
-use super::blinded_route::{ForwardTlvs, ReceiveTlvs};
+use super::blinded_route::{BlindedRoute, ForwardTlvs, ReceiveTlvs};
 use util::chacha20poly1305rfc::{ChaChaPolyReadAdapter, ChaChaPolyWriteAdapter};
 use util::ser::{BigSize, FixedLengthReader, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer};
 
@@ -74,7 +74,7 @@ impl LengthReadable for Packet {
                while read_idx < hop_data_len {
                        let mut read_buffer = [0; READ_BUFFER_SIZE];
                        let read_amt = cmp::min(hop_data_len - read_idx, READ_BUFFER_SIZE);
-                       r.read_exact(&mut read_buffer[..read_amt]);
+                       r.read_exact(&mut read_buffer[..read_amt])?;
                        hop_data.extend_from_slice(&read_buffer[..read_amt]);
                        read_idx += read_amt;
                }
@@ -98,8 +98,8 @@ pub(super) enum Payload {
        /// This payload is for the final hop.
        Receive {
                control_tlvs: ReceiveControlTlvs,
+               reply_path: Option<BlindedRoute>,
                // Coming soon:
-               // reply_path: Option<BlindedRoute>,
                // message: Message,
        }
 }
@@ -135,21 +135,31 @@ pub(super) enum ReceiveControlTlvs {
 impl Writeable for (Payload, [u8; 32]) {
        fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
                match &self.0 {
-                       Payload::Forward(ForwardControlTlvs::Blinded(encrypted_bytes)) |
-                       Payload::Receive { control_tlvs: ReceiveControlTlvs::Blinded(encrypted_bytes)} => {
+                       Payload::Forward(ForwardControlTlvs::Blinded(encrypted_bytes)) => {
                                encode_varint_length_prefixed_tlv!(w, {
                                        (4, encrypted_bytes, vec_type)
                                })
                        },
+                       Payload::Receive {
+                               control_tlvs: ReceiveControlTlvs::Blinded(encrypted_bytes), reply_path
+                       } => {
+                               encode_varint_length_prefixed_tlv!(w, {
+                                       (2, reply_path, option),
+                                       (4, encrypted_bytes, vec_type)
+                               })
+                       },
                        Payload::Forward(ForwardControlTlvs::Unblinded(control_tlvs)) => {
                                let write_adapter = ChaChaPolyWriteAdapter::new(self.1, &control_tlvs);
                                encode_varint_length_prefixed_tlv!(w, {
                                        (4, write_adapter, required)
                                })
                        },
-                       Payload::Receive { control_tlvs: ReceiveControlTlvs::Unblinded(control_tlvs)} => {
+                       Payload::Receive {
+                               control_tlvs: ReceiveControlTlvs::Unblinded(control_tlvs), reply_path,
+                       } => {
                                let write_adapter = ChaChaPolyWriteAdapter::new(self.1, &control_tlvs);
                                encode_varint_length_prefixed_tlv!(w, {
+                                       (2, reply_path, option),
                                        (4, write_adapter, required)
                                })
                        },
@@ -160,15 +170,14 @@ impl Writeable for (Payload, [u8; 32]) {
 
 // Uses the provided secret to simultaneously decode and decrypt the control TLVs.
 impl ReadableArgs<SharedSecret> for Payload {
-       fn read<R: Read>(mut r: &mut R, encrypted_tlvs_ss: SharedSecret) -> Result<Self, DecodeError> {
+       fn read<R: Read>(r: &mut R, encrypted_tlvs_ss: SharedSecret) -> Result<Self, DecodeError> {
                let v: BigSize = Readable::read(r)?;
                let mut rd = FixedLengthReader::new(r, v.0);
-               // TODO: support reply paths
-               let mut _reply_path_bytes: Option<Vec<u8>> = Some(Vec::new());
+               let mut reply_path: Option<BlindedRoute> = None;
                let mut read_adapter: Option<ChaChaPolyReadAdapter<ControlTlvs>> = None;
                let rho = onion_utils::gen_rho_from_shared_secret(&encrypted_tlvs_ss.secret_bytes());
                decode_tlv_stream!(&mut rd, {
-                       (2, _reply_path_bytes, vec_type),
+                       (2, reply_path, option),
                        (4, read_adapter, (option: LengthReadableArgs, rho))
                });
                rd.eat_remaining().map_err(|_| DecodeError::ShortRead)?;
@@ -179,7 +188,7 @@ impl ReadableArgs<SharedSecret> for Payload {
                                Ok(Payload::Forward(ForwardControlTlvs::Unblinded(tlvs)))
                        },
                        Some(ChaChaPolyReadAdapter { readable: ControlTlvs::Receive(tlvs)}) => {
-                               Ok(Payload::Receive { control_tlvs: ReceiveControlTlvs::Unblinded(tlvs)})
+                               Ok(Payload::Receive { control_tlvs: ReceiveControlTlvs::Unblinded(tlvs), reply_path })
                        },
                }
        }