Merge pull request #107 from jbr/no-addr

No addr needed for accept

Author: yoshuawuyts

examples/server.rs

@@ -14,9 +14,8 @@ async fn main() -> http_types::Result<()> {
     let mut incoming = listener.incoming();
     while let Some(stream) = incoming.next().await {
         let stream = stream?;
-        let addr = addr.clone();
         task::spawn(async {
-            if let Err(err) = accept(addr, stream).await {
+            if let Err(err) = accept(stream).await {
                 eprintln!("{}", err);
             }
         });
@@ -25,9 +24,9 @@ async fn main() -> http_types::Result<()> {
 }
 
 // Take a TCP stream, and convert it into sequential HTTP request / response pairs.
-async fn accept(addr: String, stream: TcpStream) -> http_types::Result<()> {
+async fn accept(stream: TcpStream) -> http_types::Result<()> {
     println!("starting new connection from {}", stream.peer_addr()?);
-    async_h1::accept(&addr, stream.clone(), |_req| async move {
+    async_h1::accept(stream.clone(), |_req| async move {
         let mut res = Response::new(StatusCode::Ok);
         res.insert_header("Content-Type", "text/plain")?;
         res.set_body("Hello world");

src/lib.rs

@@ -67,9 +67,8 @@
 //!     let mut incoming = listener.incoming();
 //!     while let Some(stream) = incoming.next().await {
 //!         let stream = stream?;
-//!         let addr = addr.clone();
 //!         task::spawn(async {
-//!             if let Err(err) = accept(addr, stream).await {
+//!             if let Err(err) = accept(stream).await {
 //!                 eprintln!("{}", err);
 //!             }
 //!         });
@@ -78,9 +77,9 @@
 //! }
 //!
 //! // Take a TCP stream, and convert it into sequential HTTP request / response pairs.
-//! async fn accept(addr: String, stream: TcpStream) -> http_types::Result<()> {
+//! async fn accept(stream: TcpStream) -> http_types::Result<()> {
 //!     println!("starting new connection from {}", stream.peer_addr()?);
-//!     async_h1::accept(&addr, stream.clone(), |_req| async move {
+//!     async_h1::accept(stream.clone(), |_req| async move {
 //!         let mut res = Response::new(StatusCode::Ok);
 //!         res.insert_header("Content-Type", "text/plain")?;
 //!         res.set_body("Hello");

src/server/decode.rs

@@ -5,7 +5,7 @@ use std::str::FromStr;
 use async_std::io::BufReader;
 use async_std::io::Read;
 use async_std::prelude::*;
-use http_types::headers::{HeaderName, HeaderValue, CONTENT_LENGTH, TRANSFER_ENCODING};
+use http_types::headers::{HeaderName, HeaderValue, CONTENT_LENGTH, HOST, TRANSFER_ENCODING};
 use http_types::{ensure, ensure_eq, format_err};
 use http_types::{Body, Method, Request};
 
@@ -18,7 +18,7 @@ const LF: u8 = b'\n';
 const HTTP_1_1_VERSION: u8 = 1;
 
 /// Decode an HTTP request on the server.
-pub(crate) async fn decode<R>(addr: &str, reader: R) -> http_types::Result<Option<Request>>
+pub(crate) async fn decode<R>(reader: R) -> http_types::Result<Option<Request>>
 where
     R: Read + Unpin + Send + Sync + 'static,
 {
@@ -57,21 +57,26 @@ where
     let method = httparse_req.method;
     let method = method.ok_or_else(|| format_err!("No method found"))?;
 
-    let uri = httparse_req.path;
-    let uri = uri.ok_or_else(|| format_err!("No uri found"))?;
-    let uri = url::Url::parse(&format!("{}{}", addr, uri))?;
+    let path = httparse_req.path;
+    let path = path.ok_or_else(|| format_err!("No uri found"))?;
 
     let version = httparse_req.version;
     let version = version.ok_or_else(|| format_err!("No version found"))?;
     ensure_eq!(version, HTTP_1_1_VERSION, "Unsupported HTTP version");
 
-    let mut req = Request::new(Method::from_str(method)?, uri);
+    let mut req = Request::new(
+        Method::from_str(method)?,
+        url::Url::parse("http://_").unwrap().join(path)?,
+    );
+
     for header in httparse_req.headers.iter() {
         let name = HeaderName::from_str(header.name)?;
         let value = HeaderValue::from_str(std::str::from_utf8(header.value)?)?;
         req.insert_header(name, value)?;
     }
 
+    set_url_and_port_from_host_header(&mut req)?;
+
     let content_length = req.header(&CONTENT_LENGTH);
     let transfer_encoding = req.header(&TRANSFER_ENCODING);
 
@@ -99,3 +104,103 @@ where
 
     Ok(Some(req))
 }
+
+fn set_url_and_port_from_host_header(req: &mut Request) -> http_types::Result<()> {
+    let host = req
+        .header(&HOST)
+        .and_then(|header| header.last()) // There must only exactly one Host header, so this is permissive
+        .ok_or_else(|| format_err!("Mandatory Host header missing"))?; //  https://tools.ietf.org/html/rfc7230#section-5.4
+
+    let host = host.to_string();
+    if let Some(colon) = host.find(":") {
+        req.url_mut().set_host(Some(&host[0..colon]))?;
+        req.url_mut()
+            .set_port(host[colon + 1..].parse().ok())
+            .unwrap();
+    } else {
+        req.url_mut().set_host(Some(&host))?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn request_with_host_header(host: &str) -> Request {
+        let mut req = Request::new(
+            Method::from_str("GET").unwrap(),
+            url::Url::parse("http://_")
+                .unwrap()
+                .join("/some/path")
+                .unwrap(),
+        );
+
+        req.insert_header(HOST, host).unwrap();
+
+        req
+    }
+
+    #[test]
+    fn test_setting_host_with_no_port() {
+        let mut request = request_with_host_header("subdomain.mydomain.tld");
+        set_url_and_port_from_host_header(&mut request).unwrap();
+        assert_eq!(
+            request.url(),
+            &url::Url::parse("http://subdomain.mydomain.tld/some/path").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_setting_host_with_a_port() {
+        let mut request = request_with_host_header("subdomain.mydomain.tld:8080");
+        set_url_and_port_from_host_header(&mut request).unwrap();
+        assert_eq!(
+            request.url(),
+            &url::Url::parse("http://subdomain.mydomain.tld:8080/some/path").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_setting_host_with_an_ip_and_port() {
+        let mut request = request_with_host_header("12.34.56.78:90");
+        set_url_and_port_from_host_header(&mut request).unwrap();
+        assert_eq!(
+            request.url(),
+            &url::Url::parse("http://12.34.56.78:90/some/path").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_malformed_nonnumeric_port_is_ignored() {
+        let mut request = request_with_host_header("hello.world:uh-oh");
+        set_url_and_port_from_host_header(&mut request).unwrap();
+        assert_eq!(
+            request.url(),
+            &url::Url::parse("http://hello.world/some/path").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_malformed_trailing_colon_is_ignored() {
+        let mut request = request_with_host_header("edge.cases:");
+        set_url_and_port_from_host_header(&mut request).unwrap();
+        assert_eq!(
+            request.url(),
+            &url::Url::parse("http://edge.cases/some/path").unwrap()
+        );
+    }
+
+    #[test]
+    fn test_malformed_leading_colon_is_invalid_host_value() {
+        let mut request = request_with_host_header(":300");
+        assert!(set_url_and_port_from_host_header(&mut request).is_err());
+    }
+
+    #[test]
+    fn test_malformed_invalid_url_host_is_invalid_host_header_value() {
+        let mut request = request_with_host_header(" ");
+        assert!(set_url_and_port_from_host_header(&mut request).is_err());
+    }
+}

src/server/mod.rs

@@ -31,20 +31,19 @@ impl Default for ServerOptions {
 /// Accept a new incoming HTTP/1.1 connection.
 ///
 /// Supports `KeepAlive` requests by default.
-pub async fn accept<RW, F, Fut>(addr: &str, io: RW, endpoint: F) -> http_types::Result<()>
+pub async fn accept<RW, F, Fut>(io: RW, endpoint: F) -> http_types::Result<()>
 where
     RW: Read + Write + Clone + Send + Sync + Unpin + 'static,
     F: Fn(Request) -> Fut,
     Fut: Future<Output = http_types::Result<Response>>,
 {
-    accept_with_opts(addr, io, endpoint, Default::default()).await
+    accept_with_opts(io, endpoint, Default::default()).await
 }
 
 /// Accept a new incoming HTTP/1.1 connection.
 ///
 /// Supports `KeepAlive` requests by default.
 pub async fn accept_with_opts<RW, F, Fut>(
-    addr: &str,
     mut io: RW,
     endpoint: F,
     opts: ServerOptions,
@@ -56,7 +55,7 @@ where
 {
     loop {
         // Decode a new request, timing out if this takes longer than the timeout duration.
-        let fut = decode(addr, io.clone());
+        let fut = decode(io.clone());
 
         let req = if let Some(timeout_duration) = opts.headers_timeout {
             match timeout(timeout_duration, fut).await {

tests/fixtures/request-unexpected-eof.txt

@@ -1,4 +1,5 @@
 POST / HTTP/1.1
+host: example.com
 content-type: text/plain
 content-length: 11
 

tests/fixtures/request-with-host.txt

@@ -0,0 +1,4 @@
+GET /pub/WWW/TheProject.html HTTP/1.1
+Host: www.w3.org
+Content-Length: 0
+

tests/fixtures/response-with-host.txt

@@ -0,0 +1,6 @@
+HTTP/1.1 200 OK
+content-length: 41
+date: {DATE}
+content-type: text/plain; charset=utf-8
+
+http://www.w3.org/pub/WWW/TheProject.html

tests/server-chunked-encode-large.rs

@@ -145,7 +145,7 @@ const RESPONSE: &'static str = concat![
 #[async_std::test]
 async fn server_chunked_large() {
     let case = TestCase::new(REQUEST, "").await;
-    async_h1::accept("http://example.com", case.clone(), |_| async {
+    async_h1::accept(case.clone(), |_| async {
         let mut res = Response::new(StatusCode::Ok);
         let body = Cursor::new(TEXT.to_owned());
         res.set_body(Body::from_reader(body, None));

tests/server-chunked-encode-small.rs

@@ -41,7 +41,7 @@ const RESPONSE: &'static str = concat![
 #[async_std::test]
 async fn server_chunked_large() {
     let case = TestCase::new(REQUEST, "").await;
-    async_h1::accept("http://example.com", case.clone(), |_| async {
+    async_h1::accept(case.clone(), |_| async {
         let mut res = Response::new(StatusCode::Ok);
         let body = Cursor::new(TEXT.to_owned());
         res.set_body(Body::from_reader(body, None));

tests/server.rs

@@ -12,9 +12,8 @@ async fn test_basic_request() {
         "fixtures/response-add-date.txt",
     )
     .await;
-    let addr = "http://example.com";
 
-    async_h1::accept(addr, case.clone(), |_req| async {
+    async_h1::accept(case.clone(), |_req| async {
         let mut res = Response::new(StatusCode::Ok);
         res.set_body("");
         Ok(res)
@@ -25,16 +24,34 @@ async fn test_basic_request() {
     case.assert().await;
 }
 
+#[async_std::test]
+async fn test_host() {
+    let case = TestCase::new_server(
+        "fixtures/request-with-host.txt",
+        "fixtures/response-with-host.txt",
+    )
+    .await;
+
+    async_h1::accept(case.clone(), |req| async move {
+        let mut res = Response::new(StatusCode::Ok);
+        res.set_body(req.url().as_str());
+        Ok(res)
+    })
+    .await
+    .unwrap();
+
+    case.assert().await;
+}
+
 #[async_std::test]
 async fn test_chunked_basic() {
     let case = TestCase::new_server(
         "fixtures/request-chunked-basic.txt",
         "fixtures/response-chunked-basic.txt",
     )
     .await;
-    let addr = "http://example.com";
 
-    async_h1::accept(addr, case.clone(), |_req| async {
+    async_h1::accept(case.clone(), |_req| async {
         let mut res = Response::new(StatusCode::Ok);
         res.set_body(Body::from_reader(
             Cursor::new(b"Mozilla")
@@ -59,8 +76,7 @@ async fn test_chunked_echo() {
     )
     .await;
 
-    let addr = "http://example.com";
-    async_h1::accept(addr, case.clone(), |req| async {
+    async_h1::accept(case.clone(), |req| async {
         let ct = req.content_type();
         let body: Body = req.into();
 
@@ -86,9 +102,8 @@ async fn test_unexpected_eof() {
         "fixtures/response-unexpected-eof.txt",
     )
     .await;
-    let addr = "http://example.com";
 
-    async_h1::accept(addr, case.clone(), |req| async {
+    async_h1::accept(case.clone(), |req| async {
         let mut res = Response::new(StatusCode::Ok);
         let ct = req.content_type();
         let body: Body = req.into();
@@ -112,9 +127,8 @@ async fn test_invalid_trailer() {
         "fixtures/response-invalid-trailer.txt",
     )
     .await;
-    let addr = "http://example.com";
 
-    async_h1::accept(addr, case.clone(), |req| async {
+    async_h1::accept(case.clone(), |req| async {
         let mut res = Response::new(StatusCode::Ok);
         let ct = req.content_type();
         let body: Body = req.into();