Merge branch 'master' into feature/h1_pending_timer

CHANGES.md

@@ -1,6 +1,8 @@
 # Changes
 
 ## Unreleased - 2021-xx-xx
+### Changed
+* Update `language-tags` to `0.3`.
 
 
 ## 4.0.0-beta.6 - 2021-04-17

Cargo.toml

@@ -78,7 +78,7 @@ encoding_rs = "0.8"
 futures-core = { version = "0.3.7", default-features = false }
 futures-util = { version = "0.3.7", default-features = false }
 itoa = "0.4"
-language-tags = "0.2"
+language-tags = "0.3"
 once_cell = "1.5"
 log = "0.4"
 mime = "0.3"

actix-files/CHANGES.md

@@ -11,6 +11,9 @@
 ## 0.6.0-beta.4 - 2021-04-02
 * No notable changes.
 
+* Add support for `.guard` in `Files` to selectively filter `Files` services. [#2046]
+
+[#2046]: https://github.com/actix/actix-web/pull/2046
 
 ## 0.6.0-beta.3 - 2021-03-09
 * No notable changes.

actix-files/src/files.rs

@@ -37,7 +37,8 @@ pub struct Files {
     renderer: Rc<DirectoryRenderer>,
     mime_override: Option<Rc<MimeOverride>>,
     file_flags: named::Flags,
-    guards: Option<Rc<dyn Guard>>,
+    use_guards: Option<Rc<dyn Guard>>,
+    guards: Vec<Box<Rc<dyn Guard>>>,
     hidden_files: bool,
 }
 
@@ -59,12 +60,12 @@ impl Clone for Files {
             file_flags: self.file_flags,
             path: self.path.clone(),
             mime_override: self.mime_override.clone(),
+            use_guards: self.use_guards.clone(),
             guards: self.guards.clone(),
             hidden_files: self.hidden_files,
         }
     }
 }
