h11types 0.0.3

h11spec core types
Documentation
//! Header parsing

use crate::H11Error;
use crate::H11Header;
use crate::HeaderReceiver;

use crate::parser::{HeaderKeyToken, HeaderValueToken};

use logos::{Lexer, Logos};

/// Indicative completion status of header parsing
#[derive(Debug, PartialEq)]
pub enum HeaderStatus<'h> {
    /// Completed at position relative to input
    Complete(usize),
    /// Incomplete from position relative to input
    Incomplete(usize, &'h [u8]),
}

/// Standalone header parser
#[derive(Debug, Default)]
pub struct HeaderParser {
    /// Location of the error causing header field
    pub fail_location_field: usize,
    /// Location of the error causing header value
    pub fail_location_value: usize,
    /// Headers seen so far
    pub headers_seen: usize,
}

impl HeaderParser {
    /// Parse streamed chunk of data
    pub fn parse<'raw, R: HeaderReceiver>(
        &mut self,
        r: &mut R,
        input: &'raw [u8],
    ) -> Result<HeaderStatus<'raw>, H11Error> {
        let mut lexer: Lexer<'raw, HeaderKeyToken<'raw>> = HeaderKeyToken::lexer(input);

        let mut headers_complete = false;

        while let Some(hdr_key_token) = lexer.next() {
            self.fail_location_field = lexer.span().start;
            self.fail_location_value = lexer.span().end + 1;
            let hdr: H11Header<'raw> = match hdr_key_token {
                Err(_e) => {
                    return Err(H11Error::InvalidHeaders(lexer.span().start));
                }
                Ok(HeaderKeyToken::Incomplete(s)) => {
                    return Ok(HeaderStatus::Incomplete(lexer.span().start, s));
                }
                Ok(HeaderKeyToken::EmptyHeaders) if self.headers_seen == 0 => {
                    r.req_headers_finish();
                    headers_complete = true;
                    break;
                }
                Ok(HeaderKeyToken::Complete) if self.headers_seen != 0 => {
                    r.req_headers_finish();
                    headers_complete = true;
                    break;
                }
                Ok(field_token) => {
                    let maybe_incomplete_at = lexer.span().start;
                    let mut v_lexer: Lexer<'raw, HeaderValueToken<'raw>> = lexer.morph();

                    if v_lexer.remainder().is_empty() {
                        return Ok(HeaderStatus::Incomplete(
                            maybe_incomplete_at,
                            &input[maybe_incomplete_at..],
                        ));
                    }

                    let hdr_v: H11Header<'raw> = match v_lexer.next() {
                        Some(Ok(HeaderValueToken::Incomplete(_s))) => {
                            return Ok(HeaderStatus::Incomplete(
                                maybe_incomplete_at,
                                &input[maybe_incomplete_at..],
                            ));
                        }
                        Some(Ok(value_token)) => {
                            (field_token, value_token).try_into().map_err(|e| {
                                H11Error::InvalidHeaderValue(self.fail_location_value, e)
                            })?
                        }
                        Some(Err(_e)) => {
                            return Err(H11Error::InvalidHeaders(v_lexer.span().start));
                        }
                        None => {
                            return Err(H11Error::InvalidHeaders(v_lexer.span().start));
                        }
                    };

                    self.headers_seen += 1;

                    lexer = v_lexer.morph();
                    hdr_v
                }
            };

            r.req_header(hdr);
        }

        let st = match headers_complete {
            true => HeaderStatus::Complete(lexer.span().end),
            false => HeaderStatus::Incomplete(lexer.span().end, &input[lexer.span().end..]),
        };
        Ok(st)
    }
}

#[cfg(test)]
mod test {

    use super::*;
    use insta::assert_debug_snapshot;
    use rstest::rstest;
    use rstest::Context;

    #[derive(Debug, Default, PartialEq)]
    struct TestReceiver {
        hdrs: Vec<String>,
        finished: bool,
    }

    use crate::{H11MaybeValue, H11UnknownField};

