Struct ctf::parse::RawParser

pub struct RawParser<'data> { /* private fields */ }

Raw parser.

• provides basic and intermediate parsing functions used by Parser and PacketParser;
• works at byte-level.

Implementations

impl<'data> RawParser<'data>

Basic functions.

pub fn new(data: &'data [u8], offset: usize) -> Self

Constructor.

• data: input bytes to parse;
• offset offset from the start of the original input. Used by PacketParser, which works on a slice of the original input, for consistent error-reporting.

pub fn data(&self) -> &'data [u8]

Data accessor.

pub fn take(&mut self, byte_count: usize) -> &'data [u8]

Consumes some bytes from the input, move the cursor at the end of these bytes.

impl<'data> RawParser<'data>

Position related functions.

pub fn pos(&self) -> Pos

Position accessor.

pub fn get(&self, pos: Pos) -> Option<u8>

Retrieves the byte at some position.

pub fn backtrack(&mut self, pos: Pos)

Backtracks the parser to a previous position.

Panics

• when pos is greater than the current position.

impl<'data> RawParser<'data>

RawParser helpers.

pub fn is_eof(&self) -> bool

True if the parser is at the end of its input.

pub fn real_position(&self) -> (usize, usize)

Yields the current position and the total length of the input text.

pub fn state(&self) -> String

Yields a single-line, concise description of the current position.

impl<'data> RawParser<'data>

Basic parsers.

pub fn string(&mut self) -> Res<&'data str>

Parses a string.

pub fn u8_le(&mut self) -> Res<u8>

Parses a u8.

Examples

let data = 213u8.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u8_le().unwrap(), 213);
assert!(parser.is_eof());

pub fn u8_be(&mut self) -> Res<u8>

Parses a u8.

Examples

let data = 213u8.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u8_be().unwrap(), 213);
assert!(parser.is_eof());

pub fn u16_le(&mut self) -> Res<u16>

Parses a u16.

Examples

let data = 1_213u16.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u16_le().unwrap(), 1_213);
assert!(parser.is_eof());

pub fn u16_be(&mut self) -> Res<u16>

Parses a u16.

Examples

let data = 1_213u16.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u16_be().unwrap(), 1_213);
assert!(parser.is_eof());

pub fn u32_le(&mut self) -> Res<u32>

Parses a u32.

Examples

let data = 1_701_213u32.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u32_le().unwrap(), 1_701_213);
assert!(parser.is_eof());

pub fn u32_be(&mut self) -> Res<u32>

Parses a u32.

Examples

let data = 1_701_213u32.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u32_be().unwrap(), 1_701_213);
assert!(parser.is_eof());

pub fn u64_be(&mut self) -> Res<u64>

Parses a u64.

Examples

let data = 7_501_701_213u64.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u64_be().unwrap(), 7_501_701_213);
assert!(parser.is_eof());

pub fn u64_le(&mut self) -> Res<u64>

Parses a u64, low-endian version.

Examples

let data = 7_501_701_213u64.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.u64_le().unwrap(), 7_501_701_213);
assert!(parser.is_eof());

pub fn f64_be(&mut self) -> Res<f64>

Parses a u64, big-endian version.

Examples

let data = 7_501_701.745f64.to_be_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.f64_be().unwrap(), 7_501_701.745);
assert!(parser.is_eof());

pub fn f64_le(&mut self) -> Res<f64>

Parses a u64, big-endian version.

Examples

let data = 7_501_701.745f64.to_le_bytes();
let mut parser = RawParser::new(&data, 0);
assert_eq!(parser.f64_le().unwrap(), 7_501_701.745);
assert!(parser.is_eof());

pub fn magic(&mut self) -> Res<()>

Parses and checks the CTF magic number, and sets the big-endian flag.

pub fn try_magic(self) -> Res<Either<BeParser<'data>, LeParser<'data>>>

Attemps to parse the memtrace CTF magic number.

Parsing the magic number reveals whether the dump uses a big- or low-endian convention. Thus, it returns either a big-endian parser or a low-endian one.

Trait Implementations

impl<'data> Index<Pos> for RawParser<'data>

type Output = u8

The returned type after indexing.

fn index(&self, pos: Pos) -> &u8

Performs the indexing (container[index]) operation.