refractium 3.0.2

Extensible low-level reverse proxy for port multiplexing and protocol-based routing
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

#[cfg(feature = "hooks")]
use crate::protocols::hooks::HookContext;
use tokio::io::{self, copy_bidirectional};
use tokio::net::TcpStream;

#[cfg(feature = "hooks")]
use crate::protocols::hooks::{Direction, HookedStream, ProtocolHook};
#[cfg(feature = "hooks")]
use std::sync::Arc;

/// Proxies data between two TCP streams bidirectionally.
///
/// This function sets `nodelay` on both sockets and performs a zero-copy
/// (where possible) transfer of data between the client and the backend.
///
/// # Errors
///
/// Returns an `io::Error` if:
/// - Setting `nodelay` fails.
/// - Connecting to either stream fails.
/// - The bidirectional copy operation encounters a network error.
pub async fn proxy_tcp(
    mut client: TcpStream,
    mut backend: TcpStream,
    #[cfg(feature = "hooks")] hooks: Vec<Arc<dyn ProtocolHook>>,
    #[cfg(feature = "hooks")] protocol_name: String,
) -> io::Result<()> {
    client.set_nodelay(true)?;
    backend.set_nodelay(true)?;

    #[cfg(feature = "hooks")]
    {
        if !hooks.is_empty() {
            let client_addr = client.peer_addr()?;
            let ctx = HookContext {
                client_addr,
                protocol: protocol_name,
                session_id: rand::random::<u64>(),
            };

            let mut hooked_client =
                HookedStream::new(client, Direction::Inbound, hooks.clone(), ctx.clone());
            let mut hooked_backend = HookedStream::new(backend, Direction::Outbound, hooks, ctx);
            copy_bidirectional(&mut hooked_client, &mut hooked_backend).await?;
            return Ok(());
        }
    }

    copy_bidirectional(&mut client, &mut backend).await?;
    Ok(())
}