actix-web: limit upload file size - rust

Question

I successfully uploaded the file referring to this example, but I don't know how to limit the size of the file, for example I can't save the file more than 5M
[dependencies]
actix-web = "4"
actix-multipart = "0.4"
I tried this, but it didn't work.
web::resource("/upload_file")
.app_data(web::PayloadConfig::new(1024 * 5))
.route(web::post().to(views::save_file)),

Answer 1

middleware
It is used in all requests by default, and can be used in a specified route using req.path()
use actix_web::Error;
use std::future::{ready, Ready};
use actix_web::dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform};
use futures_util::future::LocalBoxFuture;
pub struct ContentLengthLimit {
pub limit: u64, // byte
}
impl<S, B> Transform<S, ServiceRequest> for ContentLengthLimit
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S::Future: 'static,
B: 'static,
{
type Response = ServiceResponse<B>;
type Error = Error;
type InitError = ();
type Transform = ContentLengthLimitMiddleware<S>;
type Future = Ready<Result<Self::Transform, Self::InitError>>;
fn new_transform(&self, service: S) -> Self::Future {
ready(Ok(ContentLengthLimitMiddleware {
service,
limit: self.limit,
}))
}
}
impl Default for ContentLengthLimit {
fn default() -> Self {
Self {
limit: 1024 * 1024 * 5, /* 5M */
}
}
}
pub struct ContentLengthLimitMiddleware<S> {
service: S,
limit: u64,
}
impl<S, B> ContentLengthLimitMiddleware<S>
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S::Future: 'static,
B: 'static,
{
fn is_big(&self, req: &ServiceRequest) -> Result<bool, ()> {
Ok(req
.headers()
.get("content-length")
.ok_or(())?
.to_str()
.map_err(|_| ())?
.parse::<u64>()
.map_err(|_| ())?
> self.limit)
}
}
impl<S, B> Service<ServiceRequest> for ContentLengthLimitMiddleware<S>
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
S::Future: 'static,
B: 'static,
{
type Response = ServiceResponse<B>;
type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
forward_ready!(service);
fn call(&self, req: ServiceRequest) -> Self::Future {
if let Ok(r) = self.is_big(&req) {
if r {
return Box::pin(async { Err(hje("error").actix()) });
}
}
let fut = self.service.call(req);
Box::pin(async move {
let res = fut.await?;
Ok(res)
})
}
}
use
App::new().wrap(ContentLengthLimit::default())

Answer 2

This posted answer refers to the multipart upload example within Actix. Currently, due to:
https://github.com/actix/actix-web/issues/2695
It's necessary to drain the payload before returning an error, or the connection may hang or the thread may panic. Here an example that will drain the payload first, prior to returning a PayloadTooLarge error. That may not be necessary once the aforementioned is resolved:
lazy_static! {
pub static ref MAX_ALLOWED_CONTENT_LENGTH: u64 =
settings::get_setting("service_max_content_length")
.unwrap_or("20971520".to_owned())
.parse::<u64>()
.unwrap_or(20971520);
}
#[derive(Debug)]
pub struct ContentLengthChecker;
impl<S, B> Transform<S, ServiceRequest> for ContentLengthChecker
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
S::Future: 'static,
B: 'static,
{
type Response = ServiceResponse<EitherBody<B>>;
type Error = Error;
type Transform = ContentLengthCheckerMiddleware<S>;
type InitError = ();
type Future = Ready<Result<Self::Transform, Self::InitError>>;
fn new_transform(&self, service: S) -> Self::Future {
ok(ContentLengthCheckerMiddleware {
service: Rc::new(service),
})
}
}
#[derive(Debug)]
pub struct ContentLengthCheckerMiddleware<S> {
service: Rc<S>,
}
impl<S, B> Service<ServiceRequest> for ContentLengthCheckerMiddleware<S>
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
S::Future: 'static,
B: 'static,
{
type Response = ServiceResponse<EitherBody<B>>;
type Error = Error;
type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
forward_ready!(service);
fn call(&self, mut req: ServiceRequest) -> Self::Future {
let service = Rc::clone(&self.service);
let content_length = match req.headers().get("content-length") {
None => 0,
Some(content_length) => MiddlewareUtility::get_content_length(Some(content_length)),
};
if content_length <= *MAX_ALLOWED_CONTENT_LENGTH {
return Box::pin(async move {
service
.call(req)
.await
.map(ServiceResponse::map_into_left_body)
});
}
Box::pin(async move {
/* need to drain the body due to
https://github.com/actix/actix-web/issues/2695
*/
let mut payload = req.take_payload();
while let Ok(Some(_)) = payload.try_next().await {}
Ok(req.into_response(
HttpResponse::new(StatusCode::PAYLOAD_TOO_LARGE).map_into_right_body(),
))
})
}
}