init

crates/vpnshare-core/src/lib.rs

@@ -0,0 +1,117 @@
+//! Core VPN Share engine primitives.
+
+pub mod dns;
+pub mod lease;
+pub mod mtu;
+pub mod nat;
+pub mod packet;
+
+use std::time::Instant;
+
+pub use dns::{DnsPolicy, DnsRequest};
+pub use lease::{Lease, LeaseAllocator, PeerId};
+pub use mtu::MtuPolicy;
+pub use nat::{FlowKey, FlowTable, TransportProtocol};
+pub use packet::{IpPacket, PacketError};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum GatewayState {
+    Stopped,
+    Starting,
+    Running,
+    Failed,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GatewayConfig {
+    pub max_peers: usize,
+    pub default_mtu: u16,
+    pub ipv6_enabled: bool,
+}
+
+impl Default for GatewayConfig {
+    fn default() -> Self {
+        Self {
+            max_peers: 4,
+            default_mtu: 1280,
+            ipv6_enabled: false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct VpnStatus {
+    pub active: bool,
+    pub interface_name: Option<String>,
+    pub supports_ipv4: bool,
+    pub supports_ipv6: bool,
+}
+
+#[derive(Debug)]
+pub struct GatewayEngine {
+    state: GatewayState,
+    config: GatewayConfig,
+    leases: LeaseAllocator,
+    flows: FlowTable,
+    started_at: Option<Instant>,
+}
+
+impl GatewayEngine {
+    pub fn new(config: GatewayConfig) -> Self {
+        Self {
+            state: GatewayState::Stopped,
+            leases: LeaseAllocator::new(config.default_mtu),
+            flows: FlowTable::default(),
+            config,
+            started_at: None,
+        }
+    }
+
+    pub fn start(&mut self, now: Instant) {
+        self.state = GatewayState::Running;
+        self.started_at = Some(now);
+    }
+
+    pub fn stop(&mut self) {
+        self.state = GatewayState::Stopped;
+        self.started_at = None;
+        self.flows.clear();
+        self.leases.clear();
+    }
+
+    pub fn state(&self) -> GatewayState {
+        self.state
+    }
+
+    pub fn config(&self) -> &GatewayConfig {
+        &self.config
+    }
+
+    pub fn leases(&mut self) -> &mut LeaseAllocator {
+        &mut self.leases
+    }
+
+    pub fn flows(&mut self) -> &mut FlowTable {
+        &mut self.flows
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn gateway_start_stop_clears_runtime_state() {
+        let mut engine = GatewayEngine::new(GatewayConfig::default());
+        engine.start(Instant::now());
+        assert_eq!(engine.state(), GatewayState::Running);
+
+        let peer = PeerId::from_u128(1);
+        engine.leases().allocate(peer).unwrap();
+        assert_eq!(engine.leases().active_count(), 1);
+
+        engine.stop();
+        assert_eq!(engine.state(), GatewayState::Stopped);
+        assert_eq!(engine.leases().active_count(), 0);
+    }
+}