From a4f5c75bd0ea430034c5ac1fb7152c0bebe200f3 Mon Sep 17 00:00:00 2001
From: yggverse <yggverse@project>
Date: Sat, 22 Feb 2025 01:25:10 +0200
Subject: [PATCH] send response on error

---
 src/main.rs | 117 ++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 95 insertions(+), 22 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index a9e4590..ba2e888 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -38,8 +38,8 @@ fn main() -> Result<()> {
                 thread::spawn({
                     let argument = argument.clone();
                     let peer = stream.peer_addr()?;
-                    let stream = acceptor.accept(stream)?;
-                    move || handle(argument, peer, stream)
+                    let mut stream = acceptor.accept(stream)?;
+                    move || handle(argument, peer, &mut stream)
                 });
             }
             Err(e) => println!("[{}] [error] Failed to accept connection: {e}", now()),
@@ -48,7 +48,7 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn handle(argument: Arc<Argument>, peer: SocketAddr, mut stream: TlsStream<TcpStream>) {
+fn handle(argument: Arc<Argument>, peer: SocketAddr, stream: &mut TlsStream<TcpStream>) {
     use titanite::*;
     println!("[{}] [info] [{peer}] New connection", now());
 
@@ -129,44 +129,117 @@ fn handle(argument: Arc<Argument>, peer: SocketAddr, mut stream: TlsStream<TcpSt
                                                         now(),
                                                         pmt.path.to_string_lossy()
                                                     ),
-                                                    Err(e) => {
-                                                        println!(
-                                                            "[{}] [warning] [{peer}] {e}",
+                                                    Err(e) => println!(
+                                                        "[{}] [warning] [{peer}] {e}",
+                                                        now()
+                                                    ),
+                                                },
+                                            ),
+                                            Err((tmp, e)) => send(
+                                                &response::failure::temporary::General {
+                                                    message: Some(
+                                                        "Internal server error".to_string(),
+                                                    ),
+                                                }
+                                                .into_bytes(),
+                                                stream,
+                                                |result| {
+                                                    match result {
+                                                        Ok(()) => println!(
+                                                            "[{}] [error] [{peer}] {e}",
                                                             now()
-                                                        )
+                                                        ),
+                                                        Err(e) => println!(
+                                                            "[{}] [error] [{peer}] {e}",
+                                                            now()
+                                                        ),
+                                                    };
+                                                    if let Err(e) = tmp.delete() {
+                                                        println!(
+                                                            "[{}] [error] [{peer}] {e}",
+                                                            now()
+                                                        );
                                                     }
                                                 },
                                             ),
-                                            Err((tmp, e)) => {
-                                                println!("[{}] [error] [{peer}] {e}", now());
+                                        },
+                                        Err(e) => send(
+                                            &response::failure::temporary::General {
+                                                message: Some("Internal server error".to_string()),
+                                            }
+                                            .into_bytes(),
+                                            stream,
+                                            |result| {
+                                                match result {
+                                                    Ok(()) => {
+                                                        println!("[{}] [error] [{peer}] {e}", now())
+                                                    }
+                                                    Err(e) => {
+                                                        println!("[{}] [error] [{peer}] {e}", now())
+                                                    }
+                                                };
                                                 if let Err(e) = tmp.delete() {
                                                     println!("[{}] [error] [{peer}] {e}", now());
                                                 }
-                                            }
-                                        },
-                                        Err(e) => {
-                                            println!("[{}] [error] [{peer}] {e}", now());
-                                            if let Err(e) = tmp.delete() {
-                                                println!("[{}] [error] [{peer}] {e}", now());
-                                            }
-                                        }
+                                            },
+                                        ),
                                     },
-                                    Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
+                                    Err(e) => send(
+                                        &response::failure::temporary::General {
+                                            message: Some("Internal server error".to_string()),
+                                        }
+                                        .into_bytes(),
+                                        stream,
+                                        |result| match result {
+                                            Ok(()) => println!("[{}] [error] [{peer}] {e}", now()),
+                                            Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
+                                        },
+                                    ),
                                 }
                                 break;
                             }
                         }
-                        Err(e) => todo!("{e}"),
+                        Err(e) => send(
+                            &response::failure::temporary::General {
+                                message: Some("Internal server error".to_string()),
+                            }
+                            .into_bytes(),
+                            stream,
+                            |result| match result {
+                                Ok(()) => println!("[{}] [error] [{peer}] {e}", now()),
+                                Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
+                            },
+                        ),
                     }
                 }
             }
-            Err(e) => todo!("{e}"),
+            Err(e) => send(
+                &response::failure::temporary::General {
+                    message: Some("Internal server error".to_string()),
+                }
+                .into_bytes(),
+                stream,
+                |result| match result {
+                    Ok(()) => println!("[{}] [error] [{peer}] {e}", now()),
+                    Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
+                },
+            ),
         },
-        Err(e) => todo!("{e}"),
+        Err(e) => send(
+            &response::failure::temporary::General {
+                message: Some("Internal server error".to_string()),
+            }
+            .into_bytes(),
+            stream,
+            |result| match result {
+                Ok(()) => println!("[{}] [error] [{peer}] {e}", now()),
+                Err(e) => println!("[{}] [error] [{peer}] {e}", now()),
+            },
+        ),
     }
 }
 
-fn send(data: &[u8], mut stream: TlsStream<TcpStream>, callback: impl FnOnce(Result<()>)) {
+fn send(data: &[u8], stream: &mut TlsStream<TcpStream>, callback: impl FnOnce(Result<()>)) {
     callback((|| {
         stream.write_all(data)?;
         stream.flush()?;