httpcan 0.8.0

A simple HTTP Request & Response Service, with httpbin compatibility
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
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
141
142
143
144
145
146
147

use super::*;
use actix_web::http::header::HeaderName;

pub async fn get_handler(req: HttpRequest, config: web::Data<AppConfig>) -> Result<HttpResponse> {
    let request_info = extract_get_request_info(&req, &config.exclude_headers);
    Ok(HttpResponse::Ok().json(request_info))
}

// Universal handler for body-containing requests (POST, PUT, PATCH, DELETE)
// Returns HTTPBin compatible format (without method and user_agent fields)
async fn universal_body_handler_httpbin(
    req: HttpRequest,
    payload: web::Payload,
    config: web::Data<AppConfig>,
) -> Result<HttpResponse> {
    let content_type = req
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("");

    if content_type
        .to_lowercase()
        .starts_with("multipart/form-data")
    {
        // Handle multipart form data
        let multipart = Multipart::new(req.headers(), payload);
        match extract_request_info_multipart(&req, multipart, &config.exclude_headers).await {
            Ok(mut request_info) => {
                fix_request_info_url(&req, &mut request_info);
                let http_methods_info = to_http_methods_format(request_info);
                Ok(HttpResponse::Ok().json(http_methods_info))
            }
            Err(_) => {
                let mut request_info = extract_request_info(&req, None, &config.exclude_headers);
                fix_request_info_url(&req, &mut request_info);
                let http_methods_info = to_http_methods_format(request_info);
                Ok(HttpResponse::Ok().json(http_methods_info))
            }
        }
    } else {
        // Handle other content types (JSON, form-urlencoded, etc.)
        use actix_web::web::BytesMut;
        use futures_util::StreamExt;

        let mut body = BytesMut::new();
        let mut payload = payload;
        while let Some(chunk) = payload.next().await {
            let chunk = chunk?;
            body.extend_from_slice(&chunk);
        }

        let body_string = String::from_utf8_lossy(&body);
        let mut request_info =
            extract_request_info(&req, Some(&body_string), &config.exclude_headers);
        fix_request_info_url(&req, &mut request_info);
        let http_methods_info = to_http_methods_format(request_info);
        Ok(HttpResponse::Ok().json(http_methods_info))
    }
}

pub async fn post_handler(
    req: HttpRequest,
    payload: web::Payload,
    config: web::Data<AppConfig>,
) -> Result<HttpResponse> {
    universal_body_handler_httpbin(req, payload, config).await
}

pub async fn put_handler(
    req: HttpRequest,
    payload: web::Payload,
    config: web::Data<AppConfig>,
) -> Result<HttpResponse> {
    universal_body_handler_httpbin(req, payload, config).await
}

pub async fn patch_handler(
    req: HttpRequest,
    payload: web::Payload,
    config: web::Data<AppConfig>,
) -> Result<HttpResponse> {
    universal_body_handler_httpbin(req, payload, config).await
}

pub async fn delete_handler(
    req: HttpRequest,
    payload: web::Payload,
    config: web::Data<AppConfig>,
) -> Result<HttpResponse> {
    universal_body_handler_httpbin(req, payload, config).await
}

/// Echo the request's HTTP method name, accepting ANY HTTP method (httpbin #522).
pub async fn method_handler(req: HttpRequest) -> Result<HttpResponse> {
    Ok(HttpResponse::Ok().json(json!({ "method": req.method().as_str() })))
}

/// HEAD-only endpoint echoing request headers as `X-Echo-<name>` response
/// headers, with an empty body (httpbin #630).
pub async fn head_handler(req: HttpRequest) -> Result<HttpResponse> {
    let mut builder = HttpResponse::Ok();
    for (name, value) in req.headers().iter() {
        let Ok(value_str) = value.to_str() else {
            continue;
        };
        if let Ok(echo_name) =
            HeaderName::from_bytes(format!("x-echo-{}", name.as_str()).as_bytes())
        {
            builder.append_header((echo_name, value_str));
        }
    }
    Ok(builder.finish())
}

/// `/query` — dedicated echo endpoint for the QUERY method (RFC 9430).
/// QUERY is a safe, idempotent method whose request body carries the query,
/// so this echoes URL args *and* the parsed body (form/JSON/multipart),
/// exactly like /post.
pub async fn query_handler(
    req: HttpRequest,
    payload: web::Payload,
    config: web::Data<AppConfig>,
) -> Result<HttpResponse> {
    universal_body_handler_httpbin(req, payload, config).await
}

/// `/trace` — dedicated echo endpoint for the TRACE method (RFC 9110 §9.8).
/// TRACE requests carry no body; echo the request metadata like /anything.
pub async fn trace_handler(req: HttpRequest, config: web::Data<AppConfig>) -> Result<HttpResponse> {
    anything_handler_get(req, config).await
}

/// `/options` — dedicated echo endpoint for the OPTIONS method
/// (RFC 9110 §9.3.7). Plain OPTIONS returns 200 with an `Allow` header
/// listing the target resource's methods (§10.2.1) plus a `/get`-style JSON
/// echo. CORS preflight OPTIONS (carrying `Access-Control-Request-Method`)
/// is intercepted earlier by the CORS middleware and never reaches this.
pub async fn options_handler(
    req: HttpRequest,
    config: web::Data<AppConfig>,
) -> Result<HttpResponse> {
    let request_info = extract_get_request_info(&req, &config.exclude_headers);
    Ok(HttpResponse::Ok()
        .insert_header((actix_web::http::header::ALLOW, "OPTIONS"))
        .json(request_info))
}