Upgrade nom to version 8.0

Author: chifflier

Cargo.toml

@@ -46,8 +46,8 @@ rustdoc-args = ["--cfg", "docsrs"]
 [dependencies]
 circular = "0.3"
 cookie-factory = { version="0.3.0", optional=true }
-nom = "7.0"
-rusticata-macros = "4.0"
+nom = "8.0"
+rusticata-macros = "5.0"
 
 [dev-dependencies]
 criterion = { version="0.5", features=["html_reports"] }

src/data/exported_pdu.rs

@@ -2,7 +2,7 @@ use crate::data::PacketData;
 use nom::bytes::streaming::{tag, take};
 use nom::multi::many_till;
 use nom::number::streaming::be_u16;
-use nom::IResult;
+use nom::{IResult, Parser as _};
 use std::convert::TryFrom;
 
 /* values from epan/exported_pdu.h */
@@ -27,7 +27,9 @@ pub fn parse_exported_tlv(i: &[u8]) -> IResult<&[u8], ExportedTlv<'_>> {
 }
 
 pub fn parse_many_exported_tlv(i: &[u8]) -> IResult<&[u8], Vec<ExportedTlv<'_>>> {
- many_till(parse_exported_tlv, tag(b"\x00\x00\x00\x00"))(i).map(|(rem, (v, _))| (rem, v))
+ many_till(parse_exported_tlv, tag(b"\x00\x00\x00\x00" as &[u8]))
+ .parse(i)
+ .map(|(rem, (v, _))| (rem, v))
 }
 
 /// Get packet data for WIRESHARK_UPPER_PDU (252)

src/data/pcap_nflog.rs

@@ -10,7 +10,7 @@ use nom::bytes::streaming::take;
 use nom::combinator::{complete, cond, verify};
 use nom::multi::many0;
 use nom::number::streaming::{be_u16, le_u16, le_u8};
-use nom::IResult;
+use nom::{IResult, Parser as _};
 
 // Defined in linux/netfilter/nfnetlink_log.h
 #[derive(Copy, Clone)]
@@ -68,10 +68,10 @@ pub struct NflogTlv<'a> {
 }
 
 pub fn parse_nflog_tlv(i: &[u8]) -> IResult<&[u8], NflogTlv<'_>> {
- let (i, l) = verify(le_u16, |&n| n >= 4)(i)?;
+ let (i, l) = verify(le_u16, |&n| n >= 4).parse(i)?;
  let (i, t) = le_u16(i)?;
  let (i, v) = take(l - 4)(i)?;
- let (i, _padding) = cond(l % 4 != 0, take(4 - (l % 4)))(i)?;
+ let (i, _padding) = cond(l % 4 != 0, take(4 - (l % 4))).parse(i)?;
  Ok((i, NflogTlv { l, t, v }))
 }
 
@@ -112,7 +112,7 @@ impl NflogPacket<'_> {
 
 pub fn parse_nflog(i: &[u8]) -> IResult<&[u8], NflogPacket<'_>> {
  let (i, header) = parse_nflog_header(i)?;
- let (i, data) = many0(complete(parse_nflog_tlv))(i)?;
+ let (i, data) = many0(complete(parse_nflog_tlv)).parse(i)?;
  Ok((i, NflogPacket { header, data }))
 }
 

src/pcap/capture.rs

@@ -5,7 +5,7 @@ use crate::linktype::Linktype;
 use crate::pcap::{parse_pcap_frame, parse_pcap_header, LegacyPcapBlock, PcapHeader};
 use nom::combinator::complete;
 use nom::multi::many0;
-use nom::{IResult, Needed};
+use nom::{IResult, Needed, Parser as _};
 use std::fmt;
 
 /// Parsing iterator over legacy pcap data (requires data to be loaded into memory)
@@ -121,6 +121,6 @@ impl Capture for PcapCapture<'_> {
 /// Note: this requires the file to be fully loaded to memory.
 pub fn parse_pcap(i: &[u8]) -> IResult<&[u8], PcapCapture<'_>, PcapError<&[u8]>> {
  let (i, header) = parse_pcap_header(i)?;
- let (i, blocks) = many0(complete(parse_pcap_frame))(i)?;
+ let (i, blocks) = many0(complete(parse_pcap_frame)).parse(i)?;
  Ok((i, PcapCapture { header, blocks }))
 }

src/pcapng/block.rs

@@ -1,7 +1,7 @@
 use nom::bytes::streaming::take;
 use nom::combinator::map;
-use nom::error::*;
 use nom::number::streaming::{be_u32, le_u32};
+use nom::{error::*, Parser as _};
 use nom::{Err, IResult};
 
 use crate::endianness::PcapEndianness;
