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

rust/detect: convert error.rs and dependent parsers to nom 8

Browse Source 
Ticket: #8051
pull/14332/head
Jason Ish 10 months ago committed by Victor Julien
parent efc32dea41
commit dea3f9e260
7 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File

16
rust/src/detect/byte_extract.rs
Unescape Escape View File

@ -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<RuleParseError<&'static str>> {
fn make_error(reason: String) -> nom8::Err<RuleParseError<&'static str>> {
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

16
rust/src/detect/byte_math.rs
Unescape Escape View File

@ -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<ByteMathOperator, ()> {
fn parse_bytemath(input: &str) -> IResult<&str, DetectByteMathData, RuleParseError<&str>> {
// Inner utility function for easy error creation.
fn make_error(reason: String) -> nom7::Err<RuleParseError<&'static str>> {
fn make_error(reason: String) -> nom8::Err<RuleParseError<&'static str>> {
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

16
rust/src/detect/entropy.rs
Unescape Escape View File

@ -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<RuleParseError<&'static str>> {
fn make_error(reason: String) -> nom8::Err<RuleParseError<&'static str>> {
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

2
rust/src/detect/error.rs
Unescape Escape View File

@ -15,7 +15,7 @@
* 02110-1301, USA.
*/
use nom7::error::{ErrorKind, ParseError};
use nom8::error::{ErrorKind, ParseError};
/// Custom rule parse errors.
///

18
rust/src/detect/iprep.rs
Unescape Escape View File

@ -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<RuleParseError<&'static str>> {
fn make_error(reason: String) -> nom8::Err<RuleParseError<&'static str>> {
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 {

12
rust/src/detect/parser.rs
Unescape Escape View File

@ -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)
}

16
rust/src/detect/transforms/base64.rs
Unescape Escape View File

@ -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<RuleParseError<&'static str>> {
fn make_error(reason: String) -> nom8::Err<RuleParseError<&'static str>> {
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 {

Write Preview
Loading…
Cancel
Save