rproxy 0.2.1

Platform independent asynchronous UDP/TCP proxy
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

#![recursion_limit="512"]
#![warn(rust_2018_idioms)]
#[cfg(tcp)]
#[cfg(udp)]

use std::sync::Arc;
use chrono::Local;
use std::path::PathBuf;
use std::path::Path;
use log::*;
use argh::FromArgs;
use log4rs;
mod tcp;
mod udp;
mod dns;
use rproxy::Proxy;

#[allow(dead_code)]
#[derive(FromArgs)]
#[argh(description = "rproxy is a platform independent UDP TCP high performance async proxy")]
struct Options {
    /// remote service endpoint (UDP & TCP)
    #[argh(option, short='r', default="\"\".to_string()")]
    remote: String,
    /// local endpoint to be binded by rproxy
    #[argh(option, short='b', default="\"\".to_string()")]
    bind: String,
    /// protocol of the remote service(UDP|TCP)
    #[argh(option, short='p', default="\"UDP\".to_string()")]
    protocol: String,
    /// set logger level to debug or not
    #[argh(switch, short='d')]
    debug: bool,

    /// logger settings rotating etc...
    #[argh(option, short = 'l', default = "\"rproxy.logger.yaml\".to_string()")]
    logger_settings: String,

    /// configuration for multiple proxy instances
    #[argh(option, short = 'c')]
    config: Option<PathBuf>,
}


static MY_LOGGER: MyLogger = MyLogger;

struct MyLogger;

impl log::Log for MyLogger {
    fn enabled(&self, _metadata: &Metadata<'_>) -> bool {
        true
    }

    fn log(&self, record: &Record<'_>) {
        if self.enabled(record.metadata()) {
            println!("[{}][{}] - {}", record.level(), Local::now(), record.args());
        }
    }
    fn flush(&self) {}
}

#[tokio::main]
async fn main(){
    let options: Options = argh::from_env();
    
    if Path::new(&options.logger_settings).exists(){
        log4rs::init_file(&options.logger_settings, 
            Default::default()).unwrap();
        debug!("NICE");
    } else {
        log::set_logger(&MY_LOGGER).unwrap();
        if options.debug {
            log::set_max_level(LevelFilter::Debug);
        } else {
            log::set_max_level(LevelFilter::Info);
        }
    }

    match options.config {
        None => {
            if options.protocol == "UDP"{
                udp::udp_proxy(&options.bind, &options.remote).await.unwrap();
            } else if options.protocol == "TCP" {
                tcp::tcp_proxy(&options.bind, &options.remote).await.unwrap();
            }
        },
        Some(_config) => {
            if _config.as_path().exists() {
                if let Ok(_path) = _config.to_owned().into_os_string().into_string(){
                    let content = std::fs::read_to_string(_path).unwrap();
                    match serde_json::from_str::<Vec<Proxy>>(content.as_str()){
                        Ok(proxies) => {
                            let mut procs = vec![];
                            for i in 0..proxies.len() {
                                let bind = proxies[i].bind.to_owned();
                                let remote = proxies[i].remote.to_owned();
                                if proxies[i].protocol == "UDP"{
                                    procs.push(tokio::spawn(async move {udp::udp_proxy(&bind, &remote).await}))
                                } else if proxies[i].protocol == "TCP" {
                                    procs.push(tokio::spawn(async move {tcp::tcp_proxy(&bind, &remote).await}))
                                }
                            }
                            futures::future::join_all(procs).await;
                        },
                        Err(e) => {
                            error!("Failed to parse configuration json {:?}", e);
                        }
                    }
                }

            } else {
                error!("Invalid configuration file path {}", _config.as_path().display());
            }
        }
    }
}