@@ -56,27 +56,30 @@ impl Block<'_> {
 pub fn parse_block_le(i: &[u8]) -> IResult<&[u8], Block<'_>, PcapError<&[u8]>> {
  match le_u32(i) {
  Ok((_, id)) => match id {
- SHB_MAGIC => map(parse_sectionheaderblock, Block::SectionHeader)(i),
+ SHB_MAGIC => map(parse_sectionheaderblock, Block::SectionHeader).parse(i),
  IDB_MAGIC => map(
  parse_interfacedescriptionblock_le,
  Block::InterfaceDescription,
- )(i),
- SPB_MAGIC => map(parse_simplepacketblock_le, Block::SimplePacket)(i),
- EPB_MAGIC => map(parse_enhancedpacketblock_le, Block::EnhancedPacket)(i),
- NRB_MAGIC => map(parse_nameresolutionblock_le, Block::NameResolution)(i),
+ )
+ .parse(i),
+ SPB_MAGIC => map(parse_simplepacketblock_le, Block::SimplePacket).parse(i),
+ EPB_MAGIC => map(parse_enhancedpacketblock_le, Block::EnhancedPacket).parse(i),
+ NRB_MAGIC => map(parse_nameresolutionblock_le, Block::NameResolution).parse(i),
  ISB_MAGIC => map(
  parse_interfacestatisticsblock_le,
  Block::InterfaceStatistics,
- )(i),
+ )
+ .parse(i),
  SJE_MAGIC => map(
  parse_systemdjournalexportblock_le,
  Block::SystemdJournalExport,
- )(i),
- DSB_MAGIC => map(parse_decryptionsecretsblock_le, Block::DecryptionSecrets)(i),
- CB_MAGIC => map(parse_customblock_le, Block::Custom)(i),
- DCB_MAGIC => map(parse_dcb_le, Block::Custom)(i),
- PIB_MAGIC => map(parse_processinformationblock_le, Block::ProcessInformation)(i),
- _ => map(parse_unknownblock_le, Block::Unknown)(i),
+ )
+ .parse(i),
+ DSB_MAGIC => map(parse_decryptionsecretsblock_le, Block::DecryptionSecrets).parse(i),
+ CB_MAGIC => map(parse_customblock_le, Block::Custom).parse(i),
+ DCB_MAGIC => map(parse_dcb_le, Block::Custom).parse(i),
+ PIB_MAGIC => map(parse_processinformationblock_le, Block::ProcessInformation).parse(i),
+ _ => map(parse_unknownblock_le, Block::Unknown).parse(i),
  },
  Err(e) => Err(e),
  }
@@ -89,27 +92,30 @@ pub fn parse_block_le(i: &[u8]) -> IResult<&[u8], Block<'_>, PcapError<&[u8]>> {
 pub fn parse_block_be(i: &[u8]) -> IResult<&[u8], Block<'_>, PcapError<&[u8]>> {
  match be_u32(i) {
  Ok((_, id)) => match id {
- SHB_MAGIC => map(parse_sectionheaderblock, Block::SectionHeader)(i),
+ SHB_MAGIC => map(parse_sectionheaderblock, Block::SectionHeader).parse(i),
  IDB_MAGIC => map(
  parse_interfacedescriptionblock_be,
  Block::InterfaceDescription,
- )(i),
- SPB_MAGIC => map(parse_simplepacketblock_be, Block::SimplePacket)(i),
- EPB_MAGIC => map(parse_enhancedpacketblock_be, Block::EnhancedPacket)(i),
- NRB_MAGIC => map(parse_nameresolutionblock_be, Block::NameResolution)(i),
+ )
+ .parse(i),
+ SPB_MAGIC => map(parse_simplepacketblock_be, Block::SimplePacket).parse(i),
+ EPB_MAGIC => map(parse_enhancedpacketblock_be, Block::EnhancedPacket).parse(i),
+ NRB_MAGIC => map(parse_nameresolutionblock_be, Block::NameResolution).parse(i),
  ISB_MAGIC => map(
  parse_interfacestatisticsblock_be,
  Block::InterfaceStatistics,
- )(i),
+ )
+ .parse(i),
  SJE_MAGIC => map(
  parse_systemdjournalexportblock_be,
  Block::SystemdJournalExport,
- )(i),
- DSB_MAGIC => map(parse_decryptionsecretsblock_be, Block::DecryptionSecrets)(i),
- CB_MAGIC => map(parse_customblock_be, Block::Custom)(i),
- DCB_MAGIC => map(parse_dcb_be, Block::Custom)(i),
- PIB_MAGIC => map(parse_processinformationblock_be, Block::ProcessInformation)(i),
- _ => map(parse_unknownblock_be, Block::Unknown)(i),
+ )
+ .parse(i),
+ DSB_MAGIC => map(parse_decryptionsecretsblock_be, Block::DecryptionSecrets).parse(i),
+ CB_MAGIC => map(parse_customblock_be, Block::Custom).parse(i),
+ DCB_MAGIC => map(parse_dcb_be, Block::Custom).parse(i),
+ PIB_MAGIC => map(parse_processinformationblock_be, Block::ProcessInformation).parse(i),
+ _ => map(parse_unknownblock_be, Block::Unknown).parse(i),
  },
  Err(e) => Err(e),
  }

