mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 06:26:14 -05:00
Merge branch 'dev' into gpauth_windows
This commit is contained in:
91 files changed
+5486
-3171
No files matched your search
@@ -8,6 +8,7 @@ edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
common = { path = "../common" }
|
||||
gpapi = { path = "../gpapi" }
|
||||
|
||||
# Shared dependencies
|
||||
@@ -32,10 +33,10 @@ html-escape = { version = "0.2.13", optional = true }
|
||||
webkit2gtk = { version = "2", optional = true }
|
||||
|
||||
[target.'cfg(target_os="macos")'.dependencies]
|
||||
block2 = { version = "0.5", optional = true }
|
||||
objc2 = { version = "0.5", optional = true }
|
||||
objc2-foundation = { version = "0.2", optional = true }
|
||||
objc2-web-kit = { version = "0.2", optional = true }
|
||||
block2 = { version = "0.6", optional = true }
|
||||
objc2 = { version = "0.6", optional = true }
|
||||
objc2-foundation = { version = "0.3", optional = true }
|
||||
objc2-web-kit = { version = "0.3", optional = true }
|
||||
|
||||
[target.'cfg(target_os="windows")'.dependencies]
|
||||
webview2-com = { version = "0.34", optional = true }
|
||||
|
||||
@@ -10,8 +10,8 @@ pub(super) struct AuthServer {
|
||||
}
|
||||
|
||||
impl AuthServer {
|
||||
pub fn new() -> anyhow::Result<Self> {
|
||||
let server = Server::http("127.0.0.1:0").map_err(|err| anyhow::anyhow!(err))?;
|
||||
pub fn new(addr: &str) -> anyhow::Result<Self> {
|
||||
let server = Server::http(addr).map_err(|err| anyhow::anyhow!(err))?;
|
||||
let auth_id = Uuid::new_v4().to_string();
|
||||
|
||||
Ok(Self { server, auth_id })
|
||||
|
||||
@@ -1,8 +1,12 @@
|
||||
use std::{env::temp_dir, fs};
|
||||
|
||||
use gpapi::{auth::SamlAuthData, GP_CALLBACK_PORT_FILENAME};
|
||||
use common::constants::GP_CALLBACK_PORT_FILENAME;
|
||||
use gpapi::auth::SamlAuthData;
|
||||
use log::info;
|
||||
use tokio::{io::AsyncReadExt, net::TcpListener};
|
||||
use tokio::{
|
||||
io::AsyncReadExt,
|
||||
net::{TcpListener, UdpSocket},
|
||||
};
|
||||
|
||||
use crate::browser::auth_server::AuthServer;
|
||||
|
||||
@@ -10,6 +14,7 @@ pub enum Browser<'a> {
|
||||
Default,
|
||||
Chrome,
|
||||
Firefox,
|
||||
Remote,
|
||||
Other(&'a str),
|
||||
}
|
||||
|
||||
@@ -19,6 +24,7 @@ impl<'a> Browser<'a> {
|
||||
"default" => Browser::Default,
|
||||
"chrome" => Browser::Chrome,
|
||||
"firefox" => Browser::Firefox,
|
||||
"remote" => Browser::Remote,
|
||||
_ => Browser::Other(browser),
|
||||
}
|
||||
}
|
||||
@@ -28,6 +34,7 @@ impl<'a> Browser<'a> {
|
||||
Browser::Default => "default",
|
||||
Browser::Chrome => "chrome",
|
||||
Browser::Firefox => "firefox",
|
||||
Browser::Remote => "remote",
|
||||
Browser::Other(browser) => browser,
|
||||
}
|
||||
}
|
||||
@@ -47,7 +54,8 @@ impl<'a> BrowserAuthenticator<'a> {
|
||||
}
|
||||
|
||||
pub async fn authenticate(&self) -> anyhow::Result<SamlAuthData> {
|
||||
let auth_server = AuthServer::new()?;
|
||||
let addr = self.determine_addr().await?;
|
||||
let auth_server = AuthServer::new(&addr)?;
|
||||
let auth_url = auth_server.auth_url();
|
||||
|
||||
let auth_request = self.auth_request.to_string();
|
||||
@@ -56,6 +64,25 @@ impl<'a> BrowserAuthenticator<'a> {
|
||||
});
|
||||
|
||||
match self.browser {
|
||||
Browser::Remote => {
|
||||
info!(
|
||||
r#"
|
||||
|
||||
==== Manual Authentication Required ====
|
||||
|
||||
Please open the following URL in your browser:
|
||||
|
||||
{}
|
||||
|
||||
After completing the authentication, please paste the authentication data back to this terminal.
|
||||
(The data should start with "globalprotectcallback:...")
|
||||
|
||||
Note that the URL is only valid for a single use.
|
||||
"#,
|
||||
auth_url
|
||||
);
|
||||
return read_auth_data_from_stdin();
|
||||
}
|
||||
Browser::Default => {
|
||||
info!("Launching the default browser...");
|
||||
webbrowser::open(&auth_url)?;
|
||||
@@ -71,6 +98,28 @@ impl<'a> BrowserAuthenticator<'a> {
|
||||
info!("Please continue the authentication process in the default browser");
|
||||
wait_auth_data().await
|
||||
}
|
||||
|
||||
async fn determine_addr(&self) -> anyhow::Result<String> {
|
||||
if matches!(self.browser, Browser::Remote) {
|
||||
let local_ip = detect_local_ip().await?;
|
||||
Ok(format!("{}:0", local_ip))
|
||||
} else {
|
||||
Ok("127.0.0.1:0".to_string())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Detect the local IP address by creating a UDP socket and connecting to an external address
|
||||
async fn detect_local_ip() -> anyhow::Result<String> {
|
||||
let socket = UdpSocket::bind("0.0.0.0:0").await?;
|
||||
if let Err(err) = socket.connect("1.1.1.1:80").await {
|
||||
anyhow::bail!("Failed to connect to external address to determine local IP: {}", err);
|
||||
}
|
||||
let local_addr = socket.local_addr()?;
|
||||
let ip = local_addr.ip().to_string();
|
||||
info!("Determined local IP address: {}", ip);
|
||||
|
||||
Ok(ip.to_string())
|
||||
}
|
||||
|
||||
fn find_browser_path(browser: &Browser) -> String {
|
||||
@@ -123,3 +172,11 @@ async fn wait_auth_data() -> anyhow::Result<SamlAuthData> {
|
||||
let auth_data = SamlAuthData::from_gpcallback(&data)?;
|
||||
Ok(auth_data)
|
||||
}
|
||||
|
||||
fn read_auth_data_from_stdin() -> anyhow::Result<SamlAuthData> {
|
||||
let mut data = String::new();
|
||||
std::io::stdin().read_line(&mut data)?;
|
||||
|
||||
let auth_data = SamlAuthData::from_gpcallback(data.trim())?;
|
||||
Ok(auth_data)
|
||||
}
|
||||
@@ -103,7 +103,8 @@ impl<'a> WebviewAuthenticator<'a> {
|
||||
.title("GlobalProtect Login")
|
||||
.inner_size(900.0, 650.0 + title_bar_height)
|
||||
.focused(true)
|
||||
.visible(false)
|
||||
// when clean is true, the window is expected to be shown because the cookies are cleared
|
||||
.visible(self.clean)
|
||||
.center()
|
||||
.build()?;
|
||||
|
||||
|
||||
@@ -6,6 +6,3 @@ authors.workspace = true
|
||||
homepage.workspace = true
|
||||
edition.workspace = true
|
||||
license.workspace = true
|
||||
|
||||
[dependencies]
|
||||
is_executable.workspace = true
|
||||
@@ -14,6 +14,9 @@ fn main() {
|
||||
println!("cargo:rustc-env=GP_SERVICE_BINARY={}", gp_service_binary.display());
|
||||
println!("cargo:rustc-env=GP_CLIENT_BINARY={}", gp_client_binary.display());
|
||||
println!("cargo:rustc-env=GP_AUTH_BINARY={}", gp_auth_binary.display());
|
||||
println!("cargo:rustc-env=GP_GUI_HELPER_BINARY={}", gp_gui_helper_binary.display());
|
||||
println!(
|
||||
"cargo:rustc-env=GP_GUI_HELPER_BINARY={}",
|
||||
gp_gui_helper_binary.display()
|
||||
);
|
||||
println!("cargo:rustc-env=GP_GUI_BINARY={}", gp_gui_binary.display());
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
pub const GP_USER_AGENT: &str = "PAN GlobalProtect";
|
||||
pub const GP_CLIENT_VERSION: &str = "6.3.0-33";
|
||||
pub const GP_SERVICE_LOCK_FILE: &str = "/var/run/gpservice.lock";
|
||||
pub const GP_CALLBACK_PORT_FILENAME: &str = "gpcallback.port";
|
||||
|
||||
// Release binaries - macOS (Apple Silicon Homebrew)
|
||||
#[cfg(all(not(debug_assertions), target_os = "macos"))]
|
||||
pub const GP_CLIENT_BINARY: &str = "/opt/homebrew/bin/gpclient";
|
||||
#[cfg(all(not(debug_assertions), target_os = "macos"))]
|
||||
pub const GP_SERVICE_BINARY: &str = "/opt/homebrew/bin/gpservice";
|
||||
#[cfg(all(not(debug_assertions), target_os = "macos"))]
|
||||
pub const GP_GUI_BINARY: &str = "/opt/homebrew/bin/gpgui";
|
||||
#[cfg(all(not(debug_assertions), target_os = "macos"))]
|
||||
pub const GP_GUI_HELPER_BINARY: &str = "/opt/homebrew/bin/gpgui-helper";
|
||||
#[cfg(all(not(debug_assertions), target_os = "macos"))]
|
||||
pub const GP_AUTH_BINARY: &str = "/opt/homebrew/bin/gpauth";
|
||||
|
||||
// Release binaries - Linux
|
||||
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
|
||||
pub const GP_CLIENT_BINARY: &str = "/usr/bin/gpclient";
|
||||
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
|
||||
pub const GP_SERVICE_BINARY: &str = "/usr/bin/gpservice";
|
||||
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
|
||||
pub const GP_GUI_BINARY: &str = "/usr/bin/gpgui";
|
||||
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
|
||||
pub const GP_GUI_HELPER_BINARY: &str = "/usr/bin/gpgui-helper";
|
||||
#[cfg(all(not(debug_assertions), not(target_os = "macos")))]
|
||||
pub const GP_AUTH_BINARY: &str = "/usr/bin/gpauth";
|
||||
|
||||
// Debug binaries are set in build.rs via environment variables
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_CLIENT_BINARY: &str = env!("GP_CLIENT_BINARY");
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_SERVICE_BINARY: &str = env!("GP_SERVICE_BINARY");
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_GUI_BINARY: &str = env!("GP_GUI_BINARY");
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_GUI_HELPER_BINARY: &str = env!("GP_GUI_HELPER_BINARY");
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_AUTH_BINARY: &str = env!("GP_AUTH_BINARY");
|
||||
@@ -1 +1 @@
|
||||
pub mod vpn_utils;
|
||||
pub mod constants;
|
||||
+14
-1
@@ -6,6 +6,7 @@ edition.workspace = true
|
||||
license = "MIT"
|
||||
|
||||
[dependencies]
|
||||
common = { path = "../common" }
|
||||
anyhow.workspace = true
|
||||
base64.workspace = true
|
||||
dns-lookup.workspace = true
|
||||
@@ -14,7 +15,7 @@ reqwest.workspace = true
|
||||
openssl.workspace = true
|
||||
version-compare = "0.2"
|
||||
pem.workspace = true
|
||||
roxmltree.workspace = true
|
||||
xmltree.workspace = true
|
||||
serde.workspace = true
|
||||
specta = { workspace = true, features = ["derive"] }
|
||||
urlencoding.workspace = true
|
||||
@@ -31,7 +32,10 @@ regex.workspace = true
|
||||
serde_urlencoded.workspace = true
|
||||
md5.workspace = true
|
||||
sha256.workspace = true
|
||||
machine-uid.workspace = true
|
||||
uuid = { workspace = true, features = ["v5"] }
|
||||
|
||||
# Optional dependencies for features
|
||||
tauri = { workspace = true, optional = true }
|
||||
clap = { workspace = true, optional = true }
|
||||
clap-verbosity-flag = { workspace = true, optional = true }
|
||||
@@ -39,6 +43,15 @@ clap-verbosity-flag = { workspace = true, optional = true }
|
||||
env_logger = { workspace = true, optional = true }
|
||||
log-reload = { version = "0.1", optional = true }
|
||||
|
||||
# Dependencies for macOS and Windows only
|
||||
[target.'cfg(any(target_os="macos", target_os="windows"))'.dependencies]
|
||||
os_info = { version = "3", default-features = false }
|
||||
|
||||
# Dependencies for Linux and other OSes only
|
||||
[target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies]
|
||||
gtk = "0.18"
|
||||
|
||||
# Dependencies for Unix-like systems only
|
||||
[target.'cfg(target_family="unix")'.dependencies]
|
||||
uzers.workspace = true
|
||||
|
||||
|
||||
@@ -2,9 +2,13 @@ use std::collections::HashMap;
|
||||
|
||||
use log::{info, warn};
|
||||
use reqwest::Client;
|
||||
use roxmltree::Document;
|
||||
use xmltree::Element;
|
||||
|
||||
use crate::{gp_params::GpParams, process::hip_launcher::HipLauncher, utils::normalize_server};
|
||||
use crate::{
|
||||
gp_params::GpParams,
|
||||
process::hip_launcher::HipLauncher,
|
||||
utils::{normalize_server, xml::ElementExt},
|
||||
};
|
||||
|
||||
struct HipReporter<'a> {
|
||||
server: String,
|
||||
@@ -65,13 +69,11 @@ impl HipReporter<'_> {
|
||||
|
||||
let res = self.client.post(&config_url).form(¶ms).send().await?;
|
||||
let res_xml = res.error_for_status()?.text().await?;
|
||||
let doc = Document::parse(&res_xml)?;
|
||||
let root = Element::parse(res_xml.as_bytes())?;
|
||||
|
||||
// Get <ip-address>
|
||||
let ip = doc
|
||||
.descendants()
|
||||
.find(|n| n.has_tag_name("ip-address"))
|
||||
.and_then(|n| n.text())
|
||||
let ip = root
|
||||
.descendant_text("ip-address")
|
||||
.ok_or_else(|| anyhow::anyhow!("ip-address not found"))?;
|
||||
|
||||
Ok(ip.to_string())
|
||||
@@ -122,12 +124,9 @@ impl HipReporter<'_> {
|
||||
}
|
||||
|
||||
fn is_hip_needed(res_xml: &str) -> anyhow::Result<bool> {
|
||||
let doc = Document::parse(res_xml)?;
|
||||
|
||||
let hip_needed = doc
|
||||
.descendants()
|
||||
.find(|n| n.has_tag_name("hip-report-needed"))
|
||||
.and_then(|n| n.text())
|
||||
let root = Element::parse(res_xml.as_bytes())?;
|
||||
let hip_needed = root
|
||||
.descendant_text("hip-report-needed")
|
||||
.ok_or_else(|| anyhow::anyhow!("hip-report-needed not found"))?;
|
||||
|
||||
Ok(hip_needed == "yes")
|
||||
|
||||
@@ -1,14 +1,16 @@
|
||||
use std::borrow::Cow;
|
||||
|
||||
use anyhow::bail;
|
||||
use log::{info, warn};
|
||||
use log::{debug, info, warn};
|
||||
use reqwest::Client;
|
||||
use roxmltree::Document;
|
||||
use urlencoding::encode;
|
||||
use xmltree::Element;
|
||||
|
||||
use crate::{
|
||||
credential::Credential,
|
||||
error::PortalError,
|
||||
gp_params::GpParams,
|
||||
utils::{normalize_server, parse_gp_response, remove_url_scheme},
|
||||
utils::{normalize_server, parse_gp_response, remove_url_scheme, xml::ElementExt},
|
||||
};
|
||||
|
||||
pub enum GatewayLogin {
|
||||
@@ -50,18 +52,20 @@ pub async fn gateway_login(gateway: &str, cred: &Credential, gp_params: &GpParam
|
||||
return Ok(GatewayLogin::Mfa(message, input_str));
|
||||
}
|
||||
|
||||
let doc = Document::parse(&res)?;
|
||||
debug!("Gateway login response: {}", res);
|
||||
|
||||
let cookie = build_gateway_token(&doc, gp_params.computer())?;
|
||||
let root = Element::parse(res.as_bytes())?;
|
||||
|
||||
let cookie = build_gateway_token(&root, gp_params.computer())?;
|
||||
|
||||
Ok(GatewayLogin::Cookie(cookie))
|
||||
}
|
||||
|
||||
fn build_gateway_token(doc: &Document, computer: &str) -> anyhow::Result<String> {
|
||||
let args = doc
|
||||
.descendants()
|
||||
.filter(|n| n.has_tag_name("argument"))
|
||||
.map(|n| n.text().unwrap_or("").to_string())
|
||||
fn build_gateway_token(element: &Element, computer: &str) -> anyhow::Result<String> {
|
||||
let args = element
|
||||
.descendants("argument")
|
||||
.iter()
|
||||
.map(|e| e.get_text().unwrap_or_default())
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
let params = [
|
||||
@@ -82,7 +86,7 @@ fn build_gateway_token(doc: &Document, computer: &str) -> anyhow::Result<String>
|
||||
Ok(token)
|
||||
}
|
||||
|
||||
fn read_args<'a>(args: &'a [String], index: usize, key: &'a str) -> anyhow::Result<(&'a str, &'a str)> {
|
||||
fn read_args<'a>(args: &'a [Cow<'_, str>], index: usize, key: &'a str) -> anyhow::Result<(&'a str, &'a str)> {
|
||||
args
|
||||
.get(index)
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to read {key} from args"))
|
||||
|
||||
@@ -1,64 +1,64 @@
|
||||
use log::info;
|
||||
use roxmltree::Node;
|
||||
use xmltree::Element;
|
||||
|
||||
use crate::utils::xml::NodeExt;
|
||||
use crate::utils::xml::ElementExt;
|
||||
|
||||
use super::{Gateway, PriorityRule};
|
||||
|
||||
pub(crate) fn parse_gateways(node: &Node, prefer_internal: bool) -> Option<Vec<Gateway>> {
|
||||
let node_gateways = node.find_descendant("gateways")?;
|
||||
pub(crate) fn parse_gateways(element: &Element, prefer_internal: bool) -> Option<Vec<Gateway>> {
|
||||
let node_gateways = element.descendant("gateways")?;
|
||||
let internal_gateway_list = if prefer_internal {
|
||||
info!("Try to parse the internal gateways...");
|
||||
node_gateways.find_descendant("internal").and_then(|n| n.find_child("list"))
|
||||
node_gateways.descendant("internal").and_then(|n| n.child("list"))
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let gateway_list = internal_gateway_list.or_else(|| {
|
||||
info!("Try to parse the external gateways...");
|
||||
node_gateways.find_descendant("external").and_then(|n| n.find_child("list"))
|
||||
node_gateways.descendant("external").and_then(|n| n.child("list"))
|
||||
})?;
|
||||
|
||||
let gateways = gateway_list
|
||||
.children()
|
||||
.filter_map(|gateway_item| {
|
||||
if !gateway_item.has_tag_name("entry") {
|
||||
return None;
|
||||
}
|
||||
let address = gateway_item.attribute("name").unwrap_or_default().to_string();
|
||||
let name = gateway_item.child_text("description").unwrap_or_default().to_string();
|
||||
let priority = gateway_item
|
||||
.child_text("priority")
|
||||
.and_then(|s| s.parse().ok())
|
||||
.unwrap_or(u32::MAX);
|
||||
.children("entry")
|
||||
.iter()
|
||||
.map(|gateway_item| {
|
||||
let address = gateway_item.attr("name").map(|s| s.to_string()).unwrap_or_default();
|
||||
let name = gateway_item.child_text("description").unwrap_or_default();
|
||||
let priority = parse_priority(gateway_item);
|
||||
let priority_rules = gateway_item
|
||||
.find_child("priority-rule")
|
||||
.map(|n| {
|
||||
n.children()
|
||||
.filter_map(|n| {
|
||||
if !n.has_tag_name("entry") {
|
||||
return None;
|
||||
}
|
||||
let name = n.attribute("name").unwrap_or_default().to_string();
|
||||
let priority: u32 = n
|
||||
.child_text("priority")
|
||||
.and_then(|s| s.parse().ok())
|
||||
.unwrap_or(u32::MAX);
|
||||
|
||||
Some(PriorityRule { name, priority })
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
.child("priority-rule")
|
||||
.map(|n| parse_priority_rules(n))
|
||||
.unwrap_or_default();
|
||||
|
||||
Some(Gateway {
|
||||
Gateway {
|
||||
name,
|
||||
address,
|
||||
priority,
|
||||
priority_rules,
|
||||
})
|
||||
}
|
||||
})
|
||||
.collect();
|
||||
|
||||
Some(gateways)
|
||||
}
|
||||
|
||||
fn parse_priority_rules(element: &Element) -> Vec<PriorityRule> {
|
||||
element
|
||||
.children("entry")
|
||||
.iter()
|
||||
.map(|n| {
|
||||
let name = n.attr("name").map(|s| s.to_string()).unwrap_or_default();
|
||||
let priority: u32 = parse_priority(n);
|
||||
|
||||
PriorityRule { name, priority }
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn parse_priority(element: &Element) -> u32 {
|
||||
element
|
||||
.child_text("priority")
|
||||
.and_then(|s| s.parse().ok())
|
||||
.unwrap_or(u32::MAX)
|
||||
}
|
||||
@@ -1,11 +1,12 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use common::constants::GP_USER_AGENT;
|
||||
use log::info;
|
||||
use reqwest::Client;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use specta::Type;
|
||||
|
||||
use crate::{utils::request::create_identity, GP_USER_AGENT};
|
||||
use crate::utils::request::create_identity;
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Clone, Type, Default)]
|
||||
pub enum ClientOs {
|
||||
|
||||
@@ -19,29 +19,3 @@ pub mod clap;
|
||||
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_API_KEY: &[u8; 32] = &[0; 32];
|
||||
|
||||
pub const GP_USER_AGENT: &str = "PAN GlobalProtect";
|
||||
pub const GP_SERVICE_LOCK_FILE: &str = "/var/run/gpservice.lock";
|
||||
pub const GP_CALLBACK_PORT_FILENAME: &str = "gpcallback.port";
|
||||
|
||||
#[cfg(not(debug_assertions))]
|
||||
pub const GP_CLIENT_BINARY: &str = "/usr/bin/gpclient";
|
||||
#[cfg(not(debug_assertions))]
|
||||
pub const GP_SERVICE_BINARY: &str = "/usr/bin/gpservice";
|
||||
#[cfg(not(debug_assertions))]
|
||||
pub const GP_GUI_BINARY: &str = "/usr/bin/gpgui";
|
||||
#[cfg(not(debug_assertions))]
|
||||
pub const GP_GUI_HELPER_BINARY: &str = "/usr/bin/gpgui-helper";
|
||||
#[cfg(not(debug_assertions))]
|
||||
pub(crate) const GP_AUTH_BINARY: &str = "/usr/bin/gpauth";
|
||||
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_CLIENT_BINARY: &str = env!("GP_CLIENT_BINARY");
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_SERVICE_BINARY: &str = env!("GP_SERVICE_BINARY");
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_GUI_BINARY: &str = env!("GP_GUI_BINARY");
|
||||
#[cfg(debug_assertions)]
|
||||
pub const GP_GUI_HELPER_BINARY: &str = env!("GP_GUI_HELPER_BINARY");
|
||||
#[cfg(debug_assertions)]
|
||||
pub(crate) const GP_AUTH_BINARY: &str = env!("GP_AUTH_BINARY");
|
||||
@@ -1,17 +1,17 @@
|
||||
use anyhow::bail;
|
||||
use dns_lookup::lookup_addr;
|
||||
use log::{info, warn};
|
||||
use log::{debug, info, warn};
|
||||
use reqwest::{Client, StatusCode};
|
||||
use roxmltree::{Document, Node};
|
||||
use serde::Serialize;
|
||||
use specta::Type;
|
||||
use xmltree::Element;
|
||||
|
||||
use crate::{
|
||||
credential::{AuthCookieCredential, Credential},
|
||||
error::PortalError,
|
||||
gateway::{parse_gateways, Gateway},
|
||||
gateway::{Gateway, parse_gateways},
|
||||
gp_params::GpParams,
|
||||
utils::{normalize_server, parse_gp_response, remove_url_scheme, xml::NodeExt},
|
||||
utils::{normalize_server, parse_gp_response, remove_url_scheme, xml::ElementExt},
|
||||
};
|
||||
|
||||
#[derive(Debug, Serialize, Type)]
|
||||
@@ -29,6 +29,10 @@ pub struct PortalConfig {
|
||||
* - Some(true): Internal host detection is supported and the user is connected to the internal network
|
||||
*/
|
||||
internal_host_detection: Option<bool>,
|
||||
/**
|
||||
* The version returned by the portal config, if any
|
||||
*/
|
||||
version: Option<String>,
|
||||
}
|
||||
|
||||
impl PortalConfig {
|
||||
@@ -52,6 +56,10 @@ impl PortalConfig {
|
||||
self.internal_host_detection
|
||||
}
|
||||
|
||||
pub fn version(&self) -> Option<&str> {
|
||||
self.version.as_deref()
|
||||
}
|
||||
|
||||
/// In-place sort the gateways by region
|
||||
pub fn sort_gateways(&mut self, region: &str) {
|
||||
let preferred_gateway = self.find_preferred_gateway(region);
|
||||
@@ -133,12 +141,12 @@ pub async fn retrieve_config(portal: &str, cred: &Credential, gp_params: &GpPara
|
||||
bail!(PortalError::ConfigError("Empty portal config response".to_string()))
|
||||
}
|
||||
|
||||
let doc = Document::parse(&res_xml).map_err(|e| PortalError::ConfigError(e.to_string()))?;
|
||||
let root = doc.root();
|
||||
debug!("Portal config response: {}", res_xml);
|
||||
let root = Element::parse(res_xml.as_bytes()).map_err(|e| PortalError::ConfigError(e.to_string()))?;
|
||||
|
||||
let mut ihd_enabled = false;
|
||||
let mut prefer_internal = false;
|
||||
if let Some(ihd_node) = root.find_descendant("internal-host-detection") {
|
||||
if let Some(ihd_node) = root.descendant("internal-host-detection") {
|
||||
ihd_enabled = true;
|
||||
prefer_internal = internal_host_detect(&ihd_node)
|
||||
}
|
||||
@@ -158,21 +166,25 @@ pub async fn retrieve_config(portal: &str, cred: &Credential, gp_params: &GpPara
|
||||
gateways.push(Gateway::new(server.to_string(), server.to_string()));
|
||||
}
|
||||
|
||||
let version = root.descendant_text("version").map(|s| s.to_string());
|
||||
info!("Detected portal version: {:?}", version);
|
||||
|
||||
Ok(PortalConfig {
|
||||
portal: server.to_string(),
|
||||
auth_cookie: AuthCookieCredential::new(cred.username(), user_auth_cookie, prelogon_user_auth_cookie),
|
||||
auth_cookie: AuthCookieCredential::new(cred.username(), &user_auth_cookie, &prelogon_user_auth_cookie),
|
||||
config_cred: cred.clone(),
|
||||
gateways,
|
||||
config_digest: config_digest.map(|s| s.to_string()),
|
||||
internal_host_detection: if ihd_enabled { Some(prefer_internal) } else { None },
|
||||
version,
|
||||
})
|
||||
}
|
||||
|
||||
// Perform DNS lookup and compare the result with the expected hostname
|
||||
fn internal_host_detect(node: &Node) -> bool {
|
||||
fn internal_host_detect(element: &Element) -> bool {
|
||||
let ip_info = [
|
||||
(node.child_text("ip-address"), node.child_text("host")),
|
||||
(node.child_text("ipv6-address"), node.child_text("ipv6-host")),
|
||||
(element.child_text("ip-address"), element.child_text("host")),
|
||||
(element.child_text("ipv6-address"), element.child_text("ipv6-host")),
|
||||
];
|
||||
|
||||
info!("Found internal-host-detection, performing DNS lookup");
|
||||
|
||||
@@ -1,14 +1,14 @@
|
||||
use anyhow::{anyhow, bail};
|
||||
use log::{info, warn};
|
||||
use reqwest::{Client, StatusCode};
|
||||
use roxmltree::Document;
|
||||
use serde::Serialize;
|
||||
use specta::Type;
|
||||
use xmltree::Element;
|
||||
|
||||
use crate::{
|
||||
error::PortalError,
|
||||
gp_params::GpParams,
|
||||
utils::{base64, normalize_server, parse_gp_response, xml::NodeExt},
|
||||
utils::{base64, normalize_server, parse_gp_response, xml::ElementExt},
|
||||
};
|
||||
|
||||
const REQUIRED_PARAMS: [&str; 8] = [
|
||||
@@ -143,32 +143,30 @@ pub async fn prelogin(portal: &str, gp_params: &GpParams) -> anyhow::Result<Prel
|
||||
}
|
||||
|
||||
fn parse_res_xml(res_xml: &str, is_gateway: bool) -> anyhow::Result<Prelogin> {
|
||||
let doc = Document::parse(res_xml)?;
|
||||
let root = doc.root();
|
||||
let root = Element::parse(res_xml.as_bytes())?;
|
||||
|
||||
let status = root
|
||||
.descendant_text("status")
|
||||
.ok_or_else(|| anyhow::anyhow!("Prelogin response does not contain status element"))?;
|
||||
// Check the status of the prelogin response
|
||||
if status.to_uppercase() != "SUCCESS" {
|
||||
let msg = root.descendant_text("msg").unwrap_or("Unknown error");
|
||||
let msg = root
|
||||
.descendant_text("msg")
|
||||
.unwrap_or_else(|| String::from("Unknown error"));
|
||||
bail!("{}", msg)
|
||||
}
|
||||
|
||||
let region = root
|
||||
.descendant_text("region")
|
||||
.unwrap_or_else(|| {
|
||||
info!("Prelogin response does not contain region element");
|
||||
"Unknown"
|
||||
})
|
||||
.to_string();
|
||||
let region = root.descendant_text("region").unwrap_or_else(|| {
|
||||
info!("Prelogin response does not contain region element");
|
||||
String::from("Unknown")
|
||||
});
|
||||
|
||||
let saml_method = root.descendant_text("saml-auth-method");
|
||||
let saml_request = root.descendant_text("saml-request");
|
||||
let saml_default_browser = root.descendant_text("saml-default-browser");
|
||||
// Check if the prelogin response is SAML
|
||||
if saml_method.is_some() && saml_request.is_some() {
|
||||
let saml_request = base64::decode_to_string(saml_request.unwrap())?;
|
||||
let saml_request = base64::decode_to_string(&saml_request.unwrap())?;
|
||||
let support_default_browser = saml_default_browser.map(|s| s.to_lowercase() == "yes").unwrap_or(false);
|
||||
|
||||
let saml_prelogin = SamlPrelogin {
|
||||
@@ -181,25 +179,18 @@ fn parse_res_xml(res_xml: &str, is_gateway: bool) -> anyhow::Result<Prelogin> {
|
||||
return Ok(Prelogin::Saml(saml_prelogin));
|
||||
}
|
||||
|
||||
let label_username = root
|
||||
.descendant_text("username-label")
|
||||
.unwrap_or_else(|| {
|
||||
info!("Username label has no value, using default");
|
||||
"Username"
|
||||
})
|
||||
.to_string();
|
||||
let label_password = root
|
||||
.descendant_text("password-label")
|
||||
.unwrap_or_else(|| {
|
||||
info!("Password label has no value, using default");
|
||||
"Password"
|
||||
})
|
||||
.to_string();
|
||||
let label_username = root.descendant_text("username-label").unwrap_or_else(|| {
|
||||
info!("Username label has no value, using default");
|
||||
String::from("Username")
|
||||
});
|
||||
let label_password = root.descendant_text("password-label").unwrap_or_else(|| {
|
||||
info!("Password label has no value, using default");
|
||||
String::from("Password")
|
||||
});
|
||||
|
||||
let auth_message = root
|
||||
.descendant_text("authentication-message")
|
||||
.unwrap_or("Please enter the login credentials")
|
||||
.to_string();
|
||||
.unwrap_or_else(|| String::from("Please enter the login credentials"));
|
||||
let standard_prelogin = StandardPrelogin {
|
||||
region,
|
||||
is_gateway,
|
||||
|
||||
@@ -1,14 +1,16 @@
|
||||
use std::process::Stdio;
|
||||
|
||||
use anyhow::bail;
|
||||
use common::constants::GP_AUTH_BINARY;
|
||||
use tokio::process::Command;
|
||||
|
||||
use crate::{auth::SamlAuthResult, credential::Credential, GP_AUTH_BINARY};
|
||||
use crate::{auth::SamlAuthResult, credential::Credential};
|
||||
|
||||
use super::command_traits::CommandExt;
|
||||
|
||||
pub struct SamlAuthLauncher<'a> {
|
||||
server: &'a str,
|
||||
auth_executable: Option<&'a str>,
|
||||
gateway: bool,
|
||||
saml_request: Option<&'a str>,
|
||||
user_agent: Option<&'a str>,
|
||||
@@ -30,6 +32,7 @@ impl<'a> SamlAuthLauncher<'a> {
|
||||
pub fn new(server: &'a str) -> Self {
|
||||
Self {
|
||||
server,
|
||||
auth_executable: None,
|
||||
gateway: false,
|
||||
saml_request: None,
|
||||
user_agent: None,
|
||||
@@ -48,6 +51,11 @@ impl<'a> SamlAuthLauncher<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn auth_executable(mut self, auth_executable: Option<&'a str>) -> Self {
|
||||
self.auth_executable = auth_executable;
|
||||
self
|
||||
}
|
||||
|
||||
pub fn gateway(mut self, gateway: bool) -> Self {
|
||||
self.gateway = gateway;
|
||||
self
|
||||
@@ -113,7 +121,8 @@ impl<'a> SamlAuthLauncher<'a> {
|
||||
|
||||
/// Launch the authenticator binary as the current user or SUDO_USER if available.
|
||||
pub async fn launch(self) -> anyhow::Result<Credential> {
|
||||
let mut auth_cmd = Command::new(GP_AUTH_BINARY);
|
||||
let program = self.auth_executable.unwrap_or(GP_AUTH_BINARY);
|
||||
let mut auth_cmd = Command::new(program);
|
||||
auth_cmd.arg(self.server);
|
||||
|
||||
if self.gateway {
|
||||
|
||||
@@ -11,10 +11,18 @@ pub trait CommandExt {
|
||||
|
||||
impl CommandExt for Command {
|
||||
fn new_pkexec<S: AsRef<OsStr>>(program: S) -> Command {
|
||||
let mut cmd = Command::new("pkexec");
|
||||
cmd.arg("--user").arg("root").arg(program);
|
||||
|
||||
cmd
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
let mut cmd = Command::new("sudo");
|
||||
cmd.arg(program);
|
||||
cmd
|
||||
}
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
{
|
||||
let mut cmd = Command::new("pkexec");
|
||||
cmd.arg("--user").arg("root").arg(program);
|
||||
cmd
|
||||
}
|
||||
}
|
||||
|
||||
fn into_non_root(mut self) -> anyhow::Result<Command> {
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
use std::{collections::HashMap, path::PathBuf, process::Stdio};
|
||||
|
||||
use anyhow::bail;
|
||||
use common::constants::GP_GUI_HELPER_BINARY;
|
||||
use log::info;
|
||||
use tokio::{io::AsyncWriteExt, process::Command};
|
||||
|
||||
use crate::{process::command_traits::CommandExt, utils, GP_GUI_HELPER_BINARY};
|
||||
use crate::{process::command_traits::CommandExt, utils};
|
||||
|
||||
pub struct GuiHelperLauncher<'a> {
|
||||
program: PathBuf,
|
||||
|
||||
@@ -5,10 +5,11 @@ use std::{
|
||||
};
|
||||
|
||||
use anyhow::bail;
|
||||
use common::constants::GP_GUI_BINARY;
|
||||
use log::info;
|
||||
use tokio::{io::AsyncWriteExt, process::Command};
|
||||
|
||||
use crate::{process::gui_helper_launcher::GuiHelperLauncher, utils::base64, GP_GUI_BINARY};
|
||||
use crate::{process::gui_helper_launcher::GuiHelperLauncher, utils::base64};
|
||||
|
||||
use super::command_traits::CommandExt;
|
||||
|
||||
|
||||
@@ -4,10 +4,9 @@ use std::{
|
||||
process::{ExitStatus, Stdio},
|
||||
};
|
||||
|
||||
use common::constants::GP_SERVICE_BINARY;
|
||||
use tokio::process::Command;
|
||||
|
||||
use crate::GP_SERVICE_BINARY;
|
||||
|
||||
use super::command_traits::CommandExt;
|
||||
|
||||
pub struct ServiceLauncher<'a> {
|
||||
@@ -15,7 +14,7 @@ pub struct ServiceLauncher<'a> {
|
||||
minimized: bool,
|
||||
env_file: Option<String>,
|
||||
log_file: Option<String>,
|
||||
verbose: Option<&'a str>
|
||||
verbose: Option<&'a str>,
|
||||
}
|
||||
|
||||
impl Default for ServiceLauncher<'_> {
|
||||
@@ -31,7 +30,7 @@ impl<'a> ServiceLauncher<'a> {
|
||||
minimized: false,
|
||||
env_file: None,
|
||||
log_file: None,
|
||||
verbose: None
|
||||
verbose: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,10 +1,11 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use super::vpn_state::VpnState;
|
||||
use crate::service::{vpn_env::VpnEnv, vpn_state::VpnState};
|
||||
|
||||
/// Events that can be emitted by the service
|
||||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||||
pub enum WsEvent {
|
||||
VpnEnv(VpnEnv),
|
||||
VpnState(VpnState),
|
||||
ActiveGui,
|
||||
ResumeConnection,
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
pub mod event;
|
||||
pub mod request;
|
||||
pub mod vpn_env;
|
||||
pub mod vpn_state;
|
||||
@@ -31,13 +31,19 @@ impl LaunchGuiRequest {
|
||||
pub struct ConnectArgs {
|
||||
cookie: String,
|
||||
vpnc_script: Option<String>,
|
||||
|
||||
user_agent: Option<String>,
|
||||
os: Option<ClientOs>,
|
||||
client_version: Option<String>,
|
||||
|
||||
certificate: Option<String>,
|
||||
sslkey: Option<String>,
|
||||
key_password: Option<String>,
|
||||
|
||||
hip: bool,
|
||||
csd_uid: u32,
|
||||
csd_wrapper: Option<String>,
|
||||
|
||||
reconnect_timeout: u32,
|
||||
mtu: u32,
|
||||
disable_ipv6: bool,
|
||||
@@ -51,9 +57,11 @@ impl ConnectArgs {
|
||||
vpnc_script: None,
|
||||
user_agent: None,
|
||||
os: None,
|
||||
client_version: None,
|
||||
certificate: None,
|
||||
sslkey: None,
|
||||
key_password: None,
|
||||
hip: false,
|
||||
csd_uid: 0,
|
||||
csd_wrapper: None,
|
||||
reconnect_timeout: 300,
|
||||
@@ -79,6 +87,10 @@ impl ConnectArgs {
|
||||
self.os.as_ref().map(|os| os.to_openconnect_os().to_string())
|
||||
}
|
||||
|
||||
pub fn client_version(&self) -> Option<String> {
|
||||
self.client_version.clone()
|
||||
}
|
||||
|
||||
pub fn certificate(&self) -> Option<String> {
|
||||
self.certificate.clone()
|
||||
}
|
||||
@@ -91,6 +103,10 @@ impl ConnectArgs {
|
||||
self.key_password.clone()
|
||||
}
|
||||
|
||||
pub fn hip(&self) -> bool {
|
||||
self.hip
|
||||
}
|
||||
|
||||
pub fn csd_uid(&self) -> u32 {
|
||||
self.csd_uid
|
||||
}
|
||||
@@ -135,6 +151,11 @@ impl ConnectRequest {
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_hip(mut self, hip: bool) -> Self {
|
||||
self.args.hip = hip;
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_csd_uid(mut self, csd_uid: u32) -> Self {
|
||||
self.args.csd_uid = csd_uid;
|
||||
self
|
||||
@@ -155,6 +176,11 @@ impl ConnectRequest {
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_client_version(mut self, client_version: &str) -> Self {
|
||||
self.args.client_version = Some(client_version.to_string());
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_certificate<T: Into<Option<String>>>(mut self, certificate: T) -> Self {
|
||||
self.args.certificate = certificate.into();
|
||||
self
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::service::vpn_state::VpnState;
|
||||
|
||||
/// Represents the VPN environment configuration.
|
||||
/// When a client connects, the gpservice sends the current VPN environment
|
||||
/// to the client so that it can configure itself accordingly.
|
||||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||||
pub struct VpnEnv {
|
||||
/// The VPN connection state
|
||||
pub vpn_state: VpnState,
|
||||
|
||||
/// The default VPN script path
|
||||
pub vpnc_script: Option<String>,
|
||||
|
||||
/// The default CSD wrapper script path
|
||||
pub csd_wrapper: Option<String>,
|
||||
|
||||
/// The gpauth executable path
|
||||
/// Used by the client to launch gpauth for authentication
|
||||
pub auth_executable: String,
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
use chacha20poly1305::{
|
||||
aead::{Aead, OsRng},
|
||||
AeadCore, ChaCha20Poly1305, Key, KeyInit, Nonce,
|
||||
AeadCore, ChaCha20Poly1305, Key, KeyInit,
|
||||
};
|
||||
use serde::{de::DeserializeOwned, Serialize};
|
||||
|
||||
@@ -31,10 +31,10 @@ where
|
||||
{
|
||||
let cipher = ChaCha20Poly1305::new(key);
|
||||
|
||||
let nonce = Nonce::from_slice(&encrypted[..12]);
|
||||
let nonce = &encrypted[..12];
|
||||
let cipher_text = &encrypted[12..];
|
||||
|
||||
let plaintext = cipher.decrypt(nonce, cipher_text)?;
|
||||
let plaintext = cipher.decrypt(nonce.into(), cipher_text)?;
|
||||
|
||||
let value = serde_json::from_slice(&plaintext)?;
|
||||
|
||||
|
||||
@@ -39,17 +39,13 @@ pub fn load_env_vars<T: AsRef<Path>>(env_file: T) -> anyhow::Result<HashMap<Stri
|
||||
|
||||
pub fn patch_gui_runtime_env(hidpi: bool) {
|
||||
// This is to avoid blank screen on some systems
|
||||
std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1");
|
||||
|
||||
// Workaround for https://github.com/tauri-apps/tao/issues/929
|
||||
let is_wayland = std::env::var("XDG_SESSION_TYPE").unwrap_or_default() == "wayland";
|
||||
if is_wayland {
|
||||
env::set_var("GDK_BACKEND", "x11");
|
||||
}
|
||||
unsafe { std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1") };
|
||||
|
||||
if hidpi {
|
||||
info!("Setting GDK_SCALE=2 and GDK_DPI_SCALE=0.5");
|
||||
std::env::set_var("GDK_SCALE", "2");
|
||||
std::env::set_var("GDK_DPI_SCALE", "0.5");
|
||||
unsafe {
|
||||
std::env::set_var("GDK_SCALE", "2");
|
||||
std::env::set_var("GDK_DPI_SCALE", "0.5");
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
use std::sync::OnceLock;
|
||||
|
||||
const DEFAULT_MACOS_VERSION: &str = "13.4.0";
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
const DEFAULT_LINUX_DISTRO: &str = "Ubuntu 24.04.3 LTS";
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
const DEFAULT_WINDOWS_DISTRO: &str = "Windows 11 Pro";
|
||||
const DEFAULT_WINDOWS_VERSION: &str = "10.0.22631.0";
|
||||
const DEFAULT_MACHINE_ID: &str = "DEADBEEF-DEAD-BEEF-DEAD-BEEFDEADBEEF";
|
||||
|
||||
static MACHINE_ID: OnceLock<&'static str> = OnceLock::new();
|
||||
static MACOS_VERSION: OnceLock<&'static str> = OnceLock::new();
|
||||
static MACOS_OS_STRING: OnceLock<String> = OnceLock::new();
|
||||
static LINUX_OS_STRING: OnceLock<String> = OnceLock::new();
|
||||
static WINDOWS_VERSION: OnceLock<&'static str> = OnceLock::new();
|
||||
static WINDOWS_OS_STRING: OnceLock<String> = OnceLock::new();
|
||||
|
||||
/// On macOS, get the OS version, or fallback to default
|
||||
/// On other OSes, always return default
|
||||
pub fn get_macos_version() -> &'static str {
|
||||
MACOS_VERSION.get_or_init(|| {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
match os_info::get().version() {
|
||||
os_info::Version::Unknown => DEFAULT_MACOS_VERSION,
|
||||
v => v.to_string().leak(),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
DEFAULT_MACOS_VERSION
|
||||
})
|
||||
}
|
||||
|
||||
pub fn get_macos_os_string() -> &'static str {
|
||||
MACOS_OS_STRING.get_or_init(|| format!("Apple Mac OS X {}", get_macos_version()))
|
||||
}
|
||||
|
||||
/// On Linux, use the real distro name if possible
|
||||
/// On other OSes, fallback to default
|
||||
pub fn get_linux_os_string() -> &'static str {
|
||||
LINUX_OS_STRING.get_or_init(|| {
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
format!("Linux {}", whoami::distro())
|
||||
}
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
{
|
||||
format!("Linux {}", DEFAULT_LINUX_DISTRO)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// On Windows, get the OS version, or fallback to default
|
||||
/// On other OSes, always return default
|
||||
pub fn get_windows_version() -> &'static str {
|
||||
WINDOWS_VERSION.get_or_init(|| {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
match os_info::get().version() {
|
||||
os_info::Version::Unknown => DEFAULT_WINDOWS_VERSION,
|
||||
v => format!("{}.0", v).leak(),
|
||||
}
|
||||
}
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
DEFAULT_WINDOWS_VERSION
|
||||
})
|
||||
}
|
||||
|
||||
/// On Windows, use the real edition if possible
|
||||
/// On other OSes, fallback to default
|
||||
/// The trailing space is intentional
|
||||
pub fn get_windows_os_string() -> &'static str {
|
||||
WINDOWS_OS_STRING.get_or_init(|| {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
let edition = os_info::get()
|
||||
.edition()
|
||||
.map(|e| e.to_string())
|
||||
.unwrap_or_else(|| whoami::distro());
|
||||
format!("Microsoft {} , 64-bit", edition)
|
||||
}
|
||||
#[cfg(not(target_os = "windows"))]
|
||||
{
|
||||
format!("Microsoft {} , 64-bit", DEFAULT_WINDOWS_DISTRO)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Get machine ID or fallback to default
|
||||
pub fn get_machine_id() -> &'static str {
|
||||
MACHINE_ID.get_or_init(|| {
|
||||
machine_uid::get()
|
||||
.map(|id| id.to_string().leak() as &'static str)
|
||||
.unwrap_or(DEFAULT_MACHINE_ID)
|
||||
})
|
||||
}
|
||||
|
||||
/// Generate a UUID v5 based on machine ID and provided seeds
|
||||
pub fn derive_uuid(seeds: &[&str]) -> String {
|
||||
use uuid::Uuid;
|
||||
|
||||
let namespace = Uuid::NAMESPACE_DNS;
|
||||
let name = format!("{}-{}", get_machine_id(), seeds.join("-"));
|
||||
|
||||
let uuid = Uuid::new_v5(&namespace, name.as_bytes());
|
||||
uuid.hyphenated().to_string()
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
use std::path::PathBuf;
|
||||
|
||||
use common::constants::GP_SERVICE_LOCK_FILE;
|
||||
use thiserror::Error;
|
||||
use tokio::fs;
|
||||
|
||||
@@ -94,7 +95,7 @@ impl LockInfo {
|
||||
}
|
||||
|
||||
pub async fn gpservice_lock_info() -> Result<LockInfo, LockFileError> {
|
||||
LockInfo::from_file(crate::GP_SERVICE_LOCK_FILE).await
|
||||
LockInfo::from_file(GP_SERVICE_LOCK_FILE).await
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -5,6 +5,7 @@ pub mod checksum;
|
||||
pub mod crypto;
|
||||
pub mod endpoint;
|
||||
pub mod env_utils;
|
||||
pub mod host_utils;
|
||||
pub mod lock_file;
|
||||
pub mod openssl;
|
||||
pub mod redact;
|
||||
|
||||
@@ -46,7 +46,7 @@ pub fn fix_openssl_env() -> anyhow::Result<NamedTempFile> {
|
||||
let openssl_conf_path = openssl_conf.path();
|
||||
|
||||
fix_openssl(openssl_conf_path)?;
|
||||
std::env::set_var("OPENSSL_CONF", openssl_conf_path);
|
||||
unsafe { std::env::set_var("OPENSSL_CONF", openssl_conf_path) };
|
||||
|
||||
Ok(openssl_conf)
|
||||
}
|
||||
|
||||
@@ -1,73 +1,97 @@
|
||||
use std::{process::ExitStatus, time::Duration};
|
||||
|
||||
use anyhow::bail;
|
||||
use log::info;
|
||||
use tauri::WebviewWindow;
|
||||
use tokio::process::Command;
|
||||
|
||||
pub trait WindowExt {
|
||||
fn raise(&self) -> anyhow::Result<()>;
|
||||
}
|
||||
|
||||
impl WindowExt for WebviewWindow {
|
||||
#[cfg(any(target_os = "macos", target_os = "windows"))]
|
||||
fn raise(&self) -> anyhow::Result<()> {
|
||||
raise_window(self)
|
||||
self.show()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
|
||||
fn raise(&self) -> anyhow::Result<()> {
|
||||
unix::raise_window(self)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn raise_window(win: &WebviewWindow) -> anyhow::Result<()> {
|
||||
let is_wayland = std::env::var("XDG_SESSION_TYPE").unwrap_or_default() == "wayland";
|
||||
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
|
||||
mod unix {
|
||||
use std::{process::ExitStatus, time::Duration};
|
||||
|
||||
if is_wayland {
|
||||
win.hide()?;
|
||||
win.show()?;
|
||||
} else {
|
||||
if !win.is_visible()? {
|
||||
win.show()?;
|
||||
}
|
||||
let title = win.title()?;
|
||||
tokio::spawn(async move {
|
||||
if let Err(err) = wmctrl_raise_window(&title).await {
|
||||
info!("Window not raised: {}", err);
|
||||
use anyhow::bail;
|
||||
use gtk::{
|
||||
glib::Cast,
|
||||
traits::{EventBoxExt, GtkWindowExt, WidgetExt},
|
||||
EventBox,
|
||||
};
|
||||
use log::info;
|
||||
use tauri::WebviewWindow;
|
||||
use tokio::process::Command;
|
||||
|
||||
pub fn raise_window(win: &WebviewWindow) -> anyhow::Result<()> {
|
||||
let is_wayland = std::env::var("XDG_SESSION_TYPE").unwrap_or_default() == "wayland";
|
||||
|
||||
if is_wayland {
|
||||
let gtk_win = win.gtk_window()?;
|
||||
if let Some(header) = gtk_win.titlebar() {
|
||||
let _ = header.downcast::<EventBox>().map(|event_box| {
|
||||
event_box.set_above_child(false);
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Calling window.show() on Windows will cause the menu to be shown.
|
||||
// We need to hide it again.
|
||||
win.hide_menu()?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn wmctrl_raise_window(title: &str) -> anyhow::Result<()> {
|
||||
let mut counter = 0;
|
||||
|
||||
loop {
|
||||
if let Ok(exit_status) = wmctrl_try_raise_window(title).await {
|
||||
if exit_status.success() {
|
||||
info!("Window raised after {} attempts", counter + 1);
|
||||
return Ok(());
|
||||
gtk_win.hide();
|
||||
gtk_win.show_all();
|
||||
} else {
|
||||
if !win.is_visible()? {
|
||||
win.show()?;
|
||||
}
|
||||
let title = win.title()?;
|
||||
tokio::spawn(async move {
|
||||
if let Err(err) = wmctrl_raise_window(&title).await {
|
||||
info!("Window not raised: {}", err);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if counter >= 10 {
|
||||
bail!("Failed to raise window: {}", title)
|
||||
}
|
||||
// Calling window.show() on window object will cause the menu to be shown.
|
||||
// We need to hide it again.
|
||||
win.hide_menu()?;
|
||||
|
||||
counter += 1;
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn wmctrl_raise_window(title: &str) -> anyhow::Result<()> {
|
||||
let mut counter = 0;
|
||||
|
||||
loop {
|
||||
if let Ok(exit_status) = wmctrl_try_raise_window(title).await {
|
||||
if exit_status.success() {
|
||||
info!("Window raised after {} attempts", counter + 1);
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
|
||||
if counter >= 10 {
|
||||
bail!("Failed to raise window: {}", title)
|
||||
}
|
||||
|
||||
counter += 1;
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
}
|
||||
|
||||
async fn wmctrl_try_raise_window(title: &str) -> anyhow::Result<ExitStatus> {
|
||||
let exit_status = Command::new("wmctrl")
|
||||
.arg("-F")
|
||||
.arg("-a")
|
||||
.arg(title)
|
||||
.spawn()?
|
||||
.wait()
|
||||
.await?;
|
||||
|
||||
Ok(exit_status)
|
||||
}
|
||||
}
|
||||
|
||||
async fn wmctrl_try_raise_window(title: &str) -> anyhow::Result<ExitStatus> {
|
||||
let exit_status = Command::new("wmctrl")
|
||||
.arg("-F")
|
||||
.arg("-a")
|
||||
.arg(title)
|
||||
.spawn()?
|
||||
.wait()
|
||||
.await?;
|
||||
|
||||
Ok(exit_status)
|
||||
}
|
||||
@@ -1,27 +1,87 @@
|
||||
use roxmltree::Node;
|
||||
use xmltree::Element;
|
||||
|
||||
pub(crate) trait NodeExt<'a> {
|
||||
fn find_descendant(&self, name: &str) -> Option<Node<'a, 'a>>;
|
||||
fn descendant_text(&self, name: &str) -> Option<&'a str>;
|
||||
pub(crate) trait ElementExt {
|
||||
/// Recursively find all descendants with the given name
|
||||
fn descendants(&self, name: &str) -> Vec<&Element>;
|
||||
|
||||
fn find_child(&self, name: &str) -> Option<Node<'a, 'a>>;
|
||||
fn child_text(&self, name: &str) -> Option<&'a str>;
|
||||
/// Recursively find the first descendant with the given name
|
||||
fn descendant(&self, name: &str) -> Option<&Element>;
|
||||
|
||||
/// Recursively find the text of the first descendant with the given name
|
||||
fn descendant_text(&self, name: &str) -> Option<String>;
|
||||
|
||||
/// Find the first child with the given name
|
||||
fn child(&self, name: &str) -> Option<&Element>;
|
||||
|
||||
/// Find the text of the first child with the given name
|
||||
fn child_text(&self, name: &str) -> Option<String>;
|
||||
|
||||
/// Get the direct child element with the given name
|
||||
fn children(&self, name: &str) -> Vec<&Element>;
|
||||
|
||||
/// Get the attribute value by name
|
||||
fn attr(&self, name: &str) -> Option<&str>;
|
||||
}
|
||||
|
||||
impl<'a> NodeExt<'a> for Node<'a, 'a> {
|
||||
fn find_descendant(&self, name: &str) -> Option<Node<'a, 'a>> {
|
||||
self.descendants().find(|n| n.has_tag_name(name))
|
||||
impl ElementExt for Element {
|
||||
fn descendants(&self, name: &str) -> Vec<&Element> {
|
||||
let mut results = Vec::new();
|
||||
|
||||
if self.name == name {
|
||||
results.push(self);
|
||||
}
|
||||
|
||||
for child in &self.children {
|
||||
if let Some(element) = child.as_element() {
|
||||
results.extend(element.descendants(name));
|
||||
}
|
||||
}
|
||||
|
||||
results
|
||||
}
|
||||
|
||||
fn descendant_text(&self, name: &str) -> Option<&'a str> {
|
||||
self.find_descendant(name).and_then(|node| node.text())
|
||||
fn descendant(&self, name: &str) -> Option<&Element> {
|
||||
if self.name == name {
|
||||
return Some(self);
|
||||
}
|
||||
|
||||
for child in &self.children {
|
||||
if let Some(element) = child.as_element() {
|
||||
if let Some(found) = element.descendant(name) {
|
||||
return Some(found);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
|
||||
fn find_child(&self, name: &str) -> Option<Node<'a, 'a>> {
|
||||
self.children().find(|n| n.has_tag_name(name))
|
||||
fn descendant_text(&self, name: &str) -> Option<String> {
|
||||
self
|
||||
.descendant(name)
|
||||
.and_then(|element| element.get_text().map(|s| s.to_string()))
|
||||
}
|
||||
|
||||
fn child_text(&self, name: &str) -> Option<&'a str> {
|
||||
self.find_child(name).and_then(|node| node.text())
|
||||
fn child(&self, name: &str) -> Option<&Element> {
|
||||
self.get_child(name)
|
||||
}
|
||||
|
||||
fn child_text(&self, name: &str) -> Option<String> {
|
||||
self
|
||||
.get_child(name)
|
||||
.and_then(|element| element.get_text().map(|s| s.to_string()))
|
||||
}
|
||||
|
||||
fn children(&self, name: &str) -> Vec<&Element> {
|
||||
self
|
||||
.children
|
||||
.iter()
|
||||
.filter_map(|child| child.as_element())
|
||||
.filter(|element| element.name == name)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn attr(&self, name: &str) -> Option<&str> {
|
||||
self.attributes.get(name).map(|s| s.as_str())
|
||||
}
|
||||
}
|
||||
@@ -6,8 +6,11 @@ license.workspace = true
|
||||
links = "openconnect"
|
||||
|
||||
[dependencies]
|
||||
common = { path = "../common" }
|
||||
log.workspace = true
|
||||
is_executable.workspace = true
|
||||
|
||||
[build-dependencies]
|
||||
cc = "1"
|
||||
autotools = "0.2"
|
||||
pkg-config = "0.3"
|
||||
fs_extra = "1"
|
||||
@@ -1,14 +1,91 @@
|
||||
use std::{env, path::PathBuf, process::Command};
|
||||
|
||||
fn main() {
|
||||
// Link to the native openconnect library
|
||||
println!("cargo:rustc-link-lib=openconnect");
|
||||
println!("cargo:rustc-link-search=/opt/homebrew/lib"); // Homebrew path
|
||||
let manifest_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
|
||||
let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
|
||||
let deps_dir = PathBuf::from(&manifest_dir).join("../../deps");
|
||||
let openconnect_dir = deps_dir.join("openconnect");
|
||||
let gp_version_patch = deps_dir.join("patches/openconnect-gp-version.patch");
|
||||
|
||||
// The temporary location where we will build
|
||||
let build_src = out_dir.join("openconnect_build");
|
||||
|
||||
// Track changes so cargo rebuilds if patch or submodule changes
|
||||
println!("cargo:rerun-if-changed={}", openconnect_dir.display());
|
||||
println!("cargo:rerun-if-changed={}", gp_version_patch.display());
|
||||
|
||||
// Prepare the build directory
|
||||
// If the directory exists from a previous run, remove it to ensure a clean slate
|
||||
if build_src.exists() {
|
||||
std::fs::remove_dir_all(&build_src).unwrap();
|
||||
}
|
||||
std::fs::create_dir_all(&build_src).unwrap();
|
||||
|
||||
// Copy the source code to OUT_DIR
|
||||
// We use fs_extra options to copy contents recursively
|
||||
let mut options = fs_extra::dir::CopyOptions::new();
|
||||
options.overwrite = true;
|
||||
options.content_only = true; // Copy content of src into dest, not src folder itself
|
||||
|
||||
fs_extra::dir::copy(&openconnect_dir, &build_src, &options).expect("Failed to copy C source code to OUT_DIR");
|
||||
|
||||
// Apply the Patch
|
||||
// We use the system `patch` command.
|
||||
let status = Command::new("patch")
|
||||
.arg("-p1") // Strip one level of path (standard for git diffs)
|
||||
.arg("-i") // Input file
|
||||
.arg(&gp_version_patch)
|
||||
.current_dir(&build_src) // Run INSIDE the copied dir
|
||||
.status()
|
||||
.expect("Failed to execute patch command");
|
||||
|
||||
if !status.success() {
|
||||
panic!("Failed to apply patch file: {}", gp_version_patch.display());
|
||||
}
|
||||
|
||||
// Build the OpenConnect library using autotools
|
||||
// We explicitly enable static and disable shared to ensure we get a .a file.
|
||||
// .reconf("-ivf") is CRITICAL for git submodules because 'configure'
|
||||
// usually doesn't exist yet and needs to be generated.
|
||||
let dst = autotools::Config::new(&build_src)
|
||||
.reconf("-ivf")
|
||||
.enable_static()
|
||||
.disable_shared()
|
||||
.disable("nls", None) // disable translations to save space
|
||||
.disable("docs", None)
|
||||
.disable("dsa-tests", None)
|
||||
.without("libproxy", None)
|
||||
.without("stoken", None)
|
||||
.without("libpcsclite", None)
|
||||
.without("libpskc", None)
|
||||
.without("gssapi", None)
|
||||
.with("gnutls-tss2", Some("no"))
|
||||
.with("vpnc-script", Some("/etc/vpnc/vpnc-script")) // Specify vpnc-script, otherwise it will fail on macOS
|
||||
.build();
|
||||
|
||||
// Link the 'openconnect' static library
|
||||
println!("cargo:rustc-link-search=native={}/lib", dst.display());
|
||||
println!("cargo:rustc-link-lib=static=openconnect");
|
||||
|
||||
// Using pkg-config to find system deps
|
||||
pkg_config::probe_library("libxml-2.0").unwrap();
|
||||
pkg_config::probe_library("zlib").unwrap();
|
||||
pkg_config::probe_library("liblz4").unwrap();
|
||||
pkg_config::probe_library("gnutls").unwrap();
|
||||
|
||||
// Below are required by gnutls
|
||||
pkg_config::probe_library("p11-kit-1").unwrap();
|
||||
pkg_config::probe_library("hogweed").unwrap();
|
||||
pkg_config::probe_library("nettle").unwrap();
|
||||
pkg_config::probe_library("gmp").unwrap();
|
||||
|
||||
// Compile the vpn.c file
|
||||
println!("cargo:rerun-if-changed=src/ffi/vpn.c");
|
||||
println!("cargo:rerun-if-changed=src/ffi/vpn.h");
|
||||
|
||||
// Compile the vpn.c file
|
||||
cc::Build::new()
|
||||
.file("src/ffi/vpn.c")
|
||||
.include("src/ffi")
|
||||
.include("/opt/homebrew/include") // Homebrew path
|
||||
.include(&dst.join("include"))
|
||||
.compile("vpn");
|
||||
}
|
||||
@@ -2,6 +2,7 @@ use crate::Vpn;
|
||||
use log::{debug, info, trace, warn};
|
||||
use std::ffi::{c_char, c_int, c_void};
|
||||
|
||||
/// ConnectOptions struct for FFI, the field names and order must match the C definition.
|
||||
#[repr(C)]
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct ConnectOptions {
|
||||
@@ -9,10 +10,15 @@ pub(crate) struct ConnectOptions {
|
||||
|
||||
pub server: *const c_char,
|
||||
pub cookie: *const c_char,
|
||||
|
||||
pub user_agent: *const c_char,
|
||||
pub os: *const c_char,
|
||||
pub client_version: *const c_char,
|
||||
|
||||
pub script: *const c_char,
|
||||
pub os: *const c_char,
|
||||
pub interface: *const c_char,
|
||||
pub script_tun: u32,
|
||||
|
||||
pub certificate: *const c_char,
|
||||
pub sslkey: *const c_char,
|
||||
pub key_password: *const c_char,
|
||||
@@ -25,10 +31,12 @@ pub(crate) struct ConnectOptions {
|
||||
pub mtu: u32,
|
||||
pub disable_ipv6: u32,
|
||||
pub no_dtls: u32,
|
||||
|
||||
pub dpd_interval: u32,
|
||||
}
|
||||
|
||||
#[link(name = "vpn")]
|
||||
extern "C" {
|
||||
unsafe extern "C" {
|
||||
#[link_name = "vpn_connect"]
|
||||
fn vpn_connect(options: *const ConnectOptions, callback: extern "C" fn(i32, *mut c_void)) -> c_int;
|
||||
|
||||
@@ -44,7 +52,7 @@ pub(crate) fn disconnect() {
|
||||
unsafe { vpn_disconnect() }
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn on_vpn_connected(pipe_fd: i32, vpn: *mut c_void) {
|
||||
let vpn = unsafe { &*(vpn as *const Vpn) };
|
||||
vpn.on_connected(pipe_fd);
|
||||
@@ -53,7 +61,7 @@ extern "C" fn on_vpn_connected(pipe_fd: i32, vpn: *mut c_void) {
|
||||
// Logger used in the C code.
|
||||
// level: 0 = error, 1 = info, 2 = debug, 3 = trace
|
||||
// map the error level log in openconnect to the warning level
|
||||
#[no_mangle]
|
||||
#[unsafe(no_mangle)]
|
||||
extern "C" fn vpn_log(level: i32, message: *const c_char) {
|
||||
let message = unsafe { std::ffi::CStr::from_ptr(message) };
|
||||
let message = message.to_str().unwrap_or("Invalid log message");
|
||||
|
||||
@@ -1,9 +1,9 @@
|
||||
#include <openconnect.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/utsname.h>
|
||||
#include <openconnect.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "vpn.h"
|
||||
|
||||
@@ -11,143 +11,173 @@ void *g_user_data;
|
||||
|
||||
static int g_cmd_pipe_fd;
|
||||
static const char *g_vpnc_script;
|
||||
static const char *g_vpnc_interface;
|
||||
static int g_script_tun;
|
||||
static vpn_connected_callback on_vpn_connected;
|
||||
|
||||
/* Validate the peer certificate */
|
||||
static int validate_peer_cert(__attribute__((unused)) void *_vpninfo, const char *reason)
|
||||
static int validate_peer_cert(__attribute__((unused)) void *_vpninfo,
|
||||
const char *reason)
|
||||
{
|
||||
INFO("Accepting the server certificate though %s", reason);
|
||||
return 0;
|
||||
INFO("Accepting the server certificate though %s", reason);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Print progress messages */
|
||||
static void print_progress(__attribute__((unused)) void *_vpninfo, int level, const char *format, ...)
|
||||
static void print_progress(__attribute__((unused)) void *_vpninfo, int level,
|
||||
const char *format, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
char *message = format_message(format, args);
|
||||
va_end(args);
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
char *message = format_message(format, args);
|
||||
va_end(args);
|
||||
|
||||
if (message == NULL) {
|
||||
ERROR("Failed to format log message");
|
||||
} else {
|
||||
LOG(level, message);
|
||||
free(message);
|
||||
}
|
||||
if (message == NULL) {
|
||||
ERROR("Failed to format log message");
|
||||
} else {
|
||||
LOG(level, message);
|
||||
free(message);
|
||||
}
|
||||
}
|
||||
|
||||
static void setup_tun_handler(void *_vpninfo)
|
||||
{
|
||||
int ret = openconnect_setup_tun_device(_vpninfo, g_vpnc_script, NULL);
|
||||
if (!ret) {
|
||||
on_vpn_connected(g_cmd_pipe_fd, g_user_data);
|
||||
}
|
||||
int ret;
|
||||
if (g_script_tun) {
|
||||
ret = openconnect_setup_tun_script(_vpninfo, g_vpnc_script);
|
||||
} else {
|
||||
ret = openconnect_setup_tun_device(_vpninfo, g_vpnc_script,
|
||||
g_vpnc_interface);
|
||||
}
|
||||
|
||||
if (!ret) {
|
||||
on_vpn_connected(g_cmd_pipe_fd, g_user_data);
|
||||
}
|
||||
}
|
||||
|
||||
/* Initialize VPN connection */
|
||||
int vpn_connect(const vpn_options *options, vpn_connected_callback callback)
|
||||
{
|
||||
INFO("openconnect version: %s", openconnect_get_version());
|
||||
struct openconnect_info *vpninfo;
|
||||
struct utsname utsbuf;
|
||||
struct openconnect_info *vpninfo;
|
||||
struct utsname utsbuf;
|
||||
|
||||
g_user_data = options->user_data;
|
||||
g_vpnc_script = options->script;
|
||||
on_vpn_connected = callback;
|
||||
g_user_data = options->user_data;
|
||||
g_vpnc_script = options->script;
|
||||
g_vpnc_interface = options->interface;
|
||||
g_script_tun = options->script_tun;
|
||||
on_vpn_connected = callback;
|
||||
|
||||
INFO("User agent: %s", options->user_agent);
|
||||
INFO("VPNC script: %s", options->script);
|
||||
INFO("OS: %s", options->os);
|
||||
INFO("CSD_USER: %d", options->csd_uid);
|
||||
INFO("CSD_WRAPPER: %s", options->csd_wrapper);
|
||||
INFO("RECONNECT_TIMEOUT: %d", options->reconnect_timeout);
|
||||
INFO("MTU: %d", options->mtu);
|
||||
INFO("DISABLE_IPV6: %d", options->disable_ipv6);
|
||||
INFO("NO_DTLS: %d", options->no_dtls);
|
||||
INFO("USER_AGENT: %s", options->user_agent);
|
||||
INFO("OS: %s", options->os);
|
||||
INFO("CLIENT_VERSION: %s", options->client_version);
|
||||
INFO("VPNC_SCRIPT: %s", options->script);
|
||||
INFO("SCRIPT_TUN: %d", g_script_tun);
|
||||
INFO("CSD_USER: %d", options->csd_uid);
|
||||
INFO("CSD_WRAPPER: %s", options->csd_wrapper);
|
||||
INFO("RECONNECT_TIMEOUT: %d", options->reconnect_timeout);
|
||||
INFO("MTU: %d", options->mtu);
|
||||
INFO("DISABLE_IPV6: %d", options->disable_ipv6);
|
||||
INFO("NO_DTLS: %d", options->no_dtls);
|
||||
INFO("DPD_INTERVAL: %d", options->dpd_interval);
|
||||
|
||||
vpninfo = openconnect_vpninfo_new(options->user_agent, validate_peer_cert, NULL, NULL, print_progress, NULL);
|
||||
vpninfo =
|
||||
openconnect_vpninfo_new(options->user_agent, validate_peer_cert,
|
||||
NULL, NULL, print_progress, NULL);
|
||||
|
||||
if (!vpninfo) {
|
||||
ERROR("openconnect_vpninfo_new failed");
|
||||
return 1;
|
||||
}
|
||||
if (!vpninfo) {
|
||||
ERROR("openconnect_vpninfo_new failed");
|
||||
return 1;
|
||||
}
|
||||
|
||||
openconnect_set_loglevel(vpninfo, PRG_TRACE);
|
||||
openconnect_init_ssl();
|
||||
openconnect_set_protocol(vpninfo, "gp");
|
||||
openconnect_set_hostname(vpninfo, options->server);
|
||||
openconnect_set_cookie(vpninfo, options->cookie);
|
||||
openconnect_set_loglevel(vpninfo, PRG_TRACE);
|
||||
openconnect_init_ssl();
|
||||
openconnect_set_protocol(vpninfo, "gp");
|
||||
openconnect_parse_url(vpninfo, options->server);
|
||||
openconnect_set_cookie(vpninfo, options->cookie);
|
||||
|
||||
if (options->os) {
|
||||
openconnect_set_reported_os(vpninfo, options->os);
|
||||
}
|
||||
if (options->os) {
|
||||
openconnect_set_reported_os(vpninfo, options->os);
|
||||
}
|
||||
|
||||
if (options->certificate) {
|
||||
INFO("Setting client certificate: %s", options->certificate);
|
||||
openconnect_set_client_cert(vpninfo, options->certificate, options->sslkey);
|
||||
}
|
||||
if (options->client_version) {
|
||||
openconnect_set_gp_app_version(vpninfo,
|
||||
options->client_version);
|
||||
}
|
||||
|
||||
if (options->key_password) {
|
||||
openconnect_set_key_password(vpninfo, options->key_password);
|
||||
}
|
||||
if (options->certificate) {
|
||||
INFO("Setting client certificate: %s", options->certificate);
|
||||
openconnect_set_client_cert(vpninfo, options->certificate,
|
||||
options->sslkey);
|
||||
}
|
||||
|
||||
if (options->csd_wrapper) {
|
||||
openconnect_setup_csd(vpninfo, options->csd_uid, 1, options->csd_wrapper);
|
||||
}
|
||||
if (options->key_password) {
|
||||
openconnect_set_key_password(vpninfo, options->key_password);
|
||||
}
|
||||
|
||||
if (options->mtu > 0) {
|
||||
int mtu = options->mtu < 576 ? 576 : options->mtu;
|
||||
openconnect_set_reqmtu(vpninfo, mtu);
|
||||
}
|
||||
if (options->csd_wrapper) {
|
||||
openconnect_setup_csd(vpninfo, options->csd_uid, 1,
|
||||
options->csd_wrapper);
|
||||
}
|
||||
|
||||
if (options->disable_ipv6) {
|
||||
openconnect_disable_ipv6(vpninfo);
|
||||
}
|
||||
if (options->mtu > 0) {
|
||||
int mtu = options->mtu < 576 ? 576 : options->mtu;
|
||||
openconnect_set_reqmtu(vpninfo, mtu);
|
||||
}
|
||||
|
||||
g_cmd_pipe_fd = openconnect_setup_cmd_pipe(vpninfo);
|
||||
if (g_cmd_pipe_fd < 0) {
|
||||
ERROR("openconnect_setup_cmd_pipe failed");
|
||||
return 1;
|
||||
}
|
||||
if (options->disable_ipv6) {
|
||||
openconnect_disable_ipv6(vpninfo);
|
||||
}
|
||||
|
||||
if (!uname(&utsbuf)) {
|
||||
openconnect_set_localname(vpninfo, utsbuf.nodename);
|
||||
}
|
||||
if (options->dpd_interval > 0) {
|
||||
openconnect_set_dpd(vpninfo, options->dpd_interval);
|
||||
}
|
||||
|
||||
// Essential step
|
||||
if (openconnect_make_cstp_connection(vpninfo) != 0) {
|
||||
ERROR("openconnect_make_cstp_connection failed");
|
||||
return 1;
|
||||
}
|
||||
g_cmd_pipe_fd = openconnect_setup_cmd_pipe(vpninfo);
|
||||
if (g_cmd_pipe_fd < 0) {
|
||||
ERROR("openconnect_setup_cmd_pipe failed");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (options->no_dtls || openconnect_setup_dtls(vpninfo, 60) != 0) {
|
||||
openconnect_disable_dtls(vpninfo);
|
||||
}
|
||||
if (!uname(&utsbuf)) {
|
||||
openconnect_set_localname(vpninfo, utsbuf.nodename);
|
||||
}
|
||||
|
||||
// Essential step
|
||||
openconnect_set_setup_tun_handler(vpninfo, setup_tun_handler);
|
||||
// Essential step
|
||||
if (openconnect_make_cstp_connection(vpninfo) != 0) {
|
||||
ERROR("openconnect_make_cstp_connection failed");
|
||||
return 1;
|
||||
}
|
||||
|
||||
while (1) {
|
||||
int ret = openconnect_mainloop(vpninfo, options->reconnect_timeout, 10);
|
||||
if (options->no_dtls || openconnect_setup_dtls(vpninfo, 60) != 0) {
|
||||
openconnect_disable_dtls(vpninfo);
|
||||
}
|
||||
|
||||
if (ret) {
|
||||
INFO("openconnect_mainloop returned %d, exiting", ret);
|
||||
openconnect_vpninfo_free(vpninfo);
|
||||
return ret;
|
||||
}
|
||||
// Essential step
|
||||
openconnect_set_setup_tun_handler(vpninfo, setup_tun_handler);
|
||||
|
||||
INFO("openconnect_mainloop returned 0, reconnecting");
|
||||
}
|
||||
while (1) {
|
||||
int ret = openconnect_mainloop(vpninfo,
|
||||
options->reconnect_timeout, 10);
|
||||
|
||||
if (ret) {
|
||||
INFO("openconnect_mainloop returned %d, exiting", ret);
|
||||
openconnect_vpninfo_free(vpninfo);
|
||||
return ret;
|
||||
}
|
||||
|
||||
INFO("openconnect_mainloop returned 0, reconnecting");
|
||||
}
|
||||
}
|
||||
|
||||
/* Stop the VPN connection */
|
||||
void vpn_disconnect()
|
||||
{
|
||||
char cmd = OC_CMD_CANCEL;
|
||||
char cmd = OC_CMD_CANCEL;
|
||||
|
||||
INFO("Stopping VPN connection: %d", g_cmd_pipe_fd);
|
||||
INFO("Stopping VPN connection: %d", g_cmd_pipe_fd);
|
||||
|
||||
if (write(g_cmd_pipe_fd, &cmd, 1) < 0) {
|
||||
ERROR("Failed to write to command pipe, VPN connection may not be stopped");
|
||||
}
|
||||
if (write(g_cmd_pipe_fd, &cmd, 1) < 0) {
|
||||
ERROR("Failed to write to command pipe, VPN connection may not "
|
||||
"be stopped");
|
||||
}
|
||||
}
|
||||
@@ -1,31 +1,38 @@
|
||||
#include <openconnect.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
#include <openconnect.h>
|
||||
|
||||
typedef void (*vpn_connected_callback)(int cmd_pipe_fd, void *user_data);
|
||||
|
||||
typedef struct vpn_options
|
||||
{
|
||||
void *user_data;
|
||||
const char *server;
|
||||
const char *cookie;
|
||||
const char *user_agent;
|
||||
typedef struct vpn_options {
|
||||
void *user_data;
|
||||
|
||||
const char *script;
|
||||
const char *os;
|
||||
const char *certificate;
|
||||
const char *sslkey;
|
||||
const char *key_password;
|
||||
const char *servercert;
|
||||
const char *server;
|
||||
const char *cookie;
|
||||
|
||||
const uid_t csd_uid;
|
||||
const char *csd_wrapper;
|
||||
const char *user_agent;
|
||||
const char *os;
|
||||
const char *client_version;
|
||||
|
||||
const int reconnect_timeout;
|
||||
const int mtu;
|
||||
const int disable_ipv6;
|
||||
const int no_dtls;
|
||||
const char *script;
|
||||
const char *interface;
|
||||
const int script_tun;
|
||||
|
||||
const char *certificate;
|
||||
const char *sslkey;
|
||||
const char *key_password;
|
||||
const char *servercert;
|
||||
|
||||
const uid_t csd_uid;
|
||||
const char *csd_wrapper;
|
||||
|
||||
const int reconnect_timeout;
|
||||
const int mtu;
|
||||
const int disable_ipv6;
|
||||
const int no_dtls;
|
||||
|
||||
const int dpd_interval;
|
||||
} vpn_options;
|
||||
|
||||
int vpn_connect(const vpn_options *options, vpn_connected_callback callback);
|
||||
@@ -35,40 +42,36 @@ extern void vpn_log(int level, const char *msg);
|
||||
|
||||
static char *format_message(const char *format, va_list args)
|
||||
{
|
||||
va_list args_copy;
|
||||
va_copy(args_copy, args);
|
||||
int len = vsnprintf(NULL, 0, format, args_copy);
|
||||
va_end(args_copy);
|
||||
va_list args_copy;
|
||||
va_copy(args_copy, args);
|
||||
int len = vsnprintf(NULL, 0, format, args_copy);
|
||||
va_end(args_copy);
|
||||
|
||||
char *buffer = (char*)malloc(len + 1);
|
||||
if (buffer == NULL)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
char *buffer = (char *)malloc(len + 1);
|
||||
if (buffer == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
vsnprintf(buffer, len + 1, format, args);
|
||||
return buffer;
|
||||
vsnprintf(buffer, len + 1, format, args);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
static void _log(int level, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, level);
|
||||
va_list args;
|
||||
va_start(args, level);
|
||||
|
||||
char *format = va_arg(args, char *);
|
||||
char *message = format_message(format, args);
|
||||
char *format = va_arg(args, char *);
|
||||
char *message = format_message(format, args);
|
||||
|
||||
va_end(args);
|
||||
va_end(args);
|
||||
|
||||
if (message == NULL)
|
||||
{
|
||||
vpn_log(PRG_ERR, "Failed to format log message");
|
||||
}
|
||||
else
|
||||
{
|
||||
vpn_log(level, message);
|
||||
free(message);
|
||||
}
|
||||
if (message == NULL) {
|
||||
vpn_log(PRG_ERR, "Failed to format log message");
|
||||
} else {
|
||||
vpn_log(level, message);
|
||||
free(message);
|
||||
}
|
||||
}
|
||||
|
||||
#define LOG(level, ...) _log(level, __VA_ARGS__)
|
||||
|
||||
@@ -1,4 +1,6 @@
|
||||
mod ffi;
|
||||
mod vpn;
|
||||
mod vpn_utils;
|
||||
|
||||
pub use vpn::*;
|
||||
pub use vpn_utils::*;
|
||||
@@ -4,19 +4,25 @@ use std::{
|
||||
sync::{Arc, RwLock},
|
||||
};
|
||||
|
||||
use common::vpn_utils::{check_executable, find_vpnc_script};
|
||||
use log::info;
|
||||
|
||||
use crate::ffi;
|
||||
use crate::vpn_utils::{check_executable, find_csd_wrapper, find_vpnc_script};
|
||||
|
||||
type OnConnectedCallback = Arc<RwLock<Option<Box<dyn FnOnce() + 'static + Send + Sync>>>>;
|
||||
|
||||
pub struct Vpn {
|
||||
server: CString,
|
||||
cookie: CString,
|
||||
|
||||
user_agent: CString,
|
||||
script: CString,
|
||||
os: CString,
|
||||
client_version: Option<CString>,
|
||||
|
||||
script: CString,
|
||||
interface: Option<CString>,
|
||||
script_tun: bool,
|
||||
|
||||
certificate: Option<CString>,
|
||||
sslkey: Option<CString>,
|
||||
key_password: Option<CString>,
|
||||
@@ -30,6 +36,8 @@ pub struct Vpn {
|
||||
disable_ipv6: bool,
|
||||
no_dtls: bool,
|
||||
|
||||
dpd_interval: u32,
|
||||
|
||||
callback: OnConnectedCallback,
|
||||
}
|
||||
|
||||
@@ -63,9 +71,14 @@ impl Vpn {
|
||||
|
||||
server: self.server.as_ptr(),
|
||||
cookie: self.cookie.as_ptr(),
|
||||
|
||||
user_agent: self.user_agent.as_ptr(),
|
||||
script: self.script.as_ptr(),
|
||||
os: self.os.as_ptr(),
|
||||
client_version: Self::option_to_ptr(&self.client_version),
|
||||
|
||||
script: self.script.as_ptr(),
|
||||
interface: Self::option_to_ptr(&self.interface),
|
||||
script_tun: self.script_tun as u32,
|
||||
|
||||
certificate: Self::option_to_ptr(&self.certificate),
|
||||
sslkey: Self::option_to_ptr(&self.sslkey),
|
||||
@@ -79,6 +92,7 @@ impl Vpn {
|
||||
mtu: self.mtu,
|
||||
disable_ipv6: self.disable_ipv6 as u32,
|
||||
no_dtls: self.no_dtls as u32,
|
||||
dpd_interval: self.dpd_interval,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -113,14 +127,18 @@ pub struct VpnBuilder {
|
||||
server: String,
|
||||
cookie: String,
|
||||
script: Option<String>,
|
||||
interface: Option<String>,
|
||||
script_tun: bool,
|
||||
|
||||
user_agent: Option<String>,
|
||||
os: Option<String>,
|
||||
client_version: Option<String>,
|
||||
|
||||
certificate: Option<String>,
|
||||
sslkey: Option<String>,
|
||||
key_password: Option<String>,
|
||||
|
||||
hip: bool,
|
||||
csd_uid: u32,
|
||||
csd_wrapper: Option<String>,
|
||||
|
||||
@@ -128,6 +146,8 @@ pub struct VpnBuilder {
|
||||
mtu: u32,
|
||||
disable_ipv6: bool,
|
||||
no_dtls: bool,
|
||||
|
||||
dpd_interval: u32,
|
||||
}
|
||||
|
||||
impl VpnBuilder {
|
||||
@@ -136,14 +156,18 @@ impl VpnBuilder {
|
||||
server: server.to_string(),
|
||||
cookie: cookie.to_string(),
|
||||
script: None,
|
||||
interface: None,
|
||||
script_tun: false,
|
||||
|
||||
user_agent: None,
|
||||
os: None,
|
||||
client_version: None,
|
||||
|
||||
certificate: None,
|
||||
sslkey: None,
|
||||
key_password: None,
|
||||
|
||||
hip: false,
|
||||
csd_uid: 0,
|
||||
csd_wrapper: None,
|
||||
|
||||
@@ -151,6 +175,7 @@ impl VpnBuilder {
|
||||
mtu: 0,
|
||||
disable_ipv6: false,
|
||||
no_dtls: false,
|
||||
dpd_interval: 0,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -159,6 +184,16 @@ impl VpnBuilder {
|
||||
self
|
||||
}
|
||||
|
||||
pub fn interface<T: Into<Option<String>>>(mut self, interface: T) -> Self {
|
||||
self.interface = interface.into();
|
||||
self
|
||||
}
|
||||
|
||||
pub fn script_tun(mut self, script_tun: bool) -> Self {
|
||||
self.script_tun = script_tun;
|
||||
self
|
||||
}
|
||||
|
||||
pub fn user_agent<T: Into<Option<String>>>(mut self, user_agent: T) -> Self {
|
||||
self.user_agent = user_agent.into();
|
||||
self
|
||||
@@ -169,6 +204,11 @@ impl VpnBuilder {
|
||||
self
|
||||
}
|
||||
|
||||
pub fn client_version<T: Into<Option<String>>>(mut self, client_version: T) -> Self {
|
||||
self.client_version = client_version.into();
|
||||
self
|
||||
}
|
||||
|
||||
pub fn certificate<T: Into<Option<String>>>(mut self, certificate: T) -> Self {
|
||||
self.certificate = certificate.into();
|
||||
self
|
||||
@@ -184,6 +224,11 @@ impl VpnBuilder {
|
||||
self
|
||||
}
|
||||
|
||||
pub fn hip(mut self, hip: bool) -> Self {
|
||||
self.hip = hip;
|
||||
self
|
||||
}
|
||||
|
||||
pub fn csd_uid(mut self, csd_uid: u32) -> Self {
|
||||
self.csd_uid = csd_uid;
|
||||
self
|
||||
@@ -214,18 +259,41 @@ impl VpnBuilder {
|
||||
self
|
||||
}
|
||||
|
||||
pub fn build(self) -> Result<Vpn, VpnError> {
|
||||
let script = match self.script {
|
||||
Some(script) => {
|
||||
check_executable(&script).map_err(|e| VpnError::new(e.to_string()))?;
|
||||
script
|
||||
}
|
||||
None => find_vpnc_script().ok_or_else(|| VpnError::new(String::from("Failed to find vpnc-script")))?,
|
||||
};
|
||||
pub fn dpd_interval(mut self, dpd_interval: u32) -> Self {
|
||||
self.dpd_interval = dpd_interval;
|
||||
self
|
||||
}
|
||||
|
||||
if let Some(csd_wrapper) = &self.csd_wrapper {
|
||||
check_executable(csd_wrapper).map_err(|e| VpnError::new(e.to_string()))?;
|
||||
fn determine_script(&self) -> Result<&str, VpnError> {
|
||||
match &self.script {
|
||||
Some(script) => {
|
||||
check_executable(script).map_err(|e| VpnError::new(e.to_string()))?;
|
||||
Ok(script)
|
||||
}
|
||||
None => find_vpnc_script().ok_or_else(|| VpnError::new(String::from("Failed to find vpnc-script"))),
|
||||
}
|
||||
}
|
||||
|
||||
fn determine_csd_wrapper(&self) -> Result<Option<&str>, VpnError> {
|
||||
if !self.hip {
|
||||
return Ok(None);
|
||||
}
|
||||
|
||||
match &self.csd_wrapper {
|
||||
Some(csd_wrapper) if !csd_wrapper.is_empty() => {
|
||||
check_executable(csd_wrapper).map_err(|e| VpnError::new(e.to_string()))?;
|
||||
Ok(Some(csd_wrapper))
|
||||
}
|
||||
_ => {
|
||||
let s = find_csd_wrapper().ok_or_else(|| VpnError::new(String::from("Failed to find csd wrapper")))?;
|
||||
Ok(Some(s))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn build(self) -> Result<Vpn, VpnError> {
|
||||
let script = self.determine_script()?.to_owned();
|
||||
let csd_wrapper = self.determine_csd_wrapper()?.map(|s| s.to_owned());
|
||||
|
||||
let user_agent = self.user_agent.unwrap_or_default();
|
||||
let os = self.os.unwrap_or("linux".to_string());
|
||||
@@ -233,9 +301,14 @@ impl VpnBuilder {
|
||||
Ok(Vpn {
|
||||
server: Self::to_cstring(&self.server),
|
||||
cookie: Self::to_cstring(&self.cookie),
|
||||
|
||||
user_agent: Self::to_cstring(&user_agent),
|
||||
script: Self::to_cstring(&script),
|
||||
os: Self::to_cstring(&os),
|
||||
client_version: self.client_version.as_deref().map(Self::to_cstring),
|
||||
|
||||
script: Self::to_cstring(&script),
|
||||
interface: self.interface.as_deref().map(Self::to_cstring),
|
||||
script_tun: self.script_tun,
|
||||
|
||||
certificate: self.certificate.as_deref().map(Self::to_cstring),
|
||||
sslkey: self.sslkey.as_deref().map(Self::to_cstring),
|
||||
@@ -243,12 +316,13 @@ impl VpnBuilder {
|
||||
servercert: None,
|
||||
|
||||
csd_uid: self.csd_uid,
|
||||
csd_wrapper: self.csd_wrapper.as_deref().map(Self::to_cstring),
|
||||
csd_wrapper: csd_wrapper.as_deref().map(Self::to_cstring),
|
||||
|
||||
reconnect_timeout: self.reconnect_timeout,
|
||||
mtu: self.mtu,
|
||||
disable_ipv6: self.disable_ipv6,
|
||||
no_dtls: self.no_dtls,
|
||||
dpd_interval: self.dpd_interval,
|
||||
|
||||
callback: Default::default(),
|
||||
})
|
||||
|
||||
@@ -9,11 +9,13 @@ const VPNC_SCRIPT_LOCATIONS: &[&str] = &[
|
||||
"/usr/sbin/vpnc-script",
|
||||
"/etc/vpnc/vpnc-script",
|
||||
"/etc/openconnect/vpnc-script",
|
||||
"/usr/libexec/vpnc-scripts/vpnc-script",
|
||||
#[cfg(target_os = "macos")]
|
||||
"/opt/homebrew/etc/vpnc/vpnc-script",
|
||||
];
|
||||
|
||||
const CSD_WRAPPER_LOCATIONS: &[&str] = &[
|
||||
"/usr/libexec/gpclient/hipreport.sh",
|
||||
#[cfg(target_arch = "x86_64")]
|
||||
"/usr/lib/x86_64-linux-gnu/openconnect/hipreport.sh",
|
||||
#[cfg(target_arch = "aarch64")]
|
||||
@@ -24,22 +26,22 @@ const CSD_WRAPPER_LOCATIONS: &[&str] = &[
|
||||
"/opt/homebrew/opt/openconnect/libexec/openconnect/hipreport.sh",
|
||||
];
|
||||
|
||||
fn find_executable(locations: &[&str]) -> Option<String> {
|
||||
fn find_executable(locations: &[&'static str]) -> Option<&'static str> {
|
||||
for location in locations.iter() {
|
||||
let path = Path::new(location);
|
||||
if path.is_executable() {
|
||||
return Some(location.to_string());
|
||||
return Some(*location);
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
|
||||
pub fn find_vpnc_script() -> Option<String> {
|
||||
pub fn find_vpnc_script() -> Option<&'static str> {
|
||||
find_executable(&VPNC_SCRIPT_LOCATIONS)
|
||||
}
|
||||
|
||||
pub fn find_csd_wrapper() -> Option<String> {
|
||||
pub fn find_csd_wrapper() -> Option<&'static str> {
|
||||
find_executable(&CSD_WRAPPER_LOCATIONS)
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user