Implement LengthLimitedRead for &[u8]

We want to slowly phase out the use of Cursor in the codebase, which means we
want to be able to call LengthLimitedRead::read(&mut &slice_of_bytes[..])
instead of wrapping the slice in a Cursor.

However, this breaks the current LengthLimitedRead::total_bytes method because
the underlying Read implementation for slice advances the slice as it is read,
so slice.len() can't be used to get the total bytes after any part of the struct
is read.

Therefore here we also switch the ::total_bytes method to ::remaining_bytes,
which seems like a more sensible method anyway since the reader is being
consumed.

Author: valentinewallace

lightning/src/crypto/streams.rs

@@ -60,12 +60,12 @@ impl<T: Readable> LengthReadableArgs<[u8; 32]> for ChaChaPolyReadAdapter<T> {
 	// Self::readable. LengthLimitedRead must be used instead of std::io::Read because we need the
 	// total length to separate out the tag at the end.
 	fn read<R: LengthLimitedRead>(r: &mut R, secret: [u8; 32]) -> Result<Self, DecodeError> {
-		if r.total_bytes() < 16 {
+		if r.remaining_bytes() < 16 {
 			return Err(DecodeError::InvalidValue);
 		}
 
 		let mut chacha = ChaCha20Poly1305RFC::new(&secret, &[0; 12], &[]);
-		let decrypted_len = r.total_bytes() - 16;
+		let decrypted_len = r.remaining_bytes() - 16;
 		let s = FixedLengthReader::new(r, decrypted_len);
 		let mut chacha_stream = ChaChaPolyReader { chacha: &mut chacha, read: s };
 		let readable: T = Readable::read(&mut chacha_stream)?;

lightning/src/ln/msgs.rs

@@ -2324,10 +2324,11 @@ impl Writeable for TrampolineOnionPacket {
 
 impl LengthReadable for TrampolineOnionPacket {
 	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
+		let hop_data_len = r.remaining_bytes().saturating_sub(66); // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
+
 		let version = Readable::read(r)?;
 		let public_key = Readable::read(r)?;
 
-		let hop_data_len = r.total_bytes().saturating_sub(66); // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
 		let mut rd = FixedLengthReader::new(r, hop_data_len);
 		let hop_data = WithoutLength::<Vec<u8>>::read(&mut rd)?.0;
 

lightning/src/onion_message/packet.rs

@@ -85,12 +85,12 @@ impl Writeable for Packet {
 impl LengthReadable for Packet {
 	fn read_from_fixed_length_buffer<R: LengthLimitedRead>(r: &mut R) -> Result<Self, DecodeError> {
 		const READ_BUFFER_SIZE: usize = 4096;
+		let hop_data_len = r.remaining_bytes().saturating_sub(66) as usize; // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
 
 		let version = Readable::read(r)?;
 		let public_key = Readable::read(r)?;
 
 		let mut hop_data = Vec::new();
-		let hop_data_len = r.total_bytes().saturating_sub(66) as usize; // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
 		let mut read_idx = 0;
 		while read_idx < hop_data_len {
 			let mut read_buffer = [0; READ_BUFFER_SIZE];

lightning/src/util/ser.rs

@@ -228,8 +228,8 @@ impl<'a, R: Read> Read for FixedLengthReader<'a, R> {
 
 impl<'a, R: Read> LengthLimitedRead for FixedLengthReader<'a, R> {
 	#[inline]
-	fn total_bytes(&self) -> u64 {
-		self.total_bytes
+	fn remaining_bytes(&self) -> u64 {
+		self.total_bytes.saturating_sub(self.bytes_read)
 	}
 }
 
@@ -348,8 +348,16 @@ where
 /// that the object being read will only consume a fixed number of bytes from the underlying
 /// [`io::Read`], see [`FixedLengthReader`] for an example.
 pub trait LengthLimitedRead: Read {
-	/// The total number of bytes available to be read.
-	fn total_bytes(&self) -> u64;
+	/// The number of bytes remaining to be read.
+	fn remaining_bytes(&self) -> u64;
+}
+
+impl LengthLimitedRead for &[u8] {
+	fn remaining_bytes(&self) -> u64 {
+		// The underlying `Read` implementation for slice updates the slice to point to the yet unread
+		// part.
+		self.len() as u64
+	}
 }
 
 /// Similar to [`LengthReadable`]. Useful when an additional set of arguments is required to