src/pcapng/capture.rs

@@ -3,7 +3,7 @@ use crate::error::PcapError;
 use crate::pcapng::*;
 use nom::combinator::{complete, map};
 use nom::multi::many1;
-use nom::{IResult, Needed};
+use nom::{IResult, Needed, Parser as _};
 use std::fmt;
 
 #[derive(Default)]
@@ -122,5 +122,6 @@ impl<'a> PcapNGCapture<'a> {
 pub fn parse_pcapng(i: &[u8]) -> IResult<&[u8], PcapNGCapture<'_>, PcapError<&[u8]>> {
  map(many1(complete(parse_section)), |sections| PcapNGCapture {
  sections,
- })(i)
+ })
+ .parse(i)
 }

src/pcapng/name_resolution.rs

@@ -2,7 +2,7 @@ use nom::bytes::streaming::{tag, take};
 use nom::combinator::map;
 use nom::error::{ErrorKind, ParseError};
 use nom::multi::many_till;
-use nom::{Err, IResult};
+use nom::{Err, IResult, Parser as _};
 use rusticata_macros::{align32, newtype_enum};
 
 use crate::endianness::{PcapBE, PcapEndianness, PcapLE};
@@ -94,12 +94,16 @@ fn parse_name_record_list<'a, En: PcapEndianness, E: ParseError<&'a [u8]>>(
  i: &'a [u8],
 ) -> IResult<&'a [u8], Vec<NameRecord<'a>>, E> {
  map(
- many_till(parse_name_record::<En, E>, tag(b"\x00\x00\x00\x00")),
+ many_till(
+ parse_name_record::<En, E>,
+ tag(b"\x00\x00\x00\x00" as &[u8]),
+ ),
  |(mut v, _)| {
  v.push(NameRecord::END);
  v
  },
- )(i)
+ )
+ .parse(i)
 }
 
 /// Parse a Name Resolution Block (little-endian)

src/pcapng/option.rs

@@ -4,8 +4,8 @@ use std::fmt;
 
 use nom::combinator::{complete, map_parser};
 use nom::multi::many0;
-use nom::IResult;
 use nom::{bytes::streaming::take, error::ParseError};
+use nom::{IResult, Parser as _};
 use rusticata_macros::{align32, newtype_enum};
 
 use crate::endianness::{PcapBE, PcapEndianness, PcapLE};
@@ -193,7 +193,8 @@ pub(crate) fn opt_parse_options<'i, En: PcapEndianness, E: ParseError<&'i [u8]>>
  map_parser(
  take(len - opt_offset),
  many0(complete(parse_option::<En, E>)),
- )(i)
+ )
+ .parse(i)
  } else {
  Ok((i, Vec::new()))
  }

src/pcapng/section.rs

@@ -2,7 +2,7 @@ use nom::{
  combinator::complete,
  error::{make_error, ErrorKind},
  multi::{many0, many1},
- Err, IResult,
+ Err, IResult, Parser as _,
 };
 
 use crate::{PcapBlock, PcapError};
@@ -106,9 +106,9 @@ pub fn parse_section(i: &[u8]) -> IResult<&[u8], Section<'_>, PcapError<&[u8]>>
  let (rem, shb) = parse_sectionheaderblock(i)?;
  let big_endian = shb.big_endian();
  let (rem, mut b) = if big_endian {
- many0(complete(parse_section_content_block_be))(rem)?
+ many0(complete(parse_section_content_block_be)).parse(rem)?
  } else {
- many0(complete(parse_section_content_block_le))(rem)?
+ many0(complete(parse_section_content_block_le)).parse(rem)?
  };
  let mut blocks = Vec::with_capacity(b.len() + 1);
  blocks.push(Block::SectionHeader(shb));
@@ -120,5 +120,5 @@ pub fn parse_section(i: &[u8]) -> IResult<&[u8], Section<'_>, PcapError<&[u8]>>
 /// Parse multiple sections (little or big endian)
 #[inline]
 pub fn parse_sections(i: &[u8]) -> IResult<&[u8], Vec<Section<'_>>, PcapError<&[u8]>> {
- many1(complete(parse_section))(i)
+ many1(complete(parse_section)).parse(i)
 }