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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
extern crate httparse;
extern crate netencode;
extern crate arglib_netencode;
extern crate ascii;
extern crate exec_helpers;
use std::os::unix::io::FromRawFd;
use std::io::Read;
use std::io::Write;
use exec_helpers::{die_user_error, die_expected_error, die_temporary};
use netencode::{U, T};
enum What {
Request,
Response
}
fn main() -> std::io::Result<()> {
let what : What = match arglib_netencode::arglib_netencode(None).unwrap() {
T::Record(rec) => match rec.get("what") {
Some(T::Text(t)) => match t.as_str() {
"request" => What::Request,
"response" => What::Response,
_ => die_user_error("read-http arglib", "`what` should be either t:request or t:response"),
},
Some(o) => die_user_error("read-http arglib", format!("expected a record of text, got {:#?}", o)),
None => {
eprintln!("read-http arglib: no `what` given, defaulting to Response");
What::Response
}
}
o => die_user_error("read-http arglib", format!("expected a record, got {:#?}", o))
};
fn read_stdin_to_complete<F>(mut parse: F) -> ()
where F: FnMut(&[u8]) -> httparse::Result<usize>
{
let mut res = httparse::Status::Partial;
loop {
if let httparse::Status::Complete(_) = res {
return;
}
let mut buf = [0; 2048];
match std::io::stdin().read(&mut buf[..]) {
Ok(size) => if size == 0 {
break;
},
Err(err) => die_temporary("read-http", format!("could not read from stdin, {:?}", err))
}
match parse(&buf) {
Ok(status) => {
res = status;
}
Err(err) => die_temporary("read-http", format!("httparse parsing failed: {:#?}", err))
}
}
}
fn normalize_headers<'a>(headers: &'a [httparse::Header]) -> Vec<(String, &'a str)> {
let mut res = vec![];
for httparse::Header { name, value } in headers {
let val = ascii::AsciiStr::from_ascii(*value)
.expect(&format!("read-http: we require header values to be ASCII, but the header {} was {:?}", name, value));
// lowercase the headers, since the standard doesn’t care
// and we want unique strings to match agains
res.push((name.to_lowercase(), val.as_str()))
}
res
}
// tries to read until the end of the http header (deliniated by two newlines "\r\n\r\n")
fn read_till_end_of_header<R: Read>(buf: &mut Vec<u8>, reader: R) -> Option<()> {
let mut chunker = Chunkyboi::new(reader, 4096);
loop {
match chunker.next() {
Some(Ok(chunk)) => {
buf.extend_from_slice(&chunk);
if chunk.windows(4).any(|c| c == b"\r\n\r\n" ) {
return Some(());
}
},
Some(Err(err)) => die_temporary("read-http", format!("error reading from stdin: {:?}", err)),
None => return None
}
}
}
// max header size chosen arbitrarily
let mut headers = [httparse::EMPTY_HEADER; 128];
let stdin = std::io::stdin();
match what {
Request => {
let mut req = httparse::Request::new(&mut headers);
let mut buf: Vec<u8> = vec![];
match read_till_end_of_header(&mut buf, stdin.lock()) {
Some(()) => match req.parse(&buf) {
Ok(httparse::Status::Complete(_body_start)) => {},
Ok(httparse::Status::Partial) => die_expected_error("read-http", "httparse should have gotten a full header"),
Err(err) => die_expected_error("read-http", format!("httparse response parsing failed: {:#?}", err))
},
None => die_expected_error("read-http", format!("httparse end of stdin reached before able to parse request headers"))
}
let method = req.method.expect("method must be filled on complete parse");
let path = req.path.expect("path must be filled on complete parse");
write_dict_req(method, path, &normalize_headers(req.headers))
},
Response => {
let mut resp = httparse::Response::new(&mut headers);
let mut buf: Vec<u8> = vec![];
match read_till_end_of_header(&mut buf, stdin.lock()) {
Some(()) => match resp.parse(&buf) {
Ok(httparse::Status::Complete(_body_start)) => {},
Ok(httparse::Status::Partial) => die_expected_error("read-http", "httparse should have gotten a full header"),
Err(err) => die_expected_error("read-http", format!("httparse response parsing failed: {:#?}", err))
},
None => die_expected_error("read-http", format!("httparse end of stdin reached before able to parse response headers"))
}
let code = resp.code.expect("code must be filled on complete parse");
let reason = resp.reason.expect("reason must be filled on complete parse");
write_dict_resp(code, reason, &normalize_headers(resp.headers))
}
}
}
fn write_dict_req<'buf>(method: &'buf str, path: &'buf str, headers: &[(String, &str)]) -> std::io::Result<()> {
let mut http = vec![
("method", U::Text(method)),
("path", U::Text(path)),
];
write_dict(http, headers)
}
fn write_dict_resp<'buf>(code: u16, reason: &'buf str, headers: &[(String, &str)]) -> std::io::Result<()> {
let mut http = vec![
("status", U::N6(code as u64)),
("status-text", U::Text(reason)),
];
write_dict(http, headers)
}
fn write_dict<'buf, 'a>(mut http: Vec<(&str, U<'a>)>, headers: &'a[(String, &str)]) -> std::io::Result<()> {
http.push(("headers", U::Record(
headers.iter().map(
|(name, value)|
(name.as_str(), U::Text(value))
).collect::<Vec<_>>()
)));
netencode::encode(
&mut std::io::stdout(),
U::Record(http)
)?;
Ok(())
}
// iter helper
struct Chunkyboi<T> {
inner: T,
buf: Vec<u8>,
}
impl<R: Read> Chunkyboi<R> {
fn new(inner: R, chunksize: usize) -> Self {
let buf = vec![0; chunksize];
Chunkyboi {
inner,
buf
}
}
}
impl<R: Read> Iterator for Chunkyboi<R> {
type Item = std::io::Result<Vec<u8>>;
fn next(&mut self) -> Option<std::io::Result<Vec<u8>>> {
match self.inner.read(&mut self.buf) {
Ok(0) => None,
Ok(read) => {
// clone a new buffer so we can reuse the internal one
Some(Ok(self.buf[..read].to_owned()))
}
Err(err) => Some(Err(err))
}
}
}
|