-
 impl Files {
     /// Create new `Files` instance for a specified base directory.
     ///
@@ -80,10 +81,9 @@ impl Files {
     /// If the mount path is set as the root path `/`, services registered after this one will
     /// be inaccessible. Register more specific handlers and services first.
     ///
-    /// `Files` uses a threadpool for blocking filesystem operations. By default, the pool uses a
+    /// `Files` utilizes the existing Tokio thread-pool for blocking filesystem operations.
-    /// max number of threads equal to `512 * HttpServer::worker`. Real time thread count are
+    /// The number of running threads is adjusted over time as needed, up to a maximum of 512 times
-    /// adjusted with work load. More threads would spawn when need and threads goes idle for a
+    /// the number of server [workers](HttpServer::workers), by default.
-    /// period of time would be de-spawned.
     pub fn new<T: Into<PathBuf>>(mount_path: &str, serve_from: T) -> Files {
         let orig_dir = serve_from.into();
         let dir = match orig_dir.canonicalize() {
@@ -104,7 +104,8 @@ impl Files {
             renderer: Rc::new(directory_listing),
             mime_override: None,
             file_flags: named::Flags::default(),
-            guards: None,
+            use_guards: None,
+            guards: Vec::new(),
             hidden_files: false,
         }
     }
@@ -156,7 +157,6 @@ impl Files {
     /// Specifies whether to use ETag or not.
     ///
     /// Default is true.
-    #[inline]
     pub fn use_etag(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::ETAG, value);
         self
@@ -165,7 +165,6 @@ impl Files {
     /// Specifies whether to use Last-Modified or not.
     ///
     /// Default is true.
-    #[inline]
     pub fn use_last_modified(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::LAST_MD, value);
         self
@@ -174,25 +173,55 @@ impl Files {
     /// Specifies whether text responses should signal a UTF-8 encoding.
     ///
     /// Default is false (but will default to true in a future version).
-    #[inline]
     pub fn prefer_utf8(mut self, value: bool) -> Self {
         self.file_flags.set(named::Flags::PREFER_UTF8, value);
         self
     }
 
-    /// Specifies custom guards to use for directory listings and files.
+    /// Adds a routing guard.
     ///
-    /// Default behaviour allows GET and HEAD.
+    /// Use this to allow multiple chained file services that respond to strictly different
-    #[inline]
+    /// properties of a request. Due to the way routing works, if a guard check returns true and the
-    pub fn use_guards<G: Guard + 'static>(mut self, guards: G) -> Self {
+    /// request starts being handled by the file service, it will not be able to back-out and try
-        self.guards = Some(Rc::new(guards));
+    /// the next service, you will simply get a 404 (or 405) error response.
+    ///
+    /// To allow `POST` requests to retrieve files, see [`Files::use_guards`].
+    ///
+    /// # Examples
+    /// ```
+    /// use actix_web::{guard::Header, App};
+    /// use actix_files::Files;
+    ///
+    /// App::new().service(
+    ///     Files::new("/","/my/site/files")
+    ///         .guard(Header("Host", "example.com"))
+    /// );
+    /// ```
+    pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
+        self.guards.push(Box::new(Rc::new(guard)));
         self
     }
 
+    /// Specifies guard to check before fetching directory listings or files.
+    ///
+    /// Note that this guard has no effect on routing; it's main use is to guard on the request's
+    /// method just before serving the file, only allowing `GET` and `HEAD` requests by default.
+    /// See [`Files::guard`] for routing guards.
+    pub fn method_guard<G: Guard + 'static>(mut self, guard: G) -> Self {
+        self.use_guards = Some(Rc::new(guard));
+        self
+    }
+
+    #[doc(hidden)]
+    #[deprecated(since = "0.6.0", note = "Renamed to `method_guard`.")]
+    /// See [`Files::method_guard`].
+    pub fn use_guards<G: Guard + 'static>(self, guard: G) -> Self {
+        self.method_guard(guard)
+    }
+
     /// Disable `Content-Disposition` header.
     ///
     /// By default Content-Disposition` header is enabled.
-    #[inline]
     pub fn disable_content_disposition(mut self) -> Self {
         self.file_flags.remove(named::Flags::CONTENT_DISPOSITION);
         self
@@ -200,8 +229,9 @@ impl Files {
 
     /// Sets default handler which is used when no matched file could be found.
     ///
-    /// For example, you could set a fall back static file handler:
+    /// # Examples
-    /// ```rust
+    /// Setting a fallback static file handler:
+    /// ```
     /// use actix_files::{Files, NamedFile};
     ///
     /// # fn run() -> Result<(), actix_web::Error> {
@@ -230,7 +260,6 @@ impl Files {
     }
 
     /// Enables serving hidden files and directories, allowing a leading dots in url fragments.
-    #[inline]
     pub fn use_hidden_files(mut self) -> Self {
         self.hidden_files = true;
         self
@@ -238,7 +267,19 @@ impl Files {
 }
 
 impl HttpServiceFactory for Files {
-    fn register(self, config: &mut AppService) {
+    fn register(mut self, config: &mut AppService) {
+        let guards = if self.guards.is_empty() {
+            None
+        } else {
+            let guards = std::mem::take(&mut self.guards);
+            Some(
+                guards
+                    .into_iter()
+                    .map(|guard| -> Box<dyn Guard> { guard })
+                    .collect::<Vec<_>>(),
+            )
+        };
+
         if self.default.borrow().is_none() {
             *self.default.borrow_mut() = Some(config.default_service());
         }
@@ -249,7 +290,7 @@ impl HttpServiceFactory for Files {
             ResourceDef::prefix(&self.path)
         };
 
-        config.register_service(rdef, None, self, None)
+        config.register_service(rdef, guards, self, None)
     }
 }
 
@@ -271,7 +312,7 @@ impl ServiceFactory<ServiceRequest> for Files {
             renderer: self.renderer.clone(),
             mime_override: self.mime_override.clone(),
             file_flags: self.file_flags,
-            guards: self.guards.clone(),
+            guards: self.use_guards.clone(),
             hidden_files: self.hidden_files,
         };
 

actix-files/src/lib.rs

@@ -532,7 +532,7 @@ mod tests {
     #[actix_rt::test]
     async fn test_files_guards() {
         let srv = test::init_service(
-            App::new().service(Files::new("/", ".").use_guards(guard::Post())),
+            App::new().service(Files::new("/", ".").method_guard(guard::Post())),
         )
         .await;
 

actix-files/tests/fixtures/guards/first/index.txt

@@ -0,0 +1 @@
+first

actix-files/tests/fixtures/guards/second/index.txt

@@ -0,0 +1 @@
+second

actix-files/tests/guard.rs

@@ -0,0 +1,36 @@
+use actix_files::Files;
+use actix_web::{
+    guard::Host,
+    http::StatusCode,
+    test::{self, TestRequest},
+    App,
+};
+use bytes::Bytes;
+
+#[actix_rt::test]
+async fn test_guard_filter() {
+    let srv = test::init_service(
+        App::new()
+            .service(Files::new("/", "./tests/fixtures/guards/first").guard(Host("first.com")))
+            .service(
+                Files::new("/", "./tests/fixtures/guards/second").guard(Host("second.com")),
+            ),
+    )
+    .await;
+
+    let req = TestRequest::with_uri("/index.txt")
+        .append_header(("Host", "first.com"))
+        .to_request();
+    let res = test::call_service(&srv, req).await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    assert_eq!(test::read_body(res).await, Bytes::from("first"));
+
+    let req = TestRequest::with_uri("/index.txt")
+        .append_header(("Host", "second.com"))
+        .to_request();
+    let res = test::call_service(&srv, req).await;
+
+    assert_eq!(res.status(), StatusCode::OK);
+    assert_eq!(test::read_body(res).await, Bytes::from("second"));
+}

actix-http/CHANGES.md

@@ -2,18 +2,25 @@
 
 ## Unreleased - 2021-xx-xx
 ### Added
+* `BoxAnyBody`: a boxed message body with boxed errors. [#2183]
 * Re-export `http` crate's `Error` type as `error::HttpError`. [#2171]
 * Re-export `StatusCode`, `Method`, `Version` and `Uri` at the crate root. [#2171]
 * Re-export `ContentEncoding` and `ConnectionType` at the crate root. [#2171]
 
 ### Changed
+* The `MessageBody` trait now has an associated `Error` type. [#2183]
 * `header` mod is now public. [#2171]
 * `uri` mod is now public. [#2171]
+* Update `language-tags` to `0.3`.
+* Reduce the level from `error` to `debug` for the log line that is emitted when a `500 Internal Server Error` is built using `HttpResponse::from_error`. [#2196]
 
 ### Removed
 * Stop re-exporting `http` crate's `HeaderMap` types in addition to ours. [#2171]
+* Down-casting for `MessageBody` types. [#2183]
 
 [#2171]: https://github.com/actix/actix-web/pull/2171
+[#2183]: https://github.com/actix/actix-web/pull/2183
+[#2196]: https://github.com/actix/actix-web/pull/2196
 
 
 ## 3.0.0-beta.6 - 2021-04-17

actix-http/Cargo.toml

@@ -57,7 +57,7 @@ h2 = "0.3.1"
 http = "0.2.2"
 httparse = "1.3"
 itoa = "0.4"
-language-tags = "0.2"
+language-tags = "0.3"
 local-channel = "0.1"
 once_cell = "1.5"
 log = "0.4"

actix-http/src/body/body.rs

@@ -1,16 +1,17 @@
 use std::{
     borrow::Cow,
+    error::Error as StdError,
     fmt, mem,
     pin::Pin,
     task::{Context, Poll},
 };
 
 use bytes::{Bytes, BytesMut};
-use futures_core::Stream;
+use futures_core::{ready, Stream};
 
 use crate::error::Error;
 
-use super::{BodySize, BodyStream, MessageBody, SizedStream};
+use super::{BodySize, BodyStream, MessageBody, MessageBodyMapErr, SizedStream};
 
 /// Represents various types of HTTP message body.
 // #[deprecated(since = "4.0.0", note = "Use body types directly.")]
@@ -25,7 +26,7 @@ pub enum Body {
     Bytes(Bytes),
 
     /// Generic message body.
-    Message(Pin<Box<dyn MessageBody>>),
+    Message(BoxAnyBody),
 }
 
 impl Body {
@@ -35,12 +36,18 @@ impl Body {
     }
 
     /// Create body from generic message body.
-    pub fn from_message<B: MessageBody + 'static>(body: B) -> Body {
+    pub fn from_message<B>(body: B) -> Body
-        Body::Message(Box::pin(body))
+    where
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError + 'static>>,
+    {
+        Self::Message(BoxAnyBody::from_body(body))
     }
 }
 
 impl MessageBody for Body {
+    type Error = Error;
+
     fn size(&self) -> BodySize {
         match self {
             Body::None => BodySize::None,
@@ -53,7 +60,7 @@ impl MessageBody for Body {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         match self.get_mut() {
             Body::None => Poll::Ready(None),
             Body::Empty => Poll::Ready(None),
@@ -65,7 +72,13 @@ impl MessageBody for Body {
                     Poll::Ready(Some(Ok(mem::take(bin))))
                 }
             }
-            Body::Message(body) => body.as_mut().poll_next(cx),
+
+            // TODO: MSRV 1.51: poll_map_err
+            Body::Message(body) => match ready!(body.as_pin_mut().poll_next(cx)) {
+                Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
         }
     }
 }
@@ -166,3 +179,51 @@ where
         Body::from_message(s)
     }
 }
+
+/// A boxed message body with boxed errors.
+pub struct BoxAnyBody(Pin<Box<dyn MessageBody<Error = Box<dyn StdError + 'static>>>>);
+
+impl BoxAnyBody {
+    /// Boxes a `MessageBody` and any errors it generates.
+    pub fn from_body<B>(body: B) -> Self
+    where
+        B: MessageBody + 'static,
+        B::Error: Into<Box<dyn StdError + 'static>>,
+    {
+        let body = MessageBodyMapErr::new(body, Into::into);
+        Self(Box::pin(body))
+    }
+
+    /// Returns a mutable pinned reference to the inner message body type.
+    pub fn as_pin_mut(
+        &mut self,
+    ) -> Pin<&mut (dyn MessageBody<Error = Box<dyn StdError + 'static>>)> {
+        self.0.as_mut()
+    }
+}
+
+impl fmt::Debug for BoxAnyBody {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("BoxAnyBody(dyn MessageBody)")
+    }
+}
+
+impl MessageBody for BoxAnyBody {
+    type Error = Error;
+
+    fn size(&self) -> BodySize {
+        self.0.size()
+    }
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        // TODO: MSRV 1.51: poll_map_err
+        match ready!(self.0.as_mut().poll_next(cx)) {
+            Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
+            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+            None => Poll::Ready(None),
+        }
+    }
+}

actix-http/src/body/body_stream.rs

@@ -36,6 +36,8 @@ where
     S: Stream<Item = Result<Bytes, E>>,
     E: Into<Error>,
 {
+    type Error = Error;
+
     fn size(&self) -> BodySize {
         BodySize::Stream
     }
@@ -48,7 +50,7 @@ where
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         loop {
             let stream = self.as_mut().project().stream;
 

actix-http/src/body/message_body.rs

@@ -1,12 +1,15 @@
 //! [`MessageBody`] trait and foreign implementations.
 
 use std::{
+    convert::Infallible,
     mem,
     pin::Pin,
     task::{Context, Poll},
 };
 
 use bytes::{Bytes, BytesMut};
+use futures_core::ready;
+use pin_project_lite::pin_project;
 
 use crate::error::Error;
 
@@ -14,6 +17,8 @@ use super::BodySize;
 
 /// An interface for response bodies.
 pub trait MessageBody {
+    type Error;
+
     /// Body size hint.
     fn size(&self) -> BodySize;
 
@@ -21,14 +26,12 @@ pub trait MessageBody {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>>;
+    ) -> Poll<Option<Result<Bytes, Self::Error>>>;
-
-    downcast_get_type_id!();
 }
 
-downcast!(MessageBody);
-
 impl MessageBody for () {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Empty
     }
@@ -36,12 +39,18 @@ impl MessageBody for () {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         Poll::Ready(None)
     }
 }
 
-impl<T: MessageBody + Unpin> MessageBody for Box<T> {
+impl<B> MessageBody for Box<B>
+where
+    B: MessageBody + Unpin,
+    B::Error: Into<Error>,
+{
+    type Error = B::Error;
+
     fn size(&self) -> BodySize {
         self.as_ref().size()
     }
@@ -49,12 +58,18 @@ impl<T: MessageBody + Unpin> MessageBody for Box<T> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         Pin::new(self.get_mut().as_mut()).poll_next(cx)
     }
 }
 
-impl<T: MessageBody> MessageBody for Pin<Box<T>> {
+impl<B> MessageBody for Pin<Box<B>>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = B::Error;
+
     fn size(&self) -> BodySize {
         self.as_ref().size()
     }
@@ -62,12 +77,14 @@ impl<T: MessageBody> MessageBody for Pin<Box<T>> {
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         self.as_mut().poll_next(cx)
     }
 }
 
 impl MessageBody for Bytes {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -75,7 +92,7 @@ impl MessageBody for Bytes {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -85,6 +102,8 @@ impl MessageBody for Bytes {
 }
 
 impl MessageBody for BytesMut {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -92,7 +111,7 @@ impl MessageBody for BytesMut {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -102,6 +121,8 @@ impl MessageBody for BytesMut {
 }
 
 impl MessageBody for &'static str {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -109,7 +130,7 @@ impl MessageBody for &'static str {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -121,6 +142,8 @@ impl MessageBody for &'static str {
 }
 
 impl MessageBody for Vec<u8> {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -128,7 +151,7 @@ impl MessageBody for Vec<u8> {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -138,6 +161,8 @@ impl MessageBody for Vec<u8> {
 }
 
 impl MessageBody for String {
+    type Error = Infallible;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.len() as u64)
     }
@@ -145,7 +170,7 @@ impl MessageBody for String {
     fn poll_next(
         self: Pin<&mut Self>,
         _: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         if self.is_empty() {
             Poll::Ready(None)
         } else {
@@ -155,3 +180,53 @@ impl MessageBody for String {
         }
     }
 }
+
+pin_project! {
+    pub(crate) struct MessageBodyMapErr<B, F> {
+        #[pin]
+        body: B,
+        mapper: Option<F>,
+    }
+}
+
+impl<B, F, E> MessageBodyMapErr<B, F>
+where
+    B: MessageBody,
+    F: FnOnce(B::Error) -> E,
+{
+    pub(crate) fn new(body: B, mapper: F) -> Self {
+        Self {
+            body,
+            mapper: Some(mapper),
+        }
+    }
+}
+
+impl<B, F, E> MessageBody for MessageBodyMapErr<B, F>
+where
+    B: MessageBody,
+    F: FnOnce(B::Error) -> E,
+{
+    type Error = E;
+
+    fn size(&self) -> BodySize {
+        self.body.size()
+    }
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
+        let this = self.as_mut().project();
+
+        match ready!(this.body.poll_next(cx)) {
+            Some(Err(err)) => {
+                let f = self.as_mut().project().mapper.take().unwrap();
+                let mapped_err = (f)(err);
+                Poll::Ready(Some(Err(mapped_err)))
+            }
+            Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+            None => Poll::Ready(None),
+        }
+    }
+}

actix-http/src/body/mod.rs

@@ -15,9 +15,10 @@ mod response_body;
 mod size;
 mod sized_stream;
 
-pub use self::body::Body;
+pub use self::body::{Body, BoxAnyBody};
 pub use self::body_stream::BodyStream;
 pub use self::message_body::MessageBody;
+pub(crate) use self::message_body::MessageBodyMapErr;
 pub use self::response_body::ResponseBody;
 pub use self::size::BodySize;
 pub use self::sized_stream::SizedStream;
@@ -41,7 +42,7 @@ pub use self::sized_stream::SizedStream;
 /// assert_eq!(bytes, b"123"[..]);
 /// # }
 /// ```
-pub async fn to_bytes(body: impl MessageBody) -> Result<Bytes, crate::Error> {
+pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
     let cap = match body.size() {
         BodySize::None | BodySize::Empty | BodySize::Sized(0) => return Ok(Bytes::new()),
         BodySize::Sized(size) => size as usize,
@@ -237,10 +238,13 @@ mod tests {
         );
     }
 
+    // down-casting used to be done with a method on MessageBody trait
+    // test is kept to demonstrate equivalence of Any trait
     #[actix_rt::test]
     async fn test_body_casting() {
         let mut body = String::from("hello cast");
-        let resp_body: &mut dyn MessageBody = &mut body;
+        // let mut resp_body: &mut dyn MessageBody<Error = Error> = &mut body;
+        let resp_body: &mut dyn std::any::Any = &mut body;
         let body = resp_body.downcast_ref::<String>().unwrap();
         assert_eq!(body, "hello cast");
         let body = &mut resp_body.downcast_mut::<String>().unwrap();

actix-http/src/body/response_body.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use bytes::Bytes;
-use futures_core::Stream;
+use futures_core::{ready, Stream};
 use pin_project::pin_project;
 
 use crate::error::Error;
@@ -43,7 +43,13 @@ impl<B: MessageBody> ResponseBody<B> {
     }
 }
 
-impl<B: MessageBody> MessageBody for ResponseBody<B> {
+impl<B> MessageBody for ResponseBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = Error;
+
     fn size(&self) -> BodySize {
         match self {
             ResponseBody::Body(ref body) => body.size(),
@@ -54,12 +60,16 @@ impl<B: MessageBody> MessageBody for ResponseBody<B> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         Stream::poll_next(self, cx)
     }
 }
 
-impl<B: MessageBody> Stream for ResponseBody<B> {
+impl<B> Stream for ResponseBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
     type Item = Result<Bytes, Error>;
 
     fn poll_next(
@@ -67,7 +77,12 @@ impl<B: MessageBody> Stream for ResponseBody<B> {
         cx: &mut Context<'_>,
     ) -> Poll<Option<Self::Item>> {
         match self.project() {
-            ResponseBodyProj::Body(body) => body.poll_next(cx),
+            // TODO: MSRV 1.51: poll_map_err
+            ResponseBodyProj::Body(body) => match ready!(body.poll_next(cx)) {
+                Some(Err(err)) => Poll::Ready(Some(Err(err.into()))),
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
             ResponseBodyProj::Other(body) => Pin::new(body).poll_next(cx),
         }
     }

actix-http/src/body/sized_stream.rs

@@ -36,6 +36,8 @@ impl<S> MessageBody for SizedStream<S>
 where
     S: Stream<Item = Result<Bytes, Error>>,
 {
+    type Error = Error;
+
     fn size(&self) -> BodySize {
         BodySize::Sized(self.size as u64)
     }
@@ -48,7 +50,7 @@ where
     fn poll_next(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         loop {
             let stream = self.as_mut().project().stream;
 

actix-http/src/builder.rs

@@ -202,11 +202,13 @@ where
     /// Finish service configuration and create a HTTP service for HTTP/2 protocol.
     pub fn h2<F, B>(self, service: F) -> H2Service<T, S, B>
     where
-        B: MessageBody + 'static,
         F: IntoServiceFactory<S, Request>,
         S::Error: Into<Error> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
+
+        B: MessageBody + 'static,
+        B::Error: Into<Error>,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,
@@ -223,11 +225,13 @@ where
     /// Finish service configuration and create `HttpService` instance.
     pub fn finish<F, B>(self, service: F) -> HttpService<T, S, B, X, U>
     where
-        B: MessageBody + 'static,
         F: IntoServiceFactory<S, Request>,
         S::Error: Into<Error> + 'static,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>> + 'static,
+
+        B: MessageBody + 'static,
+        B::Error: Into<Error>,
     {
         let cfg = ServiceConfig::new(
             self.keep_alive,

actix-http/src/client/connection.rs

@@ -12,10 +12,10 @@ use bytes::Bytes;
 use futures_core::future::LocalBoxFuture;
 use h2::client::SendRequest;
 
-use crate::body::MessageBody;
 use crate::h1::ClientCodec;
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
+use crate::{body::MessageBody, Error};
 
 use super::error::SendRequestError;
 use super::pool::Acquired;
@@ -256,8 +256,9 @@ where
         body: RB,
     ) -> LocalBoxFuture<'static, Result<(ResponseHead, Payload), SendRequestError>>
     where
-        RB: MessageBody + 'static,
         H: Into<RequestHeadType> + 'static,
+        RB: MessageBody + 'static,
+        RB::Error: Into<Error>,
     {
         Box::pin(async move {
             match self {

actix-http/src/client/h1proto.rs

@@ -11,7 +11,6 @@ use bytes::{Bytes, BytesMut};
 use futures_core::{ready, Stream};
 use futures_util::SinkExt as _;
 
-use crate::error::PayloadError;
 use crate::h1;
 use crate::http::{
     header::{HeaderMap, IntoHeaderValue, EXPECT, HOST},
@@ -19,6 +18,7 @@ use crate::http::{
 };
 use crate::message::{RequestHeadType, ResponseHead};
 use crate::payload::Payload;
+use crate::{error::PayloadError, Error};
 
 use super::connection::{ConnectionIo, H1Connection};
 use super::error::{ConnectError, SendRequestError};
@@ -32,6 +32,7 @@ pub(crate) async fn send_request<Io, B>(
 where
     Io: ConnectionIo,
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     // set request host header
     if !head.as_ref().headers.contains_key(HOST)
@@ -154,6 +155,7 @@ pub(crate) async fn send_body<Io, B>(
 where
     Io: ConnectionIo,
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     actix_rt::pin!(body);
 
@@ -161,9 +163,10 @@ where
     while !eof {
         while !eof && !framed.as_ref().is_write_buf_full() {
             match poll_fn(|cx| body.as_mut().poll_next(cx)).await {
-                Some(result) => {
+                Some(Ok(chunk)) => {
-                    framed.as_mut().write(h1::Message::Chunk(Some(result?)))?;
+                    framed.as_mut().write(h1::Message::Chunk(Some(chunk)))?;
                 }
+                Some(Err(err)) => return Err(err.into().into()),
                 None => {
                     eof = true;
                     framed.as_mut().write(h1::Message::Chunk(None))?;

actix-http/src/client/h2proto.rs

@@ -9,14 +9,19 @@ use h2::{
 use http::header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING};
 use http::{request::Request, Method, Version};
 
-use crate::body::{BodySize, MessageBody};
+use crate::{
-use crate::header::HeaderMap;
+    body::{BodySize, MessageBody},
-use crate::message::{RequestHeadType, ResponseHead};
+    header::HeaderMap,
-use crate::payload::Payload;
+    message::{RequestHeadType, ResponseHead},
+    payload::Payload,
+    Error,
+};
 
-use super::config::ConnectorConfig;
+use super::{
-use super::connection::{ConnectionIo, H2Connection};
+    config::ConnectorConfig,
-use super::error::SendRequestError;
+    connection::{ConnectionIo, H2Connection},
+    error::SendRequestError,
+};
 
 pub(crate) async fn send_request<Io, B>(
     mut io: H2Connection<Io>,
@@ -26,6 +31,7 @@ pub(crate) async fn send_request<Io, B>(
 where
     Io: ConnectionIo,
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     trace!("Sending client request: {:?} {:?}", head, body.size());
 
@@ -125,10 +131,14 @@ where
     Ok((head, payload))
 }
 
-async fn send_body<B: MessageBody>(
+async fn send_body<B>(
     body: B,
     mut send: SendStream<Bytes>,
-) -> Result<(), SendRequestError> {
+) -> Result<(), SendRequestError>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
     let mut buf = None;
     actix_rt::pin!(body);
     loop {
@@ -138,7 +148,7 @@ async fn send_body<B: MessageBody>(
                     send.reserve_capacity(b.len());
                     buf = Some(b);
                 }
-                Some(Err(e)) => return Err(e.into()),
+                Some(Err(e)) => return Err(e.into().into()),
                 None => {
                     if let Err(e) = send.send_data(Bytes::new(), true) {
                         return Err(e.into());

actix-http/src/encoding/encoder.rs

@@ -1,6 +1,7 @@
 //! Stream encoders.
 
 use std::{
+    error::Error as StdError,
     future::Future,
     io::{self, Write as _},
     pin::Pin,
@@ -10,12 +11,13 @@ use std::{
 use actix_rt::task::{spawn_blocking, JoinHandle};
 use brotli2::write::BrotliEncoder;
 use bytes::Bytes;
+use derive_more::Display;
 use flate2::write::{GzEncoder, ZlibEncoder};
 use futures_core::ready;
 use pin_project::pin_project;
 
 use crate::{
-    body::{Body, BodySize, MessageBody, ResponseBody},
+    body::{Body, BodySize, BoxAnyBody, MessageBody, ResponseBody},
     http::{
         header::{ContentEncoding, CONTENT_ENCODING},
         HeaderValue, StatusCode,
@@ -92,10 +94,16 @@ impl<B: MessageBody> Encoder<B> {
 enum EncoderBody<B> {
     Bytes(Bytes),
     Stream(#[pin] B),
-    BoxedStream(Pin<Box<dyn MessageBody>>),
+    BoxedStream(BoxAnyBody),
 }
 
-impl<B: MessageBody> MessageBody for EncoderBody<B> {
+impl<B> MessageBody for EncoderBody<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = EncoderError<B::Error>;
+
     fn size(&self) -> BodySize {
         match self {
             EncoderBody::Bytes(ref b) => b.size(),
@@ -107,7 +115,7 @@ impl<B: MessageBody> MessageBody for EncoderBody<B> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         match self.project() {
             EncoderBodyProj::Bytes(b) => {
                 if b.is_empty() {
@@ -116,13 +124,32 @@ impl<B: MessageBody> MessageBody for EncoderBody<B> {
                     Poll::Ready(Some(Ok(std::mem::take(b))))
                 }
             }
-            EncoderBodyProj::Stream(b) => b.poll_next(cx),
+            // TODO: MSRV 1.51: poll_map_err
-            EncoderBodyProj::BoxedStream(ref mut b) => b.as_mut().poll_next(cx),
+            EncoderBodyProj::Stream(b) => match ready!(b.poll_next(cx)) {
+                Some(Err(err)) => Poll::Ready(Some(Err(EncoderError::Body(err)))),
+                Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                None => Poll::Ready(None),
+            },
+            EncoderBodyProj::BoxedStream(ref mut b) => {
+                match ready!(b.as_pin_mut().poll_next(cx)) {
+                    Some(Err(err)) => {
+                        Poll::Ready(Some(Err(EncoderError::Boxed(err.into()))))
+                    }
+                    Some(Ok(val)) => Poll::Ready(Some(Ok(val))),
+                    None => Poll::Ready(None),
+                }
+            }
         }
     }
 }
 
-impl<B: MessageBody> MessageBody for Encoder<B> {
+impl<B> MessageBody for Encoder<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = EncoderError<B::Error>;
+
     fn size(&self) -> BodySize {
         if self.encoder.is_none() {
             self.body.size()
@@ -134,7 +161,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         let mut this = self.project();
         loop {
             if *this.eof {
@@ -142,8 +169,9 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
             }
 
             if let Some(ref mut fut) = this.fut {
-                let mut encoder =
+                let mut encoder = ready!(Pin::new(fut).poll(cx))
-                    ready!(Pin::new(fut).poll(cx)).map_err(|_| BlockingError)??;
+                    .map_err(|_| EncoderError::Blocking(BlockingError))?
+                    .map_err(EncoderError::Io)?;
 
                 let chunk = encoder.take();
                 *this.encoder = Some(encoder);
@@ -162,7 +190,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
                 Some(Ok(chunk)) => {
                     if let Some(mut encoder) = this.encoder.take() {
                         if chunk.len() < MAX_CHUNK_SIZE_ENCODE_IN_PLACE {
-                            encoder.write(&chunk)?;
+                            encoder.write(&chunk).map_err(EncoderError::Io)?;
                             let chunk = encoder.take();
                             *this.encoder = Some(encoder);
 
@@ -182,7 +210,7 @@ impl<B: MessageBody> MessageBody for Encoder<B> {
 
                 None => {
                     if let Some(encoder) = this.encoder.take() {
-                        let chunk = encoder.finish()?;
+                        let chunk = encoder.finish().map_err(EncoderError::Io)?;
                         if chunk.is_empty() {
                             return Poll::Ready(None);
                         } else {
@@ -281,3 +309,36 @@ impl ContentEncoder {
         }
     }
 }
+
+#[derive(Debug, Display)]
+#[non_exhaustive]
+pub enum EncoderError<E> {
+    #[display(fmt = "body")]
+    Body(E),
+
+    #[display(fmt = "boxed")]
+    Boxed(Error),
+
+    #[display(fmt = "blocking")]
+    Blocking(BlockingError),
+
+    #[display(fmt = "io")]
+    Io(io::Error),
+}
+
+impl<E: StdError> StdError for EncoderError<E> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        None
+    }
+}
+
+impl<E: Into<Error>> From<EncoderError<E>> for Error {
+    fn from(err: EncoderError<E>) -> Self {
+        match err {
+            EncoderError::Body(err) => err.into(),
+            EncoderError::Boxed(err) => err,
+            EncoderError::Blocking(err) => err.into(),
+            EncoderError::Io(err) => err.into(),
+        }
+    }
+}

actix-http/src/error.rs

@@ -2,6 +2,7 @@
 
 use std::{
     cell::RefCell,
+    error::Error as StdError,
     fmt,
     io::{self, Write as _},
     str::Utf8Error,
@@ -105,8 +106,7 @@ impl From<()> for Error {
 
 impl From<std::convert::Infallible> for Error {
     fn from(_: std::convert::Infallible) -> Self {
-        // `std::convert::Infallible` indicates an error
+        // hint that an error that will never happen
-        // that will never happen
         unreachable!()
     }
 }
@@ -145,6 +145,8 @@ impl From<ResponseBuilder> for Error {
 #[display(fmt = "Unknown Error")]
 struct UnitError;
 
+impl ResponseError for Box<dyn StdError + 'static> {}
+
 /// Returns [`StatusCode::INTERNAL_SERVER_ERROR`] for [`UnitError`].
 impl ResponseError for UnitError {}
 

actix-http/src/h1/dispatcher.rs

@@ -56,9 +56,13 @@ pub struct Dispatcher<T, S, B, X, U>
 where
     S: Service<Request>,
     S::Error: Into<Error>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -74,9 +78,13 @@ enum DispatcherState<T, S, B, X, U>
 where
     S: Service<Request>,
     S::Error: Into<Error>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -89,9 +97,13 @@ struct InnerDispatcher<T, S, B, X, U>
 where
     S: Service<Request>,
     S::Error: Into<Error>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -127,7 +139,9 @@ enum State<S, B, X>
 where
     S: Service<Request>,
     X: Service<Request, Response = Request>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     None,
     ExpectCall(#[pin] X::Future),
@@ -138,8 +152,11 @@ where
 impl<S, B, X> State<S, B, X>
 where
     S: Service<Request>,
+
     X: Service<Request, Response = Request>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     fn is_empty(&self) -> bool {
         matches!(self, State::None)
@@ -155,12 +172,17 @@ enum PollResponse {
 impl<T, S, B, X, U> Dispatcher<T, S, B, X, U>
 where
     T: ActixStream,
+
     S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -211,12 +233,17 @@ where
 impl<T, S, B, X, U> InnerDispatcher<T, S, B, X, U>
 where
     T: ActixStream,
+
     S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -868,12 +895,17 @@ where
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
     T: ActixStream,
+
     S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display,
 {

actix-http/src/h1/service.rs

@@ -64,11 +64,15 @@ where
     S::Error: Into<Error>,
     S::InitError: fmt::Debug,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
+
     U: ServiceFactory<(Request, Framed<TcpStream, Codec>), Config = (), Response = ()>,
     U::Future: 'static,
     U::Error: fmt::Display + Into<Error>,
@@ -109,11 +113,15 @@ mod openssl {
         S::Error: Into<Error>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
+
         B: MessageBody,
+        B::Error: Into<Error>,
+
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
         X::Error: Into<Error>,
         X::InitError: fmt::Debug,
+
         U: ServiceFactory<
             (Request, Framed<TlsStream<TcpStream>, Codec>),
             Config = (),
@@ -165,11 +173,15 @@ mod rustls {
         S::Error: Into<Error>,
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
+
         B: MessageBody,
+        B::Error: Into<Error>,
+
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
         X::Error: Into<Error>,
         X::InitError: fmt::Debug,
+
         U: ServiceFactory<
             (Request, Framed<TlsStream<TcpStream>, Codec>),
             Config = (),
@@ -253,16 +265,21 @@ impl<T, S, B, X, U> ServiceFactory<(T, Option<net::SocketAddr>)>
     for H1Service<T, S, B, X, U>
 where
     T: ActixStream + 'static,
+
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
     S::InitError: fmt::Debug,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
     X::Error: Into<Error>,
     X::InitError: fmt::Debug,
+
     U: ServiceFactory<(Request, Framed<T, Codec>), Config = (), Response = ()>,
     U::Future: 'static,
     U::Error: fmt::Display + Into<Error>,
@@ -319,12 +336,17 @@ impl<T, S, B, X, U> Service<(T, Option<net::SocketAddr>)>
     for HttpServiceHandler<T, S, B, X, U>
 where
     T: ActixStream,
+
     S: Service<Request>,
     S::Error: Into<Error>,
     S::Response: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, Codec>), Response = ()>,
     U::Error: fmt::Display + Into<Error>,
 {

actix-http/src/h1/utils.rs

@@ -22,6 +22,7 @@ pub struct SendResponse<T, B> {
 impl<T, B> SendResponse<T, B>
 where
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     pub fn new(framed: Framed<T, Codec>, response: Response<B>) -> Self {
         let (res, body) = response.into_parts();
@@ -38,6 +39,7 @@ impl<T, B> Future for SendResponse<T, B>
 where
     T: AsyncRead + AsyncWrite + Unpin,
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
 {
     type Output = Result<Framed<T, Codec>, Error>;
 

actix-http/src/h2/dispatcher.rs

@@ -69,11 +69,14 @@ where
 impl<T, S, B, X, U> Future for Dispatcher<T, S, B, X, U>
 where
     T: AsyncRead + AsyncWrite + Unpin,
+
     S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     type Output = Result<(), DispatchError>;
 
@@ -140,7 +143,9 @@ where
     F: Future<Output = Result<I, E>>,
     E: Into<Error>,
     I: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     fn prepare_response(
         &self,
@@ -216,7 +221,9 @@ where
     F: Future<Output = Result<I, E>>,
     E: Into<Error>,
     I: Into<Response<B>>,
+
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     type Output = ();
 

actix-http/src/h2/service.rs

@@ -40,7 +40,9 @@ where
     S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     /// Create new `H2Service` instance with config.
     pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
@@ -69,7 +71,9 @@ where
     S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     /// Create plain TCP based service
     pub fn tcp(
@@ -106,7 +110,9 @@ mod openssl {
         S::Error: Into<Error> + 'static,
         S::Response: Into<Response<B>> + 'static,
         <S::Service as Service<Request>>::Future: 'static,
+
         B: MessageBody + 'static,
+        B::Error: Into<Error>,
     {
         /// Create OpenSSL based service
         pub fn openssl(
@@ -150,7 +156,9 @@ mod rustls {
         S::Error: Into<Error> + 'static,
         S::Response: Into<Response<B>> + 'static,
         <S::Service as Service<Request>>::Future: 'static,
+
         B: MessageBody + 'static,
+        B::Error: Into<Error>,
     {
         /// Create Rustls based service
         pub fn rustls(
@@ -185,12 +193,15 @@ mod rustls {
 impl<T, S, B> ServiceFactory<(T, Option<net::SocketAddr>)> for H2Service<T, S, B>
 where
     T: AsyncRead + AsyncWrite + Unpin + 'static,
+
     S: ServiceFactory<Request, Config = ()>,
     S::Future: 'static,
     S::Error: Into<Error> + 'static,
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     type Response = ();
     type Error = DispatchError;
@@ -252,6 +263,7 @@ where
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     type Response = ();
     type Error = DispatchError;
@@ -316,6 +328,7 @@ where
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
     B: MessageBody,
+    B::Error: Into<Error>,
 {
     type Output = Result<(), DispatchError>;
 

actix-http/src/macros.rs

@@ -15,8 +15,15 @@ macro_rules! downcast_get_type_id {
         /// making it impossible for safe code to construct outside of
         /// this module. This ensures that safe code cannot violate
         /// type-safety by implementing this method.
+        ///
+        /// We also take `PrivateHelper` as a parameter, to ensure that
+        /// safe code cannot obtain a `PrivateHelper` instance by
+        /// delegating to an existing implementation of `__private_get_type_id__`
         #[doc(hidden)]
-        fn __private_get_type_id__(&self) -> (std::any::TypeId, PrivateHelper)
+        fn __private_get_type_id__(
+            &self,
+            _: PrivateHelper,
+        ) -> (std::any::TypeId, PrivateHelper)
         where
             Self: 'static,
         {
@@ -39,7 +46,9 @@ macro_rules! downcast {
         impl dyn $name + 'static {
             /// Downcasts generic body to a specific type.
             pub fn downcast_ref<T: $name + 'static>(&self) -> Option<&T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
+                if self.__private_get_type_id__(PrivateHelper(())).0
+                    == std::any::TypeId::of::<T>()
+                {
                     // SAFETY: external crates cannot override the default
                     // implementation of `__private_get_type_id__`, since
                     // it requires returning a private type. We can therefore
@@ -53,7 +62,9 @@ macro_rules! downcast {
 
             /// Downcasts a generic body to a mutable specific type.
             pub fn downcast_mut<T: $name + 'static>(&mut self) -> Option<&mut T> {
-                if self.__private_get_type_id__().0 == std::any::TypeId::of::<T>() {
+                if self.__private_get_type_id__(PrivateHelper(())).0
+                    == std::any::TypeId::of::<T>()
+                {
                     // SAFETY: external crates cannot override the default
                     // implementation of `__private_get_type_id__`, since
                     // it requires returning a private type. We can therefore

actix-http/src/response.rs

@@ -78,7 +78,7 @@ impl Response<Body> {
     pub fn from_error(error: Error) -> Response<Body> {
         let mut resp = error.as_response_error().error_response();
         if resp.head.status == StatusCode::INTERNAL_SERVER_ERROR {
-            error!("Internal Server Error: {:?}", error);
+            debug!("Internal Server Error: {:?}", error);
         }
         resp.error = Some(error);
         resp
@@ -242,7 +242,11 @@ impl<B> Response<B> {
     }
 }
 
-impl<B: MessageBody> fmt::Debug for Response<B> {
+impl<B> fmt::Debug for Response<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let res = writeln!(
             f,

actix-http/src/service.rs

@@ -59,6 +59,7 @@ where
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     /// Create new `HttpService` instance.
     pub fn new<F: IntoServiceFactory<S, Request>>(service: F) -> Self {
@@ -157,6 +158,7 @@ where
     <S::Service as Service<Request>>::Future: 'static,
 
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
@@ -208,6 +210,7 @@ mod openssl {
         <S::Service as Service<Request>>::Future: 'static,
 
         B: MessageBody + 'static,
+        B::Error: Into<Error>,
 
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
@@ -275,6 +278,7 @@ mod rustls {
         <S::Service as Service<Request>>::Future: 'static,
 
         B: MessageBody + 'static,
+        B::Error: Into<Error>,
 
         X: ServiceFactory<Request, Config = (), Response = Request>,
         X::Future: 'static,
@@ -338,6 +342,7 @@ where
     <S::Service as Service<Request>>::Future: 'static,
 
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 
     X: ServiceFactory<Request, Config = (), Response = Request>,
     X::Future: 'static,
@@ -464,13 +469,18 @@ impl<T, S, B, X, U> Service<(T, Protocol, Option<net::SocketAddr>)>
     for HttpServiceHandler<T, S, B, X, U>
 where
     T: ActixStream,
+
     S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
+
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display + Into<Error>,
 {
@@ -521,13 +531,18 @@ where
 #[pin_project(project = StateProj)]
 enum State<T, S, B, X, U>
 where
+    T: ActixStream,
+
     S: Service<Request>,
     S::Future: 'static,
     S::Error: Into<Error>,
-    T: ActixStream,
+
     B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -548,13 +563,18 @@ where
 pub struct HttpServiceHandlerResponse<T, S, B, X, U>
 where
     T: ActixStream,
+
     S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
-    B: MessageBody + 'static,
+
+    B: MessageBody,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {
@@ -565,13 +585,18 @@ where
 impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, S, B, X, U>
 where
     T: ActixStream,
+
     S: Service<Request>,
     S::Error: Into<Error> + 'static,
     S::Future: 'static,
     S::Response: Into<Response<B>> + 'static,
-    B: MessageBody,
+
+    B: MessageBody + 'static,
+    B::Error: Into<Error>,
+
     X: Service<Request, Response = Request>,
     X::Error: Into<Error>,
+
     U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
     U::Error: fmt::Display,
 {

actix-test/src/lib.rs

@@ -86,6 +86,7 @@ where
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     start_with(TestServerConfig::default(), factory)
 }
@@ -125,6 +126,7 @@ where
     S::Response: Into<Response<B>> + 'static,
     <S::Service as Service<Request>>::Future: 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     let (tx, rx) = mpsc::channel();
 

src/guard.rs

@@ -26,6 +26,8 @@
 //! ```
 #![allow(non_snake_case)]
 use std::convert::TryFrom;
+use std::ops::Deref;
+use std::rc::Rc;
 
 use actix_http::http::{self, header, uri::Uri};
 use actix_http::RequestHead;
@@ -40,6 +42,12 @@ pub trait Guard {
     fn check(&self, request: &RequestHead) -> bool;
 }
 
+impl Guard for Rc<dyn Guard> {
+    fn check(&self, request: &RequestHead) -> bool {
+        self.deref().check(request)
+    }
+}
+
 /// Create guard object for supplied function.
 ///
 /// ```

src/http/header/accept_language.rs

@@ -24,14 +24,11 @@ crate::__define_common_header! {
     /// # Examples
     ///
     /// ```
-    /// use language_tags::langtag;
     /// use actix_web::HttpResponse;
     /// use actix_web::http::header::{AcceptLanguage, LanguageTag, qitem};
     ///
     /// let mut builder = HttpResponse::Ok();
-    /// let mut langtag: LanguageTag = Default::default();
+    /// let langtag = LanguageTag::parse("en-US").unwrap();
-    /// langtag.language = Some("en".to_owned());
-    /// langtag.region = Some("US".to_owned());
     /// builder.insert_header(
     ///     AcceptLanguage(vec![
     ///         qitem(langtag),
@@ -40,16 +37,15 @@ crate::__define_common_header! {
     /// ```
     ///
     /// ```
-    /// use language_tags::langtag;
     /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{AcceptLanguage, QualityItem, q, qitem};
+    /// use actix_web::http::header::{AcceptLanguage, LanguageTag, QualityItem, q, qitem};
     ///
     /// let mut builder = HttpResponse::Ok();
     /// builder.insert_header(
     ///     AcceptLanguage(vec![
-    ///         qitem(langtag!(da)),
+    ///         qitem(LanguageTag::parse("da").unwrap()),
-    ///         QualityItem::new(langtag!(en;;;GB), q(800)),
+    ///         QualityItem::new(LanguageTag::parse("en-GB").unwrap(), q(800)),
-    ///         QualityItem::new(langtag!(en), q(700)),
+    ///         QualityItem::new(LanguageTag::parse("en").unwrap(), q(700)),
     ///     ])
     /// );
     /// ```

src/http/header/content_language.rs

@@ -24,28 +24,26 @@ crate::__define_common_header! {
     /// # Examples
     ///
     /// ```
-    /// use language_tags::langtag;
     /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{ContentLanguage, qitem};
+    /// use actix_web::http::header::{ContentLanguage, LanguageTag, qitem};
     ///
     /// let mut builder = HttpResponse::Ok();
     /// builder.insert_header(
     ///     ContentLanguage(vec![
-    ///         qitem(langtag!(en)),
+    ///         qitem(LanguageTag::parse("en").unwrap()),
     ///     ])
     /// );
     /// ```
     ///
     /// ```
-    /// use language_tags::langtag;
     /// use actix_web::HttpResponse;
-    /// use actix_web::http::header::{ContentLanguage, qitem};
+    /// use actix_web::http::header::{ContentLanguage, LanguageTag, qitem};
     ///
     /// let mut builder = HttpResponse::Ok();
     /// builder.insert_header(
     ///     ContentLanguage(vec![
-    ///         qitem(langtag!(da)),
+    ///         qitem(LanguageTag::parse("da").unwrap()),
-    ///         qitem(langtag!(en;;;GB)),
+    ///         qitem(LanguageTag::parse("en-GB").unwrap()),
     ///     ])
     /// );
     /// ```

src/middleware/compat.rs

@@ -113,7 +113,11 @@ pub trait MapServiceResponseBody {
     fn map_body(self) -> ServiceResponse;
 }
 
-impl<B: MessageBody + Unpin + 'static> MapServiceResponseBody for ServiceResponse<B> {
+impl<B> MapServiceResponseBody for ServiceResponse<B>
+where
+    B: MessageBody + Unpin + 'static,
+    B::Error: Into<Error>,
+{
     fn map_body(self) -> ServiceResponse {
         self.map_body(|_, body| ResponseBody::Other(Body::from_message(body)))
     }

src/middleware/logger.rs

@@ -22,10 +22,9 @@ use time::OffsetDateTime;
 
 use crate::{
     dev::{BodySize, MessageBody, ResponseBody},
-    error::{Error, Result},
     http::{HeaderName, StatusCode},
     service::{ServiceRequest, ServiceResponse},
-    HttpResponse,
+    Error, HttpResponse, Result,
 };
 
 /// Middleware for logging request and response summaries to the terminal.
@@ -327,7 +326,13 @@ impl<B> PinnedDrop for StreamLog<B> {
     }
 }
 
-impl<B: MessageBody> MessageBody for StreamLog<B> {
+impl<B> MessageBody for StreamLog<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
+    type Error = Error;
+
     fn size(&self) -> BodySize {
         self.body.size()
     }
@@ -335,7 +340,7 @@ impl<B: MessageBody> MessageBody for StreamLog<B> {
     fn poll_next(
         self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<Option<Result<Bytes, Error>>> {
+    ) -> Poll<Option<Result<Bytes, Self::Error>>> {
         let this = self.project();
         match this.body.poll_next(cx) {
             Poll::Ready(Some(Ok(chunk))) => {

src/response/response.rs

@@ -243,7 +243,11 @@ impl<B> HttpResponse<B> {
     }
 }
 
-impl<B: MessageBody> fmt::Debug for HttpResponse<B> {
+impl<B> fmt::Debug for HttpResponse<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("HttpResponse")
             .field("error", &self.error)

src/server.rs

@@ -81,6 +81,7 @@ where
     S::Service: 'static,
     // S::Service: 'static,
     B: MessageBody + 'static,
+    B::Error: Into<Error>,
 {
     /// Create new HTTP server with application factory
     pub fn new(factory: F) -> Self {

src/service.rs

@@ -443,7 +443,11 @@ impl<B> From<ServiceResponse<B>> for Response<B> {
     }
 }
 
-impl<B: MessageBody> fmt::Debug for ServiceResponse<B> {
+impl<B> fmt::Debug for ServiceResponse<B>
+where
+    B: MessageBody,
+    B::Error: Into<Error>,
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let res = writeln!(
             f,

src/test.rs

@@ -151,6 +151,7 @@ pub async fn read_response<S, B>(app: &S, req: Request) -> Bytes
 where
     S: Service<Request, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
 {
     let mut resp = app
         .call(req)
@@ -196,6 +197,7 @@ where
 pub async fn read_body<B>(mut res: ServiceResponse<B>) -> Bytes
 where
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
 {
     let mut body = res.take_body();
     let mut bytes = BytesMut::new();
@@ -245,6 +247,7 @@ where
 pub async fn read_body_json<T, B>(res: ServiceResponse<B>) -> T
 where
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
     T: DeserializeOwned,
 {
     let body = read_body(res).await;
@@ -306,6 +309,7 @@ pub async fn read_response_json<S, B, T>(app: &S, req: Request) -> T
 where
     S: Service<Request, Response = ServiceResponse<B>, Error = Error>,
     B: MessageBody + Unpin,
+    B::Error: Into<Error>,
     T: DeserializeOwned,
 {
     let body = read_response(app, req).await;

src/types/either.rs

@@ -1,8 +1,14 @@
 //! For either helper, see [`Either`].
 
+use std::{
+    future::Future,
+    mem,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
 use bytes::Bytes;
-use futures_core::future::LocalBoxFuture;
+use futures_core::ready;
-use futures_util::{FutureExt as _, TryFutureExt as _};
 
 use crate::{
     dev,
@@ -180,41 +186,111 @@ where
     R: FromRequest + 'static,
 {
     type Error = EitherExtractError<L::Error, R::Error>;
-    type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;
+    type Future = EitherExtractFut<L, R>;
     type Config = ();
 
     fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::Future {
-        let req2 = req.clone();
+        EitherExtractFut {
-
+            req: req.clone(),
-        Bytes::from_request(req, payload)
+            state: EitherExtractState::Bytes {
-            .map_err(EitherExtractError::Bytes)
+                bytes: Bytes::from_request(req, payload),
-            .and_then(|bytes| bytes_to_l_or_r(req2, bytes))
+            },
-            .boxed_local()
+        }
     }
 }
 
-async fn bytes_to_l_or_r<L, R>(
+#[pin_project::pin_project]
-    req: HttpRequest,
+pub struct EitherExtractFut<L, R>
-    bytes: Bytes,
-) -> Result<Either<L, R>, EitherExtractError<L::Error, R::Error>>
 where
-    L: FromRequest + 'static,
+    R: FromRequest,
-    R: FromRequest + 'static,
+    L: FromRequest,
 {
-    let fallback = bytes.clone();
+    req: HttpRequest,
-    let a_err;
+    #[pin]
+    state: EitherExtractState<L, R>,
+}
 
-    let mut pl = payload_from_bytes(bytes);
+#[pin_project::pin_project(project = EitherExtractProj)]
-    match L::from_request(&req, &mut pl).await {
+pub enum EitherExtractState<L, R>
-        Ok(a_data) => return Ok(Either::Left(a_data)),
+where
-        // store A's error for returning if B also fails
+    L: FromRequest,
-        Err(err) => a_err = err,
+    R: FromRequest,
-    };
+{
+    Bytes {
+        #[pin]
+        bytes: <Bytes as FromRequest>::Future,
+    },
+    Left {
+        #[pin]
+        left: L::Future,
+        fallback: Bytes,
+    },
+    Right {
+        #[pin]
+        right: R::Future,
+        left_err: Option<L::Error>,
+    },
+}
 
-    let mut pl = payload_from_bytes(fallback);
+impl<R, RF, RE, L, LF, LE> Future for EitherExtractFut<L, R>
-    match R::from_request(&req, &mut pl).await {
+where
-        Ok(b_data) => return Ok(Either::Right(b_data)),
+    L: FromRequest<Future = LF, Error = LE>,
-        Err(b_err) => Err(EitherExtractError::Extract(a_err, b_err)),
+    R: FromRequest<Future = RF, Error = RE>,
+    LF: Future<Output = Result<L, LE>> + 'static,
+    RF: Future<Output = Result<R, RE>> + 'static,
+    LE: Into<Error>,
+    RE: Into<Error>,
+{
+    type Output = Result<Either<L, R>, EitherExtractError<LE, RE>>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+        let ready = loop {
+            let next = match this.state.as_mut().project() {
+                EitherExtractProj::Bytes { bytes } => {
+                    let res = ready!(bytes.poll(cx));
+                    match res {
+                        Ok(bytes) => {
+                            let fallback = bytes.clone();
+                            let left =
+                                L::from_request(&this.req, &mut payload_from_bytes(bytes));
+                            EitherExtractState::Left { left, fallback }
+                        }
+                        Err(err) => break Err(EitherExtractError::Bytes(err)),
+                    }
+                }
+                EitherExtractProj::Left { left, fallback } => {
+                    let res = ready!(left.poll(cx));
+                    match res {
+                        Ok(extracted) => break Ok(Either::Left(extracted)),
+                        Err(left_err) => {
+                            let right = R::from_request(
+                                &this.req,
+                                &mut payload_from_bytes(mem::take(fallback)),
+                            );
+                            EitherExtractState::Right {
+                                left_err: Some(left_err),
+                                right,
+                            }
+                        }
+                    }
+                }
+                EitherExtractProj::Right { right, left_err } => {
+                    let res = ready!(right.poll(cx));
+                    match res {
+                        Ok(data) => break Ok(Either::Right(data)),
+                        Err(err) => {
+                            break Err(EitherExtractError::Extract(
+                                left_err.take().unwrap(),
+                                err,
+                            ));
+                        }
+                    }
+                }
+            };
+            this.state.set(next);
+        };
+        Poll::Ready(ready)
     }
 }
 

src/types/form.rs

@@ -12,7 +12,7 @@ use std::{
 use actix_http::Payload;
 use bytes::BytesMut;
 use encoding_rs::{Encoding, UTF_8};
-use futures_core::future::LocalBoxFuture;
+use futures_core::{future::LocalBoxFuture, ready};
 use futures_util::{FutureExt as _, StreamExt as _};
 use serde::{de::DeserializeOwned, Serialize};
 
@@ -123,11 +123,10 @@ where
 {
     type Config = FormConfig;
     type Error = Error;
-    type Future = LocalBoxFuture<'static, Result<Self, Error>>;
+    type Future = FormExtractFut<T>;
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
-        let req2 = req.clone();
         let (limit, err_handler) = req
             .app_data::<Self::Config>()
             .or_else(|| {
@@ -137,16 +136,42 @@ where
             .map(|c| (c.limit, c.err_handler.clone()))
             .unwrap_or((16384, None));
 
-        UrlEncoded::new(req, payload)
+        FormExtractFut {
-            .limit(limit)
+            fut: UrlEncoded::new(req, payload).limit(limit),
-            .map(move |res| match res {
+            req: req.clone(),
-                Err(err) => match err_handler {
+            err_handler,
-                    Some(err_handler) => Err((err_handler)(err, &req2)),
+        }
-                    None => Err(err.into()),
+    }
-                },
+}
-                Ok(item) => Ok(Form(item)),
+
-            })
+type FormErrHandler = Option<Rc<dyn Fn(UrlencodedError, &HttpRequest) -> Error>>;
-            .boxed_local()
+
+pub struct FormExtractFut<T> {
+    fut: UrlEncoded<T>,
+    err_handler: FormErrHandler,
+    req: HttpRequest,
+}
+
+impl<T> Future for FormExtractFut<T>
+where
+    T: DeserializeOwned + 'static,
+{
+    type Output = Result<Form<T>, Error>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.get_mut();
+
+        let res = ready!(Pin::new(&mut this.fut).poll(cx));
+
+        let res = match res {
+            Err(err) => match &this.err_handler {
+                Some(err_handler) => Err((err_handler)(err, &this.req)),
+                None => Err(err.into()),
+            },
+            Ok(item) => Ok(Form(item)),
+        };
+
+        Poll::Ready(res)
     }
 }
 
@@ -193,7 +218,7 @@ impl<T: Serialize> Responder for Form<T> {
 #[derive(Clone)]
 pub struct FormConfig {
     limit: usize,
-    err_handler: Option<Rc<dyn Fn(UrlencodedError, &HttpRequest) -> Error>>,
+    err_handler: FormErrHandler,
 }
 
 impl FormConfig {