🏗️ Elegant & Highly Performant Async Gemini Server Framework for the Modern Age
async
framework
gemini-protocol
protocol
gemini
rust
deps: bump tokio and tokio-openssl to latest
I've been putting off bumping these two packages for almost a year now since I
didn't know what they would break (they broke a lot). I finally had the courage
and the time to go for it, and it only took about two hours of debugging.
+36
-19
+4
-5
Cargo.toml
+4
-5
Cargo.toml
···
19
19
auto-deduce-mime = ["tree_magic"]
20
20
21
21
[dependencies]
22
-
# TCP
22
+
# SSL
23
23
openssl = "0.10.38"
24
-
tokio = { version = "0.2.4", features = ["full"] }
25
-
# tokio-openssl = "0.5.0"
26
-
# tokio-uds = "0.2.7"
27
-
tokio-openssl = "0.4.0"
24
+
tokio-openssl = "0.6.3"
25
+
26
+
tokio = { version = "1.26.0", features = ["full"] } # Non-blocking I/O
28
27
29
28
# Logging
30
29
pretty_env_logger = { version = "0.4.0", optional = true }
+32
-14
src/router.rs
+32
-14
src/router.rs
···
19
19
use std::{
20
20
error::Error,
21
21
sync::{Arc, Mutex},
22
+
time,
22
23
};
23
24
24
25
use openssl::ssl::{self, SslAcceptor, SslMethod};
25
-
use tokio::{
26
-
io::{AsyncReadExt, AsyncWriteExt},
27
-
stream::StreamExt,
28
-
};
26
+
use tokio::io::{AsyncReadExt, AsyncWriteExt};
29
27
use url::Url;
30
28
31
29
use crate::{
···
44
42
.write_all(format!($error_format, e).as_bytes())
45
43
.await?;
46
44
47
-
$stream.shutdown().await?;
45
+
// $stream.shutdown().await?;
48
46
49
47
return Ok(());
50
48
}
···
223
221
pretty_env_logger::init();
224
222
}
225
223
226
-
let mut listener =
224
+
let listener =
227
225
tokio::net::TcpListener::bind(format!("0.0.0.0:{}", self.port)).await?;
228
226
229
227
#[cfg(feature = "logger")]
230
228
info!("windmark is listening for connections");
231
229
232
-
while let Some(stream) = listener.incoming().next().await {
233
-
match stream {
234
-
Ok(stream) => {
235
-
let acceptor = self.ssl_acceptor.clone();
230
+
loop {
231
+
match listener.accept().await {
232
+
Ok((stream, _)) => {
236
233
let mut self_clone = self.clone();
234
+
let acceptor = self_clone.ssl_acceptor.clone();
237
235
238
236
tokio::spawn(async move {
239
-
match tokio_openssl::accept(&acceptor, stream).await {
237
+
let ssl = match ssl::Ssl::new(acceptor.context()) {
238
+
Ok(ssl) => ssl,
239
+
Err(e) => {
240
+
error!("ssl context error: {:?}", e);
241
+
242
+
return;
243
+
}
244
+
};
245
+
246
+
match tokio_openssl::SslStream::new(ssl, stream) {
240
247
Ok(mut stream) => {
248
+
if let Err(e) = std::pin::Pin::new(&mut stream).accept().await {
249
+
println!("stream accept error: {e:?}");
250
+
}
251
+
241
252
if let Err(e) = self_clone.handle(&mut stream).await {
242
253
error!("handle error: {}", e);
243
254
}
244
255
}
245
-
Err(e) => error!("ssl error: {:?}", e),
256
+
Err(e) => error!("ssl stream error: {:?}", e),
246
257
}
247
258
});
248
259
}
249
-
Err(e) => error!("tcp error: {:?}", e),
260
+
Err(e) => error!("tcp stream error: {:?}", e),
250
261
}
251
262
}
252
263
253
-
Ok(())
264
+
// Ok(())
254
265
}
255
266
256
267
#[allow(clippy::too_many_lines)]
···
426
437
builder.set_certificate_file(&self.ca_file_name, ssl::SslFiletype::PEM)?;
427
438
builder.check_private_key()?;
428
439
builder.set_verify_callback(ssl::SslVerifyMode::PEER, |_, _| true);
440
+
builder.set_session_id_context(
441
+
time::SystemTime::now()
442
+
.duration_since(time::UNIX_EPOCH)?
443
+
.as_secs()
444
+
.to_string()
445
+
.as_bytes(),
446
+
)?;
429
447
430
448
self.ssl_acceptor = Arc::new(builder.build());
431
449