shadowsocks-service 1.24.0

shadowsocks is a fast tunnel proxy that helps you bypass firewalls.
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

//! Shadowsocks Transparent Proxy Local Server

use std::{io, sync::Arc, time::Duration};

use futures::{FutureExt, future};
use shadowsocks::{ServerAddr, config::Mode};

use crate::{
    config::RedirType,
    local::{context::ServiceContext, loadbalancing::PingBalancer},
};

use super::{tcprelay::RedirTcpServer, udprelay::RedirUdpServer};

/// Transparent Proxy builder
pub struct RedirBuilder {
    context: Arc<ServiceContext>,
    mode: Mode,
    udp_expiry_duration: Option<Duration>,
    udp_capacity: Option<usize>,
    tcp_redir: RedirType,
    udp_redir: RedirType,
    client_addr: ServerAddr,
    udp_bind_addr: Option<ServerAddr>,
    balancer: PingBalancer,
}

impl RedirBuilder {
    /// Create a new transparent proxy server with default configuration
    pub fn new(client_addr: ServerAddr, balancer: PingBalancer) -> Self {
        let context = ServiceContext::new();
        Self::with_context(Arc::new(context), client_addr, balancer)
    }

    /// Create a new transparent proxy server with context
    pub fn with_context(context: Arc<ServiceContext>, client_addr: ServerAddr, balancer: PingBalancer) -> Self {
        Self {
            context,
            mode: Mode::TcpOnly,
            udp_expiry_duration: None,
            udp_capacity: None,
            tcp_redir: RedirType::tcp_default(),
            udp_redir: RedirType::udp_default(),
            client_addr,
            udp_bind_addr: None,
            balancer,
        }
    }

    /// Set UDP association's expiry duration
    pub fn set_udp_expiry_duration(&mut self, d: Duration) {
        self.udp_expiry_duration = Some(d);
    }

    /// Set total UDP association to be kept simultaneously in server
    pub fn set_udp_capacity(&mut self, c: usize) {
        self.udp_capacity = Some(c);
    }

    /// Set server mode
    pub fn set_mode(&mut self, mode: Mode) {
        self.mode = mode;
    }

    /// Set transparent proxy type of TCP relay, which is platform dependent
    pub fn set_tcp_redir(&mut self, ty: RedirType) {
        self.tcp_redir = ty;
    }

    /// Set transparent proxy type of UDP relay, which is platform dependent
    pub fn set_udp_redir(&mut self, ty: RedirType) {
        self.udp_redir = ty;
    }

    /// Set UDP bind address
    pub fn set_udp_bind_addr(&mut self, addr: ServerAddr) {
        self.udp_bind_addr = Some(addr);
    }

    pub async fn build(self) -> io::Result<Redir> {
        let mut tcp_server = None;
        if self.mode.enable_tcp() {
            let server = RedirTcpServer::new(
                self.context.clone(),
                &self.client_addr,
                self.balancer.clone(),
                self.tcp_redir,
            )
            .await?;
            tcp_server = Some(server);
        }

        let mut udp_server = None;
        if self.mode.enable_udp() {
            let udp_addr = self.udp_bind_addr.as_ref().unwrap_or(&self.client_addr);

            let server = RedirUdpServer::new(
                self.context,
                self.udp_redir,
                udp_addr,
                self.udp_expiry_duration,
                self.udp_capacity,
                self.balancer,
            )
            .await?;
            udp_server = Some(server);
        }

        Ok(Redir { tcp_server, udp_server })
    }
}

/// Transparent Proxy
pub struct Redir {
    tcp_server: Option<RedirTcpServer>,
    udp_server: Option<RedirUdpServer>,
}

impl Redir {
    /// TCP server instance
    pub fn tcp_server(&self) -> Option<&RedirTcpServer> {
        self.tcp_server.as_ref()
    }

    /// UDP server instance
    pub fn udp_server(&self) -> Option<&RedirUdpServer> {
        self.udp_server.as_ref()
    }

    /// Start serving
    pub async fn run(self) -> io::Result<()> {
        let mut vfut = Vec::new();

        if let Some(tcp_server) = self.tcp_server {
            vfut.push(tcp_server.run().boxed());
        }

        if let Some(udp_server) = self.udp_server {
            vfut.push(udp_server.run().boxed());
        }

        let (res, ..) = future::select_all(vfut).await;
        res
    }
}