htp: remove use of deprecated nom 8 functions

Author: jasonish

rust/htp/src/decompressors.rs

@@ -1,4 +1,5 @@
 use brotli;
+use nom::Parser as _;
 use std::{
     io::{Cursor, Write},
     time::Instant,
@@ -455,11 +456,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 as _;
 
         let (rest, (_, flags, _mtime, _xfl, _operating_system)) =
-            tuple((tag(&b"\x1f\x8b\x08"[..]), le_u8, le_i32, le_u8, le_u8)).parse(data)?;
+            (tag(&b"\x1f\x8b\x08"[..]), le_u8, le_i32, le_u8, le_u8).parse(data)?;
         Ok((rest, flags))
     }
 }
@@ -468,7 +468,6 @@ 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;
 
         const FHCRC: u8 = 1 << 1;
         const FEXTRA: u8 = 1 << 2;
@@ -535,10 +534,11 @@ impl Write for GzipBufWriter {
                 }
                 GzState::Filename => {
                     if self.flags & FNAME != 0 {
-                        match tuple((
+                        match (
                             take_until::<&[u8], &[u8], nom::error::Error<&[u8]>>(b"\0" as &[u8]),
                             tag(&b"\0"[..]),
-                        ))(parse)
+                        )
+                            .parse(parse)
                         {
                             Ok((rest, _)) => {
                                 parse = rest;
@@ -558,10 +558,11 @@ impl Write for GzipBufWriter {
                 }
                 GzState::Comment => {
                     if self.flags & FCOMMENT != 0 {
-                        match tuple((
+                        match (
                             take_until::<&[u8], &[u8], nom::error::Error<&[u8]>>(b"\0" as &[u8]),
                             tag(&b"\0"[..]),
-                        ))(parse)
+                        )
+                            .parse(parse)
                         {
                             Ok((rest, _)) => {
                                 parse = rest;

rust/htp/src/headers.rs

@@ -5,7 +5,6 @@ use nom::{
     bytes::streaming::{tag, take_till, take_while, take_while1},
     character::{is_space, streaming::space0},
     combinator::{complete, map, not, opt, peek},
-    sequence::tuple,
     Err::Incomplete,
     IResult, Needed, Parser as _,
 };
@@ -147,19 +146,19 @@ 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())],
@@ -172,11 +171,11 @@ impl Parser {
             } 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),
                 )
@@ -198,13 +197,7 @@ impl Parser {
 
     /// 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))),
-                |(end, _)| end,
-            )
-            .parse(input)
-        }
+        move |input| map((self.complete_eol(), not(folding_lws)), |(end, _)| end).parse(input)
     }
 
     /// Parse one null byte or one end of line, and guarantee that it is not folding
@@ -222,16 +215,16 @@ impl Parser {
         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),
                 )
                 .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),
                 )
                 .parse(input)
