nom 2.2.1

A byte-oriented, zero-copy, parser combinators library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

#[macro_use]
extern crate nom;

use nom::{IResult,Needed,be_u8,be_u64};

// Parser definition

// We request a length that would trigger an overflow if computing consumed + requested
named!(parser01<&[u8],()>,
    do_parse!(
        hdr: take!(1) >>
        data: take!(18446744073709551615) >>
        ( () )
    )
);

// We request a length that would trigger an overflow if computing consumed + requested
named!(parser02<&[u8],()>,
    chain!(
        hdr: take!(1) ~
        data: take!(18446744073709551615),
        || ()
    )
);

// We request a length that would trigger an overflow if computing consumed + requested
named!(parser03<&[u8],(&[u8],&[u8])>,
    tuple!(take!(1),take!(18446744073709551615))
);

#[test]
fn overflow_incomplete_do_parse() {
  assert_eq!(parser01(&b"3"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_chain() {
  assert_eq!(parser02(&b"3"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_tuple() {
  assert_eq!(parser03(&b"3"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_length_bytes() {
 named!(multi<&[u8], Vec<&[u8]> >, many0!( length_bytes!(be_u64) ) );

 // Trigger an overflow in length_bytes
 assert_eq!(multi(&b"\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xff\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_many0() {
 named!(multi<&[u8], Vec<&[u8]> >, many0!( length_bytes!(be_u64) ) );

 // Trigger an overflow in many0
 assert_eq!(multi(&b"\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xef\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_many1() {
 named!(multi<&[u8], Vec<&[u8]> >, many1!( length_bytes!(be_u64) ) );

 // Trigger an overflow in many1
 assert_eq!(multi(&b"\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xef\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_many_till() {
 named!(multi<&[u8], (Vec<&[u8]>, &[u8]) >, many_till!( length_bytes!(be_u64), tag!("abc") ) );

 // Trigger an overflow in many_till
 assert_eq!(multi(&b"\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xef\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_many_m_n() {
 named!(multi<&[u8], Vec<&[u8]> >, many_m_n!(2, 4, length_bytes!(be_u64) ) );

 // Trigger an overflow in many_m_n
 assert_eq!(multi(&b"\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xef\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_count() {
 named!(counter<&[u8], Vec<&[u8]> >, count!( length_bytes!(be_u64), 2 ) );

 assert_eq!(counter(&b"\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xef\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_count_fixed() {
 named!(counter< [&[u8]; 2] >, count_fixed!( &[u8], length_bytes!(be_u64), 2 ) );

 assert_eq!(counter(&b"\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xef\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_length_count() {
 named!(multi<&[u8], Vec<&[u8]> >, length_count!( be_u8, length_bytes!(be_u64) ) );

 assert_eq!(multi(&b"\x04\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xee\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}

#[test]
fn overflow_incomplete_length_data() {
 named!(multi<&[u8], Vec<&[u8]> >, many0!( length_data!(be_u64) ) );

 assert_eq!(multi(&b"\x00\x00\x00\x00\x00\x00\x00\x01\xaa\xff\xff\xff\xff\xff\xff\xff\xff\xaa"[..]), IResult::Incomplete(Needed::Unknown));
}