YGGverse/titanit
1
0
Fork 0
mirror of https://github.com/YGGverse/titanit.git synced 2026-03-31 17:15:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

update handlers

Browse source
This commit is contained in:
yggverse 2025-02-22 08:21:10 +02:00
parent 71d75bc22f
commit 7bf68725db
1 changed files with 155 additions and 113 deletions
Download patch file Download diff file Expand all files Collapse all files

132
src/main.rs
View file

@ -55,11 +55,11 @@ fn handle(argument: Arc<Argument>, peer: SocketAddr, stream: &mut TlsStream<TcpS
println!("[{}] [info] [{peer}] New connection", now());
let mut input = vec![0; titanite::HEADER_MAX_LEN];
match stream.read(&mut input) {
Ok(0) => println!("[{}] [warning] [{peer}] Connection closed by peer", now()),
Ok(0) => println!("[{}] [warning] [{peer}] Peer closed connection", now()),
Ok(s) => match Request::from_bytes(&input[..s]) {
Ok(request) => match request {
Request::Gemini(this) => handle_gemini(this, argument, peer, stream),
Request::Titan(this) => handle_titan(this, argument, peer, stream),
Request::Gemini(this) => gemini(this, argument, peer, stream),
Request::Titan(this) => titan(this, argument, peer, stream),
},
Err(e) => send(
&response::failure::temporary::General {
@ -87,14 +87,14 @@ fn handle(argument: Arc<Argument>, peer: SocketAddr, stream: &mut TlsStream<TcpS
}
}
fn handle_gemini(
fn gemini(
gemini: titanite::request::Gemini,
argument: Arc<Argument>,
peer: SocketAddr,
stream: &mut TlsStream<TcpStream>,
) {
use titanite::*;
match storage::Item::from_url(&gemini.url.as_str(), &argument.directory) {
match storage::Item::from_url(gemini.url.as_str(), &argument.directory) {
Ok(item) => send(
&response::success::Default {
mime: "text/gemini".to_string(),
@ -121,7 +121,7 @@ fn handle_gemini(
}
}
fn handle_titan(
fn titan(
titan: titanite::request::Titan,
argument: Arc<Argument>,
peer: SocketAddr,
@ -134,34 +134,15 @@ fn handle_titan(
let mut input = vec![0; argument.chunk];
match stream.read(&mut input) {
Ok(0) => {
println!("[{}] [warning] [{peer}] Connection closed by peer", now());
println!("[{}] [warning] [{peer}] Peer closed connection", now());
if let Err(e) = tmp.delete() {
println!("[{}] [error] [{peer}] {e}", now());
}
break;
}
Ok(l) => match tmp.file.write(&input[..l]) {
Ok(s) => {
total += s;
if s != l {
if let Err(e) = tmp.delete() {
println!("[{}] [error] [{peer}] {e}", now());
}
const MESSAGE: &str = "File sizes mismatch";
return send(
&response::failure::temporary::General {
message: Some(MESSAGE.to_string()),
}
.into_bytes(),
stream,
|result| match result {
Ok(()) => println!("[{}] [error] [{peer}] {MESSAGE}", now()),
Err(e) => {
println!("[{}] [error] [{peer}] {e}", now())
}
},
);
}
Ok(read) => {
total += read;
// validate server-side limits
if argument.size.is_some_and(|limit| total > limit) {
if let Err(e) = tmp.delete() {
@ -176,15 +157,12 @@ fn handle_titan(
stream,
|result| match result {
Ok(()) => println!("[{}] [warning] [{peer}] {MESSAGE}", now()),
Err(e) => {
println!("[{}] [error] [{peer}] {e}", now())
}
Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
},
);
}
// all expected data received
if titan.size >= total {
// validate client-side limits
// validate client-side limits (from header)
if titan.size > total {
if let Err(e) = tmp.delete() {
println!("[{}] [error] [{peer}] {e}", now());
@ -196,17 +174,42 @@ fn handle_titan(
}
.into_bytes(),
stream,
|result| match result {
Ok(()) => println!("[{}] [warning] [{peer}] {MESSAGE}", now()),
Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
},
);
}
// begin chunk recording into the temporary file
match tmp.file.write(&input[..read]) {
Ok(write) => {
// validate file bytes recorded match stream bytes received
if write != read {
if let Err(e) = tmp.delete() {
println!("[{}] [error] [{peer}] {e}", now());
}
const MESSAGE: &str = "File size mismatch";
return send(
&response::failure::temporary::General {
message: Some(MESSAGE.to_string()),
}
.into_bytes(),
stream,
|result| match result {
Ok(()) => {
println!("[{}] [warning] [{peer}] {MESSAGE}", now())
println!("[{}] [error] [{peer}] {MESSAGE}", now())
}
Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
},
);
}
// all data received
if titan.size >= total {
// @TODO detect/validate/cache mime based on data received
// success
match tmp.commit() {
return match tmp.commit() {
Ok(pmt) => send(
&response::redirect::Permanent {
target: match argument.redirect {
@ -230,7 +233,12 @@ fn handle_titan(
now(),
pmt.path.to_string_lossy()
),
Err(e) => println!("[{}] [warning] [{peer}] {e}", now()),
Err(e) => {
println!("[{}] [error] [{peer}] {e}", now());
if let Err(e) = pmt.delete() {
println!("[{}] [error] [{peer}] {e}", now());
}
}
},
),
Err((tmp, e)) => send(
@ -244,18 +252,55 @@ fn handle_titan(
Ok(()) => {
println!("[{}] [warning] [{peer}] {e}", now())
}
Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
Err(e) => {
println!("[{}] [error] [{peer}] {e}", now())
}
};
if let Err(e) = tmp.delete() {
println!("[{}] [error] [{peer}] {e}", now());
}
},
),
}
break;
};
}
}
Err(e) => {
return send(
&response::failure::temporary::General {
message: Some("Internal server error".to_string()),
}
.into_bytes(),
stream,
|result| {
match result {
Ok(()) => println!("[{}] [warning] [{peer}] {e}", now()),
Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
};
if let Err(e) = tmp.delete() {
println!("[{}] [error] [{peer}] {e}", now());
}
},
)
}
}
}
Err(e) => {
if let Err(e) = tmp.delete() {
println!("[{}] [error] [{peer}] {e}", now());
}
return send(
&response::failure::temporary::General {
message: Some("Internal server error".to_string()),
}
.into_bytes(),
stream,
|result| match result {
Ok(()) => println!("[{}] [warning] [{peer}] {e}", now()),
Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
},
);
}
}
Err(e) => todo!(),
},
Err(e) => send(
&response::failure::temporary::General {
@ -269,9 +314,6 @@ fn handle_titan(
},
),
}
},
Err(e) => todo!(),
}
}
fn send(data: &[u8], stream: &mut TlsStream<TcpStream>, callback: impl FnOnce(Result<()>)) {