Merge branch 'master' into master

Author: Ben-Lichtman

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "async-h1"
-version = "2.0.0"
+version = "2.0.2"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/http-rs/async-h1"
 documentation = "https://docs.rs/async-h1"

src/server/decode.rs

@@ -128,7 +128,7 @@ fn url_from_httparse_req(req: &httparse::Request<'_, '_>) -> http_types::Result<
 }
 
 const EXPECT_HEADER_VALUE: &str = "100-continue";
-const EXPECT_RESPONSE: &[u8] = b"HTTP/1.1 100 Continue\r\n";
+const EXPECT_RESPONSE: &[u8] = b"HTTP/1.1 100 Continue\r\n\r\n";
 
 async fn handle_100_continue<IO>(req: &Request, io: &mut IO) -> http_types::Result<()>
 where
@@ -223,7 +223,7 @@ mod tests {
         let result = async_std::task::block_on(handle_100_continue(&request, &mut io));
         assert_eq!(
             std::str::from_utf8(&io.into_inner()).unwrap(),
-            "HTTP/1.1 100 Continue\r\n"
+            "HTTP/1.1 100 Continue\r\n\r\n"
         );
         assert!(result.is_ok());
     }

src/server/encode.rs

@@ -6,7 +6,7 @@ use async_std::io;
 use async_std::io::prelude::*;
 use async_std::task::{Context, Poll};
 use http_types::headers::{CONTENT_LENGTH, DATE, TRANSFER_ENCODING};
-use http_types::Response;
+use http_types::{Method, Response};
 
 use crate::chunked::ChunkedEncoder;
 use crate::date::fmt_http_date;
@@ -36,6 +36,8 @@ pub struct Encoder {
     body_bytes_written: usize,
     /// An encoder for chunked encoding.
     chunked: ChunkedEncoder,
+    /// the http method that this response is in reply to
+    method: Method,
 }
 
 #[derive(Debug)]
@@ -80,6 +82,7 @@ impl Encoder {
             body_len: 0,
             body_bytes_written: 0,
             chunked: ChunkedEncoder::new(),
+            method,
         }
     }
 
@@ -97,7 +100,7 @@ impl Encoder {
         match self.state {
             Start => assert!(matches!(state, ComputeHead)),
             ComputeHead => assert!(matches!(state, EncodeHead)),
-            EncodeHead => assert!(matches!(state, EncodeChunkedBody | EncodeFixedBody)),
+            EncodeHead => assert!(matches!(state, EncodeChunkedBody | EncodeFixedBody | End)),
             EncodeFixedBody => assert!(matches!(state, End)),
             EncodeChunkedBody => assert!(matches!(state, End)),
             End => panic!("No state transitions allowed after the ServerEncoder has ended"),
@@ -176,14 +179,20 @@ impl Encoder {
         // If we've read the total length of the head we're done
         // reading the head and can transition to reading the body
         if self.head_bytes_written == head_len {
-            // The response length lets us know if we are encoding
-            // our body in chunks or not
-            match self.res.len() {
-                Some(body_len) => {
-                    self.body_len = body_len;
-                    self.dispatch(State::EncodeFixedBody, cx, buf)
+            if self.method == Method::Head {
+                // If we are responding to a HEAD request, we MUST NOT send
+                // body content
+                self.dispatch(State::End, cx, buf)
+            } else {
+                // The response length lets us know if we are encoding
+                // our body in chunks or not
+                match self.res.len() {
+                    Some(body_len) => {
+                        self.body_len = body_len;
+                        self.dispatch(State::EncodeFixedBody, cx, buf)
+                    }
+                    None => self.dispatch(State::EncodeChunkedBody, cx, buf),
                 }
-                None => self.dispatch(State::EncodeChunkedBody, cx, buf),
             }
         } else {
             // If we haven't read the entire header it means `buf` isn't

src/server/mod.rs

@@ -70,9 +70,11 @@ where
             }
         };
 
+        let method = req.method();
         // Pass the request to the endpoint and encode the response.
         let res = endpoint(req).await?;
-        let mut encoder = Encoder::new(res);
+
+        let mut encoder = Encoder::new(res, method);
 
         // Stream the response to the writer.
         io::copy(&mut encoder, &mut io).await?;

tests/fixtures/head_request.txt

@@ -0,0 +1,4 @@
+HEAD / HTTP/1.1
+host: example.com
+user-agent: curl/7.54.0
+

tests/fixtures/head_response.txt

@@ -0,0 +1,5 @@
+HTTP/1.1 200 OK
+content-length: 5
+date: {DATE}
+content-type: text/plain;charset=utf-8
+

tests/server.rs

@@ -144,3 +144,14 @@ async fn test_invalid_trailer() {
 
     assert!(case.read_result().await.is_empty());
 }
+#[async_std::test]
+async fn empty_body_for_head_requests() {
+    let case =
+        TestCase::new_server("fixtures/head_request.txt", "fixtures/head_response.txt").await;
+
+    async_h1::accept(case.clone(), |_| async { Ok("hello".into()) })
+        .await
+        .unwrap();
+
+    case.assert().await;
+}