Struct StrictTransportSecurity 

pub struct StrictTransportSecurity { /* private fields */ }

StrictTransportSecurity header, defined in RFC6797

This specification defines a mechanism enabling web sites to declare themselves accessible only via secure connections and/or for users to be able to direct their user agent(s) to interact with given sites only over secure connections. This overall policy is referred to as HTTP Strict Transport Security (HSTS). The policy is declared by web sites via the Strict-Transport-Security HTTP response header field and/or by other means, such as user agent configuration, for example.

ABNF

     [ directive ]  *( ";" [ directive ] )

     directive                 = directive-name [ "=" directive-value ]
     directive-name            = token
     directive-value           = token | quoted-string

Example values

• max-age=31536000
• max-age=15768000 ; includeSubdomains
• max-age=31536000; includeSubDomains; preload

Example

use std::time::Duration;
use rama_http_headers::StrictTransportSecurity;

let sts = StrictTransportSecurity::including_subdomains_for_max_seconds(31_536_000)
    .with_preload(true);

Implementations

impl StrictTransportSecurity

pub fn including_subdomains_for_max_seconds( max_age: u64, ) -> StrictTransportSecurity

Create an STS header that includes subdomains

pub fn including_subdomains_for_max_duration_rounded( dur: Duration, ) -> StrictTransportSecurity

Create an STS header that includes subdomains

The given Duration is rounded by ignoring any sub nano seconds. Use Self::including_subdomains_for_max_duration in case you want to make that a fallible case instead.

pub fn including_subdomains_for_max_duration( dur: Duration, ) -> Option<StrictTransportSecurity>

Try to create a STS header that includes subdomains

Error

Errors in case the given Duration contains sub nano seconds, use Self::including_subdomains_for_max_seconds or Self::including_subdomains_for_max_duration_rounded for a infallible constructor.

pub fn excluding_subdomains_for_max_seconds( max_age: u64, ) -> StrictTransportSecurity

Create an STS header that excludes subdomains

pub fn excluding_subdomains_for_max_duration_rounded( dur: Duration, ) -> StrictTransportSecurity

Create an STS header that excludes subdomains

The given Duration is rounded by ignoring any sub nano seconds. Use Self::excluding_subdomains_for_max_duration in case you want to make that a fallible case instead.

pub fn excluding_subdomains_for_max_duration( dur: Duration, ) -> Option<StrictTransportSecurity>

Try to create a STS header that excludes subdomains

Error

Errors in case the given Duration contains sub nano seconds, use Self::excluding_subdomains_for_max_seconds or Self::excluding_subdomains_for_max_duration_rounded for a infallible constructor.

pub fn with_preload(self, preload: bool) -> StrictTransportSecurity

Mark this STS header as preload-eligible.

The preload directive is a Chromium/Mozilla extension required for HSTS preload list eligibility — sites listed there get HSTS protection on the user’s very first visit. Per the preload list submission rules preload is only meaningful alongside max-age ≥ 31536000 and includeSubDomains; this builder does not enforce that, but callers should set both.

pub fn set_preload(&mut self, preload: bool) -> &mut StrictTransportSecurity

Mark this STS header as preload-eligible.

The preload directive is a Chromium/Mozilla extension required for HSTS preload list eligibility — sites listed there get HSTS protection on the user’s very first visit. Per the preload list submission rules preload is only meaningful alongside max-age ≥ 31536000 and includeSubDomains; this builder does not enforce that, but callers should set both.

pub fn include_subdomains(&self) -> bool

Get whether this should include subdomains.

pub fn preload(&self) -> bool

Get whether the preload directive is set.

pub fn max_age(&self) -> Duration

Get the max-age.

Trait Implementations

impl Clone for StrictTransportSecurity

fn clone(&self) -> StrictTransportSecurity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StrictTransportSecurity

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

Formats the value using the given formatter.

impl HeaderDecode for StrictTransportSecurity

fn decode<'i, I>(values: &mut I) -> Result<StrictTransportSecurity, Error>

where I: Iterator<Item = &'i HeaderValue>,

Decode this type from an iterator of HeaderValues.

impl HeaderEncode for StrictTransportSecurity

fn encode<E>(&self, values: &mut E)

where E: Extend<HeaderValue>,

Encode this type to a HeaderValue, and add it to a container which has HeaderValue type as each element.

fn encode_to_value(&self) -> Option<HeaderValue>

Encode this header to HeaderValue.

impl PartialEq for StrictTransportSecurity

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for StrictTransportSecurity

impl TypedHeader for StrictTransportSecurity

fn name() -> &'static HeaderName

The name of this header.