Struct GetForwardedHeaderLayer

pub struct GetForwardedHeaderLayer<T = Forwarded> { /* private fields */ }

Layer to extract Forwarded information from the specified T headers.

This layer can be used to extract the Forwarded information from any specified header T, as long as the header implements the ForwardHeader trait.

The following headers are supported by default:

• GetForwardedHeaderLayer::forwarded: The standard Forwarded header RFC 7239.
• GetForwardedHeaderLayer::via: The canonical Via header RFC 7230.
• GetForwardedHeaderLayer::x_forwarded_for: The canonical [X-Forwarded-For] header RFC 7239.
• GetForwardedHeaderLayer::x_forwarded_host: The canonical [X-Forwarded-Host] header RFC 7239.
• GetForwardedHeaderLayer::x_forwarded_proto: The canonical [X-Forwarded-Proto] header RFC 7239.

Rama also has the following headers already implemented for you to use:

X-Real-Ip, X-Client-Ip, Client-Ip, Cf-Connecting-Ip and True-Client-Ip.

There are no GetForwardedHeaderLayer constructors for these headers, but you can use the GetForwardedHeaderLayer::new constructor and pass the header type as a type parameter, alone or in a tuple with other headers.

Example

This example shows you can extract the client IP from the X-Forwarded-For header in case your application is behind a proxy which sets this header.

use rama_core::{
    service::service_fn,
    Context, Service, Layer,
};
use rama_http::{headers::forwarded::Forwarded, layer::forwarded::GetForwardedHeaderLayer, Request};
use std::{convert::Infallible, net::IpAddr};

#[tokio::main]
async fn main() {
    let service = GetForwardedHeaderLayer::x_forwarded_for()
        .into_layer(service_fn(async |ctx: Context<()>, _| {
            let forwarded = ctx.get::<rama_net::forwarded::Forwarded>().unwrap();
            assert_eq!(forwarded.client_ip(), Some(IpAddr::from([12, 23, 34, 45])));
            assert!(forwarded.client_proto().is_none());

            // ...

            Ok::<_, Infallible>(())
        }));

    let req = Request::builder()
        .header("X-Forwarded-For", "12.23.34.45")
        .body(())
        .unwrap();

    service.serve(Context::default(), req).await.unwrap();
}

Implementations

impl<T> GetForwardedHeaderLayer<T>

pub const fn new() -> Self

Create a new GetForwardedHeaderLayer for the specified headers T.

impl GetForwardedHeaderLayer

pub fn forwarded() -> Self

Create a new GetForwardedHeaderLayer for the standard Forwarded header.

impl GetForwardedHeaderLayer<Via>

pub fn via() -> Self

Create a new GetForwardedHeaderLayer for the canonical Via header.

impl GetForwardedHeaderLayer<XForwardedFor>

pub fn x_forwarded_for() -> Self

Create a new GetForwardedHeaderLayer for the canonical [X-Forwarded-For] header.

impl GetForwardedHeaderLayer<XForwardedHost>

pub fn x_forwarded_host() -> Self

Create a new GetForwardedHeaderLayer for the canonical [X-Forwarded-Host] header.

impl GetForwardedHeaderLayer<XForwardedProto>

pub fn x_forwarded_proto() -> Self

Create a new GetForwardedHeaderLayer for the canonical [X-Forwarded-Proto] header.

Trait Implementations

impl<T: Clone> Clone for GetForwardedHeaderLayer<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for GetForwardedHeaderLayer<T>

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

Formats the value using the given formatter.

impl Default for GetForwardedHeaderLayer

fn default() -> Self

Returns the “default value” for a type.

impl<H, S> Layer<S> for GetForwardedHeaderLayer<H>

type Service = GetForwardedHeaderService<S, H>

The service produced by the layer.

fn layer(&self, inner: S) -> Self::Service

Wrap the given service with the middleware, returning a new service.

fn into_layer(self, inner: S) -> Self::Service

Same as layer but consuming self after the service was created.