mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
97 lines
2.1 KiB
Rust
97 lines
2.1 KiB
Rust
use std::process::Stdio;
|
|
|
|
use anyhow::bail;
|
|
use tokio::process::Command;
|
|
|
|
pub struct HipLauncher<'a> {
|
|
program: &'a str,
|
|
cookie: Option<&'a str>,
|
|
client_ip: Option<&'a str>,
|
|
md5: Option<&'a str>,
|
|
client_os: Option<&'a str>,
|
|
client_version: Option<&'a str>,
|
|
}
|
|
|
|
impl<'a> HipLauncher<'a> {
|
|
pub fn new(program: &'a str) -> Self {
|
|
Self {
|
|
program,
|
|
cookie: None,
|
|
client_ip: None,
|
|
md5: None,
|
|
client_os: None,
|
|
client_version: None,
|
|
}
|
|
}
|
|
|
|
pub fn cookie(mut self, cookie: &'a str) -> Self {
|
|
self.cookie = Some(cookie);
|
|
self
|
|
}
|
|
|
|
pub fn client_ip(mut self, client_ip: &'a str) -> Self {
|
|
self.client_ip = Some(client_ip);
|
|
self
|
|
}
|
|
|
|
pub fn md5(mut self, md5: &'a str) -> Self {
|
|
self.md5 = Some(md5);
|
|
self
|
|
}
|
|
|
|
pub fn client_os(mut self, client_os: &'a str) -> Self {
|
|
self.client_os = Some(client_os);
|
|
self
|
|
}
|
|
|
|
pub fn client_version(mut self, client_version: Option<&'a str>) -> Self {
|
|
self.client_version = client_version;
|
|
self
|
|
}
|
|
|
|
pub async fn launch(&self) -> anyhow::Result<String> {
|
|
let mut cmd = Command::new(self.program);
|
|
|
|
if let Some(cookie) = self.cookie {
|
|
cmd.arg("--cookie").arg(cookie);
|
|
}
|
|
|
|
if let Some(client_ip) = self.client_ip {
|
|
cmd.arg("--client-ip").arg(client_ip);
|
|
}
|
|
|
|
if let Some(md5) = self.md5 {
|
|
cmd.arg("--md5").arg(md5);
|
|
}
|
|
|
|
if let Some(client_os) = self.client_os {
|
|
cmd.arg("--client-os").arg(client_os);
|
|
}
|
|
|
|
if let Some(client_version) = self.client_version {
|
|
cmd.env("APP_VERSION", client_version);
|
|
}
|
|
|
|
let child = cmd.kill_on_drop(true).stdout(Stdio::piped()).spawn();
|
|
|
|
let child = match child {
|
|
Ok(child) => child,
|
|
Err(err) => bail!("Failed to spawn {}: {}", self.program, err),
|
|
};
|
|
|
|
let output = child.wait_with_output().await?;
|
|
|
|
if let Some(exit_status) = output.status.code() {
|
|
if exit_status != 0 {
|
|
bail!("HIP report generation failed with exit code {}", exit_status);
|
|
}
|
|
|
|
let report = String::from_utf8(output.stdout)?;
|
|
|
|
Ok(report)
|
|
} else {
|
|
bail!("HIP report generation failed");
|
|
}
|
|
}
|
|
}
|