Struct axum::extract::ContentLengthLimit

pub struct ContentLengthLimit<T, const N: u64>(pub T);

Extractor that will reject requests with a body larger than some size.

GET, HEAD, and OPTIONS requests are rejected if they have a Content-Length header, otherwise they’re accepted without the body being checked.

Note: ContentLengthLimit can wrap types that extract the body (for example, Form or Json) if that is the case, the inner type will consume the request’s body, which means the ContentLengthLimit must come last if the handler uses several extractors. See “the order of extractors”

Example

use axum::{
    extract::ContentLengthLimit,
    routing::post,
    Router,
};

async fn handler(body: ContentLengthLimit<String, 1024>) {
    // ...
}

let app = Router::new().route("/", post(handler));

This requires the request to have a Content-Length header.

If you want to limit the size of request bodies without requiring a Content-Length header, consider using tower_http::limit::RequestBodyLimitLayer.

Tuple Fields

0: T

Trait Implementations

impl<T: Clone, const N: u64> Clone for ContentLengthLimit<T, N>

fn clone(&self) -> ContentLengthLimit<T, N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, const N: u64> Debug for ContentLengthLimit<T, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, const N: u64> Deref for ContentLengthLimit<T, N>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, S, B, const N: u64> FromRequest<S, B, ViaRequest> for ContentLengthLimit<T, N>where
    T: FromRequest<S, B>,
    T::Rejection: IntoResponse,
    B: Send + 'static,
    S: Send + Sync,

type Rejection = ContentLengthLimitRejection<<T as FromRequest<S, B, ViaRequest>>::Rejection>

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request<'life0, 'async_trait>(
    req: Request<B>,
    state: &'life0 S
) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    Self: 'async_trait,

Perform the extraction.

impl<T, S, const N: u64> FromRequestParts<S> for ContentLengthLimit<T, N>where
    T: FromRequestParts<S>,
    T::Rejection: IntoResponse,
    S: Send + Sync,

type Rejection = ContentLengthLimitRejection<<T as FromRequestParts<S>>::Rejection>

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

fn from_request_parts<'life0, 'life1, 'async_trait>(
    parts: &'life0 mut Parts,
    state: &'life1 S
) -> Pin<Box<dyn Future<Output = Result<Self, Self::Rejection>> + Send + 'async_trait>>where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait,

Perform the extraction.