From dea3f9e2603c3773ef21a74f3e4bc121c7d47fc7 Mon Sep 17 00:00:00 2001 From: Jason Ish Date: Mon, 3 Nov 2025 13:03:55 -0600 Subject: [PATCH] rust/detect: convert error.rs and dependent parsers to nom 8 Ticket: #8051 --- rust/src/detect/byte_extract.rs | 16 ++++++++-------- rust/src/detect/byte_math.rs | 16 ++++++++-------- rust/src/detect/entropy.rs | 16 ++++++++-------- rust/src/detect/error.rs | 2 +- rust/src/detect/iprep.rs | 18 +++++++++--------- rust/src/detect/parser.rs | 12 ++++++------ rust/src/detect/transforms/base64.rs | 16 ++++++++-------- 7 files changed, 48 insertions(+), 48 deletions(-) diff --git a/rust/src/detect/byte_extract.rs b/rust/src/detect/byte_extract.rs index b1520fdcee..d8ff6a747d 100644 --- a/rust/src/detect/byte_extract.rs +++ b/rust/src/detect/byte_extract.rs @@ -23,10 +23,10 @@ use crate::detect::*; use std::ffi::{CStr, CString}; use std::os::raw::c_char; -use nom7::bytes::complete::tag; -use nom7::character::complete::multispace0; -use nom7::sequence::preceded; -use nom7::{Err, IResult}; +use nom8::bytes::complete::tag; +use nom8::character::complete::multispace0; +use nom8::sequence::preceded; +use nom8::{Err, IResult, Parser}; use std::str; pub const DETECT_BYTE_EXTRACT_FLAG_RELATIVE: u16 = 0x01; @@ -92,13 +92,13 @@ impl Default for SCDetectByteExtractData { fn parse_byteextract(input: &str) -> IResult<&str, SCDetectByteExtractData, RuleParseError<&str>> { // Inner utility function for easy error creation. - fn make_error(reason: String) -> nom7::Err> { + fn make_error(reason: String) -> nom8::Err> { Err::Error(RuleParseError::InvalidByteExtract(reason)) } - let (_, values) = nom7::multi::separated_list1( + let (_, values) = nom8::multi::separated_list1( tag(","), - preceded(multispace0, nom7::bytes::complete::is_not(",")), - )(input)?; + preceded(multispace0, nom8::bytes::complete::is_not(",")), + ).parse(input)?; if values.len() < DETECT_BYTE_EXTRACT_FIXED_PARAM_COUNT || values.len() > DETECT_BYTE_EXTRACT_MAX_PARAM_COUNT diff --git a/rust/src/detect/byte_math.rs b/rust/src/detect/byte_math.rs index 735d0bdfa5..69e868c17c 100644 --- a/rust/src/detect/byte_math.rs +++ b/rust/src/detect/byte_math.rs @@ -23,10 +23,10 @@ use crate::detect::{get_endian_value, get_string_value, ByteBase, ByteEndian}; use std::ffi::{CStr, CString}; use std::os::raw::c_char; -use nom7::bytes::complete::tag; -use nom7::character::complete::multispace0; -use nom7::sequence::preceded; -use nom7::{Err, IResult}; +use nom8::bytes::complete::tag; +use nom8::character::complete::multispace0; +use nom8::sequence::preceded; +use nom8::{Err, IResult, Parser}; use std::str; pub const DETECT_BYTEMATH_FLAG_RELATIVE: u8 = 0x01; @@ -152,13 +152,13 @@ fn get_oper_value(value: &str) -> Result { fn parse_bytemath(input: &str) -> IResult<&str, DetectByteMathData, RuleParseError<&str>> { // Inner utility function for easy error creation. - fn make_error(reason: String) -> nom7::Err> { + fn make_error(reason: String) -> nom8::Err> { Err::Error(RuleParseError::InvalidByteMath(reason)) } - let (_, values) = nom7::multi::separated_list1( + let (_, values) = nom8::multi::separated_list1( tag(","), - preceded(multispace0, nom7::bytes::complete::is_not(",")), - )(input)?; + preceded(multispace0, nom8::bytes::complete::is_not(",")), + ).parse(input)?; if values.len() < DETECT_BYTEMATH_FIXED_PARAM_COUNT || values.len() > DETECT_BYTEMATH_MAX_PARAM_COUNT diff --git a/rust/src/detect/entropy.rs b/rust/src/detect/entropy.rs index 6816dc7231..d9d4bca843 100644 --- a/rust/src/detect/entropy.rs +++ b/rust/src/detect/entropy.rs @@ -21,10 +21,10 @@ use crate::detect::error::RuleParseError; use crate::detect::float::{detect_match_float, detect_parse_float, DetectFloatData}; use crate::detect::parser::take_until_whitespace; -use nom7::bytes::complete::tag; -use nom7::character::complete::multispace0; -use nom7::sequence::preceded; -use nom7::{Err, IResult}; +use nom8::bytes::complete::tag; +use nom8::character::complete::multispace0; +use nom8::sequence::preceded; +use nom8::{Err, IResult, Parser}; use std::ffi::CStr; use std::os::raw::{c_double, c_char, c_void}; @@ -68,13 +68,13 @@ fn parse_entropy<'a>( input: &'a str, flags: &'a mut u8, ) -> IResult<&'a str, DetectEntropyData, RuleParseError<&'a str>> { // Inner utility function for easy error creation. - fn make_error(reason: String) -> nom7::Err> { + fn make_error(reason: String) -> nom8::Err> { Err::Error(RuleParseError::InvalidEntropy(reason)) } - let (_, values) = nom7::multi::separated_list1( + let (_, values) = nom8::multi::separated_list1( tag(","), - preceded(multispace0, nom7::bytes::complete::is_not(",")), - )(input)?; + preceded(multispace0, nom8::bytes::complete::is_not(",")), + ).parse(input)?; if values.len() < DETECT_ENTROPY_FIXED_PARAM_COUNT || values.len() > DETECT_ENTROPY_MAX_PARAM_COUNT diff --git a/rust/src/detect/error.rs b/rust/src/detect/error.rs index d16ca7dbc0..0a5cab60b5 100644 --- a/rust/src/detect/error.rs +++ b/rust/src/detect/error.rs @@ -15,7 +15,7 @@ * 02110-1301, USA. */ -use nom7::error::{ErrorKind, ParseError}; +use nom8::error::{ErrorKind, ParseError}; /// Custom rule parse errors. /// diff --git a/rust/src/detect/iprep.rs b/rust/src/detect/iprep.rs index d96b65f216..ddf9446729 100644 --- a/rust/src/detect/iprep.rs +++ b/rust/src/detect/iprep.rs @@ -17,14 +17,14 @@ use super::uint::*; use crate::detect::error::RuleParseError; -use nom7::bytes::complete::tag; -use nom7::character::complete::multispace0; -use nom7::sequence::preceded; +use nom8::bytes::complete::tag; +use nom8::character::complete::multispace0; +use nom8::sequence::preceded; use suricata_sys::sys::SCSRepCatGetByShortname; -use nom7::Err; -use nom7::IResult; +use nom8::Err; +use nom8::{IResult, Parser}; use std::ffi::{CStr, CString}; use std::str::FromStr; @@ -81,13 +81,13 @@ pub fn is_alphanumeric_or_slash(chr: char) -> bool { pub fn detect_parse_iprep(i: &str) -> IResult<&str, DetectIPRepData, RuleParseError<&str>> { // Inner utility function for easy error creation. - fn make_error(reason: String) -> nom7::Err> { + fn make_error(reason: String) -> nom8::Err> { Err::Error(RuleParseError::InvalidIPRep(reason)) } - let (_, values) = nom7::multi::separated_list1( + let (_, values) = nom8::multi::separated_list1( tag(","), - preceded(multispace0, nom7::bytes::complete::is_not(",")), - )(i)?; + preceded(multispace0, nom8::bytes::complete::is_not(",")), + ).parse(i)?; let args = values.len(); if args == 4 || args == 3 { diff --git a/rust/src/detect/parser.rs b/rust/src/detect/parser.rs index d75e010e67..5f3eb95a48 100644 --- a/rust/src/detect/parser.rs +++ b/rust/src/detect/parser.rs @@ -17,10 +17,10 @@ use crate::detect::error::RuleParseError; -use nom7::bytes::complete::is_not; -use nom7::character::complete::multispace0; -use nom7::sequence::preceded; -use nom7::IResult; +use nom8::bytes::complete::is_not; +use nom8::character::complete::multispace0; +use nom8::sequence::preceded; +use nom8::{IResult, Parser}; #[derive(Debug)] pub enum ResultValue { @@ -31,7 +31,7 @@ pub enum ResultValue { static WHITESPACE: &str = " \t\r\n"; /// Parse all characters up until the next whitespace character. pub fn take_until_whitespace(input: &str) -> IResult<&str, &str, RuleParseError<&str>> { - nom7::bytes::complete::is_not(WHITESPACE)(input) + nom8::bytes::complete::is_not(WHITESPACE).parse(input) } // Parsed as a u64 so the value can be validated against a u32 min/max if needed. @@ -49,5 +49,5 @@ pub fn parse_var(input: &str) -> IResult<&str, ResultValue, RuleParseError<&str> /// is ignore. pub fn parse_token(input: &str) -> IResult<&str, &str, RuleParseError<&str>> { let terminators = "\n\r\t,;: "; - preceded(multispace0, is_not(terminators))(input) + preceded(multispace0, is_not(terminators)).parse(input) } diff --git a/rust/src/detect/transforms/base64.rs b/rust/src/detect/transforms/base64.rs index e9de8a9fe9..3b96d2518d 100644 --- a/rust/src/detect/transforms/base64.rs +++ b/rust/src/detect/transforms/base64.rs @@ -34,10 +34,10 @@ use suricata_sys::sys::{ #[cfg(not(test))] use suricata_sys::sys::{SCInspectionBufferCheckAndExpand, SCInspectionBufferTruncate}; -use nom7::bytes::complete::tag; -use nom7::character::complete::multispace0; -use nom7::sequence::preceded; -use nom7::{Err, IResult}; +use nom8::bytes::complete::tag; +use nom8::character::complete::multispace0; +use nom8::sequence::preceded; +use nom8::{Err, IResult, Parser}; use std::ffi::CStr; use std::os::raw::{c_char, c_int, c_void}; @@ -87,7 +87,7 @@ fn parse_transform_base64( input: &str, ) -> IResult<&str, DetectTransformFromBase64Data, RuleParseError<&str>> { // Inner utility function for easy error creation. - fn make_error(reason: String) -> nom7::Err> { + fn make_error(reason: String) -> nom8::Err> { Err::Error(RuleParseError::InvalidTransformBase64(reason)) } let mut transform_base64 = DetectTransformFromBase64Data::default(); @@ -96,10 +96,10 @@ fn parse_transform_base64( if input.is_empty() { return Ok((input, transform_base64)); } - let (_, values) = nom7::multi::separated_list1( + let (_, values) = nom8::multi::separated_list1( tag(","), - preceded(multispace0, nom7::bytes::complete::is_not(",")), - )(input)?; + preceded(multispace0, nom8::bytes::complete::is_not(",")), + ).parse(input)?; // Too many options? if values.len() > DETECT_TRANSFORM_BASE64_MAX_PARAM_COUNT {