From 12aafa00d82ff97f65169e641b73082d5f0f8ef3 Mon Sep 17 00:00:00 2001 From: sigoden Date: Wed, 15 Jun 2022 19:33:51 +0800 Subject: [PATCH] feat: listen both ipv4 and ipv6 by default (#40) --- Cargo.lock | 86 ++++++++++--------------- Cargo.toml | 4 +- src/args.rs | 98 +++++++++++++--------------- src/main.rs | 151 +++++++++++++++++++++++++++++++++++++++++--- src/server.rs | 120 ++++------------------------------- src/tls.rs | 158 ++++++++++++++++++++++++++++++++++++++++++++++ tests/bind.rs | 25 +++++--- tests/fixtures.rs | 2 +- 8 files changed, 407 insertions(+), 237 deletions(-) create mode 100644 src/tls.rs diff --git a/Cargo.lock b/Cargo.lock index 8c60eaa..51567f5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -395,22 +395,21 @@ dependencies = [ [[package]] name = "clap" -version = "3.1.18" +version = "3.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2dbdf4bdacb33466e854ce889eee8dfd5729abf7ccd7664d0a2d60cd384440b" +checksum = "6d20de3739b4fb45a17837824f40aa1769cc7655d7a83e68739a77fe7b30c87a" dependencies = [ "bitflags", "clap_lex", "indexmap", - "lazy_static", "textwrap", ] [[package]] name = "clap_lex" -version = "0.2.0" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a37c35f1112dad5e6e0b1adaff798507497a18fceeb30cceb3bae7d1427b9213" +checksum = "5538cd660450ebeb4234cfecf8f2284b844ffc4c50531e66d584ad5b91293613" dependencies = [ "os_str_bytes", ] @@ -578,13 +577,13 @@ dependencies = [ "reqwest", "rstest", "rustls", - "rustls-pemfile 1.0.0", + "rustls-pemfile", "select", "serde", "serde_json", + "socket2", "tokio", "tokio-rustls", - "tokio-stream", "tokio-util", "url", "urlencoding", @@ -853,13 +852,13 @@ dependencies = [ [[package]] name = "getrandom" -version = "0.2.6" +version = "0.2.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9be70c98951c83b8d2f8f60d7065fa6d5146873094452a1008da8c2f1e4205ad" +checksum = "4eb1a864a501629691edf6c15a593b7a51eebaa1e8468e9ddc623de7c9b58ec6" dependencies = [ "cfg-if", "libc", - "wasi 0.10.0+wasi-snapshot-preview1", + "wasi 0.11.0+wasi-snapshot-preview1", ] [[package]] @@ -1147,9 +1146,9 @@ dependencies = [ [[package]] name = "js-sys" -version = "0.3.57" +version = "0.3.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "671a26f820db17c2a2750743f1dd03bafd15b98c9f30c7c2628c024c05d73397" +checksum = "c3fac17f7123a73ca62df411b1bf727ccc805daa070338fda671c86dac1bdc27" dependencies = [ "wasm-bindgen", ] @@ -1696,7 +1695,7 @@ version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7" dependencies = [ - "getrandom 0.2.6", + "getrandom 0.2.7", ] [[package]] @@ -1760,9 +1759,9 @@ dependencies = [ [[package]] name = "reqwest" -version = "0.11.10" +version = "0.11.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46a1f7aa4f35e5e8b4160449f51afc758f0ce6454315a9fa7d0d113e958c41eb" +checksum = "b75aa69a3f06bbcc66ede33af2af253c6f7a86b1ca0033f60c580a27074fbf92" dependencies = [ "base64", "bytes", @@ -1785,13 +1784,14 @@ dependencies = [ "percent-encoding", "pin-project-lite", "rustls", - "rustls-pemfile 0.3.0", + "rustls-pemfile", "serde", "serde_json", "serde_urlencoded", "tokio", "tokio-native-tls", "tokio-rustls", + "tower-service", "url", "wasm-bindgen", "wasm-bindgen-futures", @@ -1862,15 +1862,6 @@ dependencies = [ "webpki", ] -[[package]] -name = "rustls-pemfile" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ee86d63972a7c661d1536fefe8c3c8407321c3df668891286de28abcd087360" -dependencies = [ - "base64", -] - [[package]] name = "rustls-pemfile" version = "1.0.0" @@ -2251,17 +2242,6 @@ dependencies = [ "webpki", ] -[[package]] -name = "tokio-stream" -version = "0.1.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df54d54117d6fdc4e4fea40fe1e4e566b3505700e148a6827e59b34b0d2600d9" -dependencies = [ - "futures-core", - "pin-project-lite", - "tokio", -] - [[package]] name = "tokio-util" version = "0.7.3" @@ -2331,9 +2311,9 @@ checksum = "099b7128301d285f79ddd55b9a83d5e6b9e97c92e0ea0daebee7263e932de992" [[package]] name = "unicode-ident" -version = "1.0.0" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d22af068fba1eb5edcb4aea19d382b2a3deb4c8f9d475c589b6ada9e0fd493ee" +checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c" [[package]] name = "unicode-normalization" @@ -2380,7 +2360,7 @@ version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dd6469f4314d5f1ffec476e05f17cc9a78bc7a27a6a857842170bdf8d6f98d2f" dependencies = [ - "getrandom 0.2.6", + "getrandom 0.2.7", "rand 0.8.5", ] @@ -2462,9 +2442,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] name = "wasm-bindgen" -version = "0.2.80" +version = "0.2.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "27370197c907c55e3f1a9fbe26f44e937fe6451368324e009cba39e139dc08ad" +checksum = "7c53b543413a17a202f4be280a7e5c62a1c69345f5de525ee64f8cfdbc954994" dependencies = [ "cfg-if", "wasm-bindgen-macro", @@ -2472,9 +2452,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-backend" -version = "0.2.80" +version = "0.2.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53e04185bfa3a779273da532f5025e33398409573f348985af9a1cbf3774d3f4" +checksum = "5491a68ab4500fa6b4d726bd67408630c3dbe9c4fe7bda16d5c82a1fd8c7340a" dependencies = [ "bumpalo", "lazy_static", @@ -2487,9 +2467,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-futures" -version = "0.4.30" +version = "0.4.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f741de44b75e14c35df886aff5f1eb73aa114fa5d4d00dcd37b5e01259bf3b2" +checksum = "de9a9cec1733468a8c657e57fa2413d2ae2c0129b95e87c5b72b8ace4d13f31f" dependencies = [ "cfg-if", "js-sys", @@ -2499,9 +2479,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.80" +version = "0.2.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17cae7ff784d7e83a2fe7611cfe766ecf034111b49deb850a3dc7699c08251f5" +checksum = "c441e177922bc58f1e12c022624b6216378e5febc2f0533e41ba443d505b80aa" dependencies = [ "quote", "wasm-bindgen-macro-support", @@ -2509,9 +2489,9 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.80" +version = "0.2.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99ec0dc7a4756fffc231aab1b9f2f578d23cd391390ab27f952ae0c9b3ece20b" +checksum = "7d94ac45fcf608c1f45ef53e748d35660f168490c10b23704c7779ab8f5c3048" dependencies = [ "proc-macro2", "quote", @@ -2522,15 +2502,15 @@ dependencies = [ [[package]] name = "wasm-bindgen-shared" -version = "0.2.80" +version = "0.2.81" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d554b7f530dee5964d9a9468d95c1f8b8acae4f282807e7d27d4b03099a46744" +checksum = "6a89911bd99e5f3659ec4acf9c4d93b0a90fe4a2a11f15328472058edc5261be" [[package]] name = "web-sys" -version = "0.3.57" +version = "0.3.58" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b17e741662c70c8bd24ac5c5b18de314a2c26c32bf8346ee1e6f53de919c283" +checksum = "2fed94beee57daf8dd7d51f2b15dc2bcde92d7a72304cdf662a4371008b71b90" dependencies = [ "js-sys", "wasm-bindgen", diff --git a/Cargo.toml b/Cargo.toml index c845dbe..e7f2801 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,11 +11,10 @@ categories = ["command-line-utilities", "web-programming::http-server"] keywords = ["static", "file", "server", "webdav", "cli"] [dependencies] -clap = { version = "3", default-features = false, features = ["std", "cargo"] } +clap = { version = "3", default-features = false, features = ["std"] } chrono = "0.4" tokio = { version = "1", features = ["rt-multi-thread", "macros", "fs", "io-util", "signal"]} tokio-rustls = "0.23" -tokio-stream = { version = "0.1", features = ["net"] } tokio-util = { version = "0.7", features = ["codec", "io-util"] } hyper = { version = "0.14", features = ["http1", "server", "tcp", "stream"] } percent-encoding = "2.1" @@ -37,6 +36,7 @@ urlencoding = "2.1" xml-rs = "0.8" env_logger = { version = "0.9", default-features = false, features = ["humantime"] } log = "0.4" +socket2 = "0.4" [dev-dependencies] assert_cmd = "2" diff --git a/src/args.rs b/src/args.rs index 42d1941..17059a8 100644 --- a/src/args.rs +++ b/src/args.rs @@ -1,24 +1,29 @@ -use clap::crate_description; -use clap::{Arg, ArgMatches}; +use clap::{Arg, ArgMatches, Command}; use rustls::{Certificate, PrivateKey}; -use std::net::{IpAddr, SocketAddr}; +use std::env; +use std::net::IpAddr; use std::path::{Path, PathBuf}; -use std::{env, fs, io}; use crate::auth::parse_auth; +use crate::tls::{load_certs, load_private_key}; use crate::BoxResult; -const ABOUT: &str = concat!("\n", crate_description!()); // Add extra newline. - -fn app() -> clap::Command<'static> { - clap::command!() - .about(ABOUT) +fn app() -> Command<'static> { + Command::new(env!("CARGO_CRATE_NAME")) + .version(env!("CARGO_PKG_VERSION")) + .author(env!("CARGO_PKG_AUTHORS")) + .about(concat!( + env!("CARGO_PKG_DESCRIPTION"), + " - ", + env!("CARGO_PKG_REPOSITORY") + )) .arg( Arg::new("address") .short('b') .long("bind") - .default_value("0.0.0.0") .help("Specify bind address") + .multiple_values(true) + .multiple_occurrences(true) .value_name("address"), ) .arg( @@ -111,7 +116,8 @@ pub fn matches() -> ArgMatches { #[derive(Debug, Clone, Eq, PartialEq)] pub struct Args { - pub addr: SocketAddr, + pub addrs: Vec, + pub port: u16, pub path: PathBuf, pub path_prefix: String, pub uri_prefix: String, @@ -132,9 +138,12 @@ impl Args { /// If a parsing error ocurred, exit the process and print out informative /// error message to user. pub fn parse(matches: ArgMatches) -> BoxResult { - let ip = matches.value_of("address").unwrap_or_default(); let port = matches.value_of_t::("port")?; - let addr = to_addr(ip, port)?; + let addrs = matches + .values_of("address") + .map(|v| v.collect()) + .unwrap_or_else(|| vec!["0.0.0.0", "::"]); + let addrs: Vec = Args::parse_addrs(&addrs)?; let path = Args::parse_path(matches.value_of_os("path").unwrap_or_default())?; let path_prefix = matches .value_of("path-prefix") @@ -166,7 +175,8 @@ impl Args { }; Ok(Args { - addr, + addrs, + port, path, path_prefix, uri_prefix, @@ -182,7 +192,25 @@ impl Args { }) } - /// Parse path. + fn parse_addrs(addrs: &[&str]) -> BoxResult> { + let mut ip_addrs = vec![]; + let mut invalid_addrs = vec![]; + for addr in addrs { + match addr.parse::() { + Ok(v) => { + ip_addrs.push(v); + } + Err(_) => { + invalid_addrs.push(*addr); + } + } + } + if !invalid_addrs.is_empty() { + return Err(format!("Invalid bind address `{}`", invalid_addrs.join(",")).into()); + } + Ok(ip_addrs) + } + fn parse_path>(path: P) -> BoxResult { let path = path.as_ref(); if !path.exists() { @@ -197,43 +225,3 @@ impl Args { .map_err(|err| format!("Failed to access path `{}`: {}", path.display(), err,).into()) } } - -fn to_addr(ip: &str, port: u16) -> BoxResult { - let ip: IpAddr = ip.parse()?; - Ok(SocketAddr::new(ip, port)) -} - -// Load public certificate from file. -fn load_certs(filename: &str) -> BoxResult> { - // Open certificate file. - let certfile = fs::File::open(&filename) - .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?; - let mut reader = io::BufReader::new(certfile); - - // Load and return certificate. - let certs = rustls_pemfile::certs(&mut reader).map_err(|_| "Failed to load certificate")?; - if certs.is_empty() { - return Err("No supported certificate in file".into()); - } - Ok(certs.into_iter().map(Certificate).collect()) -} - -// Load private key from file. -fn load_private_key(filename: &str) -> BoxResult { - // Open keyfile. - let keyfile = fs::File::open(&filename) - .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?; - let mut reader = io::BufReader::new(keyfile); - - // Load and return a single private key. - let keys = rustls_pemfile::read_all(&mut reader) - .map_err(|e| format!("There was a problem with reading private key: {:?}", e))? - .into_iter() - .find_map(|item| match item { - rustls_pemfile::Item::RSAKey(key) | rustls_pemfile::Item::PKCS8Key(key) => Some(key), - _ => None, - }) - .ok_or("No supported private key in file")?; - - Ok(PrivateKey(keys)) -} diff --git a/src/main.rs b/src/main.rs index 3258e44..8910a1c 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,17 +1,28 @@ mod args; mod auth; mod server; +mod tls; #[macro_use] extern crate log; -pub type BoxResult = Result>; - -use std::env; -use std::io::Write; - use crate::args::{matches, Args}; -use crate::server::serve; +use crate::server::{Request, Server}; +use crate::tls::{TlsAcceptor, TlsStream}; + +use std::io::Write; +use std::net::{IpAddr, SocketAddr, TcpListener as StdTcpListener}; +use std::{env, sync::Arc}; + +use futures::future::join_all; +use tokio::net::TcpListener; +use tokio::task::JoinHandle; + +use hyper::server::conn::{AddrIncoming, AddrStream}; +use hyper::service::{make_service_fn, service_fn}; +use rustls::ServerConfig; + +pub type BoxResult = Result>; #[tokio::main] async fn main() { @@ -30,9 +41,18 @@ async fn run() -> BoxResult<()> { .init(); let args = Args::parse(matches())?; + let args = Arc::new(args); + let handles = serve(args.clone())?; + print_listening(args)?; + tokio::select! { - ret = serve(args) => { - ret + ret = join_all(handles) => { + for r in ret { + if let Err(e) = r { + error!("{}", e); + } + } + Ok(()) }, _ = shutdown_signal() => { Ok(()) @@ -40,6 +60,121 @@ async fn run() -> BoxResult<()> { } } +fn serve(args: Arc) -> BoxResult>>> { + let inner = Arc::new(Server::new(args.clone())); + let mut handles = vec![]; + let port = args.port; + for ip in args.addrs.iter() { + let inner = inner.clone(); + let incoming = create_addr_incoming(SocketAddr::new(*ip, port)) + .map_err(|e| format!("Failed to bind `{}:{}`, {}", ip, port, e))?; + let serv_func = move |remote_addr: SocketAddr| { + let inner = inner.clone(); + async move { + Ok::<_, hyper::Error>(service_fn(move |req: Request| { + let inner = inner.clone(); + inner.call(req, remote_addr) + })) + } + }; + match args.tls.clone() { + Some((certs, key)) => { + let config = ServerConfig::builder() + .with_safe_defaults() + .with_no_client_auth() + .with_single_cert(certs, key)?; + let config = Arc::new(config); + let accepter = TlsAcceptor::new(config.clone(), incoming); + let new_service = make_service_fn(move |socket: &TlsStream| { + let remote_addr = socket.remote_addr(); + serv_func(remote_addr) + }); + let server = tokio::spawn(hyper::Server::builder(accepter).serve(new_service)); + handles.push(server); + } + None => { + let new_service = make_service_fn(move |socket: &AddrStream| { + let remote_addr = socket.remote_addr(); + serv_func(remote_addr) + }); + let server = tokio::spawn(hyper::Server::builder(incoming).serve(new_service)); + handles.push(server); + } + }; + } + Ok(handles) +} + +fn create_addr_incoming(addr: SocketAddr) -> BoxResult { + use socket2::{Domain, Protocol, Socket, Type}; + let socket = Socket::new(Domain::for_address(addr), Type::STREAM, Some(Protocol::TCP))?; + if addr.is_ipv6() { + socket.set_only_v6(true)?; + } + socket.set_reuse_address(true)?; + socket.bind(&addr.into())?; + socket.listen(1024 /* Default backlog */)?; + let std_listener = StdTcpListener::from(socket); + std_listener.set_nonblocking(true)?; + let incoming = AddrIncoming::from_listener(TcpListener::from_std(std_listener)?)?; + Ok(incoming) +} + +fn print_listening(args: Arc) -> BoxResult<()> { + let mut addrs = vec![]; + let (mut ipv4, mut ipv6) = (false, false); + for ip in args.addrs.iter() { + if ip.is_unspecified() { + if ip.is_ipv6() { + ipv6 = true; + } else { + ipv4 = true; + } + } else { + addrs.push(*ip); + } + } + if ipv4 || ipv6 { + let ifaces = get_if_addrs::get_if_addrs() + .map_err(|e| format!("Failed to get local interface addresses: {}", e))?; + for iface in ifaces.into_iter() { + let local_ip = iface.ip(); + if ipv4 && local_ip.is_ipv4() { + addrs.push(local_ip) + } + if ipv6 && local_ip.is_ipv6() { + addrs.push(local_ip) + } + } + } + addrs.sort_unstable(); + let urls = addrs + .into_iter() + .map(|addr| match addr { + IpAddr::V4(_) => format!("{}:{}", addr, args.port), + IpAddr::V6(_) => format!("[{}]:{}", addr, args.port), + }) + .map(|addr| match &args.tls { + Some(_) => format!("https://{}", addr), + None => format!("http://{}", addr), + }) + .map(|url| format!("{}{}", url, args.uri_prefix)) + .collect::>(); + + if urls.len() == 1 { + println!("Listening on {}", urls[0]); + } else { + let info = urls + .iter() + .map(|v| format!(" {}", v)) + .collect::>() + .join("\n"); + println!("Listening on:\n{}\n", info); + } + + Ok(()) +} + fn handle_err(err: Box) -> T { eprintln!("error: {}", err); std::process::exit(1); diff --git a/src/server.rs b/src/server.rs index 9665374..ab76a51 100644 --- a/src/server.rs +++ b/src/server.rs @@ -8,7 +8,6 @@ use async_zip::Compression; use chrono::{TimeZone, Utc}; use futures::stream::StreamExt; use futures::TryStreamExt; -use get_if_addrs::get_if_addrs; use headers::{ AcceptRanges, AccessControlAllowHeaders, AccessControlAllowOrigin, ContentLength, ContentRange, ContentType, ETag, HeaderMap, HeaderMapExt, IfModifiedSince, IfNoneMatch, IfRange, @@ -18,28 +17,23 @@ use hyper::header::{ HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_DISPOSITION, CONTENT_TYPE, ORIGIN, RANGE, WWW_AUTHENTICATE, }; -use hyper::service::{make_service_fn, service_fn}; use hyper::{Body, Method, StatusCode, Uri}; use percent_encoding::percent_decode; -use rustls::ServerConfig; use serde::Serialize; -use std::convert::Infallible; use std::fs::Metadata; -use std::net::{IpAddr, SocketAddr}; +use std::net::SocketAddr; use std::path::{Path, PathBuf}; use std::sync::Arc; use std::time::SystemTime; use tokio::fs::File; use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWrite}; -use tokio::net::TcpListener; use tokio::{fs, io}; -use tokio_rustls::TlsAcceptor; use tokio_util::codec::{BytesCodec, FramedRead}; use tokio_util::io::{ReaderStream, StreamReader}; use uuid::Uuid; -type Request = hyper::Request; -type Response = hyper::Response; +pub type Request = hyper::Request; +pub type Response = hyper::Response; const INDEX_HTML: &str = include_str!("../assets/index.html"); const INDEX_CSS: &str = include_str!("../assets/index.css"); @@ -55,82 +49,34 @@ macro_rules! status { }; } -pub async fn serve(args: Args) -> BoxResult<()> { - let args = Arc::new(args); - let inner = Arc::new(InnerService::new(args.clone())); - match args.tls.clone() { - Some((certs, key)) => { - let config = ServerConfig::builder() - .with_safe_defaults() - .with_no_client_auth() - .with_single_cert(certs, key)?; - let tls_acceptor = TlsAcceptor::from(Arc::new(config)); - let arc_acceptor = Arc::new(tls_acceptor); - let listener = TcpListener::bind(&args.addr).await?; - let incoming = tokio_stream::wrappers::TcpListenerStream::new(listener); - let incoming = - hyper::server::accept::from_stream(incoming.filter_map(|socket| async { - match socket { - Ok(stream) => match arc_acceptor.clone().accept(stream).await { - Ok(val) => Some(Ok::<_, Infallible>(val)), - Err(_) => None, - }, - Err(_) => None, - } - })); - let server = hyper::Server::builder(incoming).serve(make_service_fn(move |_| { - let inner = inner.clone(); - async move { - Ok::<_, Infallible>(service_fn(move |req| { - let inner = inner.clone(); - inner.call(req) - })) - } - })); - print_listening(&args.addr, &args.uri_prefix, true); - server.await?; - } - None => { - let server = hyper::Server::try_bind(&args.addr)?.serve(make_service_fn(move |_| { - let inner = inner.clone(); - async move { - Ok::<_, Infallible>(service_fn(move |req| { - let inner = inner.clone(); - inner.call(req) - })) - } - })); - print_listening(&args.addr, &args.uri_prefix, false); - server.await?; - } - } - Ok(()) -} - -struct InnerService { +pub struct Server { args: Arc, } -impl InnerService { +impl Server { pub fn new(args: Arc) -> Self { Self { args } } - pub async fn call(self: Arc, req: Request) -> Result { + pub async fn call( + self: Arc, + req: Request, + addr: SocketAddr, + ) -> Result { let method = req.method().clone(); let uri = req.uri().clone(); let cors = self.args.cors; let mut res = match self.handle(req).await { Ok(res) => { - info!(r#""{} {}" - {}"#, method, uri, res.status()); + info!(r#"{} "{} {}" - {}"#, addr, method, uri, res.status()); res } Err(err) => { let mut res = Response::default(); let status = StatusCode::INTERNAL_SERVER_ERROR; status!(res, status); - error!(r#""{} {}" - {} {}"#, method, uri, status, err); + error!(r#"{} "{} {}" - {} {}"#, addr, method, uri, status, err); res } }; @@ -1052,48 +998,6 @@ fn to_content_range(range: &Range, complete_length: u64) -> Option }) } -fn print_listening(addr: &SocketAddr, prefix: &str, tls: bool) { - let prefix = encode_uri(prefix.trim_end_matches('/')); - let addrs = retrieve_listening_addrs(addr); - let protocol = if tls { "https" } else { "http" }; - if addrs.len() == 1 { - println!("Listening on {}://{}{}", protocol, addr, prefix); - } else { - let message = addrs - .iter() - .map(|addr| format!(" {}://{}{}", protocol, addr, prefix)) - .collect::>() - .join("\n"); - println!("Listening on:\n{}\n", message); - } -} - -fn retrieve_listening_addrs(addr: &SocketAddr) -> Vec { - let ip = addr.ip(); - let port = addr.port(); - if ip.is_unspecified() { - if let Ok(interfaces) = get_if_addrs() { - let mut ifaces: Vec = interfaces - .into_iter() - .map(|v| v.ip()) - .filter(|v| { - if ip.is_ipv4() { - v.is_ipv4() - } else { - v.is_ipv6() - } - }) - .collect(); - ifaces.sort(); - return ifaces - .into_iter() - .map(|v| SocketAddr::new(v, port)) - .collect(); - } - } - vec![addr.to_owned()] -} - fn encode_uri(v: &str) -> String { let parts: Vec<_> = v.split('/').map(urlencoding::encode).collect(); parts.join("/") diff --git a/src/tls.rs b/src/tls.rs new file mode 100644 index 0000000..b29353e --- /dev/null +++ b/src/tls.rs @@ -0,0 +1,158 @@ +use core::task::{Context, Poll}; +use futures::ready; +use hyper::server::accept::Accept; +use hyper::server::conn::{AddrIncoming, AddrStream}; +use rustls::{Certificate, PrivateKey}; +use std::future::Future; +use std::net::SocketAddr; +use std::pin::Pin; +use std::sync::Arc; +use std::{fs, io}; +use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; +use tokio_rustls::rustls::ServerConfig; + +enum State { + Handshaking(tokio_rustls::Accept), + Streaming(tokio_rustls::server::TlsStream), +} + +// tokio_rustls::server::TlsStream doesn't expose constructor methods, +// so we have to TlsAcceptor::accept and handshake to have access to it +// TlsStream implements AsyncRead/AsyncWrite handshaking tokio_rustls::Accept first +pub struct TlsStream { + state: State, + remote_addr: SocketAddr, +} + +impl TlsStream { + fn new(stream: AddrStream, config: Arc) -> TlsStream { + let remote_addr = stream.remote_addr(); + let accept = tokio_rustls::TlsAcceptor::from(config).accept(stream); + TlsStream { + state: State::Handshaking(accept), + remote_addr, + } + } + pub fn remote_addr(&self) -> SocketAddr { + self.remote_addr + } +} + +impl AsyncRead for TlsStream { + fn poll_read( + self: Pin<&mut Self>, + cx: &mut Context, + buf: &mut ReadBuf, + ) -> Poll> { + let pin = self.get_mut(); + match pin.state { + State::Handshaking(ref mut accept) => match ready!(Pin::new(accept).poll(cx)) { + Ok(mut stream) => { + let result = Pin::new(&mut stream).poll_read(cx, buf); + pin.state = State::Streaming(stream); + result + } + Err(err) => Poll::Ready(Err(err)), + }, + State::Streaming(ref mut stream) => Pin::new(stream).poll_read(cx, buf), + } + } +} + +impl AsyncWrite for TlsStream { + fn poll_write( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &[u8], + ) -> Poll> { + let pin = self.get_mut(); + match pin.state { + State::Handshaking(ref mut accept) => match ready!(Pin::new(accept).poll(cx)) { + Ok(mut stream) => { + let result = Pin::new(&mut stream).poll_write(cx, buf); + pin.state = State::Streaming(stream); + result + } + Err(err) => Poll::Ready(Err(err)), + }, + State::Streaming(ref mut stream) => Pin::new(stream).poll_write(cx, buf), + } + } + + fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + match self.state { + State::Handshaking(_) => Poll::Ready(Ok(())), + State::Streaming(ref mut stream) => Pin::new(stream).poll_flush(cx), + } + } + + fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + match self.state { + State::Handshaking(_) => Poll::Ready(Ok(())), + State::Streaming(ref mut stream) => Pin::new(stream).poll_shutdown(cx), + } + } +} + +pub struct TlsAcceptor { + config: Arc, + incoming: AddrIncoming, +} + +impl TlsAcceptor { + pub fn new(config: Arc, incoming: AddrIncoming) -> TlsAcceptor { + TlsAcceptor { config, incoming } + } +} + +impl Accept for TlsAcceptor { + type Conn = TlsStream; + type Error = io::Error; + + fn poll_accept( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll>> { + let pin = self.get_mut(); + match ready!(Pin::new(&mut pin.incoming).poll_accept(cx)) { + Some(Ok(sock)) => Poll::Ready(Some(Ok(TlsStream::new(sock, pin.config.clone())))), + Some(Err(e)) => Poll::Ready(Some(Err(e))), + None => Poll::Ready(None), + } + } +} + +// Load public certificate from file. +pub fn load_certs(filename: &str) -> Result, Box> { + // Open certificate file. + let certfile = fs::File::open(&filename) + .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?; + let mut reader = io::BufReader::new(certfile); + + // Load and return certificate. + let certs = rustls_pemfile::certs(&mut reader).map_err(|_| "Failed to load certificate")?; + if certs.is_empty() { + return Err("No supported certificate in file".into()); + } + Ok(certs.into_iter().map(Certificate).collect()) +} + +// Load private key from file. +pub fn load_private_key(filename: &str) -> Result> { + // Open keyfile. + let keyfile = fs::File::open(&filename) + .map_err(|e| format!("Failed to access `{}`, {}", &filename, e))?; + let mut reader = io::BufReader::new(keyfile); + + // Load and return a single private key. + let keys = rustls_pemfile::read_all(&mut reader) + .map_err(|e| format!("There was a problem with reading private key: {:?}", e))? + .into_iter() + .find_map(|item| match item { + rustls_pemfile::Item::RSAKey(key) | rustls_pemfile::Item::PKCS8Key(key) => Some(key), + _ => None, + }) + .ok_or("No supported private key in file")?; + + Ok(PrivateKey(keys)) +} diff --git a/tests/bind.rs b/tests/bind.rs index 4850d90..919d5d8 100644 --- a/tests/bind.rs +++ b/tests/bind.rs @@ -19,25 +19,30 @@ fn bind_fails(tmpdir: TempDir, port: u16, #[case] args: &[&str]) -> Result<(), E .arg(port.to_string()) .args(args) .assert() - .stderr(predicates::str::contains("creating server listener")) + .stderr(predicates::str::contains("Failed to bind")) .failure(); Ok(()) } #[rstest] -fn bind_ipv4(server: TestServer) -> Result<(), Error> { - assert!(reqwest::blocking::get(format!("http://127.0.0.1:{}", server.port()).as_str()).is_ok()); - Ok(()) -} - -#[rstest] -fn bind_ipv6(#[with(&["-b", "::"])] server: TestServer) -> Result<(), Error> { +#[case(server(&[] as &[&str]), true, true)] +#[case(server(&["-b", "0.0.0.0"]), true, false)] +#[case(server(&["-b", "127.0.0.1", "-b", "::1"]), true, true)] +fn bind_ipv4_ipv6( + #[case] server: TestServer, + #[case] bind_ipv4: bool, + #[case] bind_ipv6: bool, +) -> Result<(), Error> { assert_eq!( reqwest::blocking::get(format!("http://127.0.0.1:{}", server.port()).as_str()).is_ok(), - !cfg!(windows) + bind_ipv4 ); - assert!(reqwest::blocking::get(format!("http://[::1]:{}", server.port()).as_str()).is_ok()); + assert_eq!( + reqwest::blocking::get(format!("http://[::1]:{}", server.port()).as_str()).is_ok(), + bind_ipv6 + ); + Ok(()) } diff --git a/tests/fixtures.rs b/tests/fixtures.rs index 0ff9970..2641ddf 100644 --- a/tests/fixtures.rs +++ b/tests/fixtures.rs @@ -79,7 +79,7 @@ pub fn port() -> u16 { free_local_port().expect("Couldn't find a free local port") } -/// Run miniserve as a server; Start with a temporary directory, a free port and some +/// Run duf as a server; Start with a temporary directory, a free port and some /// optional arguments then wait for a while for the server setup to complete. #[fixture] #[allow(dead_code)]