ntex-httparse 2.2.0

A tiny, safe, speedy, zero-copy HTTP/1.x parser.
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

use super::{Error, Result, Status, iter::Bytes};

// char codes to accept URI string.
// i.e. b'!' <= char and char != 127
// TODO: Make a stricter checking for URI string?
pub(crate) static URI_MAP: [bool; 256] = byte_map!(
    b'!'..=0x7e | 0x80..=0xFF
);

pub(crate) static TOKEN_MAP: [bool; 256] = byte_map!(
    b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' |
    b'!' | b'#' | b'$' | b'%' | b'&' | b'\'' |  b'*' | b'+' |
    b'-' | b'.' | b'^' | b'_' | b'`' | b'|' | b'~'
);

pub(crate) static HEADER_VALUE_MAP: [bool; 256] = byte_map!(
    b'\t' | b' '..=0x7e | 0x80..=0xFF
);

/// `TOKEN_MAP` as a nibble bitmap for SIMD table lookups: bit `hi` of entry
/// `lo` is set if byte `hi << 4 | lo` is a token char. Only bytes below 0x80
/// can be token chars.
#[allow(dead_code)]
pub(crate) const TOKEN_NIBBLES: [u8; 16] = {
    let mut map = [0u8; 16];
    let mut b = 0;
    while b < 0x80 {
        if TOKEN_MAP[b] {
            map[b & 0x0f] |= 1 << (b >> 4);
        }
        b += 1;
    }
    map
};

/// Determines if byte is a method token char.
///
/// > ```notrust
/// > token          = 1*tchar
/// >
/// > tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
/// >                / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
/// >                / DIGIT / ALPHA
/// >                ; any VCHAR, except delimiters
/// > ```
#[inline]
pub(crate) fn is_method_token(b: u8) -> bool {
    match b {
        // For the majority case, this can be faster than the table lookup.
        b'A'..=b'Z' => true,
        _ => TOKEN_MAP[b as usize],
    }
}

#[inline]
pub(crate) fn is_uri_token(b: u8) -> bool {
    URI_MAP[b as usize]
}

#[inline]
pub(crate) fn is_header_name_token(b: u8) -> bool {
    TOKEN_MAP[b as usize]
}

#[inline]
pub(crate) fn is_header_value_token(b: u8) -> bool {
    HEADER_VALUE_MAP[b as usize]
}

#[inline]
pub(crate) fn skip_empty_lines(bytes: &mut Bytes<'_, '_>) -> Result<()> {
    loop {
        let b = bytes.peek();
        match b {
            Some(b'\r') => {
                // peeked and found `\r`, so it's safe to bump 1 pos
                bytes.advance(1);
                expect_lf!(bytes => Err(Error::NewLine));
            }
            Some(b'\n') => {
                // peeked and found `\n`, so it's safe to bump 1 pos
                bytes.advance(1);
            }
            Some(..) => {
                bytes.commit();
                return Ok(Status::Complete(()));
            }
            None => return Ok(Status::Partial),
        }
    }
}

#[inline]
pub(crate) fn skip_spaces(bytes: &mut Bytes<'_, '_>) -> Result<()> {
    loop {
        let b = bytes.peek();
        match b {
            Some(b' ') => {
                // peeked and found ` `, so it's safe to bump 1 pos
                bytes.advance(1);
            }
            Some(..) => {
                bytes.commit();
                return Ok(Status::Complete(()));
            }
            None => return Ok(Status::Partial),
        }
    }
}