rusnel 0.8.2

Rusnel is a fast TCP/UDP tunnel, transported over and encrypted using QUIC protocol. Single executable including both client and server
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204

//! Multiple clients sharing a single server.
//!
//! All other tests spawn exactly one rusnel client, so the server's
//! per-session handler is only ever exercised against a single live
//! connection. This file pins down the multi-client invariants:
//!
//!   * Two clients with disjoint forward tunnels both work concurrently.
//!   * One client disconnecting (graceful or abrupt) does not perturb
//!     the other client's in-flight or future traffic.

mod common;

use std::str::FromStr;
use std::time::Duration;

use common::{
    client_config, get_available_port, init_crypto, server_config, STARTUP_DELAY, TEST_TIMEOUT,
};
use rusnel::common::remote::RemoteRequest;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tokio::time::timeout;

/// Spawn a server task and return a handle that aborts it on drop.
struct ServerGuard(tokio::task::JoinHandle<()>);
impl Drop for ServerGuard {
    fn drop(&mut self) {
        self.0.abort();
    }
}
struct ClientGuard(tokio::task::JoinHandle<()>);
impl Drop for ClientGuard {
    fn drop(&mut self) {
        self.0.abort();
    }
}

async fn spawn_server(server_port: u16) -> ServerGuard {
    init_crypto();
    let sc = server_config(server_port, false);
    let h = tokio::spawn(async move {
        let _ = rusnel::server::run_async(sc).await;
    });
    tokio::time::sleep(STARTUP_DELAY).await;
    ServerGuard(h)
}

async fn spawn_client(server_port: u16, remotes: Vec<RemoteRequest>) -> ClientGuard {
    let cc = client_config(server_port, remotes);
    let h = tokio::spawn(async move {
        let _ = rusnel::client::run_async(cc).await;
    });
    tokio::time::sleep(STARTUP_DELAY).await;
    ClientGuard(h)
}

/// Two clients, each owning its own forward TCP tunnel through the same
/// server, both work in parallel — disjoint sessions, no port collisions,
/// both round-trips succeed.
#[tokio::test]
async fn test_two_clients_concurrent_traffic() {
    timeout(TEST_TIMEOUT, async {
        let server_port = get_available_port();
        let local_a = get_available_port();
        let target_a = get_available_port();
        let local_b = get_available_port();
        let target_b = get_available_port();

        let listener_a = TcpListener::bind(format!("127.0.0.1:{target_a}"))
            .await
            .unwrap();
        let listener_b = TcpListener::bind(format!("127.0.0.1:{target_b}"))
            .await
            .unwrap();

        let _server = spawn_server(server_port).await;
        let _ca = spawn_client(
            server_port,
            vec![
                RemoteRequest::from_str(&format!("127.0.0.1:{local_a}:127.0.0.1:{target_a}"))
                    .unwrap(),
            ],
        )
        .await;
        let _cb = spawn_client(
            server_port,
            vec![
                RemoteRequest::from_str(&format!("127.0.0.1:{local_b}:127.0.0.1:{target_b}"))
                    .unwrap(),
            ],
        )
        .await;

        let (mut app_a, mut app_b) = tokio::join!(
            async {
                TcpStream::connect(format!("127.0.0.1:{local_a}"))
                    .await
                    .unwrap()
            },
            async {
                TcpStream::connect(format!("127.0.0.1:{local_b}"))
                    .await
                    .unwrap()
            },
        );
        app_a.write_all(b"AAA").await.unwrap();
        app_b.write_all(b"BBB").await.unwrap();
        app_a.shutdown().await.unwrap();
        app_b.shutdown().await.unwrap();

        let (mut srv_a, _) = listener_a.accept().await.unwrap();
        let (mut srv_b, _) = listener_b.accept().await.unwrap();
        let mut got_a = Vec::new();
        let mut got_b = Vec::new();
        srv_a.read_to_end(&mut got_a).await.unwrap();
        srv_b.read_to_end(&mut got_b).await.unwrap();

        assert_eq!(got_a, b"AAA");
        assert_eq!(got_b, b"BBB");
    })
    .await
    .expect("test_two_clients_concurrent_traffic timed out");
}

/// Aborting client A's task must not knock client B's tunnels offline.
/// This is the regression test for any state shared across sessions on
/// the server (a single accept loop bug, a global JoinSet, a port
/// registry, etc.) that would tear down B when A's handler unwinds.
#[tokio::test]
async fn test_one_client_disconnect_doesnt_affect_other() {
    timeout(TEST_TIMEOUT, async {
        let server_port = get_available_port();
        let local_a = get_available_port();
        let target_a = get_available_port();
        let local_b = get_available_port();
        let target_b = get_available_port();

        let _listener_a = TcpListener::bind(format!("127.0.0.1:{target_a}"))
            .await
            .unwrap();
        let listener_b = TcpListener::bind(format!("127.0.0.1:{target_b}"))
            .await
            .unwrap();

        let _server = spawn_server(server_port).await;
        let client_a = spawn_client(
            server_port,
            vec![
                RemoteRequest::from_str(&format!("127.0.0.1:{local_a}:127.0.0.1:{target_a}"))
                    .unwrap(),
            ],
        )
        .await;
        let _client_b = spawn_client(
            server_port,
            vec![
                RemoteRequest::from_str(&format!("127.0.0.1:{local_b}:127.0.0.1:{target_b}"))
                    .unwrap(),
            ],
        )
        .await;

        // Verify B works before tearing down A.
        {
            let mut app = TcpStream::connect(format!("127.0.0.1:{local_b}"))
                .await
                .unwrap();
            app.write_all(b"pre").await.unwrap();
            app.shutdown().await.unwrap();
            let (mut s, _) = listener_b.accept().await.unwrap();
            let mut got = Vec::new();
            s.read_to_end(&mut got).await.unwrap();
            assert_eq!(got, b"pre");
        }

        // Abort client A. The server-side handler for A's session should
        // unwind, tear down only A's tunnels, and leave B's session
        // running.
        client_a.0.abort();
        tokio::time::sleep(Duration::from_millis(500)).await;

        // B must still be live. Use a fresh connection through B's
        // tunnel — if the server collapsed B's session, this connect
        // will succeed locally (the client-side listener is still up)
        // but no bytes will reach the target.
        let mut app = TcpStream::connect(format!("127.0.0.1:{local_b}"))
            .await
            .unwrap();
        app.write_all(b"post").await.unwrap();
        app.shutdown().await.unwrap();
        let (mut s, _) = timeout(Duration::from_secs(5), listener_b.accept())
            .await
            .expect("client B's tunnel went dark after client A disconnected")
            .unwrap();
        let mut got = Vec::new();
        s.read_to_end(&mut got).await.unwrap();
        assert_eq!(
            got, b"post",
            "client B traffic must survive client A disconnect"
        );
    })
    .await
    .expect("test_one_client_disconnect_doesnt_affect_other timed out");
}