feat(nom5): migrate to nom 5

Author: NamsooCho

Cargo.toml

@@ -34,7 +34,7 @@ byteorder = "1"
 futures = "0.1"
 log = "0.4"
 sodiumoxide = "0.2.2"
-nom = "3.2"
+nom = { git = "https://github.com/Geal/nom.git" }
 cookie-factory = "0.2"
 get_if_addrs = "0.5"
 parking_lot = "0.8"

src/toxcore/binary_io.rs

@@ -4,7 +4,7 @@
 pub use nom::IResult;
 pub use cookie_factory::GenError;
 
-use nom::{le_u8, le_u16};
+use nom::number::complete::{le_u8, le_u16};
 use std::net::{
     IpAddr,
     Ipv4Addr,
@@ -33,7 +33,7 @@ impl ToBytes for IpAddr {
 }
 
 impl FromBytes for Ipv4Addr {
-    named!(from_bytes<Ipv4Addr>, map!(count_fixed!(u8, le_u8, 4),
+    named!(from_bytes<Ipv4Addr>, map!(count!(le_u8, 4),
         |v| Ipv4Addr::new(v[0], v[1], v[2], v[3])
     ));
 }
@@ -51,7 +51,7 @@ impl ToBytes for Ipv4Addr {
 }
 
 impl FromBytes for Ipv6Addr {
-    named!(from_bytes<Ipv6Addr>, map!(count_fixed!(u16, le_u16, 8),
+    named!(from_bytes<Ipv6Addr>, map!(count!(le_u16, 8),
         |v| Ipv6Addr::new(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7])
     ));
 }
@@ -74,7 +74,7 @@ impl ToBytes for Ipv6Addr {
 
 /// Parser that returns the length of the remaining input.
 pub fn rest_len(input: &[u8]) -> IResult<&[u8], usize> {
-    IResult::Done(input, input.len())
+    Ok((input, input.len()))
 }
 
 /// Generator that ensures that length of serialized data does not exceed specified limit.

src/toxcore/dht/codec.rs

@@ -10,7 +10,9 @@ use crate::toxcore::stats::*;
 use bytes::BytesMut;
 use cookie_factory::GenError;
 use failure::Fail;
-use nom::{ErrorKind, Needed};
+use nom::{error::ErrorKind, Err,
+          Needed
+};
 use tokio::codec::{Decoder, Encoder};
 
 /// A serialized `Packet` should be not longer than 2048 bytes.
@@ -132,9 +134,13 @@ impl Decoder for DhtCodec {
         }
 
         match Packet::from_bytes(buf) {
-            IResult::Incomplete(needed) => Err(DecodeError::incomplete_packet(needed, buf.to_vec())),
-            IResult::Error(error) => Err(DecodeError::deserialize(error, buf.to_vec())),
-            IResult::Done(_, packet) => {
+            Err(Err::Incomplete(needed)) => Err(DecodeError::incomplete_packet(needed, buf.to_vec())),
+            Err(Err::Error(error)) => {
+                let (_, kind) = error;
+                Err(DecodeError::deserialize(kind, buf.to_vec()))
+            },
+            Err(Err::Failure(e)) => panic!("Packet deserialize failed with unrecoverable error: {:?}", e),
+            Ok((_, packet)) => {
                 // Add 1 to incoming counter
                 self.stats.counters.increase_incoming();
 

src/toxcore/dht/daemon_state.rs

@@ -15,7 +15,9 @@ use crate::toxcore::dht::kbucket::*;
 use crate::toxcore::dht::ktree::*;
 
 use failure::Fail;
-use nom::{Needed, ErrorKind as NomErrorKind};
+use nom::{Needed, Err,
+          error::ErrorKind as NomErrorKind
+};
 
 error_kind! {
     #[doc = "An error that can occur while serializing/deserializing object."]
@@ -86,11 +88,17 @@ impl DaemonState {
     /// Deserialize DHT close list and then re-setup close list, old means that the format of deserialization is old version
     pub fn deserialize_old(server: &Server, serialized_data: &[u8]) -> impl Future<Item=(), Error=DeserializeError> + Send {
         let nodes = match DhtState::from_bytes(serialized_data) {
-            IResult::Done(_, DhtState(nodes)) => nodes,
-            IResult::Incomplete(needed) =>
-                return Either::A(future::err(DeserializeError::incomplete(needed, serialized_data.to_vec()))),
-            IResult::Error(error) =>
-                return Either::A(future::err(DeserializeError::deserialize(error, serialized_data.to_vec()))),
+            Err(Err::Incomplete(needed)) => {
+                return Either::A(future::err(DeserializeError::incomplete(needed, serialized_data.to_vec())))
+            },
+            Err(Err::Error(error)) => {
+                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),
+            Ok((_, DhtState(nodes))) => {
+                nodes
+            }
         };
 
         let nodes_sender = nodes.iter()
@@ -148,7 +156,7 @@ mod tests {
         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(55), data: serialized_vec[..serialized_len - 1].to_vec() });
+        assert_eq!(*res.err().unwrap().kind(), DeserializeErrorKind::IncompleteData { needed: Needed::Size(39), data: serialized_vec[..serialized_len - 1].to_vec() });
 
         // test with serialized data corrupted
         let serialized_vec = [42; 10];

src/toxcore/dht/packed_node.rs

@@ -1,7 +1,7 @@
 /*! A pair of SocketAddr & PublicKey.
 */
 
-use nom::{le_u8, be_u16};
+use nom::number::complete::{le_u8, be_u16};
 
 use std::net::{
     IpAddr,

src/toxcore/dht/packet/bootstrap_info.rs

@@ -1,7 +1,9 @@
 /*! BootstrapInfo packet
 */
 
-use nom::{be_u32, rest};
+use nom::{number::complete::be_u32,
+          combinator::rest,
+};
 
 use crate::toxcore::binary_io::*;
 

src/toxcore/dht/packet/cookie.rs

@@ -1,7 +1,9 @@
 /*! Cookie struct
 */
 
-use nom::be_u64;
+use nom::{Needed, Err,
+          number::complete::be_u64,
+};
 
 use std::time::SystemTime;
 
@@ -152,15 +154,18 @@ impl EncryptedCookie {
                 GetPayloadError::decrypt()
             })?;
         match Cookie::from_bytes(&decrypted) {
-            IResult::Incomplete(needed) => {
-                debug!(target: "Dht", "Cookie return deserialize error: {:?}", needed);
+            Err(Err::Incomplete(Needed::Unknown)) => {
+                Err(GetPayloadError::incomplete(Needed::Unknown, self.payload.to_vec()))
+            },
+            Err(Err::Incomplete(needed)) => {
                 Err(GetPayloadError::incomplete(needed, self.payload.to_vec()))
             },
-            IResult::Error(error) => {
-                debug!(target: "Dht", "Cookie return deserialize error: {:?}", error);
-                Err(GetPayloadError::deserialize(error, self.payload.to_vec()))
+            Err(Err::Error(error)) => {
+                let (_, kind) = error;
+                Err(GetPayloadError::deserialize(kind, self.payload.to_vec()))
             },
-            IResult::Done(_, payload) => {
+            Err(Err::Failure(e)) => panic!("Cookie deserialize failed with unrecoverable error: {:?}", e),
+            Ok((_, payload)) => {
                 Ok(payload)
             }
         }
@@ -176,7 +181,7 @@ impl EncryptedCookie {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nom::{Needed, ErrorKind};
+    use nom::error::ErrorKind;
 
     encode_decode_test!(
         cookie_encode_decode,
@@ -238,15 +243,15 @@ mod tests {
         assert!(decoded_payload.is_err());
         assert_eq!(*decoded_payload.err().unwrap().kind(), GetPayloadErrorKind::Deserialize { error: ErrorKind::Eof, payload: invalid_encrypted_cookie.payload });
         // Try short incomplete array
-        let invalid_payload = [];
+        let invalid_payload = [42, 42];
         let invalid_payload_encoded = secretbox::seal(&invalid_payload, &nonce, &symmetric_key);
         let invalid_encrypted_cookie = EncryptedCookie {
             nonce,
             payload: invalid_payload_encoded
         };
         let decoded_payload = invalid_encrypted_cookie.get_payload(&symmetric_key);
         assert!(decoded_payload.is_err());
-        assert_eq!(*decoded_payload.err().unwrap().kind(), GetPayloadErrorKind::IncompletePayload { needed: Needed::Size(8), payload: invalid_encrypted_cookie.payload });
+        assert_eq!(*decoded_payload.err().unwrap().kind(), GetPayloadErrorKind::Deserialize { error: ErrorKind::Eof, payload: invalid_encrypted_cookie.payload });
     }
 
     #[test]

src/toxcore/dht/packet/cookie_request.rs

@@ -1,7 +1,9 @@
 /*! CookieRequest packet
 */
 
-use nom::be_u64;
+use nom::{Needed, Err,
+          number::complete::be_u64,
+};
 
 use crate::toxcore::binary_io::*;
 use crate::toxcore::crypto_core::*;
@@ -92,15 +94,18 @@ impl CookieRequest {
                 GetPayloadError::decrypt()
             })?;
         match CookieRequestPayload::from_bytes(&decrypted) {
-            IResult::Incomplete(needed) => {
-                debug!(target: "Dht", "CookieRequestPayload return deserialize error: {:?}", needed);
+            Err(Err::Incomplete(Needed::Unknown)) => {
+                Err(GetPayloadError::incomplete(Needed::Unknown, self.payload.to_vec()))
+            },
+            Err(Err::Incomplete(needed)) => {
                 Err(GetPayloadError::incomplete(needed, self.payload.to_vec()))
             },
-            IResult::Error(error) => {
-                debug!(target: "Dht", "CookieRequestPayload return deserialize error: {:?}", error);
-                Err(GetPayloadError::deserialize(error, self.payload.to_vec()))
+            Err(Err::Error(error)) => {
+                let (_, kind) = error;
+                Err(GetPayloadError::deserialize(kind, self.payload.to_vec()))
             },
-            IResult::Done(_, payload) => {
+            Err(Err::Failure(e)) => panic!("CookieRequestPayload deserialize failed with unrecoverable error: {:?}", e),
+            Ok((_, payload)) => {
                 Ok(payload)
             }
         }

src/toxcore/dht/packet/cookie_response.rs

@@ -1,7 +1,9 @@
 /*! CookieResponse packet
 */
 
-use nom::be_u64;
+use nom::{Needed, Err,
+          number::complete::be_u64,
+};
 
 use crate::toxcore::binary_io::*;
 use crate::toxcore::crypto_core::*;
@@ -77,15 +79,18 @@ impl CookieResponse {
                 GetPayloadError::decrypt()
             })?;
         match CookieResponsePayload::from_bytes(&decrypted) {
-            IResult::Incomplete(needed) => {
-                debug!(target: "Dht", "CookieResponsePayload return deserialize error: {:?}", needed);
+            Err(Err::Incomplete(Needed::Unknown)) => {
+                Err(GetPayloadError::incomplete(Needed::Unknown, self.payload.to_vec()))
+            },
+            Err(Err::Incomplete(needed)) => {
                 Err(GetPayloadError::incomplete(needed, self.payload.to_vec()))
             },
-            IResult::Error(error) => {
-                debug!(target: "Dht", "CookieResponsePayload return deserialize error: {:?}", error);
-                Err(GetPayloadError::deserialize(error, self.payload.to_vec()))
+            Err(Err::Error(error)) => {
+                let (_, kind) = error;
+                Err(GetPayloadError::deserialize(kind, self.payload.to_vec()))
             },
-            IResult::Done(_, payload) => {
+            Err(Err::Failure(e)) => panic!("CookieResponsePayload deserialize failed with unrecoverable error: {:?}", e),
+            Ok((_, payload)) => {
                 Ok(payload)
             }
         }
@@ -134,7 +139,9 @@ impl ToBytes for CookieResponsePayload {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nom::{Needed, ErrorKind};
+    use nom::{Needed,
+              error::ErrorKind
+    };
 
     encode_decode_test!(
         cookie_response_encode_decode,

src/toxcore/dht/packet/crypto_data.rs

@@ -2,7 +2,10 @@
 */
 
 use byteorder::{ByteOrder, BigEndian};
-use nom::{be_u16, be_u32, rest};
+use nom::{Needed, Err,
+          number::complete::{be_u16, be_u32},
+          combinator::rest,
+};
 
 use crate::toxcore::binary_io::*;
 use crate::toxcore::crypto_core::*;
@@ -40,7 +43,7 @@ pub struct CryptoData {
 
 impl FromBytes for CryptoData {
     named!(from_bytes<CryptoData>, do_parse!(
-        verify!(rest_len, |len| len <= MAX_CRYPTO_PACKET_SIZE) >>
+        verify!(rest_len, |len| *len <= MAX_CRYPTO_PACKET_SIZE) >>
         tag!("\x1b") >>
         nonce_last_bytes: be_u16 >>
         payload: rest >>
@@ -91,15 +94,18 @@ impl CryptoData {
                 GetPayloadError::decrypt()
             })?;
         match CryptoDataPayload::from_bytes(&decrypted) {
-            IResult::Incomplete(needed) => {
-                debug!(target: "Dht", "CryptoDataPayload return deserialize error: {:?}", needed);
+            Err(Err::Incomplete(Needed::Unknown)) => {
+                Err(GetPayloadError::incomplete(Needed::Unknown, self.payload.to_vec()))
+            },
+            Err(Err::Incomplete(needed)) => {
                 Err(GetPayloadError::incomplete(needed, self.payload.to_vec()))
             },
-            IResult::Error(error) => {
-                debug!(target: "Dht", "CryptoDataPayload return deserialize error: {:?}", error);
-                Err(GetPayloadError::deserialize(error, self.payload.to_vec()))
+            Err(Err::Error(error)) => {
+                let (_, kind) = error;
+                Err(GetPayloadError::deserialize(kind, self.payload.to_vec()))
             },
-            IResult::Done(_, payload) => {
+            Err(Err::Failure(e)) => panic!("CryptoDataPayload deserialize failed with unrecoverable error: {:?}", e),
+            Ok((_, payload)) => {
                 Ok(payload)
             }
         }
@@ -151,7 +157,7 @@ impl ToBytes for CryptoDataPayload {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nom::Needed;
+    use nom::error::ErrorKind;
 
     encode_decode_test!(
         crypto_data_encode_decode,
@@ -239,6 +245,6 @@ mod tests {
         };
         let decoded_payload = invalid_packet.get_payload(&shared_secret, &nonce);
         assert!(decoded_payload.is_err());
-        assert_eq!(*decoded_payload.err().unwrap().kind(), GetPayloadErrorKind::IncompletePayload { needed: Needed::Size(4), payload: invalid_packet.payload });
+        assert_eq!(*decoded_payload.err().unwrap().kind(), GetPayloadErrorKind::Deserialize { error: ErrorKind::Eof, payload: invalid_packet.payload });
     }
 }