rust/htp: convert to nom 8

Author: jasonish

rust/Cargo.lock.in

@@ -24,7 +24,7 @@ crate-type = ["staticlib", "rlib", "cdylib"]
 base64 = "0.22.1"
 bstr = "1.12.0"
 libc = "0.2"
-nom = "7.1.3"
+nom = "8.0.0"
 lzma-rs = { version = "0.2.0", features = ["stream"] }
 flate2 = { version = "~1.0.35", features = ["zlib-default"], default-features = false }
 brotli = "~8.0.1"

rust/htp/Cargo.toml.in

@@ -455,10 +455,10 @@ impl GzipBufWriter {
     fn parse_start(data: &[u8]) -> nom::IResult<&[u8], u8> {
         use nom::bytes::streaming::tag;
         use nom::number::streaming::{le_i32, le_u8};
-        use nom::sequence::tuple;
+        use nom::Parser;
 
         let (rest, (_, flags, _mtime, _xfl, _operating_system)) =
-            tuple((tag(b"\x1f\x8b\x08"), le_u8, le_i32, le_u8, le_u8))(data)?;
+            (tag(&b"\x1f\x8b\x08"[..]), le_u8, le_i32, le_u8, le_u8).parse(data)?;
         Ok((rest, flags))
     }
 }
@@ -467,7 +467,7 @@ impl Write for GzipBufWriter {
     fn write(&mut self, data: &[u8]) -> std::io::Result<usize> {
         use nom::bytes::streaming::{tag, take_until};
         use nom::number::streaming::le_u16;
-        use nom::sequence::tuple;
+        use nom::Parser;
 
         const FHCRC: u8 = 1 << 1;
         const FEXTRA: u8 = 1 << 2;
@@ -534,10 +534,10 @@ impl Write for GzipBufWriter {
                 }
                 GzState::Filename => {
                     if self.flags & FNAME != 0 {
-                        match tuple((
-                            take_until::<&[u8], &[u8], nom::error::Error<&[u8]>>(b"\0" as &[u8]),
-                            tag(b"\0"),
-                        ))(parse)
+                        match (
+                            take_until::<&[u8], &[u8], nom::error::Error<&[u8]>>(&b"\0"[..]),
+                            tag(&b"\0"[..]),
+                        ).parse(parse)
                         {
                             Ok((rest, _)) => {
                                 parse = rest;
@@ -557,10 +557,10 @@ impl Write for GzipBufWriter {
                 }
                 GzState::Comment => {
                     if self.flags & FCOMMENT != 0 {
-                        match tuple((
-                            take_until::<&[u8], &[u8], nom::error::Error<&[u8]>>(b"\0" as &[u8]),
-                            tag(b"\0"),
-                        ))(parse)
+                        match (
+                            take_until::<&[u8], &[u8], nom::error::Error<&[u8]>>(&b"\0"[..]),
+                            tag(&b"\0"[..]),
+                        ).parse(parse)
                         {
                             Ok((rest, _)) => {
                                 parse = rest;

rust/htp/src/decompressors.rs

@@ -1,13 +1,13 @@
-use crate::util::{is_token, trimmed, FlagOperations};
+use crate::util::{is_space, is_token, trimmed, FlagOperations};
 use nom::{
     branch::alt,
     bytes::complete::tag as complete_tag,
     bytes::streaming::{tag, take_till, take_while, take_while1},
-    character::{is_space, streaming::space0},
+    character::streaming::space0,
     combinator::{complete, map, not, opt, peek},
-    sequence::tuple,
     Err::Incomplete,
     IResult, Needed,
+    Parser as NomParser,
 };
 
 /// Helper for Parsed bytes and corresponding HeaderFlags
@@ -133,9 +133,9 @@ impl Parser {
                     complete_tag("\n\r"),
                     complete_tag("\n"),
                     complete_tag("\r"),
-                ))(input)
+                )).parse(input)
             } else {
-                alt((complete_tag("\r\n"), complete_tag("\n")))(input)
+                alt((complete_tag("\r\n"), complete_tag("\n"))).parse(input)
             }
         }
     }
@@ -146,38 +146,38 @@ impl Parser {
             if self.side == Side::Response {
                 alt((
                     map(
-                        tuple((
+                        (
                             complete_tag("\n\r\r\n"),
                             peek(alt((complete_tag("\n"), complete_tag("\r\n")))),
-                        )),
+                        ),
                         |(eol, _)| (eol, HeaderFlags::DEFORMED_EOL),
                     ),
                     map(
-                        tuple((
+                        (
                             complete_tag("\r\n\r"),
                             take_while1(|c| c == b'\r' || c == b' ' || c == b'\t'),
                             opt(complete_tag("\n")),
                             not(alt((complete_tag("\n"), complete_tag("\r\n")))),
-                        )),
+                        ),
                         |(eol1, eol2, eol3, _): (&[u8], &[u8], Option<&[u8]>, _)| {
                             (
                                 &input[..(eol1.len() + eol2.len() + eol3.unwrap_or(b"").len())],
                                 HeaderFlags::DEFORMED_EOL,
                             )
                         },
                     ),
-                ))(input)
+                )).parse(input)
             } else {
                 map(
                     alt((
-                        tuple((
+                        (
                             complete_tag("\n\r\r\n"),
                             peek(alt((complete_tag("\n"), complete_tag("\r\n")))),
-                        )),
-                        tuple((complete_tag("\n\r"), peek(complete_tag("\r\n")))),
+                        ),
+                        (complete_tag("\n\r"), peek(complete_tag("\r\n"))),
                     )),
                     |(eol, _)| (eol, HeaderFlags::DEFORMED_EOL),
-                )(input)
+                ).parse(input)
             }
         }
     }
