155 lines
4.3 KiB
Rust
155 lines
4.3 KiB
Rust
// #![feature(if_let_guard)]
|
|
|
|
use std::{ collections::HashMap, path::PathBuf, sync::Arc };
|
|
use anyhow::Result;
|
|
|
|
use tokio::{
|
|
fs::File,
|
|
io::{ AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader },
|
|
net::{ TcpListener, TcpStream },
|
|
};
|
|
|
|
mod utils;
|
|
use utils::*;
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Args {
|
|
pub directory: PathBuf,
|
|
}
|
|
|
|
type A = Arc<Args>;
|
|
|
|
|
|
fn parse_args () -> Args {
|
|
let directory = std::env::args().position(|e| e == "--directory").unwrap() + 1;
|
|
let directory = PathBuf::from(std::env::args().nth(directory).unwrap());
|
|
|
|
Args {
|
|
directory
|
|
}
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<()> {
|
|
let listener = TcpListener::bind("127.0.0.1:4221").await.unwrap();
|
|
let args = Arc::new(parse_args());
|
|
|
|
loop {
|
|
let args = args.clone();
|
|
let Ok((socket, info)) = listener.accept().await else { continue; } ;
|
|
println!("Connection from {:?} accepted, processing…", info);
|
|
let _ = process(socket, args).await;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
async fn process (mut stream: TcpStream, args: A) -> Result<()> {
|
|
let buf_reader = BufReader::new(&mut stream);
|
|
|
|
let mut data = buf_reader
|
|
.lines();
|
|
|
|
let (_method, path, _ver) = {
|
|
let start_line = data.next_line().await?.ok_or(E::InvalidRequest)?; // should be 500;
|
|
let mut parts = start_line.split_whitespace().map(ToOwned::to_owned);
|
|
let method = parts.next().ok_or(E::InvalidRequest)?;
|
|
let path = parts.next().ok_or(E::InvalidRequest)?;
|
|
let ver = parts.next().ok_or(E::InvalidRequest)?;
|
|
|
|
(method, path, ver)
|
|
};
|
|
|
|
let headers = Headers::parse(data.into_inner()).await;
|
|
|
|
let response = match path.as_str() {
|
|
"/" => Response::Empty,
|
|
"/user-agent" => Response::TextPlain(headers.get("User-Agent").to_owned()),
|
|
// p if let Some(echo) = p.strip_prefix("/echo/") => Response::TextPlain(echo), // a nicer way to do that, not available in stable yet
|
|
p if p.starts_with("/echo/") => Response::TextPlain(p.trim_start_matches("/echo/").to_owned()),
|
|
p if p.starts_with("/files/") => {
|
|
let path = args.directory.join(p.trim_start_matches("/files/"));
|
|
let mut buf = vec![];
|
|
if let Ok(mut f) = File::open(path).await {
|
|
let _ = f.read_to_end(&mut buf).await;
|
|
Response::OctetStream(buf)
|
|
} else {
|
|
Response::_404
|
|
}
|
|
},
|
|
_ => Response::_404,
|
|
};
|
|
|
|
let _ = stream.write_all(&response.build()).await;
|
|
let _ = stream.flush().await;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Headers (HashMap<String, String>);
|
|
|
|
impl Headers {
|
|
pub async fn parse (mut reader: BufReader<&'_ mut TcpStream>) -> Self {
|
|
let mut map = HashMap::new();
|
|
let mut buf = String::new();
|
|
while let Ok(_) = reader.read_line(&mut buf).await {
|
|
if let Some((k, v)) = buf.split_once(":") {
|
|
map.insert(k.trim().to_lowercase(), v.trim().to_owned());
|
|
} else {
|
|
break;
|
|
}
|
|
|
|
buf.clear();
|
|
}
|
|
Self(map)
|
|
}
|
|
|
|
pub fn get <'a> (&'a self, key: &str) -> &'a str {
|
|
self.0.get(&key.to_lowercase()).map(|e| e.as_str()).unwrap_or_default()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum Response {
|
|
_404,
|
|
Empty,
|
|
TextPlain (String),
|
|
OctetStream (Vec<u8>)
|
|
}
|
|
|
|
|
|
#[allow(non_upper_case_globals)]
|
|
impl Response {
|
|
fn build (self) -> Vec<u8> {
|
|
|
|
let headers = self.headers().join("\r\n");
|
|
|
|
let code = match self {
|
|
Self::_404 => "404 Not Found",
|
|
_ => "200 OK",
|
|
};
|
|
|
|
let mut v: Vec<u8> = f!("HTTP/1.1 {code}\r\n{headers}\r\n\r\n").into();
|
|
match self {
|
|
Self::OctetStream(bytes) => {
|
|
v.extend_from_slice(&bytes);
|
|
},
|
|
Self::TextPlain(text) => {
|
|
v.extend_from_slice(text.as_bytes());
|
|
},
|
|
_ => ()
|
|
}
|
|
|
|
v
|
|
}
|
|
|
|
fn headers (&self) -> Vec<String> {
|
|
match self {
|
|
Self::TextPlain(text) => vec![f!("Content-Type: text/plain"), format!("Content-Length: {}", text.len())],
|
|
Self::OctetStream(bytes) => vec![f!("Content-Type: application/octet-stream"), format!("Content-Length: {}", bytes.len())],
|
|
_ => d!()
|
|
}
|
|
}
|
|
}
|