gcdevproxy 0.3.0

GoodCam Device Proxy library
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

use std::{
    io::Write,
    net::{Ipv4Addr, SocketAddr},
};

use async_trait::async_trait;
use gcdevproxy::{
    auth::BasicAuthorization,
    hyper::{Request, Response},
    Body, ClientHandlerResult, ConnectionInfo, DeviceHandlerResult, Error, ProxyBuilder,
    RequestHandler,
};
use log::LevelFilter;

/// Proxy request handler.
struct MyRequestHandler;

#[async_trait]
impl RequestHandler for MyRequestHandler {
    async fn handle_device_request(
        &self,
        _: BasicAuthorization,
    ) -> Result<DeviceHandlerResult, Error> {
        // Do not use this in production! You should always check the device ID
        // and key against your device database.
        Ok(DeviceHandlerResult::Accept)
    }

    async fn handle_client_request(
        &self,
        request: Request<Body>,
    ) -> Result<ClientHandlerResult, Error> {
        let is_local_client = request
            .extensions()
            .get::<ConnectionInfo>()
            .map(|info| info.remote_addr().ip().is_loopback())
            .unwrap_or(false);

        // Here we accept only requests from localhost. In practice there would
        // be probably some sort of client authentication mechanism (e.g. JWT).
        if !is_local_client {
            return Ok(ClientHandlerResult::block(empty_response(403)));
        }

        let device_id = request
            .headers()
            .get("x-device")
            .map(|id| id.to_str())
            .and_then(|res| res.ok());

        if let Some(device_id) = device_id {
            Ok(ClientHandlerResult::forward(device_id.to_string(), request))
        } else {
            Ok(ClientHandlerResult::block(empty_response(400)))
        }
    }
}

#[tokio::main]
async fn main() {
    env_logger::builder()
        .filter(None, LevelFilter::Debug)
        .format(|buf, record| {
            writeln!(
                buf,
                "{} {} {}",
                buf.timestamp_millis(),
                record.level(),
                record.args()
            )
        })
        .init();

    let hostname = std::env::var("HOSTNAME").unwrap_or_else(|_| String::from("localhost"));

    let mut builder = ProxyBuilder::new();

    builder
        .hostname(hostname)
        .http_bind_address(SocketAddr::from((Ipv4Addr::UNSPECIFIED, 8080)));
    //.https_bind_address(SocketAddr::from((Ipv4Addr::UNSPECIFIED, 8443)))
    //.lets_encrypt();

    builder
        .build(MyRequestHandler)
        .await
        .unwrap()
        .await
        .unwrap();
}

/// Create an empty HTTP response with a given status code.
fn empty_response(status: u16) -> Response<Body> {
    Response::builder()
        .status(status)
        .body(Body::empty())
        .unwrap()
}