diff --git a/rust/src/quic/error.rs b/rust/src/quic/error.rs index 89ac1fba40..c4ba7111de 100644 --- a/rust/src/quic/error.rs +++ b/rust/src/quic/error.rs @@ -15,7 +15,7 @@ * 02110-1301, USA. */ -use nom7::error::{ErrorKind, ParseError}; +use nom8::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> for QuicError { - fn from(err: nom7::Err) -> Self { +impl From> for QuicError { + fn from(err: nom8::Err) -> Self { match err { - nom7::Err::Incomplete(_) => QuicError::Incomplete, - nom7::Err::Error(e) => e, - nom7::Err::Failure(e) => e, + nom8::Err::Incomplete(_) => QuicError::Incomplete, + nom8::Err::Error(e) => e, + nom8::Err::Failure(e) => e, } } } diff --git a/rust/src/quic/frames.rs b/rust/src/quic/frames.rs index 7a5717c5cc..e99e2154e5 100644 --- a/rust/src/quic/frames.rs +++ b/rust/src/quic/frames.rs @@ -19,12 +19,12 @@ use super::error::QuicError; use super::quic::QUIC_MAX_CRYPTO_FRAG_LEN; use crate::handshake::HandshakeParams; use crate::quic::parser::quic_var_uint; -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 nom8::bytes::complete::take; +use nom8::combinator::{all_consuming, complete}; +use nom8::multi::{count, many0}; +use nom8::number::complete::{be_u16, be_u32, be_u8, le_u16, le_u32}; +use nom8::sequence::pair; +use nom8::{IResult, Parser}; use num::FromPrimitive; use std::fmt; use tls_parser::TlsMessage::Handshake; @@ -412,19 +412,19 @@ fn parse_crypto_frame(input: &[u8]) -> IResult<&[u8], Frame, QuicError> { } _ => {} } - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::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(nom7::Err::Error(QuicError::StreamTagNoMatch(tag)))?; + let tag = StreamTag::from_u32(tag).ok_or(nom8::Err::Error(QuicError::StreamTagNoMatch(tag)))?; Ok((rest, tag)) } fn parse_tag_and_offset(input: &[u8]) -> IResult<&[u8], TagOffset, QuicError> { - pair(parse_tag, le_u32)(input) + pair(parse_tag, le_u32).parse(input) } fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec, QuicError> { @@ -434,7 +434,7 @@ fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec, QuicError> let (rest, num_entries) = le_u16(rest)?; let (rest, _padding) = take(2usize)(rest)?; - let (rest, tags_offset) = count(complete(parse_tag_and_offset), num_entries.into())(rest)?; + let (rest, tags_offset) = count(complete(parse_tag_and_offset), num_entries.into()).parse(rest)?; // Convert (Tag, Offset) to (Tag, Value) let mut tags = Vec::new(); @@ -444,7 +444,7 @@ fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec, QuicError> // offsets should be increasing let value_len = offset .checked_sub(previous_offset) - .ok_or(nom7::Err::Error(QuicError::InvalidPacket))?; + .ok_or(nom8::Err::Error(QuicError::InvalidPacket))?; let (new_rest, value) = take(value_len)(rest)?; previous_offset = offset; @@ -484,7 +484,7 @@ fn parse_stream_frame(input: &[u8], frame_ty: u8) -> IResult<&[u8], Frame, QuicE let (rest, stream_data) = take(data_length)(rest)?; - let tags = if let Ok((_, tags)) = all_consuming(parse_crypto_stream)(stream_data) { + let tags = if let Ok((_, tags)) = all_consuming(parse_crypto_stream).parse(stream_data) { Some(tags) } else { None @@ -505,11 +505,11 @@ 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(nom7::Err::Error(QuicError::Unhandled)); + return Err(nom8::Err::Error(QuicError::Unhandled)); } let (rest, stream_data) = take(data_length as u32)(rest)?; - let tags = if let Ok((_, tags)) = all_consuming(parse_crypto_stream)(stream_data) { + let tags = if let Ok((_, tags)) = all_consuming(parse_crypto_stream).parse(stream_data) { Some(tags) } else { None @@ -552,7 +552,7 @@ impl Frame { pub(crate) fn decode_frames<'a>( input: &'a [u8], past_frag: &'a [u8], past_fraglen: u32, ) -> IResult<&'a [u8], Vec, QuicError> { - let (rest, mut frames) = all_consuming(many0(complete(Frame::decode_frame)))(input)?; + let (rest, mut frames) = all_consuming(many0(complete(Frame::decode_frame))).parse(input)?; // we use the already seen past fragment data let mut crypto_max_size = past_frag.len() as u64; diff --git a/rust/src/quic/parser.rs b/rust/src/quic/parser.rs index 3fba85040b..1ddf0dd2db 100644 --- a/rust/src/quic/parser.rs +++ b/rust/src/quic/parser.rs @@ -16,10 +16,10 @@ */ use super::error::QuicError; use super::frames::Frame; -use nom7::bytes::complete::take; -use nom7::combinator::map; -use nom7::number::complete::{be_u24, be_u32, be_u8}; -use nom7::IResult; +use nom8::bytes::complete::take; +use nom8::combinator::map; +use nom8::number::complete::{be_u24, be_u32, be_u8}; +use nom8::{IResult, Parser}; use std::convert::TryFrom; /* @@ -214,7 +214,7 @@ impl QuicHeader { let version; if (flags.raw & QUIC_FLAG_VERSION) != 0 { let (_, version_buf1) = take(4_usize)(rest)?; - let (rest1, version1) = map(be_u32, QuicVersion)(rest)?; + let (rest1, version1) = map(be_u32, QuicVersion).parse(rest)?; rest = rest1; version = version1; version_buf = version_buf1; @@ -247,7 +247,7 @@ impl QuicHeader { }, )); } else { - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::Err::Error(QuicError::InvalidPacket)); } } else if !flags.is_long { // Decode short header @@ -267,12 +267,12 @@ impl QuicHeader { }, )); } else { - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::Err::Error(QuicError::InvalidPacket)); } } else { // Decode Long header let (_, version_buf) = take(4_usize)(rest)?; - let (rest, version) = map(be_u32, QuicVersion)(rest)?; + let (rest, version) = map(be_u32, QuicVersion).parse(rest)?; let ty = if version == QuicVersion(0) { QuicType::VersionNegotiation @@ -285,7 +285,7 @@ impl QuicHeader { 0x7d => QuicType::Handshake, 0x7c => QuicType::ZeroRTT, _ => { - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::Err::Error(QuicError::InvalidPacket)); } } } else if version == QuicVersion::V2 { @@ -295,7 +295,7 @@ impl QuicHeader { 0x03 => QuicType::Handshake, 0x00 => QuicType::Retry, _ => { - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::Err::Error(QuicError::InvalidPacket)); } } } else { @@ -306,7 +306,7 @@ impl QuicHeader { 0x02 => QuicType::Handshake, 0x03 => QuicType::Retry, _ => { - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::Err::Error(QuicError::InvalidPacket)); } } } @@ -366,17 +366,17 @@ impl QuicHeader { let (rest, length) = if has_length { let (rest2, plength) = quic_var_uint(rest)?; if plength > rest2.len() as u64 { - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::Err::Error(QuicError::InvalidPacket)); } if let Ok(length) = u16::try_from(plength) { (rest2, length) } else { - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::Err::Error(QuicError::InvalidPacket)); } } else if let Ok(length) = u16::try_from(rest.len()) { (rest, length) } else { - return Err(nom7::Err::Error(QuicError::InvalidPacket)); + return Err(nom8::Err::Error(QuicError::InvalidPacket)); }; Ok((