Struct Policy 

#[non_exhaustive]
pub struct Policy {
    pub percent: PercentPolicy,
    pub extended_filename: ExtendedFilenamePolicy,
    pub unknown_headers: HeaderPolicy,
    pub empty_files: EmptyFilePolicy,
    pub token_field: Option<TokenField>,
}

The behaviours a route may choose. The defaults are the strict ones; every alternative is named after what it allows.

Examples

use form_net::{EmptyFilePolicy, HeaderPolicy, Policy, TokenField};

const UPLOADS: Policy = Policy::DEFAULT
    .with_token_field(TokenField::new("csrf_token"))
    .with_empty_files(EmptyFilePolicy::Skip)
    .with_unknown_headers(HeaderPolicy::Refuse);
assert_eq!(UPLOADS.token_field.map(|t| t.name()), Some("csrf_token"));

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

percent: PercentPolicy

A malformed % in urlencoded input. Default Refuse.

extended_filename: ExtendedFilenamePolicy

filename* in a part. Default Refuse.

unknown_headers: HeaderPolicy

Part headers other than the three known ones. Default Ignore.

empty_files: EmptyFilePolicy

A file input left empty. Default Report.

token_field: Option<TokenField>

The anti-forgery token field to capture. Default none.

Implementations

impl Policy

pub const DEFAULT: Policy

The strict defaults.

pub const fn with_percent(self, policy: PercentPolicy) -> Self

Sets percent.

Examples

use form_net::{Limits, PercentPolicy, Policy};

let lenient = Policy::DEFAULT.with_percent(PercentPolicy::Literal);
let form = form_net::parse_urlencoded_with(b"rate=100%", &Limits::DEFAULT, &lenient)?;
assert_eq!(form.field("rate"), Some("100%"));
assert!(form_net::parse_urlencoded(b"rate=100%").is_err());

pub const fn with_extended_filename( self, policy: ExtendedFilenamePolicy, ) -> Self

Sets extended_filename.

Examples

use form_net::{ExtendedFilenamePolicy, Limits, Policy};

let body = b"--X\r\nContent-Disposition: form-data; name=f; filename*=UTF-8''a.txt\r\n\r\nhi\r\n--X--";
let accept = Policy::DEFAULT.with_extended_filename(ExtendedFilenamePolicy::AcceptAlone);
let form = form_net::parse_multipart_with(CT, body, &Limits::DEFAULT, &accept)?;
assert!(form.file("f").is_some());
let err = form_net::parse_multipart(CT, body).unwrap_err();
assert_eq!(err.code(), "policy.extended_filename");

pub const fn with_unknown_headers(self, policy: HeaderPolicy) -> Self

Sets unknown_headers.

Examples

use form_net::{HeaderPolicy, Limits, Policy};

let body = b"--X\r\nContent-Disposition: form-data; name=a\r\nX-Note: hi\r\n\r\n1\r\n--X--";
assert_eq!(form_net::parse_multipart(CT, body)?.field("a"), Some("1"));
let strict = Policy::DEFAULT.with_unknown_headers(HeaderPolicy::Refuse);
let err = form_net::parse_multipart_with(CT, body, &Limits::DEFAULT, &strict).unwrap_err();
assert_eq!(err.code(), "policy.unknown_header");

pub const fn with_empty_files(self, policy: EmptyFilePolicy) -> Self

Sets empty_files.

Examples

use form_net::{EmptyFilePolicy, Limits, Policy};

// A file input the user left empty.
let body = b"--X\r\nContent-Disposition: form-data; name=f; filename=\"\"\r\n\r\n\r\n--X--";
assert_eq!(form_net::parse_multipart(CT, body)?.len(), 1);
let skip = Policy::DEFAULT.with_empty_files(EmptyFilePolicy::Skip);
assert_eq!(form_net::parse_multipart_with(CT, body, &Limits::DEFAULT, &skip)?.len(), 0);

pub const fn with_token_field(self, field: TokenField) -> Self

Sets the token field to capture.

Examples

use form_net::{Limits, Policy, TokenField};

let guarded = Policy::DEFAULT.with_token_field(TokenField::new("csrf"));
// A file part before the token: refused.
let body = b"--X\r\nContent-Disposition: form-data; name=f; filename=a.txt\r\n\r\nhi\r\n\
             --X\r\nContent-Disposition: form-data; name=csrf\r\n\r\nt0k\r\n--X--";
let err = form_net::parse_multipart_with(CT, body, &Limits::DEFAULT, &guarded).unwrap_err();
assert_eq!(err.code(), "policy.token_field_late");

Trait Implementations

impl Clone for Policy

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Policy

impl Debug for Policy

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

Formats the value using the given formatter.

impl Default for Policy

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Policy

impl PartialEq for Policy

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Policy