Struct Parser

pub struct Parser { /* private fields */ }

The main parser interface.

Example

use http_muncher::{Parser, ParserHandler};
use std::str;

struct MyHandler;
impl ParserHandler for MyHandler {
   fn on_header_field(&mut self, parser: &mut Parser, header: &[u8]) -> bool {
       println!("{}: ", str::from_utf8(header).unwrap());
       true
   }
   fn on_header_value(&mut self, parser: &mut Parser, value: &[u8]) -> bool {
       println!("\t {:?}", str::from_utf8(value).unwrap());
       true
   }
}

let http_request = b"GET / HTTP/1.0\r\n\
                     Content-Length: 0\r\n\r\n";

let mut parser = Parser::request();
parser.parse(&mut MyHandler {}, http_request);

Implementations

impl Parser

pub fn response() -> Parser

Creates a new parser instance for an HTTP response.

pub fn request() -> Parser

Creates a new parser instance for an HTTP request.

Examples found in repository

examples/parser.rs (line 40)

fn main() {
    // Now we can create a parser instance with our callbacks handler:
    let mut callbacks_handler = MyHandler {};
    let mut parser = Parser::request();

    // Let's define a mock HTTP request:
    let http_request = "GET / HTTP/1.1\r\n\
                        Content-Type: text/plain\r\n\
                        Content-Length: 2\r\n\
                        Hello: World\r\n\r\n\
                        Hi";

    // And now we're ready to go!
    parser.parse(&mut callbacks_handler, http_request.as_bytes());

    // Now that callbacks have been called, we can introspect
    // the parsing results. For instance, print the HTTP version:
    let (http_major, http_minor) = parser.http_version();
    println!("\nHTTP v.{}.{}", http_major, http_minor);
}

pub fn request_and_response() -> Parser

Creates a new parser instance to handle both HTTP requests and responses.

pub fn parse<H: ParserHandler>(&mut self, handler: &mut H, data: &[u8]) -> usize

Parses the provided data and returns a number of bytes read.

Examples found in repository

examples/parser.rs (line 50)

fn main() {
    // Now we can create a parser instance with our callbacks handler:
    let mut callbacks_handler = MyHandler {};
    let mut parser = Parser::request();

    // Let's define a mock HTTP request:
    let http_request = "GET / HTTP/1.1\r\n\
                        Content-Type: text/plain\r\n\
                        Content-Length: 2\r\n\
                        Hello: World\r\n\r\n\
                        Hi";

    // And now we're ready to go!
    parser.parse(&mut callbacks_handler, http_request.as_bytes());

    // Now that callbacks have been called, we can introspect
    // the parsing results. For instance, print the HTTP version:
    let (http_major, http_minor) = parser.http_version();
    println!("\nHTTP v.{}.{}", http_major, http_minor);
}

pub fn http_version(&self) -> (u16, u16)

Returns an HTTP request or response version.

Examples found in repository

examples/parser.rs (line 54)

fn main() {
    // Now we can create a parser instance with our callbacks handler:
    let mut callbacks_handler = MyHandler {};
    let mut parser = Parser::request();

    // Let's define a mock HTTP request:
    let http_request = "GET / HTTP/1.1\r\n\
                        Content-Type: text/plain\r\n\
                        Content-Length: 2\r\n\
                        Hello: World\r\n\r\n\
                        Hi";

    // And now we're ready to go!
    parser.parse(&mut callbacks_handler, http_request.as_bytes());

    // Now that callbacks have been called, we can introspect
    // the parsing results. For instance, print the HTTP version:
    let (http_major, http_minor) = parser.http_version();
    println!("\nHTTP v.{}.{}", http_major, http_minor);
}

pub fn status_code(&self) -> u16

Returns an HTTP response status code (think 404).

pub fn http_method(&self) -> &'static str

Returns an HTTP method static string (GET, POST, and so on).

pub fn has_error(&self) -> bool

Checks if the last parse call was finished successfully. Returns true if it wasn’t.

pub fn error(&self) -> &'static str

In case of a parsing error returns its mnemonic name.

pub fn error_description(&self) -> &'static str

In case of a parsing error returns its description.

pub fn is_upgrade(&self) -> bool

Checks if an upgrade protocol (e.g. WebSocket) was requested.

pub fn is_final_chunk(&self) -> bool

Checks if it was the final body chunk.

pub fn should_keep_alive(&self) -> bool

If should_keep_alive() in the on_headers_complete or on_message_complete callback returns 0, then this should be the last message on the connection. If you are the server, respond with the “Connection: close” header. If you are the client, close the connection.

pub fn pause(&mut self)

pub fn unpause(&mut self)

Trait Implementations

impl Debug for Parser

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Send for Parser