geph4-client 4.99.0-actuallyfive.8

Geph client
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

use anyhow::Context;
use smol::future::FutureExt;

use super::ConnectContext;
use crate::config::VpnMode;

#[cfg(target_os = "linux")]
mod linux_routing;

#[cfg(target_os = "windows")]
mod windows_routing;

#[cfg(unix)]
use std::os::unix::prelude::{AsRawFd, FromRawFd};

pub(super) async fn vpn_loop(ctx: ConnectContext) -> anyhow::Result<()> {
    #[cfg(any(target_os = "linux", target_os = "android"))]
    if ctx.opt.vpn_mode == Some(VpnMode::InheritedFd) {
        let fd_num: i32 = std::env::var("GEPH_VPN_FD")
            .ok()
            .and_then(|e| e.parse().ok())
            .expect("must set GEPH_VPN_FD to a file descriptor in order to use inherited-fd mode");
        return unsafe { fd_vpn_loop(ctx, fd_num).await };
    }

    #[cfg(target_os = "linux")]
    if ctx.opt.vpn_mode == Some(VpnMode::TunNoRoute) {
        let device = configure_tun_device();
        return unsafe { fd_vpn_loop(ctx, device.as_raw_fd()).await };
    }

    #[cfg(target_os = "linux")]
    if ctx.opt.vpn_mode == Some(VpnMode::TunRoute) {
        let device = configure_tun_device();
        return unsafe {
            fd_vpn_loop(ctx.clone(), device.as_raw_fd())
                .race(linux_routing::routing_loop(ctx.clone()))
                .await
        };
    }

    #[cfg(target_os = "windows")]
    if ctx.opt.vpn_mode == Some(VpnMode::WinDivert) {
        return windows_routing::start_routing(ctx).await;
    }

    smol::future::pending().await
}

#[cfg(target_os = "linux")]
fn configure_tun_device() -> tun::platform::Device {
    let device = tun::platform::Device::new(
        tun::Configuration::default()
            .name("tun-geph")
            .address("100.64.89.64")
            .netmask("255.255.255.0")
            .destination("100.64.0.1")
            .mtu(16384)
            .up(),
    )
    .expect("could not initialize TUN device");
    device
}

#[cfg(any(target_os = "linux", target_os = "android"))]
async unsafe fn fd_vpn_loop(ctx: ConnectContext, fd_num: i32) -> anyhow::Result<()> {
    log::info!("entering fd_vpn_loop");

    use futures_util::{AsyncReadExt, AsyncWriteExt};

    let mut up_file = async_dup::Arc::new(async_dup::Mutex::new(
        smol::Async::new(std::fs::File::from_raw_fd(fd_num)).context("cannot init up_file")?,
    ));

    let mut dn_file = up_file.clone();

    let up_loop = async {
        let mut bts = vec![0; 65536];
        loop {
            let n = up_file.read(&mut bts).await?;

            ctx.tunnel.send_vpn(&bts[..n]).await?;
        }
    };
    let dn_loop = async {
        loop {
            let bts = ctx.tunnel.recv_vpn().await?;
            dn_file.write_all(&bts).await?;
        }
    };
    up_loop.race(dn_loop).await
}