aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

quic: update to nom 8.0

Browse Source 
Ticket: #8140
pull/14376/head
Jason Ish 8 months ago committed by Victor Julien
parent 3cb873e3bc
commit 83d8b1d2f8
3 changed files with 35 additions and 35 deletions
Show Stats Download Patch File Download Diff File

12
rust/src/quic/error.rs
Unescape Escape View File

@ -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<nom7::Err<QuicError>> for QuicError {
fn from(err: nom7::Err<QuicError>) -> Self {
impl From<nom8::Err<QuicError>> for QuicError {
fn from(err: nom8::Err<QuicError>) -> 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,
}
}
}

30
rust/src/quic/frames.rs
Unescape Escape View File

@ -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<TagValue>, QuicError> {
@ -434,7 +434,7 @@ fn parse_crypto_stream(input: &[u8]) -> IResult<&[u8], Vec<TagValue>, 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<TagValue>, 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<Frame>, 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;

28
rust/src/quic/parser.rs
Unescape Escape View File

@ -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((

Write Preview
Loading…
Cancel
Save