cratery 1.11.1

Cratery -- a private cargo registry
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

/*******************************************************************************
 * Copyright (c) 2022 Cénotélie Opérations SAS (cenotelie.fr)
******************************************************************************/

//! Custom extractors for Axum

use std::fmt;
use std::net::{IpAddr, SocketAddr};
use std::ops::{Deref, DerefMut};

use axum::extract::{ConnectInfo, FromRequestParts};
use axum::http::request::Parts;
use axum::{async_trait, RequestPartsExt};
use base64::prelude::BASE64_URL_SAFE;
use base64::Engine;
use cookie::{Cookie, CookieJar};
use serde::de::Visitor;
use serde::Deserialize;

/// The client for the request, if any
#[derive(Debug, Clone)]
pub struct ClientIp(pub Option<IpAddr>);

#[async_trait]
impl<S> FromRequestParts<S> for ClientIp
where
    S: Send + Sync,
{
    type Rejection = ();

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        if let Some(forwarded) = parts.headers.get("x-forwarded-for") {
            if let Ok(forwarded) = forwarded.to_str() {
                if let Some(Ok(client_ip)) = forwarded.split(',').next().map(str::trim).map(str::parse) {
                    return Ok(ClientIp(Some(client_ip)));
                }
            }
        }
        match parts.extract::<ConnectInfo<SocketAddr>>().await {
            Ok(ConnectInfo(addr)) => Ok(ClientIp(Some(addr.ip()))),
            Err(_) => Ok(ClientIp(None)),
        }
    }
}

impl fmt::Display for ClientIp {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.0 {
            None => write!(f, "--"),
            Some(ip) => write!(f, "{ip}"),
        }
    }
}

/// A matched argument encoded in base64
#[derive(Debug, Clone, Default)]
pub struct Base64(pub String);

impl Deref for Base64 {
    type Target = str;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for Base64 {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<'de> Deserialize<'de> for Base64 {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_string(Base64Visitor())
    }
}

struct Base64Visitor();

impl<'de> Visitor<'de> for Base64Visitor {
    type Value = Base64;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(formatter, "a base64 string")
    }

    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        match BASE64_URL_SAFE.decode(value).map(String::from_utf8) {
            Ok(Ok(s)) => Ok(Base64(s)),
            _ => Err(serde::de::Error::invalid_type(serde::de::Unexpected::Str(value), &self)),
        }
    }

    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        self.visit_str(v)
    }

    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        self.visit_str(&v)
    }
}

/// Cookies on a request
#[derive(Debug, Clone)]
pub struct Cookies(pub CookieJar);

#[async_trait]
impl<S> FromRequestParts<S> for Cookies
where
    S: Send + Sync,
{
    type Rejection = ();

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        let mut jar = CookieJar::new();
        for cookie in &parts.headers.get_all("cookie") {
            if let Ok(cookie_value) = cookie.to_str() {
                for part in cookie_value.split(';') {
                    if let Ok(cookie) = Cookie::parse_encoded(part.trim()) {
                        jar.add(cookie.into_owned());
                    }
                }
            }
        }
        Ok(Cookies(jar))
    }
}