f change name, fix offset, add more details to why

Author: TheBlueMatt

lightning/src/util/ser.rs

@@ -387,28 +387,31 @@ impl Readable for BigSize {
 /// primarily targets that, we must as well. However, because we may serialize objects that have
 /// more than 65K entries, we need to be able to store larger values. Thus, we define a variable
 /// length integer here which is backwards-compatible but treats 0xffff as "read eight more bytes".
-struct U16Or64(pub u64);
-impl Writeable for U16Or64 {
+///
+/// To ensure we only have one valid encoding per value, we add 0xffff to values written as eight
+/// bytes, representing 0xffff as zero-eight-bytes, which 0xfffe is 0xfffe-two-bytes.
+struct U16OrU64(pub u64);
+impl Writeable for U16OrU64 {
 	#[inline]
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
 		if self.0 < 0xffff {
 			(self.0 as u16).write(writer)
 		} else {
 			0xffffu16.write(writer)?;
-			(self.0 - 0xfffe).write(writer)
+			(self.0 - 0xffff).write(writer)
 		}
 	}
 }
 
-impl Readable for U16Or64 {
+impl Readable for U16OrU64 {
 	#[inline]
 	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 		let mut val: u64 = <u16 as Readable>::read(r)? as u64;
 		if val == 0xffff {
 			val = <u64 as Readable>::read(r)?
-				.checked_add(0xfffe).ok_or(DecodeError::InvalidValue)?;
+				.checked_add(0xffff).ok_or(DecodeError::InvalidValue)?;
 		}
-		Ok(U16Or64(val))
+		Ok(U16OrU64(val))
 	}
 }
 
@@ -626,7 +629,7 @@ macro_rules! impl_for_map {
 		{
 			#[inline]
 			fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
-				U16Or64(self.len() as u64).write(w)?;
+				U16OrU64(self.len() as u64).write(w)?;
 				for (key, value) in self.iter() {
 					key.write(w)?;
 					value.write(w)?;
@@ -640,7 +643,7 @@ macro_rules! impl_for_map {
 		{
 			#[inline]
 			fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
-				let len: U16Or64 = Readable::read(r)?;
+				let len: U16OrU64 = Readable::read(r)?;
 				let mut ret = $constr(len.0 as usize);
 				for _ in 0..len.0 {
 					let k = K::read(r)?;
@@ -666,7 +669,7 @@ where T: Writeable + Eq + Hash
 {
 	#[inline]
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
-		U16Or64(self.len() as u64).write(w)?;
+		U16OrU64(self.len() as u64).write(w)?;
 		for item in self.iter() {
 			item.write(w)?;
 		}
@@ -679,7 +682,7 @@ where T: Readable + Eq + Hash
 {
 	#[inline]
 	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
-		let len: U16Or64 = Readable::read(r)?;
+		let len: U16OrU64 = Readable::read(r)?;
 		let mut ret = HashSet::with_capacity(cmp::min(len.0 as usize, MAX_BUF_SIZE / core::mem::size_of::<T>()));
 		for _ in 0..len.0 {
 			if !ret.insert(T::read(r)?) {
@@ -696,7 +699,7 @@ macro_rules! impl_for_vec {
 		impl<$($name : Writeable),*> Writeable for Vec<$ty> {
 			#[inline]
 			fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
-				U16Or64(self.len() as u64).write(w)?;
+				U16OrU64(self.len() as u64).write(w)?;
 				for elem in self.iter() {
 					elem.write(w)?;
 				}
@@ -707,7 +710,7 @@ macro_rules! impl_for_vec {
 		impl<$($name : Readable),*> Readable for Vec<$ty> {
 			#[inline]
 			fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
-				let len: U16Or64 = Readable::read(r)?;
+				let len: U16OrU64 = Readable::read(r)?;
 				let mut ret = Vec::with_capacity(cmp::min(len.0 as usize, MAX_BUF_SIZE / core::mem::size_of::<$ty>()));
 				for _ in 0..len.0 {
 					if let Some(val) = MaybeReadable::read(r)? {
@@ -723,15 +726,15 @@ macro_rules! impl_for_vec {
 impl Writeable for Vec<u8> {
 	#[inline]
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
-		U16Or64(self.len() as u64).write(w)?;
+		U16OrU64(self.len() as u64).write(w)?;
 		w.write_all(&self)
 	}
 }
 
 impl Readable for Vec<u8> {
 	#[inline]
 	fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
-		let mut len: U16Or64 = Readable::read(r)?;
+		let mut len: U16OrU64 = Readable::read(r)?;
 		let mut ret = Vec::new();
 		while len.0 > 0 {
 			let readamt = cmp::min(len.0 as usize, MAX_BUF_SIZE);
@@ -1074,7 +1077,7 @@ impl Readable for () {
 impl Writeable for String {
 	#[inline]
 	fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
-		U16Or64(self.len() as u64).write(w)?;
+		U16OrU64(self.len() as u64).write(w)?;
 		w.write_all(self.as_bytes())
 	}
 }