Add RequestExt::with_limited_body

… and use it for Multipart extraction.

Author: jplatte

axum-core/src/ext_traits/request.rs

@@ -50,6 +50,11 @@ pub trait RequestExt<B>: sealed::Sealed<B> + Sized {
         E: FromRequestParts<S> + 'static,
         S: Send + Sync;
 
+    /// Apply the [default body limit](crate::extract::DefaultBodyLimit).
+    ///
+    /// If it is disabled, return the request as-is in `Err`.
+    fn with_limited_body(self) -> Result<Request<Limited<B>>, Request<B>>;
+
     /// Consumes the request, returning the body wrapped in [`Limited`] if a
     /// [default limit](crate::extract::DefaultBodyLimit) is in place, or not wrapped if the
     /// default limit is disabled.
@@ -112,19 +117,25 @@ where
         })
     }
 
-    fn into_limited_body(self) -> Result<Limited<B>, B> {
+    fn with_limited_body(self) -> Result<Request<Limited<B>>, Request<B>> {
         // update docs in `axum-core/src/extract/default_body_limit.rs` and
         // `axum/src/docs/extract.md` if this changes
         const DEFAULT_LIMIT: usize = 2_097_152; // 2 mb
 
         match self.extensions().get::<DefaultBodyLimitKind>().copied() {
-            Some(DefaultBodyLimitKind::Disable) => Err(self.into_body()),
+            Some(DefaultBodyLimitKind::Disable) => Err(self),
             Some(DefaultBodyLimitKind::Limit(limit)) => {
-                Ok(http_body::Limited::new(self.into_body(), limit))
+                Ok(self.map(|b| http_body::Limited::new(b, limit)))
             }
-            None => Ok(http_body::Limited::new(self.into_body(), DEFAULT_LIMIT)),
+            None => Ok(self.map(|b| http_body::Limited::new(b, DEFAULT_LIMIT))),
         }
     }
+
+    fn into_limited_body(self) -> Result<Limited<B>, B> {
+        self.with_limited_body()
+            .map(Request::into_body)
+            .map_err(Request::into_body)
+    }
 }
 
 #[cfg(test)]

axum/CHANGELOG.md

@@ -40,6 +40,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   you likely need to re-enable the `tokio` feature ([#1382])
 - **breaking:** `handler::{WithState, IntoService}` are merged into one type,
   named `HandlerService` ([#1418])
+- **changed:** The default body limit now applies to the `Multipart` extractor
 
 [#1368]: https://github.com/tokio-rs/axum/pull/1368
 [#1371]: https://github.com/tokio-rs/axum/pull/1371

axum/src/extract/multipart.rs

@@ -6,6 +6,7 @@ use super::{BodyStream, FromRequest};
 use crate::body::{Bytes, HttpBody};
 use crate::BoxError;
 use async_trait::async_trait;
+use axum_core::RequestExt;
 use futures_util::stream::Stream;
 use http::header::{HeaderMap, CONTENT_TYPE};
 use http::Request;
@@ -47,10 +48,6 @@ use std::{
 /// # axum::Server::bind(&"".parse().unwrap()).serve(app.into_make_service()).await.unwrap();
 /// # };
 /// ```
-///
-/// For security reasons it's recommended to combine this with
-/// [`RequestBodyLimitLayer`](tower_http::limit::RequestBodyLimitLayer)
-/// to limit the size of the request payload.
 #[cfg_attr(docsrs, doc(cfg(feature = "multipart")))]
 #[derive(Debug)]
 pub struct Multipart {
@@ -69,10 +66,11 @@ where
 
     async fn from_request(req: Request<B>, state: &S) -> Result<Self, Self::Rejection> {
         let boundary = parse_boundary(req.headers()).ok_or(InvalidBoundary)?;
-        let stream = match BodyStream::from_request(req, state).await {
-            Ok(stream) => stream,
-            Err(err) => match err {},
+        let stream_result = match req.with_limited_body() {
+            Ok(limited) => BodyStream::from_request(limited, state).await,
+            Err(unlimited) => BodyStream::from_request(unlimited, state).await,
         };
+        let stream = stream_result.unwrap_or_else(|err| match err {});
         let multipart = multer::Multipart::new(stream, boundary);
         Ok(Self { inner: multipart })
     }