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
//! HTTP/1 and HTTP/2 echo over TLS, selected by negotiated ALPN.
#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
fn main() -> Result<(), Box<dyn std::error::Error>> {
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use turnloop_http::{
asynchronous::server::{self, Server},
http1::{BodyLength, Event, Head, Header},
http2,
};
use turnloop_io::turnloop::{Config, LocalExecutor, Timeout, backend::Platform};
use turnloop_tls::{
ServerConfig, TlsStream,
rustls::pki_types::{CertificateDer, PrivateKeyDer, pem::PemObject},
};
let mut args = std::env::args().skip(1);
let cert = args
.next()
.ok_or("usage: tls_echo CERT.pem KEY.pem [ADDRESS]")?;
let key = args.next().ok_or("missing key")?;
let address = args
.next()
.unwrap_or_else(|| "127.0.0.1:8443".into())
.parse()?;
let now = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
let tls = ServerConfig::new(
CertificateDer::pem_file_iter(cert)?.collect::<Result<Vec<_>, _>>()?,
PrivateKeyDer::from_pem_file(key)?,
vec![b"h2".to_vec(), b"http/1.1".to_vec()],
now,
)?;
let mut executor = LocalExecutor::<Platform>::new(Config::default())?;
let h = executor.handle();
let mut server = Server::bind(h.clone(), address)?;
println!("{}", server.local_addr()?);
let task = executor.spawn_local(async move {
server
.run(move |stream, signal| {
let h = h.clone();
let tls = tls.clone();
async move {
let stream =
TlsStream::accept(stream, &tls, &h, h.now() + Duration::from_secs(10), now)
.await?;
if stream.alpn_protocol() == Some(b"h2") {
let mut pending = Vec::<(u32, Vec<u8>, usize, bool)>::with_capacity(16);
let mut buffers = Vec::<Vec<u8>>::with_capacity(16);
server::http2(stream, signal, move |core, event| {
match event {
http2::Event::Headers {
stream, end_stream, ..
} => {
core.send_headers(
stream,
&[Header::new(":status", "200")],
end_stream,
)
.map_err(std::io::Error::other)?;
}
http2::Event::Data {
stream,
bytes,
end_stream,
} => {
let mut buffer =
buffers.pop().unwrap_or_else(|| Vec::with_capacity(16384));
buffer.extend_from_slice(bytes);
pending.push((stream, buffer, 0, end_stream));
}
_ => {}
}
let mut index = 0;
while index < pending.len() {
let (id, bytes, offset, end) = &mut pending[index];
let n = core
.send_data(*id, &bytes[*offset..], *end)
.map_err(std::io::Error::other)?;
*offset += n;
core.release_capacity(*id, n as u32)
.map_err(std::io::Error::other)?;
if *offset == bytes.len() {
let (_, mut buffer, _, _) = pending.remove(index);
buffer.clear();
buffers.push(buffer);
} else {
index += 1;
}
}
Ok(())
})
.await
} else {
server::http1(stream, signal, |event, out| {
match event {
Event::Head(_) => out.start(
&Head {
method: String::new(),
target: String::new(),
status: 200,
version: 1,
headers: vec![],
keep_alive: true,
},
BodyLength::Chunked,
)?,
Event::Body(bytes) => out.body(bytes)?,
Event::End => out.finish(&[])?,
_ => {}
}
Ok(())
})
.await
}
}
})
.await
})?;
while !task.is_finished() {
executor.turn(Timeout::Forever)?;
}
Ok(())
}
#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
fn main() {
eprintln!("Browser listening sockets are unsupported");
}