diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/main.rs | 122 | ||||
| -rw-r--r-- | src/utils.rs | 2 | ||||
| -rw-r--r-- | src/utils/proxy_child.rs | 74 | ||||
| -rw-r--r-- | src/utils/serve_static.rs | 75 |
4 files changed, 272 insertions, 1 deletions
diff --git a/src/main.rs b/src/main.rs index 97a8ae6..0951518 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,4 +1,124 @@ +use std::convert::Infallible; +use std::net::SocketAddr; +use std::path::PathBuf; +use std::rc::Rc; +use std::sync::Arc; + +use hyper::service::{make_service_fn, service_fn}; +use hyper::{header, Body, Request, Response, Server, StatusCode}; +use rhai::{Dynamic, Engine, FnPtr, Map, NativeCallContext, Scope}; +use structopt::StructOpt; + +mod utils; + +#[derive(Debug, StructOpt)] +struct Opt { + #[structopt(long, parse(from_os_str), default_value = "narchttpd.rhai")] + config_script: PathBuf, +} + +fn make_engine() -> Engine { + let mut engine = Engine::new(); + engine.register_type_with_name::<Rc<Request<Body>>>("Request"); + engine.register_type::<utils::serve_static::Params>(); + engine.register_fn( + "handle_request_serve_static", + utils::serve_static::handle_request, + ); + engine.register_fn("serve_static", utils::serve_static::serve_static); + engine.register_fn( + "handle_request_proxy_child", + utils::proxy_child::handle_request, + ); + engine.register_fn("proxy_child", utils::proxy_child::proxy_child); + engine +} + +fn get_config_scope(engine: &Engine, opt: &Opt) -> Scope<'static> { + let mut ast = engine.compile_file(opt.config_script.clone()).unwrap(); + + let mut scope = Scope::new(); + scope.push("http_ports", [80]); + scope.push("https_ports", [443]); + scope.push("domains", Map::new()); + let export_ast = engine + .compile("export http_ports, https_ports, domains;") + .unwrap(); + ast.combine(export_ast); + let _: () = engine.eval_ast_with_scope(&mut scope, &ast).unwrap(); + scope +} + #[tokio::main] async fn main() { - // swag + let opt = Arc::new(Opt::from_args()); + + let engine = make_engine(); + let scope = get_config_scope(&engine, &opt); + + let http_ports: rhai::Array = scope.get_value("http_ports").unwrap(); + let http_ports: Vec<u16> = http_ports + .into_iter() + .map(|x| x.as_int().unwrap() as u16) + .collect(); + let https_ports: rhai::Array = scope.get_value("https_ports").unwrap(); + let https_ports: Vec<u16> = https_ports + .into_iter() + .map(|x| x.as_int().unwrap() as u16) + .collect(); + + assert!(https_ports.is_empty(), "HTTPS is complicated oops"); + + // TODO learn hyper + let do_response = move |ctx: &NativeCallContext, domains: Map, req: Request<Body>| { + for (domain, handler) in &domains { + let req_domain = req.headers().get(header::HOST).unwrap(); + if domain.as_str() == req_domain { + eprintln!("request {:?} matched domain {}", req, domain); + // matched! + let handler: FnPtr = handler.clone_cast(); + let args = [Dynamic::from(Rc::new(req))]; + let result = handler.call_dynamic(ctx, None, args).unwrap(); + let result: Rc<Response<Body>> = result.cast(); + return Rc::try_unwrap(result).unwrap(); + } + } + Response::builder() + .status(StatusCode::NOT_FOUND) + .body(Body::from("Not Found")) + .unwrap() + }; + let addr = http_ports.into_iter().flat_map(|port| { + ["127.0.0.1", "::1"] + .iter() + .map(move |ip| SocketAddr::new(ip.parse().unwrap(), port)) + }); + + let make_svc = make_service_fn(move |_conn| async move { + Ok::<_, Infallible>(service_fn(move |req| async move { + let handle = tokio::runtime::Handle::current(); + let response = handle + .spawn_blocking(move || { + let opt = Opt::from_args(); + let engine = make_engine(); + let scope = get_config_scope(&engine, &opt); + let request_handler_context = + NativeCallContext::new(&engine, "handle_request", &[]); + let domains: Map = scope.get_value("domains").unwrap(); + do_response(&request_handler_context, domains, req) + }) + .await + .unwrap(); + Ok::<_, Infallible>(response) + })) + }); + + // TODO uhh + let mut addr = addr; + let addr = addr.nth(0).unwrap(); + let server = Server::bind(&addr).serve(make_svc); + + if let Err(e) = server.await { + eprintln!("server error: {}", e); + } } diff --git a/src/utils.rs b/src/utils.rs new file mode 100644 index 0000000..0bd5c2e --- /dev/null +++ b/src/utils.rs @@ -0,0 +1,2 @@ +pub mod proxy_child; +pub mod serve_static; diff --git a/src/utils/proxy_child.rs b/src/utils/proxy_child.rs new file mode 100644 index 0000000..d7a021d --- /dev/null +++ b/src/utils/proxy_child.rs @@ -0,0 +1,74 @@ +use std::process::{Child as ChildProcess, Command}; +use std::rc::Rc; + +use hyper::http::uri::Scheme; +use hyper::{header, Body, Client, Request, Response}; +use rhai::{Dynamic, FnPtr, Map}; + +pub struct KillOnDrop(ChildProcess); + +impl Drop for KillOnDrop { + fn drop(&mut self) { + self.0.kill().unwrap(); + } +} + +#[derive(Clone)] +pub struct ProxyChild { + process: Rc<KillOnDrop>, + port: u16, +} + +impl ProxyChild { + fn new(params: Map) -> Self { + let command_line = params["command"].clone().into_immutable_string().unwrap(); + let port = params["port"].as_int().unwrap(); + let mut command_line = command_line.split(" "); + let command = command_line.next().unwrap(); + let mut child = Command::new(command); + child.args(command_line); + if let Some(cwd) = params.get("in_dir") { + let cwd = cwd.clone().into_immutable_string().unwrap(); + let cwd: &str = cwd.as_ref(); + child.current_dir(cwd); + } + let child = child.spawn().unwrap(); + Self { + process: Rc::new(KillOnDrop(child)), + port: port as u16, + } + } +} + +pub fn handle_request(child: &mut ProxyChild, request: Rc<Request<Body>>) -> Rc<Response<Body>> { + let ProxyChild { port, .. } = child; + let mut request_uri = request.uri().clone().into_parts(); + // TODO ipv6 loopback? + request_uri.authority = Some(format!("127.0.0.1:{}", port).parse().unwrap()); + request_uri.scheme = Some(Scheme::HTTP); + let mut proxy_request = Request::builder() + .method(request.method()) + .uri(request_uri) + .header(header::HOST, request.headers()[header::HOST].clone()); + proxy_request.headers_mut().unwrap().extend( + request + .headers() + .iter() + .map(|(x, y)| (x.clone(), y.clone())), + ); + // TODO handle nonempty body + let proxy_request = proxy_request.body(Body::empty()).unwrap(); + let response = async { + let client = Client::new(); + Rc::new(client.request(proxy_request).await.unwrap()) + }; + let runtime = tokio::runtime::Handle::current(); + runtime.block_on(response) +} + +pub fn proxy_child(params: Map) -> FnPtr { + let child = ProxyChild::new(params); + let mut result = FnPtr::new("handle_request_proxy_child").unwrap(); + result.add_curry(Dynamic::from(child)); + result +} diff --git a/src/utils/serve_static.rs b/src/utils/serve_static.rs new file mode 100644 index 0000000..2ec0a90 --- /dev/null +++ b/src/utils/serve_static.rs @@ -0,0 +1,75 @@ +use std::fs::File; +use std::io::{ErrorKind, Read}; +use std::path::PathBuf; +use std::rc::Rc; + +use hyper::{Body, Request, Response, StatusCode}; +use rhai::{Dynamic, FnPtr, Map}; + +#[derive(Clone, Debug)] +pub struct Params { + root: PathBuf, +} + +#[derive(Debug)] +pub struct KeyError(&'static str); + +impl TryFrom<Map> for Params { + type Error = KeyError; + + fn try_from(mut value: Map) -> Result<Self, Self::Error> { + let root = value + .remove("root") + .and_then(|value| value.into_immutable_string().ok()) + .ok_or(KeyError("root"))?; + let root: PathBuf = root.parse().unwrap(); + let root = root.canonicalize().unwrap(); + Ok(Self { root }) + } +} + +pub fn handle_request(params: &mut Params, request: Rc<Request<Body>>) -> Rc<Response<Body>> { + let Params { root } = params; + eprintln!("handling request {:?}", request); + let request_path = request.uri().path(); + let request_path = request_path.trim_start_matches("/"); + let target = root.join(request_path); + let target = if target.is_dir() { + target.join("index.html") + } else { + target + }; + eprintln!("target is {}", target.display()); + let response = if target.ancestors().all(|ancestor| ancestor != root) { + // oops! all directory traversal + Response::builder() + .status(StatusCode::BAD_REQUEST) + .body(Body::empty()) + } else { + let file = File::open(target); + match file { + Ok(mut file) => { + let mut result = Vec::new(); + file.read_to_end(&mut result).unwrap(); + Response::builder().body(Body::from(result)) + } + Err(err) => { + let status_code = match err.kind() { + ErrorKind::NotFound => StatusCode::NOT_FOUND, + _ => StatusCode::BAD_REQUEST, + }; + Response::builder() + .status(status_code) + .body(Body::from(status_code.canonical_reason().unwrap_or(""))) + } + } + }; + Rc::new(response.unwrap()) +} + +pub fn serve_static(params: Map) -> FnPtr { + let params: Params = params.try_into().unwrap(); + let mut result = FnPtr::new("handle_request_serve_static").unwrap(); + result.add_curry(Dynamic::from(params)); + result +} |