porta-rs 0.1.1

Zero-trust CGNAT bypass via WireGuard tunnel
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

use anyhow::Result;
use std::sync::Arc;
use parking_lot::RwLock;
use std::collections::HashMap;

use crate::config::{PortMapping, Protocol};
use super::tcp::TcpForwarder;
use super::udp::UdpForwarder;
use crate::metrics::collector::MetricsCollector;

/// Combined statistics
#[derive(Debug, Default, Clone)]
pub struct ForwarderStats {
    pub tcp: super::tcp::TcpStats,
    pub udp: super::udp::UdpStats,
}

/// Forwarder manager - coordinates TCP and UDP forwarding
pub struct ForwarderManager {
    tcp: Arc<TcpForwarder>,
    udp: Arc<UdpForwarder>,
    active_forwards: Arc<RwLock<HashMap<String, Protocol>>>,
    metrics: Arc<MetricsCollector>,
}

impl ForwarderManager {
    pub fn new() -> Self {
        Self::with_metrics(Arc::new(MetricsCollector::new()))
    }

    pub fn with_metrics(metrics: Arc<MetricsCollector>) -> Self {
        Self {
            tcp: Arc::new(TcpForwarder::new()),
            udp: Arc::new(UdpForwarder::new()),
            active_forwards: Arc::new(RwLock::new(HashMap::new())),
            metrics,
        }
    }

    /// Start forwarding for a port mapping
    pub async fn start_forward(&self, mapping: &PortMapping) -> Result<()> {
        if !mapping.enabled {
            tracing::info!("Skipping disabled port: {}", mapping.id);
            return Ok(());
        }

        match mapping.protocol {
            Protocol::Tcp => {
                self.tcp.start_forwarding(mapping).await?;
            }
            Protocol::Udp => {
                self.udp.start_forwarding(mapping).await?;
            }
        }

        let mut forwards = self.active_forwards.write();
        forwards.insert(mapping.id.clone(), mapping.protocol.clone());

        Ok(())
    }

    /// Stop forwarding for a port mapping
    pub async fn stop_forward(&self, mapping_id: &str) -> Result<()> {
        let mut forwards = self.active_forwards.write();
        forwards.remove(mapping_id);

        tracing::info!("Stopped forwarding: {}", mapping_id);

        Ok(())
    }

    /// Get combined statistics
    pub async fn stats(&self) -> ForwarderStats {
        ForwarderStats {
            tcp: self.tcp.stats(),
            udp: self.udp.stats().await,
        }
    }
}

impl Default for ForwarderManager {
    fn default() -> Self {
        Self::new()
    }
}