@@ -188,46 +188,46 @@ impl Parser {
             alt((
                 self.complete_eol_deformed(),
                 map(self.complete_eol_regular(), |eol| (eol, 0)),
-            ))(input)
+            )).parse(input)
         }
     }
 
     /// Parse one header end of line, and guarantee that it is not folding
     fn eol(&self) -> impl Fn(&[u8]) -> IResult<&[u8], ParsedBytes> + '_ {
         move |input| {
             map(
-                tuple((self.complete_eol(), not(folding_lws))),
+                (self.complete_eol(), not(folding_lws)),
                 |(end, _)| end,
-            )(input)
+            ).parse(input)
         }
     }
 
     /// Parse one null byte or one end of line, and guarantee that it is not folding
     fn null_or_eol(&self) -> impl Fn(&[u8]) -> IResult<&[u8], ParsedBytes> + '_ {
-        move |input| alt((null, self.eol()))(input)
+        move |input| alt((null, self.eol())).parse(input)
     }
 
     /// Parse one null byte or complete end of line
     fn complete_null_or_eol(&self) -> impl Fn(&[u8]) -> IResult<&[u8], ParsedBytes> + '_ {
-        move |input| alt((null, self.complete_eol()))(input)
+        move |input| alt((null, self.complete_eol())).parse(input)
     }
 
     /// Parse header folding bytes (eol + whitespace or eol + special cases)
     fn folding(&self) -> impl Fn(&[u8]) -> IResult<&[u8], FoldingBytes> + '_ {
         move |input| {
             if self.side == Side::Response {
                 map(
-                    tuple((
+                    (
                         map(self.complete_eol_regular(), |eol| (eol, 0)),
                         folding_lws,
-                    )),
+                    ),
                     |((eol, flags), (lws, other_flags))| (eol, lws, flags | other_flags),
-                )(input)
+                ).parse(input)
             } else {
                 map(
-                    tuple((self.complete_eol(), folding_lws)),
+                    (self.complete_eol(), folding_lws),
                     |((eol, flags), (lws, other_flags))| (eol, lws, flags | other_flags),
-                )(input)
+                ).parse(input)
             }
         }
     }
@@ -242,7 +242,7 @@ impl Parser {
                     ((end, flags), Some(fold))
                 })),
                 map(self.complete_null_or_eol(), |end| (end, None)),
