Struct ClientIp 

pub struct ClientIp(pub Option<IpAddr>);

Available on crate feature server only.

Return original client IP Address

If you want to get client IP by retrieving specific headers, you can use with_remote_ip_headers to set the headers.

If you want to get client IP that is trusted with specific cidrs, you can use with_trusted_cidrs to set the cidrs.

Example

Default config

default remote ip headers: ["X-Real-IP", "X-Forwarded-For"]

default trusted cidrs: ["0.0.0.0/0", "::/0"]

///
use volo_http::server::utils::client_ip::ClientIp;
use volo_http::server::{
    Server,
    route::{Router, get},
    utils::client_ip::{ClientIpConfig, ClientIpLayer},
};

async fn handler(ClientIp(client_ip): ClientIp) -> String {
    client_ip.unwrap().to_string()
}

let router: Router = Router::new()
    .route("/", get(handler))
    .layer(ClientIpLayer::new());

With custom config

use http::HeaderMap;
use volo_http::{
    context::ServerContext,
    server::{
        Server,
        route::{Router, get},
        utils::client_ip::{ClientIp, ClientIpConfig, ClientIpLayer},
    },
};

async fn handler(ClientIp(client_ip): ClientIp) -> String {
    client_ip.unwrap().to_string()
}

let router: Router = Router::new().route("/", get(handler)).layer(
    ClientIpLayer::new().with_config(
        ClientIpConfig::new()
            .with_remote_ip_headers(vec!["x-real-ip", "x-forwarded-for"])
            .unwrap()
            .with_trusted_cidrs(vec!["0.0.0.0/0".parse().unwrap(), "::/0".parse().unwrap()]),
    ),
);

Tuple Fields

0: Option<IpAddr>

Trait Implementations

impl Clone for ClientIp

fn clone(&self) -> ClientIp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClientIp

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

Formats the value using the given formatter.

impl FromContext for ClientIp

type Rejection = Infallible

If the extractor fails, it will return this Rejection type.

async fn from_context( cx: &mut ServerContext, _: &mut Parts, ) -> Result<Self, Self::Rejection>

Extract the type from context.

impl PartialEq for ClientIp

fn eq(&self, other: &ClientIp) -> 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 Eq for ClientIp

impl StructuralPartialEq for ClientIp