camo-rs 0.1.1

Camo proxies insecure HTTP images over HTTPS, preventing mixed content warnings on secure pages.
Documentation 
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

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
};

#[derive(Debug, thiserror::Error)]
#[allow(dead_code)]
pub enum CamoError {
    #[error("invalid digest")]
    InvalidDigest,

    #[error("invalid url encoding")]
    InvalidUrlEncoding,

    #[error("invalid url: {0}")]
    InvalidUrl(String),

    #[error("digest mismatch")]
    DigestMismatch,

    #[error("content type not allowed: {0}")]
    ContentTypeNotAllowed(String),

    #[error("content too large: {0} bytes")]
    ContentTooLarge(u64),

    #[error("too many redirects")]
    TooManyRedirects,

    #[error("request timeout")]
    Timeout,

    #[error("upstream error: {0}")]
    Upstream(String),

    #[cfg(feature = "server")]
    #[cfg_attr(feature = "server", error("reqwest error: {0}"))]
    ReqwestError(#[from] reqwest::Error),

    #[error("private network not allowed")]
    PrivateNetworkNotAllowed,
}

impl IntoResponse for CamoError {
    fn into_response(self) -> Response {
        let status = match &self {
            CamoError::InvalidDigest
            | CamoError::InvalidUrlEncoding
            | CamoError::InvalidUrl(_)
            | CamoError::DigestMismatch => StatusCode::BAD_REQUEST,

            CamoError::ContentTypeNotAllowed(_) => StatusCode::UNSUPPORTED_MEDIA_TYPE,

            CamoError::ContentTooLarge(_) => StatusCode::PAYLOAD_TOO_LARGE,

            CamoError::TooManyRedirects => StatusCode::BAD_GATEWAY,

            CamoError::Timeout => StatusCode::GATEWAY_TIMEOUT,

            CamoError::Upstream(_) => StatusCode::BAD_GATEWAY,
            
            #[cfg(feature = "server")]
            CamoError::ReqwestError(_) => StatusCode::BAD_GATEWAY,

            CamoError::PrivateNetworkNotAllowed => StatusCode::FORBIDDEN,
        };

        (status, self.to_string()).into_response()
    }
}

pub type Result<T> = std::result::Result<T, CamoError>;