convert index to table and show file size

src/http.rs

@@ -13,7 +13,7 @@ pub enum RequestRange {
 	Suffix(usize),
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 pub enum Method {
 	Get,
 	Head,
@@ -35,7 +35,7 @@ pub enum Status {
 
 #[derive(Debug, Clone)]
 pub struct Content {
-	content_type: &'static str,
+	mime_type: &'static str,
 	range: Option<(usize, usize, usize)>,
 	bytes: Vec<u8>,
 }
@@ -93,14 +93,14 @@ impl Response {
 			let mut buffer = format!(
 				"{}\r\nContent-Type: {}\r\nAccept-Ranges: bytes\r\nContent-Length: {}\r\n",
 				self.status.header(),
-				content.content_type,
+				content.mime_type,
 				content.bytes.len(),
 			)
 			.into_bytes();
 			if let Some((start, end, size)) = content.range {
 				buffer.extend_from_slice(
-					format!("Content-Range: bytes {}-{}/{}\r\n", start, end, size).as_bytes(),
+					format!("Content-Range: bytes {start}-{end}/{size}\r\n").as_bytes(),
-				)
+				);
 			}
 			buffer.extend_from_slice(b"\r\n");
 			if !head_only {
@@ -168,7 +168,7 @@ impl Content {
 			}
 		};
 		Self {
-			content_type,
+			mime_type: content_type,
 			range: None,
 			bytes,
 		}
@@ -209,6 +209,15 @@ impl Method {
 	}
 }
 
+impl std::fmt::Display for Method {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			Method::Get => write!(f, "GET"),
+			Method::Head => write!(f, "HEAD"),
+		}
+	}
+}
+
 impl RequestRange {
 	fn parse(source: &str) -> Option<Self> {
 		let source = source.strip_prefix("bytes=")?;

src/main.rs

@@ -27,40 +27,42 @@ fn main() {
 	for stream in listener.incoming() {
 		match stream {
 			Ok(stream) => threads.push(thread::spawn(|| handle_connection(stream))),
-			Err(err) => println!("Error with incoming stream: {}", err),
+			Err(err) => println!("Error with incoming stream: {err}"),
 		}
-		threads = threads.into_iter().filter(|j| !j.is_finished()).collect();
+		threads.retain(|j| !j.is_finished());
-		println!("{} threads open", threads.len());
+		println!("{} connections open", threads.len());
 	}
 }
 
 fn handle_connection(mut stream: TcpStream) {
-	let Ok(peer_addr) = stream.peer_addr() else {
+	const MAX_REQUEST_SIZE: usize = 1024 * 4;
+	let Ok(client_ip) = stream.peer_addr() else {
 		return;
 	};
-	println!("#### new connection from {peer_addr}");
+	println!("[{client_ip}] new connection");
 
 	let mut buffer = Vec::with_capacity(2048);
 	loop {
 		let mut b = vec![0; 512];
 		let Ok(size) = stream.read(&mut b) else {
-			println!("failed to read ");
+			println!("[{client_ip}] connection broken");
 			return;
 		};
 		if size == 0 {
-			println!("nothing read");
+			println!("[{client_ip}] connection closed by client");
 			return;
 		}
 		b.truncate(size);
 		buffer.extend_from_slice(&b);
 
-		if buffer.len() > 4096 {
+		if buffer.len() > MAX_REQUEST_SIZE {
-			println!("request too long");
+			println!("[{client_ip}] request over {MAX_REQUEST_SIZE} bytes, closing connection");
 			return;
 		}
 		if buffer.ends_with(b"\r\n\r\n") {
 			let request = String::from_utf8_lossy(&buffer).to_string();
-			// println!("Received {} bytes from {}", buffer.len(), peer_addr);
+
+			println!("[{client_ip}] received {} bytes", buffer.len());
 			// println!(
 			// 	"=======\n{}=======\n\n",
 			// 	request
@@ -69,48 +71,51 @@ fn handle_connection(mut stream: TcpStream) {
 			// 		.replace("\\r\\n", "\n")
 			// 		.replace("\\n", "\n")
 			// );
-			if handle_request(request, &mut stream) {
+			if handle_request(&request, &mut stream) {
-				println!("closing connection");
+				println!("[{client_ip}] closing connection");
 				return;
 			}
-			// println!("keeping connection");
 			buffer.clear();
 		}
 	}
 }
 
-fn handle_request(request: String, stream: &mut TcpStream) -> bool {
+fn handle_request(request: &str, stream: &mut TcpStream) -> bool {
-	let request = Request::parse(&request);
+	let Ok(client_ip) = stream.peer_addr() else {
+		return true;
+	};
+	let request = Request::parse(request);
 	let response;
 	let mut end_connection = true;
 
 	if let Some(request) = request {
+		println!("[{client_ip}] {} {}", request.method, request.path);
 		let head_only = request.method == Method::Head;
 		let path = request.path.clone();
-		response = get_file(request)
+		response = get_file(&request)
 			.map(|(content, end_of_file)| {
 				end_connection = end_of_file;
+				println!("[{client_ip}] sending file content");
 				Response::new(Status::Ok).with_content(content)
 			})
 			.unwrap_or_else(|| {
+				println!("[{client_ip}] file not found");
 				Response::new(Status::NotFound)
-					.with_content(Content::text(format!("FILE NOT FOUND - '{}'", path)))
+					.with_content(Content::text(format!("404 NOT FOUND - '{path}'")))
 			})
 			.format(head_only);
 	} else {
+		println!("[{client_ip}] bad request");
 		response = Response::new(Status::BadRequest).format(false);
 	}
 
-	stream
+	if stream.write_all(&response).is_err() || stream.flush().is_err() {
-		.write_all(&response)
+		println!("[{client_ip}] failed to send response");
-		.unwrap_or_else(|_| println!("failed to respond"));
+	}
-	stream
-		.flush()
-		.unwrap_or_else(|_| println!("failed to flush"));
 	end_connection
 }
 
-fn get_file(request: Request) -> Option<(Content, bool)> {
+fn get_file(request: &Request) -> Option<(Content, bool)> {
 	const MAX_SIZE: usize = 1024 * 1024 * 8;
 
 	let current_dir = env::current_dir().unwrap();
@@ -172,31 +177,37 @@ fn generate_index(relative_path: &str, path: &Path) -> Option<Content> {
 		.ok()?
 		.flatten()
 		.filter_map(|d| {
-			let is_dir = d.file_type().ok()?.is_dir();
+			let size = if d.file_type().ok()?.is_dir() {
-			d.file_name().to_str().map(|s| (s.to_owned(), is_dir))
+				None
+			} else {
+				Some(d.metadata().ok()?.len())
+			};
+
+			d.file_name().to_str().map(|s| (s.to_owned(), size))
 		})
 		.collect();
-	dirs.sort_by(|(name_a, dir_a), (name_b, dir_b)| dir_b.cmp(dir_a).then(name_a.cmp(name_b)));
+	dirs.sort_by(|(name_a, size_a), (name_b, size_b)| {
+		size_a
+			.is_some()
+			.cmp(&size_b.is_some())
+			.then(name_a.cmp(name_b))
+	});
 	let list = dirs
 		.into_iter()
-		.filter_map(|(name, is_dir)| {
+		.map(|(name, size)| {
-			let mut s = format!(
+			let formatted_size = size.map(format_size).unwrap_or_default();
-				"		<li><a href=\"{}\">{}",
+			format!(
-				PathBuf::from(relative_path).join(&name).display(),
+				"<tr><td><a href=\"{href}\">{name}{trailing_slash}</a></td><td>{formatted_size}</td></tr>\n",
-				name
+				href = PathBuf::from(relative_path).join(&name).display(),
-			);
+				trailing_slash = if size.is_some() { "" } else { "/" },
-			if is_dir {
+			)
-				s.push('/');
-			}
-			s.push_str("</a></li>\n");
-			Some(s)
 		})
 		.fold(String::new(), |mut content, entry| {
 			content.push_str(&entry);
 			content
 		});
 	let parent = if relative_path != "/" {
-		r#"		<li><a href="..">../</a></li>"#
+		"<tr><td><a href=\"..\">../</a></td><td></td></tr>"
 	} else {
 		""
 	};
@@ -205,13 +216,31 @@ fn generate_index(relative_path: &str, path: &Path) -> Option<Content> {
 <head>
 	<meta charset="UTF-8">
 	<title>Index of {relative_path}</title>
+	<style>
+		html {{ color-scheme: dark; }}
+		tr:nth-child(odd) {{ background-color: #333; }}
+	</style>
 </head>
 <body>
 	<h3>Index of {relative_path}</h3>
-	<ul>
+	<table>
-{parent}{list}	</ul>
+{parent}
+{list}
+	</table>
 </body>
 </html>"#,
 	);
 	Some(Content::html(page))
 }
+
+fn format_size(bytes: u64) -> String {
+	if bytes < 1024 {
+		format!("{bytes} B")
+	} else if bytes < 1024 * 1024 {
+		format!("{:.1} KiB", bytes as f64 / 1024.0)
+	} else if bytes < 1024 * 1024 * 1024 {
+		format!("{:.1} MiB", bytes as f64 / (1024.0 * 1024.0))
+	} else {
+		format!("{:.1} GiB", bytes as f64 / (1024.0 * 1024.0 * 1024.0))
+	}
+}