    impl HeaderReceiver for TestReceiver {
        fn req_header<'h>(&mut self, hdr: H11Header<'h>) -> () {
            let out = match hdr {
                H11Header::Unknown(H11UnknownField(field), H11MaybeValue::Bytes(value)) => {
                    format!(
                        "Hu[{}={}]",
                        core::str::from_utf8(field).unwrap(),
                        core::str::from_utf8(value).unwrap()
                    )
                }
                _ => format!("Hd{:?}", hdr),
            };
            self.hdrs.push(out);
        }
        fn req_headers_finish(&mut self) -> () {
            self.finished = true;
        }
    }

    pub(crate) fn ctx_insta(ctx: Context) -> String {
        let case_id = ctx.case.unwrap().to_string();
        format!("{}-{}", case_id, ctx.name)
    }

    #[inline]
    fn do_test(
        tc_input: &'static str,
    ) -> (Result<HeaderStatusStr<'static>, H11Error>, TestReceiver) {
        let mut p = HeaderParser::default();
        let mut r = TestReceiver::default();

        let data = tc_input.as_bytes();
        let res = p.parse(&mut r, &data);

        let res_str = match res {
            Err(e) => Err(e),
            Ok(s) => Ok(s.into()),
        };
        (res_str, r)
    }

    #[derive(Debug)]
    #[allow(dead_code)]
    struct InternalTc<'h> {
        input: &'static str,
        output: TestReceiver,
        res_str: Result<HeaderStatusStr<'h>, H11Error>,
    }

    #[derive(Debug, PartialEq)]
    enum HeaderStatusStr<'h> {
        Complete(usize),
        Incomplete(usize, &'h str),
    }

    impl<'h> From<HeaderStatus<'h>> for HeaderStatusStr<'h> {
        fn from(h: HeaderStatus<'h>) -> Self {
            match h {
                HeaderStatus::Complete(s) => Self::Complete(s),
                HeaderStatus::Incomplete(s, b) => {
                    Self::Incomplete(s, core::str::from_utf8(b).unwrap())
                }
            }
        }
    }

    #[rstest]
    #[case("A: ffffoo.bar\r\nB: foo\r\n\r\n", 0)]
    #[case("\r\n\r\n", 0)]
    #[case("\r\n\r\nfoo", 3)]
    #[case("Host: test.rustcryp.to:8181\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0\r\nAccept: image/avif,image/webp,image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5\r\nAccept-Language: en-US,en;q=0.9\r\nAccept-Encoding: gzip, deflate, br, zstd\r\nDNT: 1\r\nSec-GPC: 1\r\nConnection: keep-alive\r\nReferer: https://test.rustcryp.to:8181/\r\nSec-Fetch-Dest: image\r\nSec-Fetch-Mode: no-cors\r\nSec-Fetch-Site: same-origin\r\nPriority: u=6\r\nPragma: no-cache\r\nCache-Control: no-cache\r\n\r\n", 0)]
    #[case("Host: test.rustcryp.to:1234\r\nUser-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:151.0) Gecko/20100101 Firefox/151.0\r\nAccept: image/avif,image/webp,image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5\r\nAccept-Language: en-US,en;q=0.9\r\nAccept-Encoding: gzip, deflate, br, zstd\r\nDNT: 1\r\nSec-GPC: 1\r\nConnection: keep-alive\r\nReferer: https://test.rustcryp.to:8181/\r\nSec-Fetch-Dest: image\r\nSec-Fetch-Mode: no-cors\r\nSec-Fetch-Site: same-origin\r\nPriority: u=6\r\nPragma: no-cache\r\nCache-Control: no-cache\r\n\r\n", 0)]
    fn headers_complete(
        #[context] ctx: Context,
        #[case] tc_input: &'static str,
        #[case] offset: usize,
    ) {
        let (res_str, output) = do_test(tc_input);

        assert_eq!(
            res_str,
            Ok(HeaderStatusStr::Complete(tc_input.len() - offset))
        );

        assert_debug_snapshot!(
            ctx_insta(ctx),
            InternalTc {
                input: tc_input,
                output,
                res_str,
            }
        );
    }

    #[rstest]
    #[case("A: ffffoo", "A: ffffoo", 0)]
    #[case("A: foo\r\nB: ", "B: ", 8)]
    #[case("C", "C", 0)]
    fn headers_partial(
        #[context] ctx: Context,
        #[case] tc_input: &'static str,
        #[case] leftover: &'static str,
        #[case] incomplete_at: usize,
    ) {
        let (res_str, output) = do_test(tc_input);

        assert_eq!(
            res_str,
            Ok(HeaderStatusStr::Incomplete(incomplete_at, leftover))
        );

        assert_debug_snapshot!(
            ctx_insta(ctx),
            InternalTc {
                input: tc_input,
                output,
                res_str,
            }
        );
    }
}