Struct rocket::data::Limits [−][src]
pub struct Limits { /* fields omitted */ }
Expand description
Mapping from (hierarchical) data types to size limits.
A Limits
structure contains a mapping from a given hierarchical data type
(“form”, “data-form”, “ext/pdf”, and so on) to the maximum size in bytes
that should be accepted by Rocket for said data type. For instance, if the
limit for “form” is set to 256
, only 256 bytes from an incoming non-data
form (that is, url-encoded) will be accepted.
To help in preventing DoS attacks, all incoming data reads must capped by a
limit. As such, all data guards impose a limit. The name of the limit is
dictated by the data guard or type itself. For instance, Form
imposes
the form
limit for value-based forms and data-form
limit for data-based
forms.
If a limit is exceeded, a guard will typically fail. The Capped
type
allows retrieving some data types even when the limit is exceeded.
Hierarchy
Data limits are hierarchical. The /
(forward slash) character delimits the
levels, or layers, of a given limit. To obtain a limit value for a given
name, layers are peeled from right to left until a match is found, if any.
For example, fetching the limit named pet/dog/bingo
will return the first
of pet/dog/bingo
, pet/dog
or pet
:
use rocket::data::{Limits, ToByteUnit}; let limits = Limits::default() .limit("pet", 64.kibibytes()) .limit("pet/dog", 128.kibibytes()) .limit("pet/dog/bingo", 96.kibibytes()); assert_eq!(limits.get("pet/dog/bingo"), Some(96.kibibytes())); assert_eq!(limits.get("pet/dog/ralph"), Some(128.kibibytes())); assert_eq!(limits.get("pet/cat/bingo"), Some(64.kibibytes())); assert_eq!(limits.get("pet/dog/bingo/hat"), Some(96.kibibytes()));
Built-in Limits
The following table details recognized built-in limits used by Rocket.
Limit Name | Default | Type | Description |
---|---|---|---|
form | 32KiB | Form | entire non-data-based form |
data-form | 2MiB | Form | entire data-based form |
file | 1MiB | TempFile | TempFile data guard or form field |
file/$ext | N/A | TempFile | file form field with extension $ext |
string | 8KiB | String | data guard or data form field |
bytes | 8KiB | Vec<u8> | data guard |
json | 1MiB | Json | JSON data and form payloads |
msgpack | 1MiB | MsgPack | MessagePack data and form payloads |
Usage
A Limits
structure is created following the builder pattern:
use rocket::data::{Limits, ToByteUnit}; // Set a limit of 64KiB for forms, 3MiB for PDFs, and 1MiB for JSON. let limits = Limits::default() .limit("form", 64.kibibytes()) .limit("file/pdf", 3.mebibytes()) .limit("json", 2.mebibytes());
The Limits::default()
method populates the Limits
structure with default limits in the table above. A
configured limit can be retrieved via the &Limits
request guard:
use std::io; use rocket::data::{Data, Limits, ToByteUnit}; #[post("/echo", data = "<data>")] async fn echo(data: Data<'_>, limits: &Limits) -> io::Result<String> { let limit = limits.get("data").unwrap_or(1.mebibytes()); Ok(data.open(limit).into_string().await?.value) }
…or via the Request::limits()
method:
use rocket::request::Request; use rocket::data::{self, Data, FromData}; #[rocket::async_trait] impl<'r> FromData<'r> for MyType { type Error = MyError; async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> data::Outcome<'r, Self> { let limit = req.limits().get("my-data-type"); /* .. */ } }
Implementations
Default limit for MessagePack payloads.
Construct a new Limits
structure with no limits set.
Example
use rocket::data::{Limits, ToByteUnit}; let limits = Limits::default(); assert_eq!(limits.get("form"), Some(32.kibibytes())); let limits = Limits::new(); assert_eq!(limits.get("form"), None);
Adds or replaces a limit in self
, consuming self
and returning a new
Limits
structure with the added or replaced limit.
Example
use rocket::data::{Limits, ToByteUnit}; let limits = Limits::default(); assert_eq!(limits.get("form"), Some(32.kibibytes())); assert_eq!(limits.get("json"), Some(1.mebibytes())); assert_eq!(limits.get("cat"), None); let limits = limits.limit("cat", 1.mebibytes()); assert_eq!(limits.get("form"), Some(32.kibibytes())); assert_eq!(limits.get("cat"), Some(1.mebibytes())); let limits = limits.limit("json", 64.mebibytes()); assert_eq!(limits.get("json"), Some(64.mebibytes()));
Returns the limit named name
, proceeding hierarchically from right
to left until one is found, or returning None
if none is found.
Example
use rocket::data::{Limits, ToByteUnit}; let limits = Limits::default() .limit("json", 2.mebibytes()) .limit("file/jpeg", 4.mebibytes()) .limit("file/jpeg/special", 8.mebibytes()); assert_eq!(limits.get("form"), Some(32.kibibytes())); assert_eq!(limits.get("json"), Some(2.mebibytes())); assert_eq!(limits.get("data-form"), Some(Limits::DATA_FORM)); assert_eq!(limits.get("file"), Some(1.mebibytes())); assert_eq!(limits.get("file/png"), Some(1.mebibytes())); assert_eq!(limits.get("file/jpeg"), Some(4.mebibytes())); assert_eq!(limits.get("file/jpeg/inner"), Some(4.mebibytes())); assert_eq!(limits.get("file/jpeg/special"), Some(8.mebibytes())); assert!(limits.get("cats").is_none());
Returns the limit for the name created by joining the strings in
layers
with /
as a separator, then proceeding like
Limits::get()
, hierarchically from right to left until one is found,
or returning None
if none is found.
This methods exists to allow finding hierarchical limits without
constructing a string to call get()
with but otherwise returns the
same results.
Example
use rocket::data::{Limits, ToByteUnit}; let limits = Limits::default() .limit("json", 2.mebibytes()) .limit("file/jpeg", 4.mebibytes()) .limit("file/jpeg/special", 8.mebibytes()); assert_eq!(limits.find(["json"]), Some(2.mebibytes())); assert_eq!(limits.find(["json", "person"]), Some(2.mebibytes())); assert_eq!(limits.find(["file"]), Some(1.mebibytes())); assert_eq!(limits.find(["file", "png"]), Some(1.mebibytes())); assert_eq!(limits.find(["file", "jpeg"]), Some(4.mebibytes())); assert_eq!(limits.find(["file", "jpeg", "inner"]), Some(4.mebibytes())); assert_eq!(limits.find(["file", "jpeg", "special"]), Some(8.mebibytes()));
Trait Implementations
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>,
[src]
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
__D: Deserializer<'de>,
[src]Deserialize this value from the given Serde deserializer. Read more
type Error = Infallible
type Error = Infallible
The associated error to be returned if derivation fails.
Auto Trait Implementations
impl RefUnwindSafe for Limits
impl UnwindSafe for Limits
Blanket Implementations
Mutably borrows from an owned value. Read more
Compare self to key
and return true
if they are equal.
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
Converts self
into a collection.
type Output = T
type Output = T
Should always be Self
pub fn vzip(self) -> V