Stop checking size > 64KB in serialization

TheBlueMatt · TheBlueMatt · commit a399d4fcef82 · 2018-09-16T14:32:35.000-04:00
This removes a bunch of potentially new error handling in writers
and the checks were kinda useless anyway - in normal operation we
unwrap()ed anyway, and we're gonna want to use the serializtion
framework for ChannelMonitor/ChannelManager serialization, which
may generate things larger than 64KB anyway.
diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs
@@ -743,7 +743,7 @@ impl_writeable!(AnnouncementSignatures, 32+8+64*2, {
 });
 
 impl<W: Writer> Writeable<W> for ChannelReestablish {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(if self.data_loss_protect.is_some() { 32+2*8+33+32 } else { 32+2*8 });
 		self.channel_id.write(w)?;
 		self.next_local_commitment_number.write(w)?;
@@ -906,7 +906,7 @@ impl_writeable_len_match!(OnionErrorPacket, {
 });
 
 impl<W: Writer> Writeable<W> for OnionPacket {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(1 + 33 + 20*65 + 32);
 		self.version.write(w)?;
 		match self.public_key {
@@ -944,7 +944,7 @@ impl_writeable!(UpdateAddHTLC, 32+8+8+32+4+1366, {
 });
 
 impl<W: Writer> Writeable<W> for OnionRealm0HopData {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(32);
 		self.short_channel_id.write(w)?;
 		self.amt_to_forward.write(w)?;
@@ -969,7 +969,7 @@ impl<R: Read> Readable<R> for OnionRealm0HopData {
 }
 
 impl<W: Writer> Writeable<W> for OnionHopData {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(65);
 		self.realm.write(w)?;
 		self.data.write(w)?;
@@ -995,7 +995,7 @@ impl<R: Read> Readable<R> for OnionHopData {
 }
 
 impl<W: Writer> Writeable<W> for Ping {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(self.byteslen as usize + 4);
 		self.ponglen.write(w)?;
 		vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
@@ -1017,7 +1017,7 @@ impl<R: Read> Readable<R> for Ping {
 }
 
 impl<W: Writer> Writeable<W> for Pong {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(self.byteslen as usize + 2);
 		vec![0u8; self.byteslen as usize].write(w)?; // size-unchecked write
 		Ok(())
@@ -1037,7 +1037,7 @@ impl<R: Read> Readable<R> for Pong {
 }
 
 impl<W: Writer> Writeable<W> for UnsignedChannelAnnouncement {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(2 + 2*32 + 4*33 + self.features.flags.len() + self.excess_data.len());
 		self.features.write(w)?;
 		self.chain_hash.write(w)?;
@@ -1088,7 +1088,7 @@ impl_writeable_len_match!(ChannelAnnouncement, {
 });
 
 impl<W: Writer> Writeable<W> for UnsignedChannelUpdate {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(64 + self.excess_data.len());
 		self.chain_hash.write(w)?;
 		self.short_channel_id.write(w)?;
@@ -1132,7 +1132,7 @@ impl_writeable_len_match!(ChannelUpdate, {
 });
 
 impl<W: Writer> Writeable<W> for ErrorMessage {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(32 + 2 + self.data.len());
 		self.channel_id.write(w)?;
 		(self.data.len() as u16).write(w)?;
@@ -1160,7 +1160,7 @@ impl<R: Read> Readable<R> for ErrorMessage {
 }
 
 impl<W: Writer> Writeable<W> for UnsignedNodeAnnouncement {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		w.size_hint(64 + 76 + self.features.flags.len() + self.addresses.len()*38 + self.excess_address_data.len() + self.excess_data.len());
 		self.features.write(w)?;
 		self.timestamp.write(w)?;
diff --git a/src/util/ser.rs b/src/util/ser.rs
@@ -38,7 +38,7 @@ impl<W: ::std::io::Write> Writer for W {
 /// A trait that various rust-lightning types implement allowing them to be written out to a Writer
 pub trait Writeable<W: Writer> {
 	/// Writes self out to the given Writer
-	fn write(&self, writer: &mut W) -> Result<(), DecodeError>;
+	fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error>;
 }
 
 /// A trait that various rust-lightning types implement allowing them to be read in from a Read
@@ -54,8 +54,8 @@ macro_rules! impl_writeable_primitive {
 	($val_type:ty, $meth_write:ident, $len: expr, $meth_read:ident) => {
 		impl<W: Writer> Writeable<W> for $val_type {
 			#[inline]
-			fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
-				Ok(writer.write_all(&$meth_write(*self))?)
+			fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+				writer.write_all(&$meth_write(*self))
 			}
 		}
 		impl<R: Read> Readable<R> for $val_type {
@@ -75,8 +75,8 @@ impl_writeable_primitive!(u16, be16_to_array, 2, slice_to_be16);
 
 impl<W: Writer> Writeable<W> for u8 {
 	#[inline]
-	fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
-		Ok(writer.write_all(&[*self])?)
+	fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+		writer.write_all(&[*self])
 	}
 }
 impl<R: Read> Readable<R> for u8 {
@@ -90,8 +90,8 @@ impl<R: Read> Readable<R> for u8 {
 
 impl<W: Writer> Writeable<W> for bool {
 	#[inline]
-	fn write(&self, writer: &mut W) -> Result<(), DecodeError> {
-		Ok(writer.write_all(&[if *self {1} else {0}])?)
+	fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
+		writer.write_all(&[if *self {1} else {0}])
 	}
 }
 impl<R: Read> Readable<R> for bool {
@@ -112,9 +112,8 @@ macro_rules! impl_array {
 		impl<W: Writer> Writeable<W> for [u8; $size]
 		{
 			#[inline]
-			fn write(&self, w: &mut W) -> Result<(), DecodeError> {
-				w.write_all(self)?;
-				Ok(())
+			fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+				w.write_all(self)
 			}
 		}
 
@@ -143,7 +142,7 @@ impl<W, K, V> Writeable<W> for HashMap<K, V>
 	      V: Writeable<W>
 {
 	#[inline]
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 	(self.len() as u16).write(w)?;
 		for (key, value) in self.iter() {
 			key.write(w)?;
@@ -172,9 +171,9 @@ impl<R, K, V> Readable<R> for HashMap<K, V>
 // Vectors
 impl<W: Writer> Writeable<W> for Vec<u8> {
 	#[inline]
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		(self.len() as u16).write(w)?;
-		Ok(w.write_all(&self)?)
+		w.write_all(&self)
 	}
 }
 
@@ -190,13 +189,7 @@ impl<R: Read> Readable<R> for Vec<u8> {
 }
 impl<W: Writer> Writeable<W> for Vec<Signature> {
 	#[inline]
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
-		let byte_size = (self.len() as usize)
-		                .checked_mul(33)
-		                .ok_or(DecodeError::BadLengthDescriptor)?;
-		if byte_size > MAX_BUF_SIZE {
-			return Err(DecodeError::BadLengthDescriptor);
-		}
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		(self.len() as u16).write(w)?;
 		for e in self.iter() {
 			e.write(w)?;
@@ -222,9 +215,9 @@ impl<R: Read> Readable<R> for Vec<Signature> {
 }
 
 impl<W: Writer> Writeable<W> for Script {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		(self.len() as u16).write(w)?;
-		Ok(w.write_all(self.as_bytes())?)
+		w.write_all(self.as_bytes())
 	}
 }
 
@@ -238,7 +231,7 @@ impl<R: Read> Readable<R> for Script {
 }
 
 impl<W: Writer> Writeable<W> for Option<Script> {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		if let &Some(ref script) = self {
 			script.write(w)?;
 		}
@@ -261,7 +254,7 @@ impl<R: Read> Readable<R> for Option<Script> {
 }
 
 impl<W: Writer> Writeable<W> for PublicKey {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.serialize().write(w)
 	}
 }
@@ -277,7 +270,7 @@ impl<R: Read> Readable<R> for PublicKey {
 }
 
 impl<W: Writer> Writeable<W> for Sha256dHash {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.as_bytes().write(w)
 	}
 }
@@ -290,7 +283,7 @@ impl<R: Read> Readable<R> for Sha256dHash {
 }
 
 impl<W: Writer> Writeable<W> for Signature {
-	fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+	fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 		self.serialize_compact(&Secp256k1::without_caps()).write(w)
 	}
 }
diff --git a/src/util/ser_macros.rs b/src/util/ser_macros.rs
@@ -1,7 +1,7 @@
 macro_rules! impl_writeable {
 	($st:ident, $len: expr, {$($field:ident),*}) => {
 		impl<W: Writer> Writeable<W> for $st {
-			fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+			fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 				w.size_hint($len);
 				$( self.$field.write(w)?; )*
 				Ok(())
@@ -20,7 +20,7 @@ macro_rules! impl_writeable {
 macro_rules! impl_writeable_len_match {
 	($st:ident, {$({$m: pat, $l: expr}),*}, {$($field:ident),*}) => {
 		impl<W: Writer> Writeable<W> for $st {
-			fn write(&self, w: &mut W) -> Result<(), DecodeError> {
+			fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 				w.size_hint(match *self {
 					$($m => $l,)*
 				});

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ impl<W: ::std::io::Write> Writer for W {`
`38`	`38`	`/// A trait that various rust-lightning types implement allowing them to be written out to a Writer`
`39`	`39`	`pub trait Writeable<W: Writer> {`
`40`	`40`	`/// Writes self out to the given Writer`
`41`		`- fn write(&self, writer: &mut W) -> Result<(), DecodeError>;`
	`41`	`+ fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error>;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`/// A trait that various rust-lightning types implement allowing them to be read in from a Read`
`@@ -54,8 +54,8 @@ macro_rules! impl_writeable_primitive {`
`54`	`54`	`($val_type:ty, $meth_write:ident, $len: expr, $meth_read:ident) => {`
`55`	`55`	`impl<W: Writer> Writeable<W> for $val_type {`
`56`	`56`	`#[inline]`
`57`		`- fn write(&self, writer: &mut W) -> Result<(), DecodeError> {`
`58`		`- Ok(writer.write_all(&$meth_write(*self))?)`
	`57`	`+ fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
	`58`	`+ writer.write_all(&$meth_write(*self))`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`impl<R: Read> Readable<R> for $val_type {`
`@@ -75,8 +75,8 @@ impl_writeable_primitive!(u16, be16_to_array, 2, slice_to_be16);`
`75`	`75`
`76`	`76`	`impl<W: Writer> Writeable<W> for u8 {`
`77`	`77`	`#[inline]`
`78`		`- fn write(&self, writer: &mut W) -> Result<(), DecodeError> {`
`79`		`- Ok(writer.write_all(&[*self])?)`
	`78`	`+ fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
	`79`	`+ writer.write_all(&[*self])`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`	`impl<R: Read> Readable<R> for u8 {`
`@@ -90,8 +90,8 @@ impl<R: Read> Readable<R> for u8 {`
`90`	`90`
`91`	`91`	`impl<W: Writer> Writeable<W> for bool {`
`92`	`92`	`#[inline]`
`93`		`- fn write(&self, writer: &mut W) -> Result<(), DecodeError> {`
`94`		`- Ok(writer.write_all(&[if *self {1} else {0}])?)`
	`93`	`+ fn write(&self, writer: &mut W) -> Result<(), ::std::io::Error> {`
	`94`	`+ writer.write_all(&[if *self {1} else {0}])`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`	`impl<R: Read> Readable<R> for bool {`
`@@ -112,9 +112,8 @@ macro_rules! impl_array {`
`112`	`112`	`impl<W: Writer> Writeable<W> for [u8; $size]`
`113`	`113`	`{`
`114`	`114`	`#[inline]`
`115`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
`116`		`- w.write_all(self)?;`
`117`		`- Ok(())`
	`115`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
	`116`	`+ w.write_all(self)`
`118`	`117`	`}`
`119`	`118`	`}`
`120`	`119`
`@@ -143,7 +142,7 @@ impl<W, K, V> Writeable<W> for HashMap<K, V>`
`143`	`142`	`V: Writeable<W>`
`144`	`143`	`{`
`145`	`144`	`#[inline]`
`146`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
	`145`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`147`	`146`	`(self.len() as u16).write(w)?;`
`148`	`147`	`for (key, value) in self.iter() {`
`149`	`148`	`key.write(w)?;`
`@@ -172,9 +171,9 @@ impl<R, K, V> Readable<R> for HashMap<K, V>`
`172`	`171`	`// Vectors`
`173`	`172`	`impl<W: Writer> Writeable<W> for Vec<u8> {`
`174`	`173`	`#[inline]`
`175`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
	`174`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`176`	`175`	`(self.len() as u16).write(w)?;`
`177`		`- Ok(w.write_all(&self)?)`
	`176`	`+ w.write_all(&self)`
`178`	`177`	`}`
`179`	`178`	`}`
`180`	`179`
`@@ -190,13 +189,7 @@ impl<R: Read> Readable<R> for Vec<u8> {`
`190`	`189`	`}`
`191`	`190`	`impl<W: Writer> Writeable<W> for Vec<Signature> {`
`192`	`191`	`#[inline]`
`193`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
`194`		`- let byte_size = (self.len() as usize)`
`195`		`- .checked_mul(33)`
`196`		`- .ok_or(DecodeError::BadLengthDescriptor)?;`
`197`		`- if byte_size > MAX_BUF_SIZE {`
`198`		`- return Err(DecodeError::BadLengthDescriptor);`
`199`		`- }`
	`192`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`200`	`193`	`(self.len() as u16).write(w)?;`
`201`	`194`	`for e in self.iter() {`
`202`	`195`	`e.write(w)?;`
`@@ -222,9 +215,9 @@ impl<R: Read> Readable<R> for Vec<Signature> {`
`222`	`215`	`}`
`223`	`216`
`224`	`217`	`impl<W: Writer> Writeable<W> for Script {`
`225`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
	`218`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`226`	`219`	`(self.len() as u16).write(w)?;`
`227`		`- Ok(w.write_all(self.as_bytes())?)`
	`220`	`+ w.write_all(self.as_bytes())`
`228`	`221`	`}`
`229`	`222`	`}`
`230`	`223`
`@@ -238,7 +231,7 @@ impl<R: Read> Readable<R> for Script {`
`238`	`231`	`}`
`239`	`232`
`240`	`233`	`impl<W: Writer> Writeable<W> for Option<Script> {`
`241`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
	`234`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`242`	`235`	`if let &Some(ref script) = self {`
`243`	`236`	`script.write(w)?;`
`244`	`237`	`}`
`@@ -261,7 +254,7 @@ impl<R: Read> Readable<R> for Option<Script> {`
`261`	`254`	`}`
`262`	`255`
`263`	`256`	`impl<W: Writer> Writeable<W> for PublicKey {`
`264`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
	`257`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`265`	`258`	`self.serialize().write(w)`
`266`	`259`	`}`
`267`	`260`	`}`
`@@ -277,7 +270,7 @@ impl<R: Read> Readable<R> for PublicKey {`
`277`	`270`	`}`
`278`	`271`
`279`	`272`	`impl<W: Writer> Writeable<W> for Sha256dHash {`
`280`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
	`273`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`281`	`274`	`self.as_bytes().write(w)`
`282`	`275`	`}`
`283`	`276`	`}`
`@@ -290,7 +283,7 @@ impl<R: Read> Readable<R> for Sha256dHash {`
`290`	`283`	`}`
`291`	`284`
`292`	`285`	`impl<W: Writer> Writeable<W> for Signature {`
`293`		`- fn write(&self, w: &mut W) -> Result<(), DecodeError> {`
	`286`	`+ fn write(&self, w: &mut W) -> Result<(), ::std::io::Error> {`
`294`	`287`	`self.serialize_compact(&Secp256k1::without_caps()).write(w)`
`295`	`288`	`}`
`296`	`289`	`}`