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
+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
|
||||
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
use std::path::Path;
|
||||
|
||||
fn main() {
|
||||
let manifest_dir = env!("CARGO_MANIFEST_DIR");
|
||||
let workspace_dir = Path::new(manifest_dir).ancestors().nth(2).unwrap();
|
||||
let gpgui_dir = workspace_dir.parent().unwrap().join("gpgui");
|
||||
|
||||
let gp_service_binary = workspace_dir.join("target/debug/gpservice");
|
||||
let gp_client_binary = workspace_dir.join("target/debug/gpclient");
|
||||
let gp_auth_binary = workspace_dir.join("target/debug/gpauth");
|
||||
let gp_gui_helper_binary = workspace_dir.join("target/debug/gpgui-helper");
|
||||
let gp_gui_binary = gpgui_dir.join("target/debug/gpgui");
|
||||
|
||||
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_BINARY={}", gp_gui_binary.display());
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user