milo-parser 0.7.0

A fast and embeddable HTTP/1.1 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

use core::{ffi::c_uchar, slice, str};

use milo_parser::Parser;

use crate::helpers::context;

pub fn extract_payload(parser: &Parser, from: usize, size: usize) -> (*const c_uchar, impl Fn()) {
  let context = unsafe { Box::from_raw(parser.context as *mut context::Context) };
  let (ptr, len, cap) = Vec::into_raw_parts(context.input.as_bytes().into());
  let _ = Box::into_raw(context);

  (
    if size > 0 {
      unsafe { ptr.add(from) }
    } else {
      std::ptr::null()
    },
    move || {
      unsafe { Vec::from_raw_parts(ptr, len, cap) };
    },
  )
}

#[allow(unused)]
pub fn format_event(name: &str) -> String { format!("\"{}\"", name).to_string() }

#[allow(unused)]
pub fn append_output(parser: &Parser, message: String, from: usize, size: usize) {
  let (data, cleanup) = extract_payload(parser, from, size);

  let formatted = format!(
    "{{ {}, \"data\": {} }}\n",
    message,
    if !data.is_null() {
      format!("\"{}\"", unsafe {
        str::from_utf8_unchecked(slice::from_raw_parts(data, size))
      })
    } else {
      "null".into()
    },
  );

  print!("{}", formatted);

  let mut context = unsafe { Box::from_raw(parser.context as *mut context::Context) };
  context.output.push_str(formatted.as_str());
  let _ = Box::into_raw(context);
  cleanup();
}

#[allow(unused)]
pub fn event(parser: &Parser, name: &str, from: usize, size: usize) {
  append_output(
    parser,
    format!("\"pos\": {}, \"event\": \"{}\"", from, name),
    from,
    size,
  );
}

#[allow(unused)]
pub fn show_span(parser: &Parser, name: &str, from: usize, size: usize) {
  if name == "method" || name == "url" || name == "protocol" || name == "version" {
    let (data, cleanup) = extract_payload(parser, from, size);
    let mut context = unsafe { Box::from_raw(parser.context as *mut context::Context) };
    let value = unsafe { String::from_utf8_unchecked(slice::from_raw_parts(data, size).into()) };
    cleanup();

    match name {
      "method" => {
        context.method = value;
      }
      "url" => {
        context.url = value;
      }
      "protocol" => {
        context.protocol = value;
      }
      "version" => {
        context.version = value;
      }
      _ => {}
    }

    let _ = Box::into_raw(context);
  }

  event(parser, name, from, size);
}