mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
feat: add connection dashboard and improve desktop authentication
Add tunnel configuration reporting, an optional CLI dashboard, manual browser authentication, native authentication controls, and broader client identity support. Improve TLS recovery, certificate validation, desktop notifications, and platform integration.
This commit is contained in:
158 files changed
+13735
-1038
No files matched your search
@@ -5,13 +5,15 @@ use std::{
|
||||
|
||||
use anyhow::bail;
|
||||
use clap::{Parser, Subcommand};
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use gpapi::utils::openssl;
|
||||
use gpapi::{
|
||||
clap::{Args, InfoLevelVerbosity, handle_error},
|
||||
log_format::{LogFormat, write_json_record},
|
||||
utils::openssl,
|
||||
};
|
||||
use log::info;
|
||||
use sysinfo::{Pid, System};
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
use tempfile::NamedTempFile;
|
||||
use tokio::fs;
|
||||
|
||||
@@ -34,6 +36,7 @@ const VERSION: &str = concat!(
|
||||
);
|
||||
|
||||
pub(crate) struct SharedArgs<'a> {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
pub(crate) fix_openssl: bool,
|
||||
pub(crate) ignore_tls_errors: bool,
|
||||
pub(crate) lock_file: &'a Path,
|
||||
@@ -92,6 +95,7 @@ struct Cli {
|
||||
#[command(subcommand)]
|
||||
command: CliCommand,
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[arg(
|
||||
long,
|
||||
help = "Uses extended compatibility mode for OpenSSL operations to support a broader range of systems and formats."
|
||||
@@ -123,6 +127,7 @@ struct Cli {
|
||||
}
|
||||
|
||||
impl Args for Cli {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn fix_openssl(&self) -> bool {
|
||||
self.fix_openssl
|
||||
}
|
||||
@@ -164,6 +169,7 @@ impl Cli {
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fn fix_openssl(&self) -> anyhow::Result<Option<NamedTempFile>> {
|
||||
if self.fix_openssl {
|
||||
let file = openssl::fix_openssl_env()?;
|
||||
@@ -174,6 +180,11 @@ impl Cli {
|
||||
}
|
||||
|
||||
async fn run(&self) -> anyhow::Result<()> {
|
||||
if let CliCommand::Connect(args) = &self.command {
|
||||
if args.dashboard {
|
||||
crate::dashboard::validate(self.log_format)?;
|
||||
}
|
||||
}
|
||||
if self.background_worker_fd.is_some() && !matches!(&self.command, CliCommand::Connect(args) if args.background) {
|
||||
bail!("Background worker requires connect --background");
|
||||
}
|
||||
@@ -205,8 +216,10 @@ impl Cli {
|
||||
|
||||
// The temp file will be dropped automatically when the file handle is dropped
|
||||
// So, declare it here to ensure it's not dropped
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
let _file = self.fix_openssl()?;
|
||||
let shared_args = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: self.fix_openssl,
|
||||
ignore_tls_errors: self.ignore_tls_errors,
|
||||
lock_file: &self.lock_file,
|
||||
@@ -263,7 +276,13 @@ fn build_logger(cli: &Cli) -> env_logger::Builder {
|
||||
pub(crate) async fn run() {
|
||||
let cli = Cli::parse();
|
||||
|
||||
build_logger(&cli).init();
|
||||
if matches!(&cli.command, CliCommand::Connect(args) if args.dashboard) {
|
||||
let logger = build_logger(&cli).build();
|
||||
log::set_max_level(logger.filter());
|
||||
log::set_boxed_logger(Box::new(crate::dashboard::NoticeLogger::new(logger))).expect("failed to initialize logger");
|
||||
} else {
|
||||
build_logger(&cli).init();
|
||||
}
|
||||
|
||||
info!("gpclient started: {}", VERSION);
|
||||
|
||||
@@ -325,10 +344,42 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dashboard_is_opt_in_and_conflicts_with_noninteractive_connection_modes() {
|
||||
for option in ["--background", "--cookie-only"] {
|
||||
assert!(Cli::try_parse_from(["gpclient", "connect", "portal.example.com", "--dashboard", option]).is_err());
|
||||
}
|
||||
assert!(Cli::try_parse_from(["gpclient", "connect", "portal.example.com", "--stats"]).is_err());
|
||||
let cli = Cli::try_parse_from([
|
||||
"gpclient",
|
||||
"connect",
|
||||
"portal.example.com",
|
||||
"--dashboard",
|
||||
"--cookie-on-stdin",
|
||||
])
|
||||
.unwrap();
|
||||
assert!(matches!(cli.command, CliCommand::Connect(args) if args.dashboard));
|
||||
let cli = Cli::try_parse_from(["gpclient", "connect", "portal.example.com"]).unwrap();
|
||||
assert!(matches!(cli.command, CliCommand::Connect(args) if !args.dashboard));
|
||||
assert!(
|
||||
crate::dashboard::validate(LogFormat::Json)
|
||||
.unwrap_err()
|
||||
.to_string()
|
||||
.contains("--log-format json")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn openssl_option_is_available_only_on_supported_platforms() {
|
||||
let result = Cli::try_parse_from(["gpclient", "--fix-openssl", "diagnostics"]);
|
||||
assert_eq!(result.is_ok(), !cfg!(target_os = "macos"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn diagnostics_accepts_output_options_and_runs_alongside_the_client() {
|
||||
let cli = Cli::try_parse_from([
|
||||
"gpclient",
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
"--fix-openssl",
|
||||
"diagnostics",
|
||||
"--json",
|
||||
@@ -501,6 +552,40 @@ mod tests {
|
||||
captured.contents()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unicode_property_log_filters_keep_matching_and_excluding_records() {
|
||||
for (pattern, matching, excluded) in [
|
||||
(r"\p{Greek}", "α", "plain ASCII"),
|
||||
(r"\p{Mark}", "\u{0301}", "plain ASCII"),
|
||||
(r"\p{Alphabetic}", "α", "123"),
|
||||
(r"\p{Grapheme_Extend}", "\u{0301}", "plain ASCII"),
|
||||
] {
|
||||
let captured = Captured::default();
|
||||
let logger = build_logger(&parse_cli(&["gpclient", "disconnect"]))
|
||||
.parse_filters(&format!("info/{pattern}"))
|
||||
.target(env_logger::Target::Pipe(Box::new(captured.clone())))
|
||||
.build();
|
||||
for message in [excluded, matching] {
|
||||
logger.log(
|
||||
&log::Record::builder()
|
||||
.level(log::Level::Info)
|
||||
.target("gpclient")
|
||||
.args(format_args!("{message}"))
|
||||
.build(),
|
||||
);
|
||||
}
|
||||
let output = captured.contents();
|
||||
assert!(
|
||||
output.contains(matching),
|
||||
"filter {pattern} dropped its matching record"
|
||||
);
|
||||
assert!(
|
||||
!output.contains(excluded),
|
||||
"filter {pattern} allowed an excluded record"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The point of the flag: with `json`, a caller gets fields, and gets them one
|
||||
/// record per line so the stream can be read incrementally.
|
||||
#[test]
|
||||
|
||||
@@ -20,6 +20,13 @@ pub(crate) struct ConnectArgs {
|
||||
)]
|
||||
pub(crate) background: bool,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
conflicts_with_all = ["background", "cookie_only"],
|
||||
help = "Show an interactive connection dashboard after sign-in (requires a foreground terminal)"
|
||||
)]
|
||||
pub(crate) dashboard: bool,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
requires = "background",
|
||||
@@ -158,13 +165,13 @@ pub(crate) struct ConnectArgs {
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
help = "Use external browser authentication. With no value, auto-select Chrome, Firefox, then system default. Use `default` for the system default browser or `remote` for headless servers.",
|
||||
help = "Use a browser; omit the value to auto-select. Use `manual` to open the URL and paste the callback.",
|
||||
default_missing_value = "auto",
|
||||
num_args=0..=1
|
||||
)]
|
||||
pub(super) browser: Option<String>,
|
||||
|
||||
#[arg(long, help = "Listen on this IP address when using '--browser remote'")]
|
||||
#[arg(long, help = "Listen on this IP address when using '--browser manual'")]
|
||||
pub(super) browser_listen: Option<IpAddr>,
|
||||
|
||||
#[arg(
|
||||
@@ -299,7 +306,7 @@ mod tests {
|
||||
"test",
|
||||
"portal.example.com",
|
||||
"--browser",
|
||||
"remote",
|
||||
"manual",
|
||||
"--browser-listen",
|
||||
"192.168.107.15",
|
||||
])
|
||||
|
||||
@@ -129,7 +129,6 @@ impl ConnectHandler<'_> {
|
||||
.gateway(is_gateway)
|
||||
.saml_request(prelogin.saml_request())
|
||||
.os_profile(&os_profile)
|
||||
.fix_openssl(self.shared_args.fix_openssl)
|
||||
.ignore_tls_errors(self.shared_args.ignore_tls_errors)
|
||||
.certificate(self.args.certificate.as_deref())
|
||||
.sslkey(self.args.sslkey.as_deref())
|
||||
@@ -139,6 +138,9 @@ impl ConnectHandler<'_> {
|
||||
.log_format(self.shared_args.log_format)
|
||||
.verbose(verbose);
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
let auth_launcher = auth_launcher.fix_openssl(self.shared_args.fix_openssl);
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
let use_default_browser = external_browser_supported && self.args.default_browser;
|
||||
#[cfg(feature = "webview-auth")]
|
||||
|
||||
@@ -98,6 +98,7 @@ async fn cached_tunnel_authentication_does_not_require_portal_discovery() {
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -143,6 +144,7 @@ async fn internal_tunnel_keeps_gateway_authentication_after_portal_cookie_reject
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -190,6 +192,7 @@ async fn rendering_recovery_fetches_new_prelogin_metadata_and_preserves_gateway_
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -224,6 +227,7 @@ async fn cancellation_during_recovery_prelogin_stops_request() {
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -291,6 +295,7 @@ async fn auth_crash_uses_fresh_saml_and_clean_once_with_shared_budget() {
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -350,6 +355,7 @@ async fn exhausted_auth_recovery_is_terminal_before_portal_gateway_fallback() {
|
||||
let lock = directory.path().join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
@@ -497,6 +503,7 @@ printf '%s\n' '{"success":{"username":"alice","preloginCookie":"new-cookie"}}'
|
||||
let lock = directory.join("client.pid");
|
||||
let verbose = gpapi::clap::InfoLevelVerbosity::new(0, 0);
|
||||
let shared = SharedArgs {
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
fix_openssl: false,
|
||||
ignore_tls_errors: true,
|
||||
lock_file: &lock,
|
||||
|
||||
@@ -20,14 +20,14 @@ use gpapi::{
|
||||
};
|
||||
use inquire::Text;
|
||||
use log::{Level, info, warn};
|
||||
use openconnect::{HipScript, HipSource, Vpn, VpnBuilder};
|
||||
use openconnect::{HipScript, HipSource, VpnBuilder};
|
||||
use tokio::{runtime::Handle, task::JoinHandle};
|
||||
|
||||
use crate::session::{
|
||||
SessionContextInput, build_session_context, session_info_from_vpn, spawn_session_runtime_with_info,
|
||||
};
|
||||
|
||||
use super::{ConnectHandler, args::cookie_cache_path};
|
||||
use super::{ConnectHandler, args::cookie_cache_path, vpn_script};
|
||||
|
||||
const OPENCONNECT_INTERRUPTED_EXIT_CODE: i32 = -4;
|
||||
|
||||
@@ -443,10 +443,8 @@ impl ConnectHandler<'_> {
|
||||
disable_ipv6: self.args.disable_ipv6,
|
||||
extension_auth: Some(extension_auth),
|
||||
});
|
||||
let vpn_builder = Vpn::builder(gateway, cookie)
|
||||
.script(self.args.script.clone())
|
||||
let vpn_builder = vpn_script::builder(gateway, cookie, self.args)
|
||||
.interface(self.args.interface.clone())
|
||||
.script_tun(self.args.script_tun)
|
||||
.certificate(certificate)
|
||||
.sslkey(sslkey)
|
||||
.key_password(key_password)
|
||||
@@ -458,15 +456,6 @@ impl ConnectHandler<'_> {
|
||||
.local_hostname(self.args.local_hostname.clone())
|
||||
.dpd_interval(self.args.dpd_interval.unwrap_or(0))
|
||||
.no_xmlpost(self.args.no_xmlpost);
|
||||
#[cfg(target_os = "macos")]
|
||||
let vpn_builder = if self.args.script.is_none()
|
||||
&& std::env::var_os("GP_VPNC_SCRIPT").is_none_or(|value| value.is_empty())
|
||||
&& let Some(script) = common::binary_paths::bundled_vpnc_script()
|
||||
{
|
||||
vpn_builder.script_path(script.to_string_lossy().into_owned())
|
||||
} else {
|
||||
vpn_builder
|
||||
};
|
||||
let vpn = apply_os_profile(vpn_builder, &os_profile)
|
||||
.build()
|
||||
.map_err(|err| GatewayConnectError::before_establishment(err.into()))?;
|
||||
@@ -491,6 +480,16 @@ impl ConnectHandler<'_> {
|
||||
.transpose()
|
||||
.map_err(GatewayConnectError::before_establishment)?;
|
||||
|
||||
let mut dashboard = if self.args.dashboard {
|
||||
Some(
|
||||
crate::dashboard::Dashboard::prepare(gateway.to_owned(), self.cancellation.clone())
|
||||
.map_err(GatewayConnectError::before_establishment)?,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let monitor = gptunnel::TunnelMonitor::attach(vpn.clone());
|
||||
|
||||
let disconnect_task = tokio::spawn(async move {
|
||||
cancellation.cancelled().await;
|
||||
info!("Received the interrupt signal, disconnecting...");
|
||||
@@ -523,7 +522,7 @@ impl ConnectHandler<'_> {
|
||||
session_task_on_connect.lock().unwrap().replace(task);
|
||||
})
|
||||
});
|
||||
let mut background_error = None;
|
||||
let mut output_error = None;
|
||||
let connect_result = tokio::select! {
|
||||
result = &mut worker => result,
|
||||
established = established_rx => {
|
||||
@@ -537,6 +536,12 @@ impl ConnectHandler<'_> {
|
||||
self.logout_gateway(&server).await;
|
||||
}
|
||||
}, || {
|
||||
if let Some(dashboard) = &mut dashboard {
|
||||
if let Err(error) = dashboard.start_tunnel(monitor.clone()) {
|
||||
self.cancellation.cancel();
|
||||
output_error = Some(error);
|
||||
}
|
||||
}
|
||||
if let (Some(background), Some(stdio)) = (&self.background, &mut background_stdio) {
|
||||
let detach = if self.pid_written.load(Ordering::SeqCst) {
|
||||
background.detach(stdio)
|
||||
@@ -545,7 +550,7 @@ impl ConnectHandler<'_> {
|
||||
};
|
||||
if let Err(error) = detach {
|
||||
self.cancellation.cancel();
|
||||
background_error = Some(error);
|
||||
output_error = Some(error);
|
||||
}
|
||||
}
|
||||
}).await
|
||||
@@ -554,6 +559,12 @@ impl ConnectHandler<'_> {
|
||||
}
|
||||
}
|
||||
};
|
||||
monitor.stop().await;
|
||||
if let Some(dashboard) = &mut dashboard {
|
||||
if let Err(error) = dashboard.finish() {
|
||||
output_error = Some(error);
|
||||
}
|
||||
}
|
||||
let tunnel_established = tunnel_established.load(Ordering::SeqCst);
|
||||
disconnect_task.abort();
|
||||
let _ = disconnect_task.await;
|
||||
@@ -564,7 +575,7 @@ impl ConnectHandler<'_> {
|
||||
let _ = task.await;
|
||||
}
|
||||
|
||||
if let Some(error) = background_error {
|
||||
if let Some(error) = output_error {
|
||||
return Err(GatewayConnectError::after_establishment(error));
|
||||
}
|
||||
|
||||
|
||||
@@ -112,6 +112,18 @@ impl ConnectHandler<'_> {
|
||||
let source = Arc::new(source);
|
||||
let validate_network = network.clone();
|
||||
let validate_detection = detection.clone();
|
||||
let members = crate::dashboard::InternalMembers::default();
|
||||
let dashboard_members = members.clone();
|
||||
let (established_tx, established_rx) = tokio::sync::oneshot::channel();
|
||||
let established_tx = std::sync::Mutex::new(Some(established_tx));
|
||||
let mut dashboard = if self.args.dashboard {
|
||||
Some(crate::dashboard::Dashboard::prepare(
|
||||
authenticated[0].0.server().to_owned(),
|
||||
cancellation.clone(),
|
||||
)?)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let callbacks = SessionCallbacks {
|
||||
produce_report: Arc::new(move |request, control| {
|
||||
control.check()?;
|
||||
@@ -143,12 +155,23 @@ impl ConnectHandler<'_> {
|
||||
)
|
||||
}),
|
||||
report_submitted: Arc::new(|_, _| {}),
|
||||
status_changed: Arc::new(|member| match member.maintenance {
|
||||
MaintenanceState::Healthy => info!(
|
||||
"Internal network — authenticated: {} (IPv4: {:?}, IPv6: {:?})",
|
||||
member.gateway, member.client_ip, member.client_ipv6
|
||||
),
|
||||
state => info!("Internal gateway {}: {state:?}", member.gateway),
|
||||
status_changed: Arc::new(move |member| {
|
||||
match member.maintenance {
|
||||
MaintenanceState::Healthy => {
|
||||
info!(
|
||||
"Internal network — authenticated: {} (IPv4: {:?}, IPv6: {:?})",
|
||||
member.gateway, member.client_ip, member.client_ipv6
|
||||
);
|
||||
if let Some(established) = established_tx.lock().unwrap().take() {
|
||||
let _ = established.send(());
|
||||
}
|
||||
}
|
||||
state => info!("Internal gateway {}: {state:?}", member.gateway),
|
||||
}
|
||||
members.lock().unwrap().insert(
|
||||
member.gateway.server().to_owned(),
|
||||
format!("{}: {:?}", member.gateway, member.maintenance),
|
||||
);
|
||||
}),
|
||||
validate_network: Arc::new(move |cancellation| {
|
||||
let network = validate_network.clone();
|
||||
@@ -183,13 +206,38 @@ impl ConnectHandler<'_> {
|
||||
std::sync::atomic::Ordering::SeqCst,
|
||||
);
|
||||
let mut sessions = self.sessions.take();
|
||||
let result = maintain_non_tunnel_sessions(&mut sessions, policy, callbacks, cancellation, async move {
|
||||
network_signal.await.unwrap_or(SessionEndReason::NetworkChanged)
|
||||
})
|
||||
.await;
|
||||
let mut dashboard_error = None;
|
||||
let result = {
|
||||
let maintenance = maintain_non_tunnel_sessions(&mut sessions, policy, callbacks, cancellation, async move {
|
||||
network_signal.await.unwrap_or(SessionEndReason::NetworkChanged)
|
||||
});
|
||||
tokio::pin!(maintenance);
|
||||
tokio::select! {
|
||||
result = &mut maintenance => result,
|
||||
established = established_rx => {
|
||||
if established.is_ok() {
|
||||
if let Some(dashboard) = &mut dashboard {
|
||||
if let Err(error) = dashboard.start_internal(dashboard_members) {
|
||||
self.cancellation.cancel();
|
||||
dashboard_error = Some(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
maintenance.await
|
||||
}
|
||||
}
|
||||
};
|
||||
if let Some(dashboard) = &mut dashboard {
|
||||
if let Err(error) = dashboard.finish() {
|
||||
dashboard_error = Some(error);
|
||||
}
|
||||
}
|
||||
self.sessions.replace(sessions);
|
||||
monitor_cancel.cancel();
|
||||
monitor.await.context("Internal network monitor failed")?;
|
||||
if let Some(error) = dashboard_error {
|
||||
return Err(error);
|
||||
}
|
||||
match result? {
|
||||
SessionExit::Disconnected => Ok(()),
|
||||
SessionExit::Failed(reason) => bail!("Internal session ended: {reason:?}. Connect again to authenticate."),
|
||||
|
||||
@@ -4,6 +4,7 @@ mod credential;
|
||||
mod flow_tests;
|
||||
mod gateway;
|
||||
mod internal;
|
||||
mod vpn_script;
|
||||
|
||||
use std::cell::RefCell;
|
||||
use std::sync::{
|
||||
@@ -153,9 +154,9 @@ impl<'a> ConnectHandler<'a> {
|
||||
|
||||
async fn handle_attempt(&self) -> anyhow::Result<()> {
|
||||
if self.args.browser_listen.is_some()
|
||||
&& !matches!(self.args.browser.as_deref(), Some(browser) if browser.eq_ignore_ascii_case("remote"))
|
||||
&& !matches!(self.args.browser.as_deref(), Some(browser) if browser.eq_ignore_ascii_case("manual") || browser.eq_ignore_ascii_case("remote"))
|
||||
{
|
||||
bail!("The '--browser-listen' option requires '--browser remote'");
|
||||
bail!("The '--browser-listen' option requires '--browser manual'");
|
||||
}
|
||||
|
||||
#[cfg(feature = "webview-auth")]
|
||||
@@ -178,11 +179,18 @@ impl<'a> ConnectHandler<'a> {
|
||||
{
|
||||
return Err(err);
|
||||
}
|
||||
let Some(root_cause) = err.root_cause().downcast_ref::<RequestIdentityError>() else {
|
||||
let Some(identity_error) = err.downcast_ref::<RequestIdentityError>() else {
|
||||
return Err(err);
|
||||
};
|
||||
|
||||
match root_cause {
|
||||
match identity_error {
|
||||
RequestIdentityError::UnsupportedEncryption
|
||||
| RequestIdentityError::LegacyKeyConversion(_)
|
||||
| RequestIdentityError::UnsupportedKeyFormat
|
||||
| RequestIdentityError::InvalidKey
|
||||
| RequestIdentityError::InvalidCertificate
|
||||
| RequestIdentityError::IncompletePkcs12
|
||||
| RequestIdentityError::InvalidPkcs12(_) => return Err(err),
|
||||
RequestIdentityError::NoKey => {
|
||||
let format = self.shared_args.log_format;
|
||||
report(
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
|
||||
use crate::connect::ConnectArgs;
|
||||
|
||||
pub(crate) fn builder(server: &str, cookie: &str, args: &ConnectArgs) -> VpnBuilder {
|
||||
Vpn::builder(server, cookie)
|
||||
.script(args.script.clone())
|
||||
.script_tun(args.script_tun)
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
use std::ffi::OsStr;
|
||||
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
|
||||
use crate::connect::ConnectArgs;
|
||||
|
||||
pub(crate) fn builder(server: &str, cookie: &str, args: &ConnectArgs) -> VpnBuilder {
|
||||
let configured_script = std::env::var_os("GP_VPNC_SCRIPT");
|
||||
configure_builder(server, cookie, args, configured_script.as_deref())
|
||||
}
|
||||
|
||||
fn configure_builder(server: &str, cookie: &str, args: &ConnectArgs, configured_script: Option<&OsStr>) -> VpnBuilder {
|
||||
let builder = Vpn::builder(server, cookie)
|
||||
.script(args.script.clone())
|
||||
.script_tun(args.script_tun);
|
||||
let has_environment_script = configured_script.is_some_and(|value| !value.is_empty());
|
||||
if args.script.is_none() && !args.script_tun && !has_environment_script {
|
||||
builder.network_configuration_handler(|configuration| {
|
||||
gpvpnc::macos::configure_network(&configuration.reason, &configuration.environment)
|
||||
})
|
||||
} else {
|
||||
builder
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use clap::Parser;
|
||||
|
||||
#[derive(Parser)]
|
||||
struct TestCli {
|
||||
#[command(flatten)]
|
||||
args: ConnectArgs,
|
||||
}
|
||||
|
||||
fn args(options: &[&str]) -> ConnectArgs {
|
||||
TestCli::try_parse_from(
|
||||
["connect", "vpn.example.com"]
|
||||
.into_iter()
|
||||
.chain(options.iter().copied()),
|
||||
)
|
||||
.unwrap()
|
||||
.args
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_does_not_require_an_installed_script() {
|
||||
for configured in [None, Some(OsStr::new(""))] {
|
||||
assert!(
|
||||
configure_builder("server", "cookie", &args(&[]), configured)
|
||||
.build()
|
||||
.is_ok()
|
||||
);
|
||||
assert!(
|
||||
configure_builder("server", "cookie", &args(&[]), configured)
|
||||
.script("/bin/sh".to_string())
|
||||
.script_tun(true)
|
||||
.build()
|
||||
.is_err()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn explicit_commands_and_script_tunnels_remain_supported() {
|
||||
for options in [
|
||||
vec!["--script", "exec /bin/sh"],
|
||||
vec!["--script", "/bin/sh", "--script-tun"],
|
||||
] {
|
||||
assert!(
|
||||
configure_builder("server", "cookie", &args(&options), None)
|
||||
.build()
|
||||
.is_ok()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn environment_override_does_not_install_default_callback() {
|
||||
let builder = configure_builder("server", "cookie", &args(&[]), Some(OsStr::new("/bin/sh")));
|
||||
// Converting the selected builder to an explicit packet script would fail
|
||||
// if the embedded configuration callback had replaced the environment override.
|
||||
assert!(builder.script("/bin/sh".to_string()).script_tun(true).build().is_ok());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#[cfg(target_os = "macos")]
|
||||
#[path = "macos.rs"]
|
||||
mod platform;
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[path = "default.rs"]
|
||||
mod platform;
|
||||
|
||||
pub(super) use platform::builder;
|
||||
@@ -0,0 +1,625 @@
|
||||
//! Dashboard presentation only; connection ownership and sampling stay outside this module.
|
||||
use crossterm::event::KeyCode;
|
||||
use gpapi::session::tunnel::{TunnelList, TunnelPhase, TunnelState, TunnelStatisticsSnapshot, TunnelStatisticsState};
|
||||
use ratatui::{
|
||||
Frame,
|
||||
buffer::Buffer,
|
||||
layout::Rect,
|
||||
style::{Color, Modifier, Style},
|
||||
text::{Line, Span},
|
||||
widgets::{Paragraph, Widget, Wrap},
|
||||
};
|
||||
|
||||
use super::output::plain_text;
|
||||
|
||||
const MAX_CONTENT_WIDTH: u16 = 120;
|
||||
const LABEL_WIDTH: usize = 12;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct DetailScroll {
|
||||
offset: u16,
|
||||
maximum: u16,
|
||||
page: u16,
|
||||
}
|
||||
|
||||
impl DetailScroll {
|
||||
pub(super) fn handle_key(&mut self, key: KeyCode) {
|
||||
self.offset = match key {
|
||||
KeyCode::Up => self.offset.saturating_sub(1),
|
||||
KeyCode::Down => self.offset.saturating_add(1),
|
||||
KeyCode::PageUp => self.offset.saturating_sub(self.page),
|
||||
KeyCode::PageDown => self.offset.saturating_add(self.page),
|
||||
KeyCode::Home => 0,
|
||||
KeyCode::End => self.maximum,
|
||||
_ => self.offset,
|
||||
}
|
||||
.min(self.maximum);
|
||||
}
|
||||
|
||||
pub(super) fn can_scroll(&self) -> bool {
|
||||
self.maximum > 0
|
||||
}
|
||||
|
||||
fn update(&mut self, content_height: u16, viewport_height: u16) {
|
||||
self.maximum = if viewport_height == 0 {
|
||||
0
|
||||
} else {
|
||||
content_height.saturating_sub(viewport_height)
|
||||
};
|
||||
self.offset = self.offset.min(self.maximum);
|
||||
self.page = viewport_height.saturating_sub(1).max(1);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn phase_label(phase: TunnelPhase) -> &'static str {
|
||||
match phase {
|
||||
TunnelPhase::Establishing => "Establishing",
|
||||
TunnelPhase::Connected => "Connected",
|
||||
TunnelPhase::Reconnecting => "Reconnecting",
|
||||
TunnelPhase::Ended => "Disconnected",
|
||||
}
|
||||
}
|
||||
|
||||
fn uptime(milliseconds: u64) -> String {
|
||||
let seconds = milliseconds / 1000;
|
||||
format!("{:02}:{:02}:{:02}", seconds / 3600, (seconds / 60) % 60, seconds % 60)
|
||||
}
|
||||
|
||||
fn bytes(value: u64) -> String {
|
||||
const UNITS: [&str; 7] = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"];
|
||||
let mut amount = value as f64;
|
||||
let mut unit = 0;
|
||||
while amount >= 1024.0 && unit < UNITS.len() - 1 {
|
||||
amount /= 1024.0;
|
||||
unit += 1;
|
||||
}
|
||||
if unit == 0 {
|
||||
format!("{value} B")
|
||||
} else {
|
||||
format!("{amount:.1} {}", UNITS[unit])
|
||||
}
|
||||
}
|
||||
|
||||
fn muted(text: impl Into<String>) -> Span<'static> {
|
||||
Span::styled(text.into(), Style::default().fg(Color::DarkGray))
|
||||
}
|
||||
|
||||
fn heading(text: impl Into<String>) -> Line<'static> {
|
||||
Line::styled(
|
||||
text.into(),
|
||||
Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
|
||||
)
|
||||
}
|
||||
|
||||
pub(super) fn row(label: &str, value: impl Into<String>) -> Line<'static> {
|
||||
Line::from(vec![
|
||||
muted(format!("{label:<LABEL_WIDTH$} ")),
|
||||
Span::raw(plain_text(value.into().as_bytes())),
|
||||
])
|
||||
}
|
||||
|
||||
fn paragraph(lines: Vec<Line<'static>>) -> Paragraph<'static> {
|
||||
Paragraph::new(lines).wrap(Wrap { trim: false })
|
||||
}
|
||||
|
||||
fn summary(server: &str, state: &TunnelState, width: u16) -> Paragraph<'static> {
|
||||
let status = Span::styled(
|
||||
format!("{:<LABEL_WIDTH$} ", phase_label(state.phase)),
|
||||
Style::default().fg(if state.phase == TunnelPhase::Connected {
|
||||
Color::Green
|
||||
} else {
|
||||
Color::Yellow
|
||||
}),
|
||||
);
|
||||
let mut lines = if width >= 64 {
|
||||
vec![Line::from(vec![
|
||||
status,
|
||||
Span::raw(format!(
|
||||
"{} Uptime {}",
|
||||
state.transport.label(),
|
||||
uptime(state.elapsed_ms)
|
||||
)),
|
||||
])]
|
||||
} else {
|
||||
vec![
|
||||
Line::from(status),
|
||||
row("Transport", state.transport.label()),
|
||||
row("Uptime", uptime(state.elapsed_ms)),
|
||||
]
|
||||
};
|
||||
lines.insert(0, row("Server", server));
|
||||
paragraph(lines)
|
||||
}
|
||||
|
||||
fn traffic(statistics: &TunnelStatisticsSnapshot, width: u16) -> Paragraph<'static> {
|
||||
let mut lines = vec![heading("TRAFFIC")];
|
||||
if let Some(view) = statistics.view() {
|
||||
let label = match view.state {
|
||||
TunnelStatisticsState::Disabled => "disabled",
|
||||
TunnelStatisticsState::Waiting => "waiting for sample",
|
||||
TunnelStatisticsState::Fresh => "live",
|
||||
TunnelStatisticsState::Stale => "stale",
|
||||
TunnelStatisticsState::Ended => "ended",
|
||||
};
|
||||
lines[0] = heading(format!("TRAFFIC · {label}"));
|
||||
if let Some(sample) = &view.sample {
|
||||
if width >= 56 {
|
||||
let rows = [
|
||||
("Bytes", bytes(sample.received_bytes), bytes(sample.sent_bytes)),
|
||||
(
|
||||
"Packets",
|
||||
sample.received_packets.to_string(),
|
||||
sample.sent_packets.to_string(),
|
||||
),
|
||||
];
|
||||
// Size to the values, while keeping room for full u64 counters and a
|
||||
// visible gap even when both numeric columns are filled.
|
||||
let numeric_width = rows
|
||||
.iter()
|
||||
.flat_map(|(_, received, sent)| [received.len(), sent.len()])
|
||||
.max()
|
||||
.unwrap_or(0)
|
||||
.max(10);
|
||||
lines.push(Line::from(muted(format!(
|
||||
"{:<10}{:>numeric_width$} {:>numeric_width$}",
|
||||
"", "Received", "Sent"
|
||||
))));
|
||||
for (label, received, sent) in rows {
|
||||
lines.push(Line::from(vec![
|
||||
muted(format!("{label:<10}")),
|
||||
Span::raw(format!("{received:>numeric_width$} {sent:>numeric_width$}")),
|
||||
]));
|
||||
}
|
||||
} else {
|
||||
lines.push(row("Received", bytes(sample.received_bytes)));
|
||||
lines.push(row("Sent", bytes(sample.sent_bytes)));
|
||||
lines.push(row("Packets in", sample.received_packets.to_string()));
|
||||
lines.push(row("Packets out", sample.sent_packets.to_string()));
|
||||
}
|
||||
if view.state != TunnelStatisticsState::Fresh {
|
||||
if let Some(age) = view.sample_age_ms {
|
||||
lines.push(row("Sample age", format!("{} seconds", age / 1000)));
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
lines.push(row("Statistics", "unavailable"));
|
||||
}
|
||||
paragraph(lines)
|
||||
}
|
||||
|
||||
fn list_rows(lines: &mut Vec<Line<'static>>, label: &str, value: &TunnelList) {
|
||||
if value.items.is_empty() && !value.truncated {
|
||||
lines.push(row(label, "none"));
|
||||
} else {
|
||||
for (index, item) in value.items.iter().enumerate() {
|
||||
lines.push(row(if index == 0 { label } else { "" }, item));
|
||||
}
|
||||
if value.truncated {
|
||||
lines.push(row("", format!("[truncated; {} total]", value.total_count)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn routes(lines: &mut Vec<Line<'static>>, label: &str, list: &TunnelList, width: u16) {
|
||||
lines.push(row(label, list.total_count.to_string()));
|
||||
// Only whole entries move between columns. Long individual entries wrap through
|
||||
// Paragraph rather than disappearing off the edge of a narrow terminal.
|
||||
let entries: Vec<_> = list.items.iter().map(|item| plain_text(item.as_bytes())).collect();
|
||||
let cell_width = entries.iter().map(|item| Line::raw(item).width()).max().unwrap_or(0) + 3;
|
||||
let columns = (width as usize / cell_width).clamp(1, 3);
|
||||
for chunk in entries.chunks(columns) {
|
||||
let mut spans = Vec::new();
|
||||
for (index, entry) in chunk.iter().enumerate() {
|
||||
spans.push(Span::raw(entry.clone()));
|
||||
if index + 1 < chunk.len() {
|
||||
spans.push(Span::raw(" ".repeat(cell_width - Line::raw(entry).width())));
|
||||
}
|
||||
}
|
||||
lines.push(Line::from(spans));
|
||||
}
|
||||
if list.truncated {
|
||||
lines.push(Line::raw(format!(
|
||||
"[truncated; showing {} of {}]",
|
||||
list.items.len(),
|
||||
list.total_count
|
||||
)));
|
||||
}
|
||||
}
|
||||
|
||||
fn details(state: &TunnelState, statistics: &TunnelStatisticsSnapshot, width: u16) -> Buffer {
|
||||
let traffic = traffic(statistics, width);
|
||||
let traffic_height = traffic.line_count(width) as u16;
|
||||
let mut tunnel = vec![heading("TUNNEL")];
|
||||
let mut dns = vec![heading("DNS")];
|
||||
let mut route_lines = vec![heading("ROUTES")];
|
||||
if let Some(config) = &state.configuration {
|
||||
tunnel.extend([
|
||||
row("Interface", config.interface.as_deref().unwrap_or("none")),
|
||||
row(
|
||||
"IPv4",
|
||||
config
|
||||
.ipv4
|
||||
.as_ref()
|
||||
.map(|address| address.display())
|
||||
.unwrap_or_else(|| "none".into()),
|
||||
),
|
||||
row(
|
||||
"IPv6",
|
||||
config
|
||||
.ipv6
|
||||
.as_ref()
|
||||
.map(|address| address.display())
|
||||
.unwrap_or_else(|| "none".into()),
|
||||
),
|
||||
row("Gateway", config.server_ip.as_deref().unwrap_or("none")),
|
||||
row(
|
||||
"MTU",
|
||||
config.mtu.map(|mtu| mtu.to_string()).unwrap_or_else(|| "none".into()),
|
||||
),
|
||||
]);
|
||||
list_rows(&mut dns, "Servers", &config.dns);
|
||||
list_rows(&mut dns, "Domains", &config.search_domains);
|
||||
list_rows(&mut dns, "Split DNS", &config.split_dns);
|
||||
routes(&mut route_lines, "Included", &config.included_routes, width);
|
||||
routes(&mut route_lines, "Excluded", &config.excluded_routes, width);
|
||||
if config.truncated {
|
||||
route_lines.push(row("Configuration", "truncated"));
|
||||
}
|
||||
} else {
|
||||
tunnel.push(row("Configuration", "unavailable"));
|
||||
}
|
||||
let tunnel = paragraph(tunnel);
|
||||
let dns = paragraph(dns);
|
||||
let routes = paragraph(route_lines);
|
||||
let columns = width >= 88;
|
||||
let column_width = if columns { (width - 4) / 2 } else { width };
|
||||
let tunnel_height = tunnel.line_count(column_width) as u16;
|
||||
let dns_height = dns.line_count(column_width) as u16;
|
||||
let network_height = if columns {
|
||||
tunnel_height.max(dns_height)
|
||||
} else {
|
||||
tunnel_height + 1 + dns_height
|
||||
};
|
||||
let network_y = traffic_height + 1;
|
||||
let routes_y = network_y + network_height + 1;
|
||||
let height = routes_y + routes.line_count(width) as u16;
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, width, height));
|
||||
traffic.render(Rect::new(0, 0, width, traffic_height), &mut buffer);
|
||||
tunnel.render(Rect::new(0, network_y, column_width, tunnel_height), &mut buffer);
|
||||
let (dns_x, dns_y) = if columns {
|
||||
(column_width + 4, network_y)
|
||||
} else {
|
||||
(0, network_y + tunnel_height + 1)
|
||||
};
|
||||
dns.render(Rect::new(dns_x, dns_y, column_width, dns_height), &mut buffer);
|
||||
routes.render(Rect::new(0, routes_y, width, height - routes_y), &mut buffer);
|
||||
buffer
|
||||
}
|
||||
|
||||
pub(super) fn render_tunnel(
|
||||
frame: &mut Frame,
|
||||
area: Rect,
|
||||
server: &str,
|
||||
state: &TunnelState,
|
||||
statistics: &TunnelStatisticsSnapshot,
|
||||
scroll: &mut DetailScroll,
|
||||
) {
|
||||
if area.is_empty() {
|
||||
return;
|
||||
}
|
||||
let area = Rect {
|
||||
width: area.width.min(MAX_CONTENT_WIDTH),
|
||||
..area
|
||||
};
|
||||
let full_summary = summary(server, state, area.width);
|
||||
let summary = if full_summary.line_count(area.width) + 2 > area.height as usize {
|
||||
Paragraph::new(phase_label(state.phase))
|
||||
} else {
|
||||
full_summary
|
||||
};
|
||||
let summary_height = (summary.line_count(area.width) as u16).min(area.height);
|
||||
frame.render_widget(summary, Rect::new(area.x, area.y, area.width, summary_height));
|
||||
let body_y = summary_height.saturating_add(1).min(area.height);
|
||||
let viewport = Rect::new(area.x, area.y + body_y, area.width, area.height - body_y);
|
||||
let buffer = details(state, statistics, area.width);
|
||||
scroll.update(buffer.area.height, viewport.height);
|
||||
// Render the full detail layout with Ratatui, then expose just the scrolled rows.
|
||||
// This preserves wrapped fields and aligned columns through terminal resizes.
|
||||
for y in 0..viewport.height {
|
||||
if y + scroll.offset >= buffer.area.height {
|
||||
break;
|
||||
}
|
||||
for x in 0..viewport.width {
|
||||
frame.buffer_mut()[(viewport.x + x, viewport.y + y)] = buffer[(x, y + scroll.offset)].clone();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use gpapi::session::tunnel::{TunnelStatistics, TunnelStatisticsView, TunnelTransport};
|
||||
use ratatui::{Terminal, backend::TestBackend};
|
||||
|
||||
use super::*;
|
||||
|
||||
fn state() -> TunnelState {
|
||||
serde_json::from_value(serde_json::json!({
|
||||
"tunnelId": "00000000-0000-0000-0000-000000000001",
|
||||
"sequence": "1", "phase": "connected", "configurationRevision": "1",
|
||||
"transport": "ipsecEsp", "elapsedMs": "177000",
|
||||
"configuration": {
|
||||
"interface": "tun0", "serverIp": "220.191.185.154",
|
||||
"ipv4": {"address": "10.197.121.152", "prefixLength": 32, "netmask": null},
|
||||
"ipv6": null, "mtu": 1439, "truncated": false,
|
||||
"dns": {"items": ["10.197.82.140", "10.15.70.11"], "totalCount": 2, "truncated": false},
|
||||
"searchDomains": {"items": ["corp.microstrategy.com"], "totalCount": 1, "truncated": false},
|
||||
"splitDns": {"items": [], "totalCount": 0, "truncated": false},
|
||||
"includedRoutes": {"items": ["10.15.70.11/32", "10.197.82.140/32", "185.199.108.0/22", "2001:db8:1234:5678::/64"], "totalCount": 5, "truncated": true},
|
||||
"excludedRoutes": {"items": ["192.168.0.0/16"], "totalCount": 1, "truncated": false}
|
||||
}
|
||||
})).unwrap()
|
||||
}
|
||||
|
||||
fn statistics(state: &TunnelState) -> TunnelStatisticsSnapshot {
|
||||
TunnelStatisticsSnapshot::Available(TunnelStatisticsView {
|
||||
sequence: 1,
|
||||
tunnel_id: state.tunnel_id,
|
||||
state_sequence: 1,
|
||||
phase: state.phase,
|
||||
transport: TunnelTransport::IpsecEsp,
|
||||
state: TunnelStatisticsState::Fresh,
|
||||
elapsed_ms: state.elapsed_ms,
|
||||
sample_age_ms: Some(0),
|
||||
sample: Some(TunnelStatistics {
|
||||
tunnel_id: state.tunnel_id,
|
||||
sequence: 1,
|
||||
state_sequence: 1,
|
||||
configuration_revision: 1,
|
||||
elapsed_ms: state.elapsed_ms,
|
||||
received_bytes: 1_258_291,
|
||||
sent_bytes: 71_578,
|
||||
received_packets: u64::MAX,
|
||||
sent_packets: 702,
|
||||
}),
|
||||
})
|
||||
}
|
||||
|
||||
fn text(buffer: &Buffer) -> String {
|
||||
(0..buffer.area.height)
|
||||
.map(|y| {
|
||||
(0..buffer.area.width)
|
||||
.map(|x| buffer[(x, y)].symbol())
|
||||
.collect::<String>()
|
||||
.trim_end()
|
||||
.to_string()
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn server_and_transport_share_a_column_through_status_changes() {
|
||||
let mut state = state();
|
||||
for width in [40, 64, 120] {
|
||||
for phase in [
|
||||
TunnelPhase::Establishing,
|
||||
TunnelPhase::Connected,
|
||||
TunnelPhase::Reconnecting,
|
||||
TunnelPhase::Ended,
|
||||
] {
|
||||
state.phase = phase;
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, width, 8));
|
||||
summary("vpn.example.com", &state, width).render(buffer.area, &mut buffer);
|
||||
let rendered = text(&buffer);
|
||||
let server = rendered.lines().find(|line| line.contains("vpn.example.com")).unwrap();
|
||||
let transport = rendered.lines().find(|line| line.contains("IPsec (ESP)")).unwrap();
|
||||
assert_eq!(server.find("vpn.example.com"), Some(14));
|
||||
assert_eq!(
|
||||
transport.find("IPsec (ESP)"),
|
||||
server.find("vpn.example.com"),
|
||||
"{phase:?} at width {width}"
|
||||
);
|
||||
assert!(rendered.lines().any(|line| line.starts_with(phase_label(phase))));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wide_layout_groups_settings_and_keeps_routes_and_counters_intact() {
|
||||
let state = state();
|
||||
let buffer = details(&state, &statistics(&state), 100);
|
||||
let text = text(&buffer);
|
||||
let headings = text.lines().find(|line| line.starts_with("TUNNEL")).unwrap();
|
||||
assert!(headings.contains("DNS"));
|
||||
assert!(text.contains("18446744073709551615"));
|
||||
assert!(text.contains("1.2 MiB"));
|
||||
assert!(text.contains("69.9 KiB"));
|
||||
assert!(text.contains("2001:db8:1234:5678::/64"));
|
||||
assert!(text.contains("[truncated; showing 4 of 5]"));
|
||||
assert!(text.contains("192.168.0.0/16"));
|
||||
let received_column = text
|
||||
.lines()
|
||||
.find(|line| line.contains("Received"))
|
||||
.unwrap()
|
||||
.find("Received")
|
||||
.unwrap()
|
||||
+ "Received".len();
|
||||
let bytes_column = text
|
||||
.lines()
|
||||
.find(|line| line.starts_with("Bytes"))
|
||||
.unwrap()
|
||||
.find("1.2 MiB")
|
||||
.unwrap()
|
||||
+ "1.2 MiB".len();
|
||||
assert_eq!(received_column, bytes_column);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn traffic_columns_stay_compact_with_a_visible_gap() {
|
||||
let state = state();
|
||||
let mut stats = statistics(&state);
|
||||
let TunnelStatisticsSnapshot::Available(view) = &mut stats else {
|
||||
unreachable!()
|
||||
};
|
||||
view.sample.as_mut().unwrap().received_packets = 6518;
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, 120, 4));
|
||||
traffic(&stats, 120).render(buffer.area, &mut buffer);
|
||||
let rendered = text(&buffer);
|
||||
for line in rendered.lines() {
|
||||
assert!(
|
||||
line.len() <= 40,
|
||||
"traffic row should not expand with the terminal: {line}"
|
||||
);
|
||||
}
|
||||
let TunnelStatisticsSnapshot::Available(view) = &mut stats else {
|
||||
unreachable!()
|
||||
};
|
||||
view.sample.as_mut().unwrap().received_packets = u64::MAX;
|
||||
view.sample.as_mut().unwrap().sent_packets = u64::MAX;
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, 56, 4));
|
||||
traffic(&stats, 56).render(buffer.area, &mut buffer);
|
||||
assert!(text(&buffer).contains("18446744073709551615 18446744073709551615"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wide_terminal_keeps_content_left_aligned_and_within_120_columns() {
|
||||
let state = state();
|
||||
let stats = statistics(&state);
|
||||
let mut terminal = Terminal::new(TestBackend::new(220, 40)).unwrap();
|
||||
let mut scroll = DetailScroll::default();
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &stats, &mut scroll))
|
||||
.unwrap();
|
||||
let wide = terminal.backend().buffer().clone();
|
||||
terminal.backend_mut().resize(120, 40);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &stats, &mut scroll))
|
||||
.unwrap();
|
||||
for y in 0..40 {
|
||||
for x in 0..220 {
|
||||
if x < 120 {
|
||||
assert_eq!(wide[(x, y)], terminal.backend().buffer()[(x, y)]);
|
||||
} else {
|
||||
assert_eq!(wide[(x, y)].symbol(), " ");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn routes_use_at_most_three_columns_and_keep_every_entry() {
|
||||
let list = TunnelList {
|
||||
items: (1..=7).map(|n| format!("10.0.{n}.0/24")).collect(),
|
||||
total_count: 7,
|
||||
truncated: false,
|
||||
};
|
||||
let mut lines = Vec::new();
|
||||
routes(&mut lines, "Included", &list, 220);
|
||||
let mut buffer = Buffer::empty(Rect::new(0, 0, 220, 4));
|
||||
paragraph(lines).render(buffer.area, &mut buffer);
|
||||
let rendered = text(&buffer);
|
||||
let route_rows: Vec<_> = rendered.lines().skip(1).collect();
|
||||
assert_eq!(route_rows.len(), 3);
|
||||
for line in route_rows {
|
||||
assert!(line.split_whitespace().count() <= 3);
|
||||
}
|
||||
for entry in &list.items {
|
||||
assert!(rendered.contains(entry));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn narrow_layout_stacks_sections_without_losing_routes() {
|
||||
let state = state();
|
||||
for width in [24, 60, 87] {
|
||||
let text = text(&details(&state, &statistics(&state), width));
|
||||
assert!(text.lines().any(|line| line == "TUNNEL"));
|
||||
assert!(text.lines().any(|line| line == "DNS"));
|
||||
assert!(text.contains("2001:db8:1234:5678::/64"));
|
||||
assert!(text.contains("192.168.0.0/16"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scrolling_reaches_last_route_and_resize_clamps_offset_with_summary_pinned() {
|
||||
let state = state();
|
||||
let statistics = statistics(&state);
|
||||
let mut terminal = Terminal::new(TestBackend::new(60, 14)).unwrap();
|
||||
let mut scroll = DetailScroll::default();
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &statistics, &mut scroll))
|
||||
.unwrap();
|
||||
assert!(scroll.can_scroll());
|
||||
scroll.handle_key(KeyCode::End);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &statistics, &mut scroll))
|
||||
.unwrap();
|
||||
let rendered = text(terminal.backend().buffer());
|
||||
assert!(rendered.contains("Connected"));
|
||||
assert!(rendered.contains("vpn.example.com"));
|
||||
assert!(rendered.contains("192.168.0.0/16"));
|
||||
terminal.backend_mut().resize(100, 50);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &statistics, &mut scroll))
|
||||
.unwrap();
|
||||
assert!(!scroll.can_scroll());
|
||||
assert_eq!(scroll.offset, 0);
|
||||
assert!(text(terminal.backend().buffer()).contains("TRAFFIC · live"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn very_short_body_keeps_status_and_scrollable_details_visible() {
|
||||
let state = state();
|
||||
for (width, height) in [(60, 6), (24, 3)] {
|
||||
let mut terminal = Terminal::new(TestBackend::new(width, height)).unwrap();
|
||||
let mut scroll = DetailScroll::default();
|
||||
let stats = statistics(&state);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &stats, &mut scroll))
|
||||
.unwrap();
|
||||
assert!(text(terminal.backend().buffer()).contains("Connected"));
|
||||
assert!(text(terminal.backend().buffer()).contains("TRAFFIC"));
|
||||
scroll.handle_key(KeyCode::End);
|
||||
terminal
|
||||
.draw(|frame| render_tunnel(frame, frame.area(), "vpn.example.com", &state, &stats, &mut scroll))
|
||||
.unwrap();
|
||||
assert!(text(terminal.backend().buffer()).contains("192.168.0.0/16"));
|
||||
scroll.handle_key(KeyCode::PageUp);
|
||||
let page_up = scroll.offset;
|
||||
assert!(page_up < scroll.maximum);
|
||||
scroll.handle_key(KeyCode::Up);
|
||||
assert!(scroll.offset < page_up);
|
||||
scroll.handle_key(KeyCode::Down);
|
||||
assert_eq!(scroll.offset, page_up);
|
||||
scroll.handle_key(KeyCode::PageDown);
|
||||
assert_eq!(scroll.offset, scroll.maximum);
|
||||
scroll.handle_key(KeyCode::Home);
|
||||
assert_eq!(scroll.offset, 0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stale_and_missing_configuration_remain_explicit() {
|
||||
let mut state = state();
|
||||
let mut statistics = statistics(&state);
|
||||
let TunnelStatisticsSnapshot::Available(view) = &mut statistics else {
|
||||
unreachable!()
|
||||
};
|
||||
view.state = TunnelStatisticsState::Stale;
|
||||
view.sample_age_ms = Some(12_000);
|
||||
state.configuration = None;
|
||||
let rendered = text(&details(&state, &statistics, 100));
|
||||
assert!(rendered.contains("TRAFFIC · stale"));
|
||||
assert!(rendered.contains("12 seconds"));
|
||||
assert!(rendered.contains("unavailable"));
|
||||
assert!(rendered.contains("1.2 MiB"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn units_and_long_sessions_are_explicit() {
|
||||
assert_eq!(bytes(1024), "1.0 KiB");
|
||||
assert_eq!(bytes(0), "0 B");
|
||||
assert_eq!(uptime(90_061_000), "25:01:01");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
//! Optional foreground presentation. Connection ownership stays with ConnectHandler.
|
||||
mod layout;
|
||||
mod notice;
|
||||
mod output;
|
||||
mod restoration;
|
||||
mod screen;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
use std::{
|
||||
fs::{File, OpenOptions},
|
||||
io::IsTerminal,
|
||||
os::fd::AsRawFd,
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
mpsc,
|
||||
},
|
||||
thread::JoinHandle,
|
||||
};
|
||||
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::log_format::LogFormat;
|
||||
use nix::unistd::{getpgrp, tcgetpgrp};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
pub(crate) use notice::{NoticeLogger, session_notice};
|
||||
use output::OutputRouting;
|
||||
|
||||
pub(crate) type InternalMembers = Arc<Mutex<std::collections::BTreeMap<String, String>>>;
|
||||
|
||||
pub(crate) fn validate(format: LogFormat) -> anyhow::Result<()> {
|
||||
ensure!(
|
||||
format == LogFormat::Text,
|
||||
"--dashboard conflicts with --log-format json"
|
||||
);
|
||||
ensure!(
|
||||
std::env::var_os("TERM").is_some_and(|term| term != "dumb"),
|
||||
"--dashboard requires a capable terminal (TERM must not be dumb)"
|
||||
);
|
||||
let tty = terminal()?;
|
||||
ensure!(
|
||||
std::io::stderr().is_terminal(),
|
||||
"--dashboard requires stderr attached to the controlling terminal"
|
||||
);
|
||||
let stderr = output::duplicate(2)?;
|
||||
ensure!(
|
||||
same_terminal(&stderr, &tty),
|
||||
"--dashboard requires stderr attached to the controlling terminal"
|
||||
);
|
||||
ensure!(
|
||||
tcgetpgrp(&tty)? == getpgrp(),
|
||||
"--dashboard requires a foreground terminal"
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn terminal() -> anyhow::Result<File> {
|
||||
OpenOptions::new()
|
||||
.read(true)
|
||||
.write(true)
|
||||
.open("/dev/tty")
|
||||
.context("--dashboard requires a controlling terminal")
|
||||
}
|
||||
|
||||
fn same_terminal(first: &File, second: &File) -> bool {
|
||||
// /dev/tty is a multiplexor node, so its st_rdev differs from the underlying
|
||||
// PTY. A session has one controlling terminal; compare terminal session IDs.
|
||||
let first_session = unsafe { nix::libc::tcgetsid(first.as_raw_fd()) };
|
||||
let second_session = unsafe { nix::libc::tcgetsid(second.as_raw_fd()) };
|
||||
first_session >= 0 && first_session == second_session
|
||||
}
|
||||
|
||||
pub(super) enum Content {
|
||||
Tunnel(Arc<gptunnel::TunnelMonitor>),
|
||||
Internal(InternalMembers),
|
||||
}
|
||||
|
||||
pub(super) enum Command {
|
||||
Suspend,
|
||||
Resume,
|
||||
}
|
||||
|
||||
pub(crate) struct Dashboard {
|
||||
routing: OutputRouting,
|
||||
server: String,
|
||||
cancellation: CancellationToken,
|
||||
stop: Arc<AtomicBool>,
|
||||
worker: Option<JoinHandle<()>>,
|
||||
signals: Vec<tokio::task::JoinHandle<()>>,
|
||||
error: Arc<Mutex<Option<String>>>,
|
||||
}
|
||||
|
||||
impl Dashboard {
|
||||
/// Install before native startup so persistent children inherit captured descriptors.
|
||||
pub(crate) fn prepare(server: String, cancellation: CancellationToken) -> anyhow::Result<Self> {
|
||||
let capture_stdout =
|
||||
std::io::stdout().is_terminal() && same_terminal(&output::duplicate(1)?, &output::duplicate(2)?);
|
||||
Ok(Self {
|
||||
routing: OutputRouting::install(capture_stdout, cancellation.clone())?,
|
||||
server,
|
||||
cancellation,
|
||||
stop: Arc::default(),
|
||||
worker: None,
|
||||
signals: Vec::new(),
|
||||
error: Arc::default(),
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn start_tunnel(&mut self, monitor: Arc<gptunnel::TunnelMonitor>) -> anyhow::Result<()> {
|
||||
self.start(Content::Tunnel(monitor.clone()))?;
|
||||
monitor.set_statistics_enabled(true);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn start_internal(&mut self, members: InternalMembers) -> anyhow::Result<()> {
|
||||
self.start(Content::Internal(members))
|
||||
}
|
||||
|
||||
fn start(&mut self, content: Content) -> anyhow::Result<()> {
|
||||
ensure!(self.worker.is_none(), "Dashboard already started");
|
||||
let (commands, receiver) = mpsc::channel();
|
||||
for (kind, command) in [
|
||||
(
|
||||
tokio::signal::unix::SignalKind::from_raw(nix::libc::SIGTSTP),
|
||||
Command::Suspend,
|
||||
),
|
||||
(
|
||||
tokio::signal::unix::SignalKind::from_raw(nix::libc::SIGCONT),
|
||||
Command::Resume,
|
||||
),
|
||||
] {
|
||||
let mut signal = tokio::signal::unix::signal(kind)?;
|
||||
let commands = commands.clone();
|
||||
self.signals.push(tokio::spawn(async move {
|
||||
while signal.recv().await.is_some() {
|
||||
let command = match command {
|
||||
Command::Suspend => Command::Suspend,
|
||||
Command::Resume => Command::Resume,
|
||||
};
|
||||
if commands.send(command).is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}));
|
||||
}
|
||||
let mut hangup = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::hangup())?;
|
||||
let cancellation = self.cancellation.clone();
|
||||
self.signals.push(tokio::spawn(async move {
|
||||
if hangup.recv().await.is_some() {
|
||||
cancellation.cancel();
|
||||
}
|
||||
}));
|
||||
let (ready, started) = mpsc::sync_channel(1);
|
||||
let context = screen::Context {
|
||||
terminal: terminal()?,
|
||||
output: self.routing.original_error.clone(),
|
||||
saved_stdout: self.routing.saved_output(),
|
||||
saved_stdin_flags: self.routing.saved_input_flags(),
|
||||
history: self.routing.history(),
|
||||
passthrough: self.routing.passthrough(),
|
||||
gate: self.routing.gate(),
|
||||
stop: self.stop.clone(),
|
||||
cancellation: self.cancellation.clone(),
|
||||
notice: notice::slot(),
|
||||
server: self.server.clone(),
|
||||
content,
|
||||
commands: receiver,
|
||||
};
|
||||
let error = self.error.clone();
|
||||
let cancellation = self.cancellation.clone();
|
||||
self.worker = Some(std::thread::Builder::new().name("dashboard".into()).spawn(move || {
|
||||
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| screen::run(context, ready)));
|
||||
let failure = match result {
|
||||
Ok(Ok(())) => None,
|
||||
Ok(Err(failure)) => Some(format!("{failure:#}")),
|
||||
Err(_) => Some("Dashboard renderer panicked".into()),
|
||||
};
|
||||
if let Some(failure) = failure {
|
||||
*error.lock().unwrap_or_else(|error| error.into_inner()) = Some(failure);
|
||||
cancellation.cancel();
|
||||
}
|
||||
})?);
|
||||
started.recv().context("Dashboard stopped during initialization")??;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Called after native shutdown and network cleanup, while capture still drains.
|
||||
pub(crate) fn finish(&mut self) -> anyhow::Result<()> {
|
||||
self.stop.store(true, Ordering::Release);
|
||||
if let Some(worker) = self.worker.take() {
|
||||
let _ = worker.join();
|
||||
}
|
||||
for signal in self.signals.drain(..) {
|
||||
signal.abort();
|
||||
}
|
||||
self.routing.restore();
|
||||
if let Some(error) = self.routing.take_error() {
|
||||
anyhow::bail!("Dashboard failed: {error}");
|
||||
}
|
||||
if let Some(error) = self.error.lock().unwrap_or_else(|error| error.into_inner()).take() {
|
||||
anyhow::bail!("Dashboard failed: {error}");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Dashboard {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.finish();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
use std::sync::{Arc, Mutex, OnceLock};
|
||||
|
||||
use log::{Level, Log};
|
||||
|
||||
use super::output::plain_text;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(super) struct Notice {
|
||||
pub(super) level: Level,
|
||||
pub(super) message: String,
|
||||
}
|
||||
|
||||
pub(super) type NoticeSlot = Arc<Mutex<Option<Notice>>>;
|
||||
static NOTICES: OnceLock<NoticeSlot> = OnceLock::new();
|
||||
|
||||
pub(super) fn slot() -> NoticeSlot {
|
||||
NOTICES.get_or_init(Arc::default).clone()
|
||||
}
|
||||
|
||||
pub(crate) fn session_notice(level: Level, message: &str) {
|
||||
if let Some(slot) = NOTICES.get() {
|
||||
let mut end = message.len().min(8192);
|
||||
while !message.is_char_boundary(end) {
|
||||
end -= 1;
|
||||
}
|
||||
*slot.lock().unwrap_or_else(|error| error.into_inner()) = Some(Notice {
|
||||
level,
|
||||
message: plain_text(message[..end].as_bytes()),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/// Metadata goes to the notice slot; descriptor capture owns the sole history entry.
|
||||
pub(crate) struct NoticeLogger {
|
||||
inner: env_logger::Logger,
|
||||
}
|
||||
|
||||
impl NoticeLogger {
|
||||
pub(crate) fn new(inner: env_logger::Logger) -> Self {
|
||||
let _ = slot();
|
||||
Self { inner }
|
||||
}
|
||||
}
|
||||
|
||||
impl Log for NoticeLogger {
|
||||
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
|
||||
self.inner.enabled(metadata)
|
||||
}
|
||||
fn log(&self, record: &log::Record<'_>) {
|
||||
if self.inner.matches(record) {
|
||||
if record.level() <= Level::Warn {
|
||||
session_notice(record.level(), &record.args().to_string());
|
||||
}
|
||||
self.inner.log(record);
|
||||
}
|
||||
}
|
||||
fn flush(&self) {
|
||||
self.inner.flush();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn notice_tap_honors_message_filters_and_keeps_warning_severity() {
|
||||
let logger = NoticeLogger::new(
|
||||
env_logger::Builder::new()
|
||||
.parse_filters("warn/allowed")
|
||||
.target(env_logger::Target::Pipe(Box::new(std::io::sink())))
|
||||
.build(),
|
||||
);
|
||||
session_notice(Level::Info, "previous event");
|
||||
logger.log(
|
||||
&log::Record::builder()
|
||||
.level(Level::Warn)
|
||||
.args(format_args!("filtered warning"))
|
||||
.build(),
|
||||
);
|
||||
assert_eq!(slot().lock().unwrap().as_ref().unwrap().message, "previous event");
|
||||
logger.log(
|
||||
&log::Record::builder()
|
||||
.level(Level::Warn)
|
||||
.args(format_args!("allowed warning"))
|
||||
.build(),
|
||||
);
|
||||
let current = slot();
|
||||
let notice = current.lock().unwrap();
|
||||
assert_eq!(notice.as_ref().unwrap().level, Level::Warn);
|
||||
assert_eq!(notice.as_ref().unwrap().message, "allowed warning");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,338 @@
|
||||
//! Own terminal output while the native worker and its children are running.
|
||||
use std::{
|
||||
collections::VecDeque,
|
||||
fs::File,
|
||||
io::{self, Read, Write},
|
||||
os::fd::{AsFd, FromRawFd},
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
},
|
||||
thread::{self, JoinHandle},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use anyhow::Context;
|
||||
use nix::{
|
||||
fcntl::{FcntlArg, FdFlag, OFlag, fcntl},
|
||||
poll::{PollFd, PollFlags, poll},
|
||||
unistd::{dup2_stderr, dup2_stdout},
|
||||
};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
const MAX_LINES: usize = 2_000;
|
||||
const MAX_BYTES: usize = 1_048_576;
|
||||
const MAX_LINE_BYTES: usize = 8_192;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(super) struct History {
|
||||
lines: VecDeque<String>,
|
||||
bytes: usize,
|
||||
discarded: u64,
|
||||
partial: [String; 2],
|
||||
}
|
||||
|
||||
impl History {
|
||||
fn push(&mut self, line: String) {
|
||||
self.bytes += line.len();
|
||||
self.lines.push_back(line);
|
||||
while self.lines.len() > MAX_LINES || self.bytes > MAX_BYTES {
|
||||
if let Some(line) = self.lines.pop_front() {
|
||||
self.bytes -= line.len();
|
||||
self.discarded = self.discarded.saturating_add(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn tail(&self, count: usize) -> Vec<String> {
|
||||
if count == 0 {
|
||||
return Vec::new();
|
||||
}
|
||||
let mut lines = Vec::new();
|
||||
if self.discarded > 0 {
|
||||
lines.push(format!("[{} older log lines discarded]", self.discarded));
|
||||
}
|
||||
let partial_count = self.partial.iter().filter(|line| !line.is_empty()).count();
|
||||
let retained_count = count.saturating_sub(lines.len() + partial_count);
|
||||
lines.extend(
|
||||
self
|
||||
.lines
|
||||
.iter()
|
||||
.skip(self.lines.len().saturating_sub(retained_count))
|
||||
.cloned(),
|
||||
);
|
||||
lines.extend(self.partial.iter().filter(|line| !line.is_empty()).cloned());
|
||||
lines.truncate(count);
|
||||
lines
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn plain_text(bytes: &[u8]) -> String {
|
||||
String::from_utf8_lossy(&strip_ansi_escapes::strip(bytes))
|
||||
.chars()
|
||||
.filter(|ch| !ch.is_control() || *ch == '\t')
|
||||
.collect()
|
||||
}
|
||||
|
||||
struct LineDecoder {
|
||||
bytes: Vec<u8>,
|
||||
truncated: bool,
|
||||
stream: usize,
|
||||
}
|
||||
|
||||
impl LineDecoder {
|
||||
fn new(stream: usize) -> Self {
|
||||
Self {
|
||||
bytes: Vec::new(),
|
||||
truncated: false,
|
||||
stream,
|
||||
}
|
||||
}
|
||||
|
||||
fn text(&self) -> String {
|
||||
let suffix = if self.truncated { " [line truncated]" } else { "" };
|
||||
format!("{}{suffix}", plain_text(&self.bytes))
|
||||
}
|
||||
|
||||
fn ingest(&mut self, bytes: &[u8], history: &mut History) {
|
||||
for byte in bytes {
|
||||
if *byte == b'\n' {
|
||||
history.push(self.text());
|
||||
self.bytes.clear();
|
||||
self.truncated = false;
|
||||
} else if self.bytes.len() < MAX_LINE_BYTES {
|
||||
self.bytes.push(*byte);
|
||||
} else {
|
||||
self.truncated = true;
|
||||
}
|
||||
}
|
||||
history.partial[self.stream] = if self.bytes.is_empty() && !self.truncated {
|
||||
String::new()
|
||||
} else {
|
||||
self.text()
|
||||
};
|
||||
}
|
||||
|
||||
fn finish(&mut self, history: &mut History) {
|
||||
if !self.bytes.is_empty() || self.truncated {
|
||||
history.push(self.text());
|
||||
}
|
||||
history.partial[self.stream].clear();
|
||||
}
|
||||
}
|
||||
|
||||
/// The duplicate is close-on-exec: helpers inherit the capture pipe, never the renderer.
|
||||
pub(super) fn duplicate(fd: i32) -> io::Result<File> {
|
||||
let duplicate = unsafe { nix::libc::fcntl(fd, nix::libc::F_DUPFD_CLOEXEC, 3) };
|
||||
if duplicate < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
Ok(unsafe { File::from_raw_fd(duplicate) })
|
||||
}
|
||||
|
||||
pub(super) struct OutputRouting {
|
||||
pub(super) original_error: Arc<File>,
|
||||
original_input_flags: FdFlag,
|
||||
original_output: Option<Arc<File>>,
|
||||
history: Arc<Mutex<History>>,
|
||||
passthrough: Arc<AtomicBool>,
|
||||
stop: Arc<AtomicBool>,
|
||||
readers: Vec<JoinHandle<()>>,
|
||||
gate: Arc<Mutex<()>>,
|
||||
error: Arc<Mutex<Option<String>>>,
|
||||
restored: bool,
|
||||
}
|
||||
|
||||
impl OutputRouting {
|
||||
pub(super) fn install(capture_stdout: bool, cancellation: CancellationToken) -> anyhow::Result<Self> {
|
||||
io::stdout().flush()?;
|
||||
io::stderr().flush()?;
|
||||
unsafe {
|
||||
nix::libc::fflush(std::ptr::null_mut());
|
||||
}
|
||||
let mut routing = Self {
|
||||
original_error: Arc::new(duplicate(2)?),
|
||||
original_input_flags: FdFlag::from_bits_truncate(fcntl(io::stdin(), FcntlArg::F_GETFD)?),
|
||||
original_output: capture_stdout.then(|| duplicate(1).map(Arc::new)).transpose()?,
|
||||
history: Arc::default(),
|
||||
passthrough: Arc::new(AtomicBool::new(true)),
|
||||
stop: Arc::default(),
|
||||
readers: Vec::new(),
|
||||
gate: Arc::default(),
|
||||
error: Arc::default(),
|
||||
restored: false,
|
||||
};
|
||||
routing.capture(1, routing.original_error.clone(), cancellation.clone())?;
|
||||
if let Some(original) = routing.original_output.clone() {
|
||||
routing.capture(0, original, cancellation)?;
|
||||
}
|
||||
// Authentication may have initialized Crossterm's global reader with fd 0.
|
||||
// Keep that descriptor stable, but do not let executed helpers inherit it.
|
||||
// Script-TUN packet I/O continues through its separate VPNFD socket.
|
||||
fcntl(
|
||||
io::stdin(),
|
||||
FcntlArg::F_SETFD(routing.original_input_flags | FdFlag::FD_CLOEXEC),
|
||||
)?;
|
||||
Ok(routing)
|
||||
}
|
||||
|
||||
fn capture(&mut self, stream: usize, destination: Arc<File>, cancellation: CancellationToken) -> anyhow::Result<()> {
|
||||
let (reader, writer) = io::pipe()?;
|
||||
// Polling plus nonblocking reads lets teardown bound inherited pipe lifetimes.
|
||||
fcntl(&reader, FcntlArg::F_SETFL(OFlag::O_NONBLOCK))?;
|
||||
let history = self.history.clone();
|
||||
let passthrough = self.passthrough.clone();
|
||||
let stop = self.stop.clone();
|
||||
let gate = self.gate.clone();
|
||||
let error = self.error.clone();
|
||||
let thread = thread::Builder::new()
|
||||
.name(format!("dashboard-output-{stream}"))
|
||||
.spawn(move || {
|
||||
let mut reader = reader;
|
||||
let mut decoder = LineDecoder::new(stream);
|
||||
let mut buffer = [0; 4096];
|
||||
let mut deadline = None;
|
||||
loop {
|
||||
if stop.load(Ordering::Acquire) && deadline.is_none() {
|
||||
deadline = Some(Instant::now() + Duration::from_millis(250));
|
||||
}
|
||||
if deadline.is_some_and(|deadline| Instant::now() >= deadline) {
|
||||
break;
|
||||
}
|
||||
let mut descriptors = [PollFd::new(reader.as_fd(), PollFlags::POLLIN)];
|
||||
match poll(&mut descriptors, 50u16) {
|
||||
Ok(0) => {
|
||||
if deadline.is_some() {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
Ok(_) => {}
|
||||
Err(nix::errno::Errno::EINTR) => continue,
|
||||
Err(failure) => {
|
||||
*error.lock().unwrap_or_else(|error| error.into_inner()) =
|
||||
Some(format!("Cannot poll dashboard output: {failure}"));
|
||||
cancellation.cancel();
|
||||
break;
|
||||
}
|
||||
}
|
||||
match reader.read(&mut buffer) {
|
||||
Ok(0) => break,
|
||||
Ok(length) => {
|
||||
{
|
||||
let _gate = gate.lock().unwrap_or_else(|error| error.into_inner());
|
||||
if passthrough.load(Ordering::Acquire) {
|
||||
if let Err(failure) = (&*destination).write_all(&buffer[..length]) {
|
||||
*error.lock().unwrap_or_else(|error| error.into_inner()) =
|
||||
Some(format!("Cannot forward dashboard output: {failure}"));
|
||||
cancellation.cancel();
|
||||
}
|
||||
}
|
||||
}
|
||||
decoder.ingest(
|
||||
&buffer[..length],
|
||||
&mut history.lock().unwrap_or_else(|error| error.into_inner()),
|
||||
);
|
||||
}
|
||||
Err(error) if matches!(error.kind(), io::ErrorKind::WouldBlock | io::ErrorKind::Interrupted) => continue,
|
||||
Err(failure) => {
|
||||
*error.lock().unwrap_or_else(|error| error.into_inner()) =
|
||||
Some(format!("Cannot read dashboard output: {failure}"));
|
||||
cancellation.cancel();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
decoder.finish(&mut history.lock().unwrap_or_else(|error| error.into_inner()));
|
||||
})
|
||||
.context("Cannot start dashboard output reader")?;
|
||||
self.readers.push(thread);
|
||||
if stream == 0 {
|
||||
dup2_stdout(&writer)?;
|
||||
} else {
|
||||
dup2_stderr(&writer)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(super) fn history(&self) -> Arc<Mutex<History>> {
|
||||
self.history.clone()
|
||||
}
|
||||
pub(super) fn passthrough(&self) -> Arc<AtomicBool> {
|
||||
self.passthrough.clone()
|
||||
}
|
||||
pub(super) fn gate(&self) -> Arc<Mutex<()>> {
|
||||
self.gate.clone()
|
||||
}
|
||||
pub(super) fn saved_output(&self) -> Option<Arc<File>> {
|
||||
self.original_output.clone()
|
||||
}
|
||||
pub(super) fn saved_input_flags(&self) -> FdFlag {
|
||||
self.original_input_flags
|
||||
}
|
||||
pub(super) fn take_error(&self) -> Option<String> {
|
||||
self.error.lock().unwrap_or_else(|error| error.into_inner()).take()
|
||||
}
|
||||
|
||||
pub(super) fn restore(&mut self) {
|
||||
if self.restored {
|
||||
return;
|
||||
}
|
||||
let _ = io::stdout().flush();
|
||||
let _ = io::stderr().flush();
|
||||
unsafe {
|
||||
nix::libc::fflush(std::ptr::null_mut());
|
||||
}
|
||||
let _ = dup2_stderr(&*self.original_error);
|
||||
let _ = fcntl(io::stdin(), FcntlArg::F_SETFD(self.original_input_flags));
|
||||
if let Some(output) = &self.original_output {
|
||||
let _ = dup2_stdout(&**output);
|
||||
}
|
||||
self.stop.store(true, Ordering::Release);
|
||||
for reader in self.readers.drain(..) {
|
||||
let _ = reader.join();
|
||||
}
|
||||
self.restored = true;
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for OutputRouting {
|
||||
fn drop(&mut self) {
|
||||
self.restore();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn split_utf8_and_unterminated_lines_are_preserved_without_escape_commands() {
|
||||
for stream in [0, 1] {
|
||||
let mut history = History::default();
|
||||
let mut decoder = LineDecoder::new(stream);
|
||||
let bytes = "connected 日本語\x1b[2J\npartial".as_bytes();
|
||||
for byte in bytes {
|
||||
decoder.ingest(&[*byte], &mut history);
|
||||
}
|
||||
assert_eq!(history.tail(10), ["connected 日本語", "partial"]);
|
||||
decoder.finish(&mut history);
|
||||
assert_eq!(history.tail(10), ["connected 日本語", "partial"]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_long_lines_and_history_are_bounded() {
|
||||
let mut history = History::default();
|
||||
let mut decoder = LineDecoder::new(0);
|
||||
decoder.ingest(&vec![b'x'; MAX_LINE_BYTES * 3], &mut history);
|
||||
decoder.ingest(b"\n", &mut history);
|
||||
assert!(history.lines[0].ends_with("[line truncated]"));
|
||||
for _ in 0..MAX_LINES + 10 {
|
||||
decoder.ingest(b"line\n", &mut history);
|
||||
}
|
||||
assert!(history.lines.len() <= MAX_LINES);
|
||||
assert!(history.bytes <= MAX_BYTES);
|
||||
assert!(history.tail(10)[0].contains("discarded"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
//! Panic restoration must remain independent of renderer and output-ingestion locks.
|
||||
use std::{
|
||||
fs::File,
|
||||
io,
|
||||
os::fd::AsRawFd,
|
||||
sync::{
|
||||
Arc,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
},
|
||||
};
|
||||
|
||||
pub(super) struct TerminalRestoration {
|
||||
terminal: File,
|
||||
error: Arc<File>,
|
||||
output: Option<Arc<File>>,
|
||||
input_flags: nix::fcntl::FdFlag,
|
||||
termios: nix::libc::termios,
|
||||
active: AtomicBool,
|
||||
}
|
||||
|
||||
impl TerminalRestoration {
|
||||
pub(super) fn install(
|
||||
terminal: File,
|
||||
error: Arc<File>,
|
||||
output: Option<Arc<File>>,
|
||||
input_flags: nix::fcntl::FdFlag,
|
||||
) -> io::Result<Arc<Self>> {
|
||||
let mut termios = std::mem::MaybeUninit::uninit();
|
||||
if unsafe { nix::libc::tcgetattr(terminal.as_raw_fd(), termios.as_mut_ptr()) } != 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let restoration = Arc::new(Self {
|
||||
terminal,
|
||||
error,
|
||||
output,
|
||||
input_flags,
|
||||
termios: unsafe { termios.assume_init() },
|
||||
active: AtomicBool::new(false),
|
||||
});
|
||||
let previous = std::panic::take_hook();
|
||||
let panic_restoration = restoration.clone();
|
||||
std::panic::set_hook(Box::new(move |panic| {
|
||||
panic_restoration.restore();
|
||||
previous(panic);
|
||||
}));
|
||||
Ok(restoration)
|
||||
}
|
||||
|
||||
pub(super) fn arm(&self) {
|
||||
self.active.store(true, Ordering::Release);
|
||||
}
|
||||
pub(super) fn disarm(&self) {
|
||||
self.active.store(false, Ordering::Release);
|
||||
}
|
||||
|
||||
pub(super) fn restore(&self) {
|
||||
if !self.active.swap(false, Ordering::AcqRel) {
|
||||
return;
|
||||
}
|
||||
unsafe {
|
||||
nix::libc::tcsetattr(self.terminal.as_raw_fd(), nix::libc::TCSANOW, &self.termios);
|
||||
let sequence = b"\x1b[?25h\x1b[?1049l";
|
||||
nix::libc::write(self.error.as_raw_fd(), sequence.as_ptr().cast(), sequence.len());
|
||||
nix::libc::dup2(self.error.as_raw_fd(), 2);
|
||||
nix::libc::fcntl(0, nix::libc::F_SETFD, self.input_flags.bits());
|
||||
if let Some(output) = &self.output {
|
||||
nix::libc::dup2(output.as_raw_fd(), 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,359 @@
|
||||
use std::{
|
||||
fs::File,
|
||||
sync::{
|
||||
Arc, Mutex,
|
||||
atomic::{AtomicBool, Ordering},
|
||||
mpsc,
|
||||
},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use anyhow::{Context as _, ensure};
|
||||
use crossterm::{
|
||||
cursor::Show,
|
||||
event::{self, Event, KeyCode, KeyEventKind, KeyModifiers},
|
||||
execute,
|
||||
terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
|
||||
};
|
||||
use gpapi::session::tunnel::TunnelPhase;
|
||||
use log::Level;
|
||||
use nix::unistd::{getpgrp, tcgetpgrp};
|
||||
use ratatui::{
|
||||
Terminal,
|
||||
backend::CrosstermBackend,
|
||||
layout::{Constraint, Layout},
|
||||
style::{Color, Modifier, Style},
|
||||
text::Line,
|
||||
widgets::{Block, Borders, Paragraph, Wrap},
|
||||
};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use super::{
|
||||
Command, Content,
|
||||
layout::{DetailScroll, phase_label, render_tunnel, row},
|
||||
notice::{Notice, NoticeSlot},
|
||||
output::{History, plain_text},
|
||||
restoration::TerminalRestoration,
|
||||
};
|
||||
|
||||
pub(super) struct Context {
|
||||
pub(super) terminal: File,
|
||||
pub(super) output: Arc<File>,
|
||||
pub(super) saved_stdout: Option<Arc<File>>,
|
||||
pub(super) saved_stdin_flags: nix::fcntl::FdFlag,
|
||||
pub(super) history: Arc<Mutex<History>>,
|
||||
pub(super) passthrough: Arc<AtomicBool>,
|
||||
pub(super) gate: Arc<Mutex<()>>,
|
||||
pub(super) stop: Arc<AtomicBool>,
|
||||
pub(super) cancellation: CancellationToken,
|
||||
pub(super) notice: NoticeSlot,
|
||||
pub(super) server: String,
|
||||
pub(super) content: Content,
|
||||
pub(super) commands: mpsc::Receiver<Command>,
|
||||
}
|
||||
|
||||
struct Screen {
|
||||
terminal: Terminal<CrosstermBackend<File>>,
|
||||
restore: Arc<TerminalRestoration>,
|
||||
controlling_terminal: File,
|
||||
passthrough: Arc<AtomicBool>,
|
||||
gate: Arc<Mutex<()>>,
|
||||
active: bool,
|
||||
}
|
||||
|
||||
impl Screen {
|
||||
fn new(context: &Context) -> anyhow::Result<Self> {
|
||||
let restore = TerminalRestoration::install(
|
||||
context.terminal.try_clone()?,
|
||||
context.output.clone(),
|
||||
context.saved_stdout.clone(),
|
||||
context.saved_stdin_flags,
|
||||
)?;
|
||||
let terminal = Terminal::new(CrosstermBackend::new(context.output.try_clone()?))?;
|
||||
let mut screen = Self {
|
||||
terminal,
|
||||
restore,
|
||||
controlling_terminal: context.terminal.try_clone()?,
|
||||
passthrough: context.passthrough.clone(),
|
||||
gate: context.gate.clone(),
|
||||
active: false,
|
||||
};
|
||||
screen.enter()?;
|
||||
Ok(screen)
|
||||
}
|
||||
|
||||
fn enter(&mut self) -> anyhow::Result<()> {
|
||||
if self.active {
|
||||
return Ok(());
|
||||
}
|
||||
ensure!(
|
||||
tcgetpgrp(&self.controlling_terminal)? == getpgrp(),
|
||||
"Dashboard is no longer in the foreground"
|
||||
);
|
||||
let _gate = self.gate.lock().unwrap_or_else(|error| error.into_inner());
|
||||
self.passthrough.store(false, Ordering::Release);
|
||||
// Arm before changing termios, including partial initialization failures.
|
||||
self.restore.arm();
|
||||
self.active = true;
|
||||
enable_raw_mode()?;
|
||||
execute!(self.terminal.backend_mut(), EnterAlternateScreen)?;
|
||||
// Terminal::clear queries cursor position through process stdout. Fullscreen
|
||||
// resize clears and resets buffers through our saved terminal backend only.
|
||||
self.terminal.resize(self.terminal.size()?.into())?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn leave(&mut self) {
|
||||
if !self.active {
|
||||
return;
|
||||
}
|
||||
let _gate = self.gate.lock().unwrap_or_else(|error| error.into_inner());
|
||||
let _ = disable_raw_mode();
|
||||
let _ = execute!(self.terminal.backend_mut(), Show, LeaveAlternateScreen);
|
||||
self.restore.disarm();
|
||||
self.passthrough.store(true, Ordering::Release);
|
||||
self.active = false;
|
||||
}
|
||||
|
||||
fn suspend(&mut self) {
|
||||
self.leave();
|
||||
// SIGSTOP avoids recursion through our SIGTSTP listener. The shell resumes us.
|
||||
unsafe {
|
||||
nix::libc::raise(nix::libc::SIGSTOP);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Screen {
|
||||
fn drop(&mut self) {
|
||||
self.leave();
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn run(context: Context, ready: mpsc::SyncSender<anyhow::Result<()>>) -> anyhow::Result<()> {
|
||||
let screen = Screen::new(&context);
|
||||
let mut screen = match screen {
|
||||
Ok(screen) => {
|
||||
let _ = ready.send(Ok(()));
|
||||
screen
|
||||
}
|
||||
Err(error) => {
|
||||
let _ = ready.send(Err(anyhow::anyhow!("{error:#}")));
|
||||
return Err(error);
|
||||
}
|
||||
};
|
||||
let mut logs = false;
|
||||
let mut scroll = DetailScroll::default();
|
||||
let mut next_draw = Instant::now();
|
||||
let mut dirty = true;
|
||||
while !context.stop.load(Ordering::Acquire) {
|
||||
for command in context.commands.try_iter() {
|
||||
match command {
|
||||
Command::Suspend => screen.suspend(),
|
||||
Command::Resume => {}
|
||||
}
|
||||
}
|
||||
if !screen.active {
|
||||
if tcgetpgrp(&context.terminal)? == getpgrp() {
|
||||
screen.enter()?;
|
||||
} else {
|
||||
std::thread::sleep(Duration::from_millis(100));
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if dirty || Instant::now() >= next_draw {
|
||||
draw(&mut screen.terminal, &context, logs, &mut scroll)?;
|
||||
next_draw = Instant::now() + Duration::from_secs(1);
|
||||
dirty = false;
|
||||
}
|
||||
if event::poll(Duration::from_millis(100)).context("Cannot read dashboard input")? {
|
||||
if let Event::Key(key) = event::read()? {
|
||||
if key.kind != KeyEventKind::Press {
|
||||
continue;
|
||||
}
|
||||
match key.code {
|
||||
KeyCode::Tab | KeyCode::BackTab => {
|
||||
logs = !logs;
|
||||
dirty = true;
|
||||
}
|
||||
KeyCode::Up | KeyCode::Down | KeyCode::PageUp | KeyCode::PageDown | KeyCode::Home | KeyCode::End if !logs => {
|
||||
scroll.handle_key(key.code);
|
||||
dirty = true;
|
||||
}
|
||||
KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
|
||||
context.cancellation.cancel();
|
||||
dirty = true;
|
||||
}
|
||||
KeyCode::Char('z') if key.modifiers.contains(KeyModifiers::CONTROL) => screen.suspend(),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn draw(
|
||||
terminal: &mut Terminal<CrosstermBackend<File>>,
|
||||
context: &Context,
|
||||
logs: bool,
|
||||
scroll: &mut DetailScroll,
|
||||
) -> anyhow::Result<()> {
|
||||
terminal.draw(|frame| {
|
||||
let area = frame.area();
|
||||
if area.height < 8 || area.width < 24 {
|
||||
frame.render_widget(
|
||||
Paragraph::new("GP Connect\nCtrl+C Disconnect").wrap(Wrap { trim: false }),
|
||||
area,
|
||||
);
|
||||
return;
|
||||
}
|
||||
let compact = area.height < 18;
|
||||
let footer_height = if area.width < 80 { 2 } else { 1 };
|
||||
let [header, body, notice, footer] = Layout::vertical([
|
||||
Constraint::Length(2),
|
||||
Constraint::Min(1),
|
||||
Constraint::Length(if compact { 1 } else { 3 }),
|
||||
Constraint::Length(footer_height),
|
||||
])
|
||||
.areas(area);
|
||||
let view = if logs { "Live logs" } else { "Dashboard" };
|
||||
frame.render_widget(
|
||||
Paragraph::new(format!(" GP Connect · {view}"))
|
||||
.style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))
|
||||
.block(Block::default().borders(Borders::BOTTOM)),
|
||||
header,
|
||||
);
|
||||
let mut lines = vec![row("Server", context.server.clone()), Line::default()];
|
||||
if logs {
|
||||
let history = context.history.lock().unwrap_or_else(|error| error.into_inner());
|
||||
let tail = history.tail(body.height as usize);
|
||||
lines = tail.into_iter().map(Line::raw).collect();
|
||||
let skip = lines.len().saturating_sub(body.height as usize);
|
||||
lines.drain(..skip);
|
||||
} else {
|
||||
match &context.content {
|
||||
Content::Tunnel(monitor) => {
|
||||
render_tunnel(
|
||||
frame,
|
||||
body,
|
||||
&context.server,
|
||||
&monitor.state(),
|
||||
&monitor.statistics(),
|
||||
scroll,
|
||||
);
|
||||
}
|
||||
Content::Internal(members) => {
|
||||
lines.push(row("Status", "Internal network session"));
|
||||
lines.push(Line::raw("Tunnel statistics unavailable (non-tunnel session)"));
|
||||
lines.push(Line::default());
|
||||
lines.extend(
|
||||
members
|
||||
.lock()
|
||||
.unwrap_or_else(|error| error.into_inner())
|
||||
.values()
|
||||
.map(|member| Line::raw(plain_text(member.as_bytes()))),
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
if logs || matches!(context.content, Content::Internal(_)) {
|
||||
frame.render_widget(Paragraph::new(lines).wrap(Wrap { trim: false }), body);
|
||||
}
|
||||
let current = context.notice.lock().unwrap_or_else(|error| error.into_inner()).clone();
|
||||
let current = match &context.content {
|
||||
Content::Tunnel(monitor) => {
|
||||
let state = monitor.state();
|
||||
Some(notice_for_status(current, state.phase, state.transport))
|
||||
}
|
||||
Content::Internal(_) => current,
|
||||
};
|
||||
if let Some(current) = current {
|
||||
let color = if current.level <= Level::Warn {
|
||||
Color::Yellow
|
||||
} else {
|
||||
Color::Gray
|
||||
};
|
||||
let block = if compact {
|
||||
Block::default()
|
||||
} else {
|
||||
Block::default().title("Latest event").borders(Borders::TOP)
|
||||
};
|
||||
frame.render_widget(
|
||||
Paragraph::new(current.message)
|
||||
.style(Style::default().fg(color))
|
||||
.wrap(Wrap { trim: false })
|
||||
.block(block),
|
||||
notice,
|
||||
);
|
||||
}
|
||||
let ending = if context.cancellation.is_cancelled() {
|
||||
"Disconnecting…"
|
||||
} else {
|
||||
"Ctrl+C Disconnect"
|
||||
};
|
||||
frame.render_widget(
|
||||
footer_text(logs, ending, scroll.can_scroll(), area.width).style(Style::default().fg(Color::DarkGray)),
|
||||
footer,
|
||||
);
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn footer_text(logs: bool, ending: &str, scrollable: bool, width: u16) -> Paragraph<'static> {
|
||||
let view = if logs { "Dashboard" } else { "Logs" };
|
||||
let scrolling = scrollable && !logs;
|
||||
let text = if width < 80 {
|
||||
format!("{ending}\nTab {view}{}", if scrolling { " ↑↓ Scroll" } else { "" })
|
||||
} else {
|
||||
format!(
|
||||
"Tab {view} {ending}{}",
|
||||
if scrolling { " ↑↓/PgUp/PgDn Scroll" } else { "" }
|
||||
)
|
||||
};
|
||||
Paragraph::new(text)
|
||||
}
|
||||
|
||||
fn notice_for_status(
|
||||
notice: Option<Notice>,
|
||||
phase: TunnelPhase,
|
||||
transport: gpapi::session::tunnel::TunnelTransport,
|
||||
) -> Notice {
|
||||
notice.unwrap_or_else(|| Notice {
|
||||
level: Level::Info,
|
||||
message: format!("{} · {}", phase_label(phase), transport.label()),
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn narrow_footer_keeps_disconnect_switch_and_scroll_hints_visible() {
|
||||
use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
|
||||
let area = Rect::new(0, 0, 24, 2);
|
||||
let mut buffer = Buffer::empty(area);
|
||||
footer_text(false, "Ctrl+C Disconnect", true, area.width).render(area, &mut buffer);
|
||||
let lines: Vec<String> = (0..2)
|
||||
.map(|y| (0..24).map(|x| buffer[(x, y)].symbol()).collect())
|
||||
.collect();
|
||||
assert!(lines[0].contains("Ctrl+C Disconnect"));
|
||||
assert!(lines[1].contains("Tab Logs"));
|
||||
assert!(lines[1].contains("↑↓ Scroll"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_transitions_cannot_overwrite_an_existing_warning() {
|
||||
use gpapi::session::tunnel::TunnelTransport;
|
||||
let warning = Notice {
|
||||
level: Level::Warn,
|
||||
message: "ESP unavailable; using SSL".into(),
|
||||
};
|
||||
let first = notice_for_status(Some(warning), TunnelPhase::Connected, TunnelTransport::SslTls);
|
||||
let reconnecting = notice_for_status(Some(first), TunnelPhase::Reconnecting, TunnelTransport::Unavailable);
|
||||
let resumed = notice_for_status(Some(reconnecting), TunnelPhase::Connected, TunnelTransport::IpsecEsp);
|
||||
assert_eq!(resumed.level, Level::Warn);
|
||||
assert_eq!(resumed.message, "ESP unavailable; using SSL");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,456 @@
|
||||
//! Terminal integration runs in child test processes so descriptor/signal changes
|
||||
//! cannot capture another test's output or change its controlling terminal.
|
||||
use std::{
|
||||
fs::File,
|
||||
io::{self, Read, Write},
|
||||
os::unix::process::CommandExt,
|
||||
process::{Child, Command, Stdio},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
use nix::{
|
||||
fcntl::{FcntlArg, OFlag, fcntl},
|
||||
pty::{Winsize, openpty},
|
||||
sys::signal::{Signal, kill},
|
||||
unistd::Pid,
|
||||
};
|
||||
|
||||
use super::*;
|
||||
|
||||
struct Fixture {
|
||||
child: Child,
|
||||
master: File,
|
||||
slave: File,
|
||||
output: Vec<u8>,
|
||||
}
|
||||
|
||||
impl Fixture {
|
||||
fn start(piped: bool) -> Self {
|
||||
Self::start_mode(if piped { "piped" } else { "terminal" }, piped)
|
||||
}
|
||||
|
||||
fn start_mode(mode: &str, piped: bool) -> Self {
|
||||
let mut command = Command::new(std::env::current_exe().unwrap());
|
||||
command
|
||||
.args([
|
||||
"--exact",
|
||||
"dashboard::tests::terminal_fixture",
|
||||
"--ignored",
|
||||
"--nocapture",
|
||||
])
|
||||
.env("GPCLIENT_DASHBOARD_FIXTURE", mode);
|
||||
Self::spawn(command, piped)
|
||||
}
|
||||
|
||||
fn spawn(mut command: Command, piped: bool) -> Self {
|
||||
let pty = openpty(
|
||||
Some(&Winsize {
|
||||
ws_row: 40,
|
||||
ws_col: 100,
|
||||
ws_xpixel: 0,
|
||||
ws_ypixel: 0,
|
||||
}),
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
let master = File::from(pty.master);
|
||||
let slave = File::from(pty.slave);
|
||||
fcntl(&master, FcntlArg::F_SETFL(OFlag::O_NONBLOCK)).unwrap();
|
||||
command
|
||||
.env("TERM", "xterm-256color")
|
||||
.stdin(if piped {
|
||||
Stdio::piped()
|
||||
} else {
|
||||
Stdio::from(slave.try_clone().unwrap())
|
||||
})
|
||||
.stdout(if piped {
|
||||
Stdio::piped()
|
||||
} else {
|
||||
Stdio::from(slave.try_clone().unwrap())
|
||||
})
|
||||
.stderr(Stdio::from(slave.try_clone().unwrap()));
|
||||
unsafe {
|
||||
command.pre_exec(|| {
|
||||
if nix::libc::setsid() < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
if nix::libc::ioctl(2, nix::libc::TIOCSCTTY as _, 0) < 0 {
|
||||
return Err(io::Error::last_os_error());
|
||||
}
|
||||
let no_core = nix::libc::rlimit {
|
||||
rlim_cur: 0,
|
||||
rlim_max: 0,
|
||||
};
|
||||
nix::libc::setrlimit(nix::libc::RLIMIT_CORE, &no_core);
|
||||
Ok(())
|
||||
});
|
||||
}
|
||||
let mut child = command.spawn().unwrap();
|
||||
if piped {
|
||||
child.stdin.take().unwrap().write_all(b"fixture-cookie\n").unwrap();
|
||||
}
|
||||
Self {
|
||||
child,
|
||||
master,
|
||||
slave,
|
||||
output: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn drain(&mut self) {
|
||||
let mut bytes = [0; 8192];
|
||||
loop {
|
||||
match self.master.read(&mut bytes) {
|
||||
Ok(0) => break,
|
||||
Ok(length) => self.output.extend_from_slice(&bytes[..length]),
|
||||
Err(error) if error.kind() == io::ErrorKind::WouldBlock => break,
|
||||
Err(error) if error.raw_os_error() == Some(nix::libc::EIO) => break,
|
||||
Err(error) => panic!("PTY read: {error}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn wait_text(&mut self, text: &str) {
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
loop {
|
||||
self.drain();
|
||||
let plain = strip_ansi_escapes::strip(&self.output);
|
||||
if String::from_utf8_lossy(&plain).contains(text) {
|
||||
return;
|
||||
}
|
||||
if let Some(status) = self.child.try_wait().unwrap() {
|
||||
panic!(
|
||||
"Fixture exited {status} before {text:?}: {}",
|
||||
String::from_utf8_lossy(&self.output)
|
||||
);
|
||||
}
|
||||
assert!(
|
||||
Instant::now() < deadline,
|
||||
"Missing {text:?}: {}",
|
||||
String::from_utf8_lossy(&self.output)
|
||||
);
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
}
|
||||
|
||||
fn finish(&mut self) {
|
||||
self.wait_text("DASHBOARD_RESTORED");
|
||||
let attrs = nix::sys::termios::tcgetattr(&self.slave).unwrap();
|
||||
assert!(attrs.local_flags.contains(nix::sys::termios::LocalFlags::ICANON));
|
||||
assert!(attrs.local_flags.contains(nix::sys::termios::LocalFlags::ECHO));
|
||||
self.master.write_all(b"\n").unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
loop {
|
||||
self.drain();
|
||||
if let Some(status) = self.child.try_wait().unwrap() {
|
||||
assert!(
|
||||
status.success(),
|
||||
"Fixture failed {status}: {}",
|
||||
String::from_utf8_lossy(&self.output)
|
||||
);
|
||||
self.drain();
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "Fixture did not restore/exit");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
assert!(String::from_utf8_lossy(&self.output).contains("DASHBOARD_RESTORED"));
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Fixture {
|
||||
fn drop(&mut self) {
|
||||
// A failed assertion must not leave a suspended child or its helper alive.
|
||||
let _ = kill(Pid::from_raw(self.child.id() as i32), Signal::SIGCONT);
|
||||
let _ = self.child.kill();
|
||||
let _ = self.child.wait();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn panel_switches_to_captured_child_logs_and_ctrl_c_restores_terminal() {
|
||||
let mut fixture = Fixture::start(false);
|
||||
fixture.wait_text("Internal");
|
||||
fixture.master.write_all(b"\t").unwrap();
|
||||
fixture.wait_text("Live logs");
|
||||
fixture.wait_text("child-stderr-after-entry");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn warning_before_first_tunnel_frame_remains_visible() {
|
||||
let mut fixture = Fixture::start_mode("tunnel", false);
|
||||
fixture.wait_text("initial-fallback-warning");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn connected_tunnel_samples_statistics_and_accepts_ctrl_c() {
|
||||
let mut fixture = Fixture::start_mode("active-tunnel", false);
|
||||
fixture.wait_text("IPsec");
|
||||
fixture.wait_text("(ESP)");
|
||||
fixture.wait_text("Received");
|
||||
fixture.wait_text("4.0");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn authenticated_terminal_input_remains_usable_after_dashboard_entry() {
|
||||
let mut fixture = Fixture::start_mode("prompted-tunnel", false);
|
||||
fixture.wait_text("Received");
|
||||
fixture.master.write_all(b"\t").unwrap();
|
||||
fixture.wait_text("Live logs");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn piped_credentials_and_stdout_redirection_preserve_their_streams() {
|
||||
let mut fixture = Fixture::start(true);
|
||||
fixture.wait_text("Internal");
|
||||
fixture.master.write_all(b"\x03").unwrap();
|
||||
fixture.finish();
|
||||
let mut output = String::new();
|
||||
fixture
|
||||
.child
|
||||
.stdout
|
||||
.take()
|
||||
.unwrap()
|
||||
.read_to_string(&mut output)
|
||||
.unwrap();
|
||||
assert!(output.contains("redirected-stdout"));
|
||||
assert!(!output.contains('\x1b'));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn external_termination_and_suspend_resume_restore_terminal() {
|
||||
let mut fixture = Fixture::start(false);
|
||||
fixture.wait_text("Internal");
|
||||
kill(Pid::from_raw(fixture.child.id() as i32), Signal::SIGTSTP).unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
loop {
|
||||
let attrs = nix::sys::termios::tcgetattr(&fixture.slave).unwrap();
|
||||
if attrs.local_flags.contains(nix::sys::termios::LocalFlags::ICANON) {
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "suspend did not restore termios");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
kill(Pid::from_raw(fixture.child.id() as i32), Signal::SIGCONT).unwrap();
|
||||
std::thread::sleep(Duration::from_millis(200));
|
||||
kill(Pid::from_raw(fixture.child.id() as i32), Signal::SIGTERM).unwrap();
|
||||
fixture.finish();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn actual_panic_hook_restores_terminal_with_panic_abort() {
|
||||
let dependencies = std::env::current_exe().unwrap().parent().unwrap().to_path_buf();
|
||||
let nix = std::fs::read_dir(&dependencies)
|
||||
.unwrap()
|
||||
.filter_map(Result::ok)
|
||||
.map(|entry| entry.path())
|
||||
.find(|path| {
|
||||
path.file_name().unwrap().to_string_lossy().starts_with("libnix-")
|
||||
&& path.extension().is_some_and(|ext| ext == "rlib")
|
||||
})
|
||||
.expect("compiled nix rlib");
|
||||
let directory = tempfile::tempdir().unwrap();
|
||||
let binary = directory.path().join("dashboard-abort");
|
||||
let build = Command::new("rustc")
|
||||
.args(["--edition=2024", "-C", "panic=abort", "-A", "dead_code"])
|
||||
.arg(format!(
|
||||
"{}/tests/fixtures/dashboard_abort.rs",
|
||||
env!("CARGO_MANIFEST_DIR")
|
||||
))
|
||||
.arg("--extern")
|
||||
.arg(format!("nix={}", nix.display()))
|
||||
.arg("-L")
|
||||
.arg(format!("dependency={}", dependencies.display()))
|
||||
.arg("-o")
|
||||
.arg(&binary)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(
|
||||
build.status.success(),
|
||||
"Abort fixture compilation failed: {}",
|
||||
String::from_utf8_lossy(&build.stderr)
|
||||
);
|
||||
let mut fixture = Fixture::spawn(Command::new(binary), false);
|
||||
fixture.wait_text("ABORT_FIXTURE_READY");
|
||||
fixture.master.write_all(b"x").unwrap();
|
||||
fixture.wait_text("ABORT_HOOK_RESTORED");
|
||||
let attrs = nix::sys::termios::tcgetattr(&fixture.slave).unwrap();
|
||||
assert!(attrs.local_flags.contains(nix::sys::termios::LocalFlags::ICANON));
|
||||
assert!(attrs.local_flags.contains(nix::sys::termios::LocalFlags::ECHO));
|
||||
fixture.master.write_all(b"\n").unwrap();
|
||||
let deadline = Instant::now() + Duration::from_secs(5);
|
||||
loop {
|
||||
fixture.drain();
|
||||
if let Some(status) = fixture.child.try_wait().unwrap() {
|
||||
assert!(!status.success(), "panic=abort fixture unexpectedly succeeded");
|
||||
break;
|
||||
}
|
||||
assert!(Instant::now() < deadline, "abort fixture did not exit");
|
||||
std::thread::sleep(Duration::from_millis(20));
|
||||
}
|
||||
fixture.drain();
|
||||
assert!(String::from_utf8_lossy(&fixture.output).contains("intentional abort-hook fixture panic"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore = "runs in an isolated PTY subprocess"]
|
||||
fn terminal_fixture() {
|
||||
let mode = std::env::var("GPCLIENT_DASHBOARD_FIXTURE").expect("subprocess fixture only");
|
||||
if mode == "active-tunnel" || mode == "prompted-tunnel" {
|
||||
env_logger::builder()
|
||||
.filter_level(log::LevelFilter::Info)
|
||||
.try_init()
|
||||
.unwrap();
|
||||
}
|
||||
if mode == "piped" {
|
||||
let mut credentials = String::new();
|
||||
std::io::stdin().read_to_string(&mut credentials).unwrap();
|
||||
assert_eq!(credentials, "fixture-cookie\n");
|
||||
}
|
||||
validate(LogFormat::Text).unwrap();
|
||||
if mode == "prompted-tunnel" {
|
||||
// Authentication prompts use Crossterm before dashboard output routing.
|
||||
// Exercise its real global reader initialization while stdin is the TTY.
|
||||
let _ = crossterm::event::poll(Duration::from_millis(1)).unwrap();
|
||||
}
|
||||
let runtime = tokio::runtime::Runtime::new().unwrap();
|
||||
runtime.block_on(async {
|
||||
let cancellation = CancellationToken::new();
|
||||
let signal_cancel = cancellation.clone();
|
||||
let signals = tokio::spawn(async move {
|
||||
gpapi::utils::shutdown_signal().await;
|
||||
signal_cancel.cancel();
|
||||
});
|
||||
let input_flags = fcntl(std::io::stdin(), FcntlArg::F_GETFD).unwrap();
|
||||
let mut dashboard = Dashboard::prepare("vpn.example.com".into(), cancellation.clone()).unwrap();
|
||||
eprintln!("child-stderr-before-entry");
|
||||
// Native VPN helpers exec /bin/sh without Rust's standard-fd repair.
|
||||
let mut child = Command::new("/bin/sh")
|
||||
.args([
|
||||
"-c",
|
||||
r#"
|
||||
sleep 1
|
||||
if test -t 0; then exit 1; fi
|
||||
if read -r input 2>/dev/null; then exit 1; fi
|
||||
printf '%s\n' child-stderr-after-entry >&2
|
||||
"#,
|
||||
])
|
||||
.spawn()
|
||||
.unwrap();
|
||||
let members = InternalMembers::default();
|
||||
members
|
||||
.lock()
|
||||
.unwrap()
|
||||
.insert("internal.example.com".into(), "internal.example.com: Healthy".into());
|
||||
let mut native = None;
|
||||
let monitor = if mode == "tunnel" || mode == "active-tunnel" || mode == "prompted-tunnel" {
|
||||
let vpn = Arc::new(
|
||||
openconnect::Vpn::builder("vpn.example.com", "fixture-cookie")
|
||||
.network_configuration_handler(|_| Ok(()))
|
||||
.build()
|
||||
.unwrap(),
|
||||
);
|
||||
let monitor = gptunnel::TunnelMonitor::attach(vpn.clone());
|
||||
if mode == "active-tunnel" || mode == "prompted-tunnel" {
|
||||
native = Some(active_native_fixture(vpn, cancellation.clone()));
|
||||
}
|
||||
let _ = notice::slot();
|
||||
session_notice(log::Level::Warn, "initial-fallback-warning");
|
||||
dashboard.start_tunnel(monitor.clone()).unwrap();
|
||||
Some(monitor)
|
||||
} else {
|
||||
dashboard.start_internal(members).unwrap();
|
||||
None
|
||||
};
|
||||
println!("redirected-stdout");
|
||||
tokio::time::timeout(Duration::from_secs(15), cancellation.cancelled())
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(
|
||||
child.wait().unwrap().success(),
|
||||
"helper must not inherit dashboard input"
|
||||
);
|
||||
if let Some(monitor) = monitor {
|
||||
monitor.stop().await;
|
||||
}
|
||||
if let Some(native) = native {
|
||||
native.join().unwrap();
|
||||
}
|
||||
dashboard.finish().unwrap();
|
||||
assert_eq!(fcntl(std::io::stdin(), FcntlArg::F_GETFD).unwrap(), input_flags);
|
||||
signals.abort();
|
||||
eprintln!("DASHBOARD_RESTORED");
|
||||
let mut acknowledgement = String::new();
|
||||
let mut tty = std::fs::OpenOptions::new().read(true).open("/dev/tty").unwrap();
|
||||
use std::io::BufRead;
|
||||
std::io::BufReader::new(&mut tty)
|
||||
.read_line(&mut acknowledgement)
|
||||
.unwrap();
|
||||
});
|
||||
}
|
||||
|
||||
fn active_native_fixture(vpn: Arc<openconnect::Vpn>, cancellation: CancellationToken) -> std::thread::JoinHandle<()> {
|
||||
use std::{
|
||||
ffi::{c_int, c_void},
|
||||
os::fd::AsRawFd,
|
||||
os::unix::net::UnixStream,
|
||||
};
|
||||
#[repr(C)]
|
||||
struct Statistics {
|
||||
tx_pkts: u64,
|
||||
tx_bytes: u64,
|
||||
rx_pkts: u64,
|
||||
rx_bytes: u64,
|
||||
}
|
||||
unsafe extern "C" {
|
||||
fn vpn_attach_command_pipe(vpn: *mut c_void, fd: c_int) -> c_int;
|
||||
fn vpn_detach_command_pipe(vpn: *mut c_void);
|
||||
fn vpn_tunnel_event(vpn: *mut c_void, event: c_int);
|
||||
fn vpn_tunnel_statistics(vpn: *mut c_void, statistics: *const Statistics);
|
||||
}
|
||||
let (sender, mut receiver) = UnixStream::pair().unwrap();
|
||||
receiver.set_nonblocking(true).unwrap();
|
||||
let pointer = Arc::as_ptr(&vpn).cast_mut().cast();
|
||||
// SAFETY: the fixture retains Vpn and both endpoints through detach; event
|
||||
// numbers and statistics layout match the native bridge used in production.
|
||||
unsafe {
|
||||
assert_eq!(vpn_attach_command_pipe(pointer, sender.as_raw_fd()), 0);
|
||||
vpn_tunnel_event(pointer, 1);
|
||||
vpn_tunnel_event(pointer, 5);
|
||||
}
|
||||
std::thread::spawn(move || {
|
||||
let pointer = Arc::as_ptr(&vpn).cast_mut().cast();
|
||||
let mut command = [0];
|
||||
while !cancellation.is_cancelled() {
|
||||
match receiver.read(&mut command) {
|
||||
Ok(1) if command[0] == b's' => unsafe {
|
||||
vpn_tunnel_statistics(
|
||||
pointer,
|
||||
&Statistics {
|
||||
tx_pkts: 2,
|
||||
tx_bytes: 1024,
|
||||
rx_pkts: 4,
|
||||
rx_bytes: 4096,
|
||||
},
|
||||
);
|
||||
},
|
||||
Err(error) if error.kind() == io::ErrorKind::WouldBlock => std::thread::sleep(Duration::from_millis(10)),
|
||||
other => panic!("Unexpected native fixture command: {other:?}"),
|
||||
}
|
||||
}
|
||||
// SAFETY: all native observations finish before the retained Vpn is freed.
|
||||
unsafe {
|
||||
vpn_detach_command_pipe(pointer);
|
||||
vpn_tunnel_event(pointer, 7);
|
||||
}
|
||||
drop(sender);
|
||||
})
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
mod background;
|
||||
mod cli;
|
||||
mod connect;
|
||||
mod dashboard;
|
||||
mod diagnostics;
|
||||
mod disconnect;
|
||||
mod hip;
|
||||
|
||||
@@ -75,6 +75,7 @@ async fn run_session_runtime(session_ctx: SessionContext, mut session_info: Sess
|
||||
|
||||
tokio::time::sleep(schedule.delay).await;
|
||||
|
||||
crate::dashboard::session_notice(Level::Warn, &schedule.message);
|
||||
report(log_format, Level::Warn, &format!("\nWARNING: {}", schedule.message));
|
||||
|
||||
if !schedule.should_auto_extend {
|
||||
@@ -90,6 +91,7 @@ async fn run_session_runtime(session_ctx: SessionContext, mut session_info: Sess
|
||||
return;
|
||||
};
|
||||
|
||||
crate::dashboard::session_notice(Level::Info, "Session extended.");
|
||||
report(log_format, Level::Info, "Session extended.");
|
||||
session_info = next_session_info;
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user