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
|
use {
crate::{environment::ENVIRONMENT, url::from_path},
tokio::{
io::{AsyncBufReadExt, AsyncWriteExt, BufReader},
net::TcpListener,
},
};
pub async fn serve() {
let address = format!("0.0.0.0:{}", ENVIRONMENT.http09_port);
let listener = match TcpListener::bind(&address).await {
Ok(listener) => {
info!("HTTP/0.9 server listening on {address}");
listener
}
Err(error) => {
error!("failed to bind HTTP/0.9 server to {address}: {error}");
return;
}
};
loop {
let (stream, peer) = match listener.accept().await {
Ok(connection) => connection,
Err(error) => {
warn!("HTTP/0.9 accept error: {error}");
continue;
}
};
tokio::spawn(async move {
if let Err(error) = handle(stream).await {
warn!("HTTP/0.9 error from {peer}: {error}");
}
});
}
}
async fn handle(
stream: tokio::net::TcpStream,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let (reader, mut writer) = stream.into_split();
let mut reader = BufReader::new(reader);
let mut request_line = String::new();
reader.read_line(&mut request_line).await?;
let path = parse_request(&request_line)?;
let mut configuration = crate::response::configuration::Configuration::new();
let url = from_path(&path, false, &mut configuration)?;
let mut response = germ::request::request(&url).await?;
if *response.status() == germ::request::Status::PermanentRedirect
|| *response.status() == germ::request::Status::TemporaryRedirect
{
let redirect = if response.meta().starts_with('/') {
format!(
"gemini://{}{}",
url.domain().unwrap_or_default(),
response.meta()
)
} else {
response.meta().to_string()
};
response = germ::request::request(&url::Url::parse(&redirect)?).await?;
}
if response.meta().starts_with("image/") {
if let Some(bytes) = response.content_bytes() {
writer.write_all(bytes).await?;
}
} else if let Some(content) = response.content() {
writer.write_all(content.as_bytes()).await?;
}
writer.shutdown().await?;
Ok(())
}
fn parse_request(
line: &str,
) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
let line = line.trim();
line.strip_prefix("GET ").map_or_else(
|| {
if line.starts_with('/') {
Ok(line.to_string())
} else {
Err(format!("invalid HTTP/0.9 request: {line}").into())
}
},
|path| Ok(path.split_whitespace().next().unwrap_or("/").to_string()),
)
}
|