-            ))(input)
+            )).parse(input)
         }
     }
 
@@ -256,7 +256,7 @@ impl Parser {
                     ((end, flags), Some(fold))
                 }),
                 map(self.null_or_eol(), |end| (end, None)),
-            ))(input)
+            )).parse(input)
         }
     }
 
@@ -297,7 +297,7 @@ impl Parser {
                 loop {
                     if self.side == Side::Response {
                         // Peek ahead for ambiguous name with lws vs. value with folding
-                        match tuple((token_chars, separator_regular))(i) {
+                        match (token_chars, separator_regular).parse(i) {
                             Ok((_, ((_, tokens, _), (_, _)))) if !tokens.is_empty() => {
                                 flags.unset(HeaderFlags::FOLDING_SPECIAL_CASE);
                                 if value.is_empty() {
@@ -397,13 +397,13 @@ impl Parser {
 
     /// Parse a separator between header name and value
     fn separator(&self) -> impl Fn(&[u8]) -> IResult<&[u8], u64> + '_ {
-        move |input| map(separator_regular, |_| 0)(input)
+        move |input| map(separator_regular, |_| 0).parse(input)
     }
 
     /// Parse data before an eol with no colon as an empty name with the data as the value
     fn header_sans_colon(&self) -> impl Fn(&[u8]) -> IResult<&[u8], Header> + '_ {
         move |input| {
-            let (remaining, (_, value)) = tuple((not(complete_tag("\r\n")), self.value()))(input)?;
+            let (remaining, (_, value)) = (not(complete_tag("\r\n")), self.value()).parse(input)?;
 
             let flags = value.flags | HeaderFlags::MISSING_COLON;
             Ok((
@@ -417,19 +417,19 @@ impl Parser {
     fn header_with_colon(&self) -> impl Fn(&[u8]) -> IResult<&[u8], Header> + '_ {
         move |input| {
             map(
-                tuple((self.name(), self.separator(), self.value())),
+                (self.name(), self.separator(), self.value()),
                 |(mut name, flag, mut value)| {
                     name.flags |= flag;
                     value.flags |= flag;
                     Header::new(name, value)
                 },
-            )(input)
+            ).parse(input)
         }
     }
 
     /// Parses a header name and value with, or without a colon separator
     fn header(&self) -> impl Fn(&[u8]) -> IResult<&[u8], Header> + '_ {
-        move |input| alt((complete(self.header_with_colon()), self.header_sans_colon()))(input)
+        move |input| alt((complete(self.header_with_colon()), self.header_sans_colon())).parse(input)
     }
 
     /// Parse multiple headers and indicate if end of headers or null was found
@@ -475,25 +475,25 @@ impl Parser {
 fn null(input: &[u8]) -> IResult<&[u8], ParsedBytes<'_>> {
     map(complete_tag("\0"), |null| {
         (null, HeaderFlags::NULL_TERMINATED)
-    })(input)
+    }).parse(input)
 }
 
 /// Extracts folding lws (whitespace only)
 fn folding_lws(input: &[u8]) -> IResult<&[u8], ParsedBytes<'_>> {
     map(alt((tag(" "), tag("\t"), tag("\0"))), |fold| {
         (fold, HeaderFlags::FOLDING)
-    })(input)
+    }).parse(input)
 }
 
 /// Parse a regular separator (colon followed by optional spaces) between header name and value
 fn separator_regular(input: &[u8]) -> IResult<&[u8], (&[u8], &[u8])> {
-    tuple((complete_tag(":"), space0))(input)
+    (complete_tag(":"), space0).parse(input)
 }
 
 type leading_token_trailing<'a> = (&'a [u8], &'a [u8], &'a [u8]);
 /// Parse token characters with leading and trailing whitespace
 fn token_chars(input: &[u8]) -> IResult<&[u8], leading_token_trailing<'_>> {
-    tuple((space0, take_while(is_token), space0))(input)
+    (space0, take_while(is_token), space0).parse(input)
 }
 
 #[cfg(test)]