@@ -307,7 +300,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)).parse(i) {
+                        match (token_chars, separator_regular).parse(i) {
                             Ok((_, ((_, tokens, _), (_, _)))) if !tokens.is_empty() => {
                                 flags.unset(HeaderFlags::FOLDING_SPECIAL_CASE);
                                 if value.is_empty() {
@@ -414,8 +407,7 @@ impl Parser {
     /// 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())).parse(input)?;
+            let (remaining, (_, value)) = (not(complete_tag("\r\n")), self.value()).parse(input)?;
 
             let flags = value.flags | HeaderFlags::MISSING_COLON;
             Ok((
@@ -429,7 +421,7 @@ 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;
@@ -504,13 +496,13 @@ fn folding_lws(input: &[u8]) -> IResult<&[u8], ParsedBytes<'_>> {
 
 /// 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)).parse(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)).parse(input)
+    (space0, take_while(is_token), space0).parse(input)
 }
 
 #[cfg(test)]

rust/htp/src/parsers.rs

@@ -27,10 +27,10 @@ use nom::{
 fn content_type() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8]> {
     move |input| {
         map(
-            tuple((
+            (
                 take_ascii_whitespace(),
                 take_till(|c| c == b';' || c == b',' || c == b' '),
-            )),
+            ),
             |(_, content_type)| content_type,
         )
         .parse(input)
@@ -106,7 +106,7 @@ pub(crate) fn scheme() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8]> {
         // Scheme test: if it doesn't start with a forward slash character (which it must
         // for the contents to be a path or an authority), then it must be the scheme part
         map(
-            tuple((peek(not(tag("/"))), take_until(":"), tag(":"))),
+            (peek(not(tag("/"))), take_until(":"), tag(":")),
             |(_, scheme, _)| scheme,
         )
         .parse(input)
@@ -125,8 +125,8 @@ pub(crate) fn credentials() -> impl Fn(&[u8]) -> IResult<&[u8], ParsedCredential
         // One, three or more slash characters, and it's a path.
         // Note: we only attempt to parse authority if we've seen a scheme.
         let (input, (_, _, credentials, _)) =
-            tuple((tag("//"), peek(not(tag("/"))), take_until("@"), tag("@"))).parse(input)?;
-        let (password, username) = opt(tuple((take_until(":"), tag(":")))).parse(credentials)?;
+            (tag("//"), peek(not(tag("/"))), take_until("@"), tag("@")).parse(input)?;
+        let (password, username) = opt((take_until(":"), tag(":"))).parse(credentials)?;
         if let Some((username, _)) = username {
             Ok((input, (username, Some(password))))
         } else {
@@ -141,7 +141,7 @@ pub(crate) fn credentials() -> impl Fn(&[u8]) -> IResult<&[u8], ParsedCredential
 /// Returns a tuple of the remaining unconsumed data and the matched ipv6 hostname.
 pub(crate) fn ipv6() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8]> {
     move |input| -> IResult<&[u8], &[u8]> {
-        let (rest, _) = tuple((tag("["), is_not("/?#]"), opt(tag("]")))).parse(input)?;
+        let (rest, _) = (tag("["), is_not("/?#]"), opt(tag("]"))).parse(input)?;
         Ok((rest, &input[..input.len() - rest.len()]))
     }
 }
@@ -152,12 +152,12 @@ pub(crate) fn ipv6() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8]> {
 pub(crate) fn hostname() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8]> {
     move |input| {
         let (input, mut hostname) = map(
-            tuple((
+            (
                 opt(tag("//")), //If it starts with "//", skip (might have parsed a scheme and no creds)
                 peek(not(tag("/"))), //If it starts with '/', this is a path, not a hostname
                 many0(tag(" ")),
                 alt((ipv6(), is_not("/?#:"))),
-            )),
+            ),
             |(_, _, _, hostname)| hostname,
         )
         .parse(input)?;
@@ -177,7 +177,7 @@ pub(crate) fn port() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8]> {
     move |input| {
         // Must start with ":" for there to be a port to parse
         let (input, (_, _, port, _)) =
-            tuple((tag(":"), many0(tag(" ")), is_not("/?#"), many0(tag(" ")))).parse(input)?;
+            (tag(":"), many0(tag(" ")), is_not("/?#"), many0(tag(" "))).parse(input)?;
         let (_, port) = is_not(" ")(port)?; //we assume there never will be a space in the middle of a port
         Ok((input, port))
     }
@@ -198,10 +198,7 @@ pub(crate) fn path() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8]> {
 pub(crate) fn query() -> impl Fn(&[u8]) -> IResult<&[u8], &[u8]> {
     move |input| {
         // Skip the starting '?'
-        map(tuple((tag("?"), take_till(|c| c == b'#'))), |(_, query)| {
-            query
-        })
-        .parse(input)
+        map((tag("?"), take_till(|c| c == b'#')), |(_, query)| query).parse(input)
     }
 }
 
@@ -245,15 +242,15 @@ pub(crate) fn parse_hostport(input: &[u8]) -> IResult<&[u8], parsed_hostport<'_>
 /// Returns (any unparsed trailing data, (version_number, flag indicating whether input contains trailing and/or leading whitespace and/or leading zeros))
 fn protocol_version(input: &[u8]) -> IResult<&[u8], (&[u8], bool)> {
     map(
-        tuple((
+        (
             take_ascii_whitespace(),
             tag_no_case("HTTP"),
             take_ascii_whitespace(),
             tag("/"),
             take_while(|c: u8| c.is_ascii_whitespace() || c == b'0'),
             alt((tag(".9"), tag("1.0"), tag("1.1"))),
             take_ascii_whitespace(),
-        )),
+        ),
         |(_, _, leading, _, trailing, version, _)| {
             (version, !leading.is_empty() || !trailing.is_empty())
         },
@@ -311,17 +308,17 @@ pub(crate) fn parse_status(status: &[u8]) -> HtpResponseNumber {
 /// Parses Digest Authorization request header.
 fn parse_authorization_digest(auth_header_value: &[u8]) -> IResult<&[u8], Vec<u8>> {
     // Extract the username
-    let (mut remaining_input, _) = tuple((
+    let (mut remaining_input, _) = (
         take_until("username="),
         tag("username="),
         take_ascii_whitespace(), // allow lws
         tag("\""),               // First character after LWS must be a double quote
-    ))(auth_header_value)?;
+    )
+        .parse(auth_header_value)?;
     let mut result = Vec::new();
     // Unescape any escaped double quotes and find the closing quote
     loop {
-        let (remaining, (auth_header, _)) =
-            tuple((take_until("\""), tag("\""))).parse(remaining_input)?;
+        let (remaining, (auth_header, _)) = (take_until("\""), tag("\"")).parse(remaining_input)?;
         remaining_input = remaining;
         result.extend_from_slice(auth_header);
         if result.last() == Some(&(b'\\')) {
@@ -339,9 +336,9 @@ fn parse_authorization_digest(auth_header_value: &[u8]) -> IResult<&[u8], Vec<u8
 /// Parses Basic Authorization request header.
 fn parse_authorization_basic(request_tx: &mut Transaction, auth_header: &Header) -> Result<()> {
     // Skip 'Basic<lws>'
-    let (remaining_input, _) =
-        tuple((tag_no_case("basic"), take_ascii_whitespace()))(auth_header.value.as_slice())
-            .map_err(|_| HtpStatus::DECLINED)?;
+    let (remaining_input, _) = (tag_no_case("basic"), take_ascii_whitespace())
+        .parse(auth_header.value.as_slice())
+        .map_err(|_| HtpStatus::DECLINED)?;
     // Decode base64-encoded data
     let decoded = STANDARD
         .decode(remaining_input)
@@ -383,11 +380,12 @@ pub(crate) fn parse_authorization(request_tx: &mut Transaction) -> Result<()> {
         }
     } else if auth_header.value.starts_with_nocase("bearer") {
         request_tx.request_auth_type = HtpAuthType::BEARER;
-        let (token, _) = tuple((
+        let (token, _) = (
             tag_no_case("bearer"),
             take_ascii_whitespace(), // allow lws
-        ))(auth_header.value.as_slice())
-        .map_err(|_| HtpStatus::DECLINED)?;
+        )
+            .parse(auth_header.value.as_slice())
+            .map_err(|_| HtpStatus::DECLINED)?;
         request_tx.request_auth_token = Some(Bstr::from(token));
     } else {
         // Unrecognized authentication method

rust/htp/src/request.rs

@@ -18,7 +18,7 @@ use crate::{
     },
     HtpStatus,
 };
-use nom::sequence::tuple;
+use nom::Parser as _;
 use std::{
     cmp::{min, Ordering},
     mem::take,
@@ -272,7 +272,7 @@ impl ConnectionParser {
         // The request method starts at the beginning of the
         // line and ends with the first whitespace character.
         // We skip leading whitespace as IIS allows this.
-        let res = tuple((take_is_space, take_not_is_space))(buffered.as_slice());
+        let res = (take_is_space, take_not_is_space).parse(buffered.as_slice());
         if let Ok((_, (_, method))) = res {
             if HtpMethod::new(method) == HtpMethod::Unknown {
                 self.request_status = HtpStreamState::TUNNEL;
@@ -889,18 +889,18 @@ impl ConnectionParser {
         }
         // The request method starts at the beginning of the
         // line and ends with the first whitespace character.
-        let mut method_parser = tuple
+        let mut method_parser =
                                 // skip past leading whitespace. IIS allows this
-                               ((take_is_space,
+                               (take_is_space,
                                take_not_is_space,
                                 // Ignore whitespace after request method. The RFC allows
                                  // for only one SP, but then suggests any number of SP and HT
                                  // should be permitted. Apache uses isspace(), which is even
                                  // more permitting, so that's what we use here.
                                take_is_space
-                               ));
+                               );
 
-        if let Ok((remaining, (ls, method, ws))) = method_parser(data) {
+        if let Ok((remaining, (ls, method, ws))) = method_parser.parse(data) {
             if !ls.is_empty() {
                 htp_warn!(
                     self.logger,
@@ -1369,7 +1369,7 @@ impl ConnectionParser {
             //closing
             return self.state_request_complete(input);
         }
-        let res = tuple((take_is_space, take_not_is_space))(&data);
+        let res = (take_is_space, take_not_is_space).parse(&data);
 
         if let Ok((_, (_, method))) = res {
             if method.is_empty() {

rust/htp/src/request_generic.rs

@@ -12,7 +12,7 @@ use crate::{
         FlagOperations, HtpFlags,
     },
 };
-use nom::{bytes::complete::take_while, error::ErrorKind, sequence::tuple};
+use nom::{bytes::complete::take_while, error::ErrorKind};
 use std::cmp::Ordering;
 
 impl ConnectionParser {