Replace all Rlp usages with UntrustedRlp except for ethcore views (#8233)

* Replace Rlp with UntrustedRlp and unsafely unwrap

All Rlp methods return Result<_,DecoderError> now, so for this first
pass each will be marked with `expect("TODO")`. In the next pass we can
categorise figure out how to handle each case.

* Handle DecoderError for tendermint message

* Unwrap rlp results in TestBlockcChainClient

Rlp should be valid since created manually in tests

* Replace `use rlp::*` with explicit imports

* Remove rlp decode unwraps from light cli request

* Structured rlp encoding for curr best and latest in header chain

* Propogate decoder errors from send_packet

* Fix body uncles rlp index

* Use BodyView in sync and `expect` rlp errors

* Revert bbf28f removing original Rlp for this phase

This can be done again in the next phase, in order that we can leave the ethcore views unchanged

* Restore legacy Rlp and UntrustedRlp

Use legacy Rlp for ethcore views. Will redo replacing Rlp with UntrustedRlp in  a subsequent PR

* Fix tests

* Replace boilerplate Encodable/Decodable with derive

* Use BlockView instead of Rlp, remove unwrap

* Remove rlp test_cli unwraps by using BlockView instead of Rlp directly

* Remove unneccesary change to use borrowed hash

* Construct sync block using new_from_header_and_body

util/network-devp2p/src/connection.rs

@@ -23,7 +23,7 @@ use mio::deprecated::{Handler, EventLoop, TryRead, TryWrite};
 use mio::tcp::*;
 use ethereum_types::{H128, H256, H512};
 use ethcore_bytes::*;
-use rlp::*;
+use rlp::{UntrustedRlp, RlpStream};
 use std::io::{self, Cursor, Read, Write};
 use io::{IoContext, StreamToken};
 use handshake::Handshake;

util/network-devp2p/src/discovery.rs

@@ -25,7 +25,7 @@ use mio::deprecated::{Handler, EventLoop};
 use mio::udp::*;
 use hash::keccak;
 use ethereum_types::{H256, H520};
-use rlp::*;
+use rlp::{UntrustedRlp, RlpStream, encode_list};
 use node_table::*;
 use network::{Error, ErrorKind};
 use io::{StreamToken, IoContext};
@@ -216,7 +216,8 @@ impl Discovery {
 			let nearest = nearest.filter(|x| !self.discovery_nodes.contains(&x.id)).take(ALPHA).collect::<Vec<_>>();
 			for r in nearest {
 				let rlp = encode_list(&(&[self.discovery_id.clone()][..]));
-				self.send_packet(PACKET_FIND_NODE, &r.endpoint.udp_address(), &rlp);
+				self.send_packet(PACKET_FIND_NODE, &r.endpoint.udp_address(), &rlp)
+					.unwrap_or_else(|e| warn!("Error sending node discovery packet for {:?}: {:?}", &r.endpoint, e));
 				self.discovery_nodes.insert(r.id.clone());
 				tried_count += 1;
 				trace!(target: "discovery", "Sent FindNode to {:?}", &r.endpoint);
@@ -251,16 +252,17 @@ impl Discovery {
 		self.public_endpoint.to_rlp_list(&mut rlp);
 		node.to_rlp_list(&mut rlp);
 		trace!(target: "discovery", "Sent Ping to {:?}", &node);
-		self.send_packet(PACKET_PING, &node.udp_address(), &rlp.drain());
+		self.send_packet(PACKET_PING, &node.udp_address(), &rlp.drain())
+			.unwrap_or_else(|e| warn!("Error sending Ping packet: {:?}", e))
 	}
 
-	fn send_packet(&mut self, packet_id: u8, address: &SocketAddr, payload: &[u8]) {
+	fn send_packet(&mut self, packet_id: u8, address: &SocketAddr, payload: &[u8]) -> Result<(), Error> {
 		let mut rlp = RlpStream::new();
 		rlp.append_raw(&[packet_id], 1);
-		let source = Rlp::new(payload);
-		rlp.begin_list(source.item_count() + 1);
-		for i in 0 .. source.item_count() {
-			rlp.append_raw(source.at(i).as_raw(), 1);
+		let source = UntrustedRlp::new(payload);
+		rlp.begin_list(source.item_count()? + 1);
+		for i in 0 .. source.item_count()? {
+			rlp.append_raw(source.at(i)?.as_raw(), 1);
 		}
 		let timestamp = 60 + SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs() as u32;
 		rlp.append(&timestamp);
@@ -269,9 +271,9 @@ impl Discovery {
 		let hash = keccak(bytes.as_ref());
 		let signature = match sign(&self.secret, &hash) {
 			Ok(s) => s,
-			Err(_) => {
+			Err(e) => {
 				warn!("Error signing UDP packet");
-				return;
+				return Err(Error::from(e));
 			}
 		};
 		let mut packet = Bytes::with_capacity(bytes.len() + 32 + 65);
@@ -281,6 +283,7 @@ impl Discovery {
 		let signed_hash = keccak(&packet[32..]);
 		packet[0..32].clone_from_slice(&signed_hash);
 		self.send_to(packet, address.clone());
+		Ok(())
 	}
 
 	fn nearest_node_entries(target: &NodeId, buckets: &[NodeBucket]) -> Vec<NodeEntry> {
@@ -425,7 +428,7 @@ impl Discovery {
 		let mut response = RlpStream::new_list(2);
 		dest.to_rlp_list(&mut response);
 		response.append(&echo_hash);
-		self.send_packet(PACKET_PONG, from, &response.drain());
+		self.send_packet(PACKET_PONG, from, &response.drain())?;
 
 		Ok(Some(TableUpdates { added: added_map, removed: HashSet::new() }))
 	}
@@ -456,7 +459,7 @@ impl Discovery {
 		}
 		let mut packets = Discovery::prepare_neighbours_packets(&nearest);
 		for p in packets.drain(..) {
-			self.send_packet(PACKET_NEIGHBOURS, from, &p);
+			self.send_packet(PACKET_NEIGHBOURS, from, &p)?;
 		}
 		trace!(target: "discovery", "Sent {} Neighbours to {:?}", nearest.len(), &from);
 		Ok(None)

util/network-devp2p/src/handshake.rs

@@ -19,7 +19,7 @@ use hash::write_keccak;
 use mio::tcp::*;
 use ethereum_types::{H256, H520};
 use ethcore_bytes::Bytes;
-use rlp::*;
+use rlp::{UntrustedRlp, RlpStream};
 use connection::{Connection};
 use node_table::NodeId;
 use io::{IoContext, StreamToken};

util/network-devp2p/src/host.rs

@@ -30,7 +30,8 @@ use mio::*;
 use mio::deprecated::{EventLoop};
 use mio::tcp::*;
 use ethereum_types::H256;
-use rlp::*;
+use rlp::{RlpStream, Encodable};
+
 use session::{Session, SessionData};
 use io::*;
 use PROTOCOL_VERSION;

util/network-devp2p/src/node_table.rs

@@ -22,7 +22,7 @@ use std::path::PathBuf;
 use std::str::FromStr;
 use std::{fs, mem, slice};
 use ethereum_types::H512;
-use rlp::*;
+use rlp::{UntrustedRlp, RlpStream, DecoderError};
 use network::{Error, ErrorKind, AllowIP, IpFilter};
 use discovery::{TableUpdates, NodeEntry};
 use ip_utils::*;

util/network-devp2p/src/session.rs

@@ -23,7 +23,7 @@ use mio::*;
 use mio::deprecated::{Handler, EventLoop};
 use mio::tcp::*;
 use ethereum_types::H256;
-use rlp::*;
+use rlp::{UntrustedRlp, RlpStream, EMPTY_LIST_RLP};
 use connection::{EncryptedConnection, Packet, Connection, MAX_PAYLOAD_SIZE};
 use handshake::Handshake;
 use io::{IoContext, StreamToken};