stub out chunked-encoding

Author: dignifiedquire

Cargo.toml

@@ -18,6 +18,8 @@ futures-io = "0.3.0"
 async-std = { version = "1", features = ["unstable"] }
 futures-core-preview = "0.3.0-alpha.18"
 http-types = { path = '../http-types' }
+thiserror = "1.0.9"
+pin-project-lite = "0.1.1"
 
 [dev-dependencies]
 futures-util = "0.3.0"

src/chunked.rs

@@ -0,0 +1,41 @@
+use async_std::io::{self, BufRead, Read};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+pin_project_lite::pin_project! {
+    pub struct ChunkedDecoder<R> {
+        #[pin]
+        reader: R,
+    }
+}
+
+impl<R> ChunkedDecoder<R> {
+    pub fn new(reader: R) -> Self {
+        ChunkedDecoder { reader }
+    }
+}
+
+impl<R: BufRead + Unpin + Send + 'static> Read for ChunkedDecoder<R> {
+    #[allow(missing_doc_code_examples)]
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<io::Result<usize>> {
+        let this = self.project();
+        this.reader.poll_read(cx, buf)
+    }
+}
+
+impl<R: BufRead + Unpin + Send + 'static> BufRead for ChunkedDecoder<R> {
+    #[allow(missing_doc_code_examples)]
+    fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&'_ [u8]>> {
+        let this = self.project();
+        this.reader.poll_fill_buf(cx)
+    }
+
+    fn consume(self: Pin<&mut Self>, amt: usize) {
+        let this = self.project();
+        this.reader.consume(amt);
+    }
+}

src/lib.rs

@@ -28,7 +28,7 @@
 //! // tbi
 //! ```
 
-#![forbid(unsafe_code, future_incompatible, rust_2018_idioms)]
+#![forbid(unsafe_code, rust_2018_idioms)]
 #![deny(missing_debug_implementations, nonstandard_style)]
 // #![warn(missing_docs, missing_doc_code_examples, unreachable_pub)]
 #![cfg_attr(test, deny(warnings))]
@@ -43,6 +43,7 @@ mod check;
 pub mod client;
 pub mod server;
 
+mod chunked;
 mod date;
 
 /// A generic fallible type.

src/server.rs

@@ -6,16 +6,25 @@ use async_std::io::{Read, Write};
 use async_std::prelude::*;
 use async_std::task::{Context, Poll};
 use futures_core::ready;
-use http_types::headers::{HeaderName, HeaderValue, CONTENT_LENGTH};
+use http_types::headers::{HeaderName, HeaderValue, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http_types::{Body, Method, Request, Response};
 use std::str::FromStr;
 use std::time::Duration;
+use thiserror::Error;
 
 use std::pin::Pin;
 
+use crate::chunked::ChunkedDecoder;
 use crate::date::fmt_http_date;
 use crate::{Exception, MAX_HEADERS};
 
+/// Errors when handling incoming requests.
+#[derive(Debug, Error)]
+pub enum HttpError {
+    #[error("unexpected content-length header")]
+    UnexpectedContentLengthHeader,
+}
+
 /// Parse an incoming HTTP connection.
 ///
 /// Supports `KeepAlive` requests by default.
@@ -375,14 +384,36 @@ where
         req.insert_header(name, value)?;
     }
 
+    let content_length = req.header(&CONTENT_LENGTH);
+    let transfer_encoding = req.header(&TRANSFER_ENCODING);
+
+    if content_length.is_some() && transfer_encoding.is_some() {
+        // This is always an error.
+        return Err(HttpError::UnexpectedContentLengthHeader.into());
+    }
+
+    match transfer_encoding {
+        Some(encoding) if !encoding.is_empty() => {
+            if encoding.last().unwrap().as_str() == "chunked" {
+                req.set_body(Body::from_reader(ChunkedDecoder::new(reader), None));
+                return Ok(Some(req));
+            }
+            // Fall through to Content-Length
+        }
+        _ => {
+            // Fall through to Content-Length
+        }
+    }
+
     // Check for content-length, that determines determines whether we can parse
     // it with a known length, or need to use chunked encoding.
-    let len = match req.header(&CONTENT_LENGTH) {
-        Some(len) => len.last().unwrap().as_str().parse::<usize>()?,
-        None => return Ok(Some(req)),
-    };
-
-    req.set_body(Body::from_reader(reader.take(len as u64), Some(len)));
+    match content_length {
+        Some(len) => {
+            let len = len.last().unwrap().as_str().parse::<usize>()?;
+            req.set_body(Body::from_reader(reader.take(len as u64), Some(len)));
+        }
+        None => {}
+    }
 
     Ok(Some(req))
 }