feat(nom5): remove remaining panic!

Author: NamsooCho

src/toxcore/dht/codec.rs

@@ -139,7 +139,10 @@ impl Decoder for DhtCodec {
                 let (_, kind) = error;
                 Err(DecodeError::deserialize(kind, buf.to_vec()))
             },
-            Err(Err::Failure(e)) => panic!("Packet deserialize failed with unrecoverable error: {:?}", e),
+            Err(Err::Failure(error)) => {
+                let (_, kind) = error;
+                Err(DecodeError::deserialize(kind, buf.to_vec()))
+            },
             Ok((_, packet)) => {
                 // Add 1 to incoming counter
                 self.stats.counters.increase_incoming();

src/toxcore/dht/daemon_state.rs

@@ -95,7 +95,10 @@ impl DaemonState {
                 let (_, kind) = error;
                 return Either::A(future::err(DeserializeError::deserialize(kind, serialized_data.to_vec())))
             },
-            Err(Err::Failure(e)) => panic!("DhtState deserialize failed with unrecoverable error: {:?}", e),
+            Err(Err::Failure(error)) => {
+                let (_, kind) = error;
+                return Either::A(future::err(DeserializeError::deserialize(kind, serialized_data.to_vec())))
+            },
             Ok((_, DhtState(nodes))) => {
                 nodes
             }
@@ -155,14 +158,14 @@ mod tests {
         let serialized_vec = DaemonState::serialize_old(&alice);
         let serialized_len = serialized_vec.len();
         let res = DaemonState::deserialize_old(&alice, &serialized_vec[..serialized_len - 1]).wait();
-        assert!(res.is_err());
-        assert_eq!(*res.err().unwrap().kind(), DeserializeErrorKind::IncompleteData { needed: Needed::Size(39), data: serialized_vec[..serialized_len - 1].to_vec() });
+        let error = res.err().unwrap();
+        assert_eq!(*error.kind(), DeserializeErrorKind::Deserialize { error: NomErrorKind::Eof, data: serialized_vec[..serialized_len - 1].to_vec() });
 
         // test with serialized data corrupted
         let serialized_vec = [42; 10];
         let res = DaemonState::deserialize_old(&alice, &serialized_vec).wait();
-        assert!(res.is_err());
-        assert_eq!(*res.err().unwrap().kind(), DeserializeErrorKind::Deserialize { error: NomErrorKind::Tag, data: serialized_vec.to_vec() });
+        let error = res.err().unwrap();
+        assert_eq!(*error.kind(), DeserializeErrorKind::Deserialize { error: NomErrorKind::Tag, data: serialized_vec.to_vec() });
 
         // test with empty close list
         alice.close_nodes.write().remove(&pk_org);

src/toxcore/dht/packet/errors.rs

@@ -91,26 +91,26 @@ impl From<GetPayloadError> for IoError {
 
 #[cfg(test)]
 mod tests {
-//    use super::*;
-/*
+    use super::*;
+    use nom::Needed;
+
     #[test]
     fn get_payload_error() {
-        let error = GetPayloadError::deserialize(NomErrorKind::Eof, vec![1, 2, 3, 4]);
+        let error = GetPayloadError::deserialize(Err::Error((&[], ErrorKind::Eof)), vec![1, 2, 3, 4]);
         assert!(error.cause().is_none());
         assert!(error.backtrace().is_some());
-        assert_eq!(format!("{}", error), "Deserialize payload error: Eof, data: [1, 2, 3, 4]".to_owned());
+        assert_eq!(format!("{}", error), "Deserialize payload error: Error((\"\", Eof)), data: [1, 2, 3, 4]".to_owned());
     }
 
     #[test]
     fn get_payload_error_kind() {
         let decrypt = GetPayloadErrorKind::Decrypt;
         assert_eq!(format!("{}", decrypt), "Decrypt payload error".to_owned());
 
-        let incomplete = GetPayloadErrorKind::IncompletePayload { needed: Needed::Size(5), payload: vec![1, 2, 3, 4] };
-        assert_eq!(format!("{}", incomplete), "Bytes of payload should not be incomplete: Size(5), data: [1, 2, 3, 4]".to_owned());
+        let incomplete = GetPayloadErrorKind::Deserialize { error: Err::Incomplete(Needed::Size(5)), payload: vec![1, 2, 3, 4] };
+        assert_eq!(format!("{}", incomplete), "Deserialize payload error: Incomplete(Size(5)), data: [1, 2, 3, 4]".to_owned());
 
-        let deserialize = GetPayloadErrorKind::Deserialize { error: NomErrorKind::Eof, payload: vec![1, 2, 3, 4] };
-        assert_eq!(format!("{}", deserialize), "Deserialize payload error: Eof, data: [1, 2, 3, 4]".to_owned());
+        let deserialize = GetPayloadErrorKind::Deserialize { error: Err::Error(("".to_owned(), ErrorKind::Eof)), payload: vec![1, 2, 3, 4] };
+        assert_eq!(format!("{}", deserialize), "Deserialize payload error: Error((\"\", Eof)), data: [1, 2, 3, 4]".to_owned());
     }
-    */
 }

src/toxcore/onion/packet/mod.rs

@@ -34,7 +34,7 @@ use crate::toxcore::crypto_core::*;
 use crate::toxcore::dht::packed_node::PackedNode;
 use crate::toxcore::ip_port::*;
 
-use nom::{Needed, Err,
+use nom::{Err,
           number::complete::le_u8,
           combinator::rest,
 };
@@ -138,10 +138,6 @@ impl OnionReturn {
                 Error::new(ErrorKind::Other, "OnionReturn decrypt error.")
             })?;
         match OnionReturn::inner_from_bytes(&decrypted) {
-            Err(Err::Incomplete(Needed::Unknown)) => {
-                Err(Error::new(ErrorKind::Other,
-                               format!("Inner onion return deserialize error: Needed::Unknown")))
-            },
             Err(Err::Incomplete(e)) => {
                 Err(Error::new(ErrorKind::Other,
                                format!("Inner onion return deserialize error: {:?}", e)))
@@ -150,7 +146,10 @@ impl OnionReturn {
                 Err(Error::new(ErrorKind::Other,
                                format!("Inner onion return deserialize error: {:?}", e)))
             },
-            Err(Err::Failure(e)) => panic!("Inner onion return deserialize failed with unrecoverable error: {:?}", e),
+            Err(Err::Failure(e)) => {
+                Err(Error::new(ErrorKind::Other,
+                               format!("Inner onion return deserialize error: {:?}", e)))
+            },
             Ok((_, inner)) => {
                 Ok(inner)
             }

src/toxcore/state_format/old.rs

@@ -141,7 +141,7 @@ impl FromBytes for DhtState {
         num_of_bytes: le_u32 >>
         verify!(le_u16, |value| *value == DHT_SECTION_TYPE) >> // check DHT section type
         verify!(le_u16, |value| *value == DHT_2ND_MAGICAL) >> // check whether yet another magic number matches
-        nodes: flat_map!(take!(num_of_bytes), many0!(PackedNode::from_bytes)) >>
+        nodes: flat_map!(take(num_of_bytes), many0!(PackedNode::from_bytes)) >>
         (DhtState(nodes))
     ));
 }
@@ -349,14 +349,14 @@ pub struct FriendState {
     friend_status: FriendStatus,
     pk: PublicKey,
     /// Friend request message that is being sent to friend.
-    pub fr_msg: Vec<u8>,
+    fr_msg: Vec<u8>,
     /// Friend's name.
-    pub name: Name,
+    name: Name,
     status_msg: StatusMsg,
     user_status: UserWorkingStatus,
     nospam: NoSpam,
     /// Time when friend was last seen online.
-    pub last_seen: u64,
+    last_seen: u64,
 }
 
 /// Number of bytes of serialized [`FriendState`](./struct.FriendState.html).

src/toxcore/tcp/codec.rs

@@ -113,7 +113,7 @@ impl Decoder for Codec {
         let (consumed, encrypted_packet) = match EncryptedPacket::from_bytes(buf) {
             Err(Err::Incomplete(_)) => return Ok(None),
             Err(Err::Error(_)) => return Ok(None),
-            Err(Err::Failure(e)) => panic!("EncryptedPacket deserialize failed with unrecoverable error: {:?}", e),
+            Err(Err::Failure(_)) => return Ok(None),
             Ok((i, encrypted_packet)) => {
                 (buf.offset(i), encrypted_packet)
             }
@@ -130,7 +130,10 @@ impl Decoder for Codec {
                 let (_, kind) = error;
                 Err(DecodeError::DeserializeDecryptedError { error: kind, packet: decrypted_data })
             },
-            Err(Err::Failure(e)) => panic!("Packet deserialize failed with unrecoverable error: {:?}", e),
+            Err(Err::Failure(error)) => {
+                let (_, kind) = error;
+                Err(DecodeError::DeserializeDecryptedError { error: kind, packet: decrypted_data })
+            },
             Ok((_i, packet)) => {
                 // Add 1 to incoming counter
                 self.stats.counters.increase_incoming();

src/toxcore/tcp/handshake/codec.rs

@@ -20,7 +20,7 @@ impl Decoder for ClientHandshakeCodec {
         let (consumed, handshake) = match ClientHandshake::from_bytes(buf) {
             Err(Err::Incomplete(_)) => return Ok(None),
             Err(Err::Error(_)) => unreachable!("ClientHandshake cannot be deserialized with error"),
-            Err(Err::Failure(e)) => panic!("ClientHandshake deserialize failed with unrecoverable error: {:?}", e),
+            Err(Err::Failure(_)) => unreachable!("ClientHandshake cannot be deserialized with error"),
             Ok((i, handshake)) => {
                 (buf.offset(i), handshake)
             }
@@ -58,7 +58,7 @@ impl Decoder for ServerHandshakeCodec {
         let (consumed, handshake) = match ServerHandshake::from_bytes(buf) {
             Err(Err::Incomplete(_)) => return Ok(None),
             Err(Err::Error(_)) => unreachable!("ClientHandshake cannot be deserialized with error"),
-            Err(Err::Failure(e)) => panic!("ClientHandshake deserialize failed with unrecoverable error: {:?}", e),
+            Err(Err::Failure(_)) => unreachable!("ClientHandshake cannot be deserialized with error"),
             Ok((i, handshake)) => {
                 (buf.offset(i), handshake)
             }