quic: update to nom7

rust/src/quic/error.rs

@@ -15,7 +15,7 @@
  * 02110-1301, USA.
  */
 
-use nom::error::{ErrorKind, ParseError};
+use nom7::error::{ErrorKind, ParseError};
 use std::error::Error;
 use std::fmt;
 
@@ -54,12 +54,12 @@ impl fmt::Display for QuicError {
 
 impl Error for QuicError {}
 
-impl From<nom::Err<QuicError>> for QuicError {
-    fn from(err: nom::Err<QuicError>) -> Self {
+impl From<nom7::Err<QuicError>> for QuicError {
+    fn from(err: nom7::Err<QuicError>) -> Self {
         match err {
-            nom::Err::Incomplete(_) => QuicError::Incomplete,
-            nom::Err::Error(e) => e,
-            nom::Err::Failure(e) => e,
+            nom7::Err::Incomplete(_) => QuicError::Incomplete,
+            nom7::Err::Error(e) => e,
+            nom7::Err::Failure(e) => e,
         }
     }
 }

rust/src/quic/frames.rs

@@ -17,12 +17,12 @@
 
 use super::error::QuicError;
 use crate::quic::parser::quic_var_uint;
-use nom::bytes::complete::take;
-use nom::combinator::{all_consuming, complete};
-use nom::multi::{count, many0};
-use nom::number::complete::{be_u16, be_u32, be_u8, le_u16, le_u32};
-use nom::sequence::pair;
-use nom::IResult;
+use nom7::bytes::complete::take;
+use nom7::combinator::{all_consuming, complete};
+use nom7::multi::{count, many0};
+use nom7::number::complete::{be_u16, be_u32, be_u8, le_u16, le_u32};
+use nom7::sequence::pair;
+use nom7::IResult;
 use num::FromPrimitive;
 use std::fmt;
 use tls_parser::TlsMessage::Handshake;
@@ -355,13 +355,13 @@ fn parse_crypto_frame(input: &[u8]) -> IResult<&[u8], Frame, QuicError> {
         }
         _ => {}
     }
-    return Err(nom::Err::Error(QuicError::InvalidPacket));
+    return Err(nom7::Err::Error(QuicError::InvalidPacket));
 }
 
 fn parse_tag(input: &[u8]) -> IResult<&[u8], StreamTag, QuicError> {
     let (rest, tag) = be_u32(input)?;
 
-    let tag = StreamTag::from_u32(tag).ok_or(nom::Err::Error(QuicError::StreamTagNoMatch(tag)))?;
+    let tag = StreamTag::from_u32(tag).ok_or(nom7::Err::Error(QuicError::StreamTagNoMatch(tag)))?;
 
     Ok((rest, tag))
 }
@@ -387,7 +387,7 @@ fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec<TagValue>, QuicError>
         // offsets should be increasing
         let value_len = offset
             .checked_sub(previous_offset)
-            .ok_or(nom::Err::Error(QuicError::InvalidPacket))?;
+            .ok_or(nom7::Err::Error(QuicError::InvalidPacket))?;
         let (new_rest, value) = take(value_len)(rest)?;
 
         previous_offset = offset;
@@ -448,7 +448,7 @@ fn parse_crypto_stream_frame(input: &[u8]) -> IResult<&[u8], Frame, QuicError> {
     let (rest, _offset) = quic_var_uint(input)?;
     let (rest, data_length) = quic_var_uint(rest)?;
     if data_length > u32::MAX as u64 {
-        return Err(nom::Err::Error(QuicError::Unhandled));
+        return Err(nom7::Err::Error(QuicError::Unhandled));
     }
     let (rest, stream_data) = take(data_length as u32)(rest)?;
 

rust/src/quic/parser.rs

@@ -16,10 +16,10 @@
  */
 use super::error::QuicError;
 use super::frames::Frame;
-use nom::bytes::complete::take;
-use nom::combinator::{all_consuming, map};
-use nom::number::complete::{be_u24, be_u32, be_u8};
-use nom::IResult;
+use nom7::bytes::complete::take;
+use nom7::combinator::{all_consuming, map};
+use nom7::number::complete::{be_u24, be_u32, be_u8};
+use nom7::IResult;
 use std::convert::TryFrom;
 
 /*
@@ -246,7 +246,7 @@ impl QuicHeader {
                     },
                 ));
             } else {
-                return Err(nom::Err::Error(QuicError::InvalidPacket));
+                return Err(nom7::Err::Error(QuicError::InvalidPacket));
             }
         } else if !flags.is_long {
             // Decode short header
@@ -266,7 +266,7 @@ impl QuicHeader {
                     },
                 ));
             } else {
-                return Err(nom::Err::Error(QuicError::InvalidPacket));
+                return Err(nom7::Err::Error(QuicError::InvalidPacket));
             }
         } else {
             // Decode Long header
@@ -284,7 +284,7 @@ impl QuicHeader {
                         0x7d => QuicType::Handshake,
                         0x7c => QuicType::ZeroRTT,
                         _ => {
-                            return Err(nom::Err::Error(QuicError::InvalidPacket));
+                            return Err(nom7::Err::Error(QuicError::InvalidPacket));
                         }
                     }
                 } else {
@@ -294,7 +294,7 @@ impl QuicHeader {
                         0x02 => QuicType::Handshake,
                         0x03 => QuicType::Retry,
                         _ => {
-                            return Err(nom::Err::Error(QuicError::InvalidPacket));
+                            return Err(nom7::Err::Error(QuicError::InvalidPacket));
                         }
                     }
                 }
@@ -350,18 +350,18 @@ impl QuicHeader {
             let (rest, length) = if has_length {
                 let (rest2, plength) = quic_var_uint(rest)?;
                 if plength > rest2.len() as u64 {
-                    return Err(nom::Err::Error(QuicError::InvalidPacket));
+                    return Err(nom7::Err::Error(QuicError::InvalidPacket));
                 }
                 if let Ok(length) = u16::try_from(plength) {
                     (rest2, length)
                 } else {
-                    return Err(nom::Err::Error(QuicError::InvalidPacket));
+                    return Err(nom7::Err::Error(QuicError::InvalidPacket));
                 }
             } else {
                 if let Ok(length) = u16::try_from(rest.len()) {
                     (rest, length)
                 } else {
-                    return Err(nom::Err::Error(QuicError::InvalidPacket));
+                    return Err(nom7::Err::Error(QuicError::InvalidPacket));
                 }
             };