bstein/lesavka
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
lesavka/client/src/launcher/ui/utility_button_bindings.rs

542 lines
24 KiB
Rust
Raw Blame History

{
fn default_client_pki_dir() -> PathBuf {
if let Some(home) = std::env::var_os("HOME") {
return PathBuf::from(home).join(".config/lesavka/pki");
}
std::env::current_dir()
.unwrap_or_else(|_| PathBuf::from("."))
.join(".config/lesavka/pki")
}
fn install_client_pki_bundle(bundle: &Path) -> Result<PathBuf, String> {
let target = default_client_pki_dir();
let scratch = std::env::temp_dir().join(format!(
"lesavka-client-pki-{}",
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_millis()
));
std::fs::create_dir_all(&scratch)
.map_err(|err| format!("could not create extraction folder: {err}"))?;
let extract = Command::new("tar")
.arg("-xzf")
.arg(bundle)
.arg("-C")
.arg(&scratch)
.status()
.map_err(|err| format!("tar is unavailable: {err}"))?;
if !extract.success() {
let _ = std::fs::remove_dir_all(&scratch);
return Err(format!("could not extract {}", bundle.display()));
}
for item in ["ca.crt", "client.crt", "client.key"] {
if !scratch.join(item).is_file() {
let _ = std::fs::remove_dir_all(&scratch);
return Err(format!("bundle is missing {item}"));
}
}
std::fs::create_dir_all(&target)
.map_err(|err| format!("could not create {}: {err}", target.display()))?;
for item in ["ca.crt", "client.crt", "client.key"] {
std::fs::copy(scratch.join(item), target.join(item))
.map_err(|err| format!("could not install {item}: {err}"))?;
}
tighten_client_key_permissions(&target.join("client.key"));
let _ = std::fs::remove_dir_all(&scratch);
Ok(target)
}
#[cfg(unix)]
fn tighten_client_key_permissions(path: &Path) {
use std::os::unix::fs::PermissionsExt;
if let Ok(mut permissions) = std::fs::metadata(path).map(|metadata| metadata.permissions()) {
permissions.set_mode(0o600);
let _ = std::fs::set_permissions(path, permissions);
}
}
#[cfg(not(unix))]
fn tighten_client_key_permissions(_path: &Path) {}
{
let widgets = widgets.clone();
let window = window.clone();
let certs_button = widgets.certs_button.clone();
certs_button.connect_clicked(move |_| {
let chooser = gtk::FileChooserNative::new(
Some("Choose Lesavka Client TLS Bundle"),
Some(&window),
gtk::FileChooserAction::Open,
Some("Install"),
Some("Cancel"),
);
chooser.set_modal(true);
let widgets = widgets.clone();
chooser.connect_response(move |dialog, response| {
if response == gtk::ResponseType::Accept {
if let Some(bundle) = dialog.file().and_then(|file| file.path()) {
widgets.status_label.set_text(&format!(
"Installing Lesavka client TLS bundle from {}...",
bundle.display()
));
match install_client_pki_bundle(&bundle) {
Ok(target) => widgets.status_label.set_text(&format!(
"Client TLS certs installed at {}. Reconnect the relay to use them.",
target.display()
)),
Err(err) => widgets
.status_label
.set_text(&format!("Client TLS bundle install failed: {err}")),
}
} else {
widgets
.status_label
.set_text("Selected TLS bundle did not provide a filesystem path.");
}
}
dialog.destroy();
});
chooser.show();
});
}
{
let child_proc = Rc::clone(&child_proc);
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let clipboard_tx = clipboard_tx.clone();
widgets.clipboard_button.connect_clicked(move |_| {
if child_proc.borrow().is_none() {
widgets
.status_label
.set_text("Start the relay before sending clipboard text.");
return;
}
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
let Some(display) = gtk::gdk::Display::default() else {
widgets
.status_label
.set_text("No desktop clipboard is available in this session.");
return;
};
widgets
.status_label
.set_text("Reading the local clipboard and preparing remote paste...");
let clipboard = display.clipboard();
let clipboard_tx = clipboard_tx.clone();
clipboard.read_text_async(None::<&gtk::gio::Cancellable>, move |result| match result {
Ok(Some(text)) => {
let text = text.trim_end_matches(['\r', '\n']).to_string();
if text.is_empty() {
let _ = clipboard_tx
.send(ClipboardMessage::Finished(Err("clipboard is empty".to_string())));
return;
}
let clipboard_tx = clipboard_tx.clone();
std::thread::spawn(move || {
let result = send_clipboard_text_to_remote(&server_addr, &text)
.map_err(|err| err.to_string());
let _ = clipboard_tx.send(ClipboardMessage::Finished(result));
});
}
Ok(None) => {
let _ = clipboard_tx
.send(ClipboardMessage::Finished(Err("clipboard is empty".to_string())));
}
Err(err) => {
let _ = clipboard_tx.send(ClipboardMessage::Finished(Err(format!(
"clipboard read failed: {err}"
))));
}
});
});
}
{
let child_proc = Rc::clone(&child_proc);
let widgets = widgets.clone();
widgets.wake_combo.connect_changed(move |combo| {
let id = combo
.active_id()
.map(|value| value.to_string())
.unwrap_or_else(|| "off".to_string());
let minutes = match id.as_str() {
"5" => Some(5),
"10" => Some(10),
"20" => Some(20),
"30" => Some(30),
"60" => Some(60),
_ => None,
};
let path = wake_control_path();
match write_wake_control_request(&path, minutes) {
Ok(()) => {
let relay_live = child_proc
.try_borrow()
.map(|child| child.is_some())
.unwrap_or(false);
match minutes {
Some(minutes) if relay_live => widgets.status_label.set_text(&format!(
"Wake armed: after {minutes}m without relayed HID input, the live relay will send a tiny random mouse nudge."
)),
Some(minutes) => widgets.status_label.set_text(&format!(
"Wake staged: the next relay will nudge after {minutes}m without relayed HID input."
)),
None if relay_live => widgets
.status_label
.set_text("Wake disabled for the live relay."),
None => widgets
.status_label
.set_text("Wake disabled for the next relay launch."),
}
}
Err(err) => widgets
.status_label
.set_text(&format!("Wake setting could not be written: {err}")),
}
combo.set_tooltip_text(Some(match minutes {
Some(5) => "Wake is on: nudge the RCT after 5 minutes without relayed keyboard or mouse input.",
Some(10) => "Wake is on: nudge the RCT after 10 minutes without relayed keyboard or mouse input.",
Some(20) => "Wake is on: nudge the RCT after 20 minutes without relayed keyboard or mouse input.",
Some(30) => "Wake is on: nudge the RCT after 30 minutes without relayed keyboard or mouse input.",
Some(60) => "Wake is on: nudge the RCT after 60 minutes without relayed keyboard or mouse input.",
_ => "Wake is off: Lesavka will not synthesize mouse movement.",
}));
});
}
{
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let widgets_for_click = widgets.clone();
widgets.usb_recover_button.connect_clicked(move |_| {
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
widgets_for_click.status_label.set_text(
"Recover HID 1/3: reopening keyboard/mouse handles and checking enumeration...",
);
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let result = recover_usb_soft(&server_addr).map_err(|err| format!("{err:#}"));
let _ = tx.send(result);
});
let widgets = widgets_for_click.clone();
glib::timeout_add_local(Duration::from_millis(100), move || match rx.try_recv() {
Ok(Ok(())) => {
widgets.status_label.set_text(
"Recover HID 2/3: handles reopened. Recover HID 3/3: watching chips for stable enumeration.",
);
glib::ControlFlow::Break
}
Ok(Err(err)) => {
widgets
.status_label
.set_text(&format!("Recover HID failed: {err}"));
glib::ControlFlow::Break
}
Err(std::sync::mpsc::TryRecvError::Empty) => glib::ControlFlow::Continue,
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
widgets.status_label.set_text(
"Recover HID failed: relay stopped responding before completion.",
);
glib::ControlFlow::Break
}
});
});
}
{
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let widgets_for_click = widgets.clone();
widgets.uac_recover_button.connect_clicked(move |_| {
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
widgets_for_click
.status_label
.set_text("Recover Audio 1/3: retiring the stale upstream audio epoch cleanly...");
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let result = recover_uac_soft(&server_addr).map_err(|err| format!("{err:#}"));
let _ = tx.send(result);
});
let widgets = widgets_for_click.clone();
glib::timeout_add_local(Duration::from_millis(100), move || match rx.try_recv() {
Ok(Ok(())) => {
widgets.status_label.set_text(
"Recover Audio 2/3: old epoch released. Recover Audio 3/3: bundled media will reconnect without resetting USB or calibration.",
);
glib::ControlFlow::Break
}
Ok(Err(err)) => {
widgets
.status_label
.set_text(&format!("Recover Audio failed: {err}"));
glib::ControlFlow::Break
}
Err(std::sync::mpsc::TryRecvError::Empty) => glib::ControlFlow::Continue,
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
widgets.status_label.set_text(
"Recover Audio failed: relay stopped responding before completion.",
);
glib::ControlFlow::Break
}
});
});
}
{
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let widgets_for_click = widgets.clone();
widgets.uvc_recover_button.connect_clicked(move |_| {
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
widgets_for_click
.status_label
.set_text("Recover Video 1/3: retiring the webcam spool pipeline safely...");
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
let result = recover_uvc_soft(&server_addr).map_err(|err| format!("{err:#}"));
let _ = tx.send(result);
});
let widgets = widgets_for_click.clone();
glib::timeout_add_local(Duration::from_millis(100), move || match rx.try_recv() {
Ok(Ok(())) => {
widgets.status_label.set_text(
"Recover Video 2/3: webcam sink retired. Recover Video 3/3: client will recreate the UVC spool on reconnect.",
);
glib::ControlFlow::Break
}
Ok(Err(err)) => {
widgets
.status_label
.set_text(&format!("Recover Video failed: {err}"));
glib::ControlFlow::Break
}
Err(std::sync::mpsc::TryRecvError::Empty) => glib::ControlFlow::Continue,
Err(std::sync::mpsc::TryRecvError::Disconnected) => {
widgets.status_label.set_text(
"Recover Video failed: relay stopped responding before completion.",
);
glib::ControlFlow::Break
}
});
});
}
{
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let calibration_tx = calibration_tx.clone();
let calibration_request_in_flight = Rc::clone(&calibration_request_in_flight);
widgets.calibration_default_button.connect_clicked(move |_| {
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
widgets
.status_label
.set_text("Calibration 1/2: restoring saved upstream A/V default...");
calibration_request_in_flight.set(true);
request_calibration_command(calibration_tx.clone(), server_addr, |server_addr| {
restore_default_calibration(server_addr)
});
});
}
{
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let calibration_tx = calibration_tx.clone();
let calibration_request_in_flight = Rc::clone(&calibration_request_in_flight);
widgets.calibration_factory_button.connect_clicked(move |_| {
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
widgets
.status_label
.set_text("Calibration 1/2: restoring factory MJPEG upstream A/V baseline...");
calibration_request_in_flight.set(true);
request_calibration_command(calibration_tx.clone(), server_addr, |server_addr| {
restore_factory_calibration(server_addr)
});
});
}
{
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let calibration_tx = calibration_tx.clone();
let calibration_request_in_flight = Rc::clone(&calibration_request_in_flight);
widgets.calibration_minus_button.connect_clicked(move |_| {
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
widgets
.status_label
.set_text("Calibration 1/2: nudging upstream audio 5 ms earlier...");
calibration_request_in_flight.set(true);
request_calibration_command(calibration_tx.clone(), server_addr, |server_addr| {
nudge_audio_calibration(server_addr, -5_000)
});
});
}
{
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let calibration_tx = calibration_tx.clone();
let calibration_request_in_flight = Rc::clone(&calibration_request_in_flight);
widgets.calibration_plus_button.connect_clicked(move |_| {
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
widgets
.status_label
.set_text("Calibration 1/2: nudging upstream audio 5 ms later...");
calibration_request_in_flight.set(true);
request_calibration_command(calibration_tx.clone(), server_addr, |server_addr| {
nudge_audio_calibration(server_addr, 5_000)
});
});
}
{
let widgets = widgets.clone();
let server_entry = server_entry.clone();
let server_addr_fallback = Rc::clone(&server_addr);
let calibration_tx = calibration_tx.clone();
let calibration_request_in_flight = Rc::clone(&calibration_request_in_flight);
widgets.calibration_blind_button.connect_clicked(move |_| {
let Some(sample) = widgets.diagnostics_log.borrow().latest().cloned() else {
widgets.status_label.set_text(
"Blind calibration needs a live upstream camera and microphone sample first.",
);
return;
};
let camera = sample.upstream_camera;
let microphone = sample.upstream_microphone;
if !camera.connected || !microphone.connected {
widgets.status_label.set_text(
"Blind calibration refused: upstream camera and microphone are not both live.",
);
return;
}
let delivery_delta_ms =
microphone.latest_delivery_age_ms - camera.latest_delivery_age_ms;
let delivery_skew_ms = delivery_delta_ms.abs();
let enqueue_skew_ms =
(microphone.latest_enqueue_age_ms - camera.latest_enqueue_age_ms).abs();
if camera.queue_depth >= 28 || microphone.queue_depth >= 14 || delivery_skew_ms > 80.0
{
widgets.status_label.set_text(
"Blind calibration refused: live queues are too backed up to make a safe timing estimate. Use the test rig or fix queue churn first.",
);
return;
}
let audio_delta_us = (-(delivery_delta_ms as f64) * 500.0)
.round()
.clamp(-10_000.0, 10_000.0) as i64;
let note = format!(
"blind estimate from live telemetry: mic-camera delivery delta {delivery_delta_ms:+.1}ms, enqueue skew {enqueue_skew_ms:.1}ms; applying half-step audio delta {:+.1}ms",
audio_delta_us as f64 / 1000.0
);
let server_addr = selected_server_addr(&server_entry, server_addr_fallback.as_ref());
widgets
.status_label
.set_text("Calibration 1/2: applying blind upstream A/V estimate...");
calibration_request_in_flight.set(true);
request_calibration_command(calibration_tx.clone(), server_addr, move |server_addr| {
blind_calibration_estimate(
server_addr,
audio_delta_us,
delivery_skew_ms,
enqueue_skew_ms,
&note,
)
});
});
}
{
let widgets = widgets.clone();
widgets.calibration_rig_button.connect_clicked(move |_| {
widgets.status_label.set_text(
"Rig calibration wizard is queued for lab tooling; for now the mirrored Tethys sync probe remains the measured-default path.",
);
});
}
{
let widgets = widgets.clone();
widgets.diagnostics_copy_button.connect_clicked(move |_| {
if let Err(err) = copy_plain_text(&widgets.diagnostics_rendered_text.borrow()) {
widgets
.status_label
.set_text(&format!("Could not copy the diagnostics report: {err}"));
} else {
widgets
.status_label
.set_text("Diagnostics report copied to the local clipboard.");
}
});
}
{
let app = app.clone();
let widgets = widgets.clone();
let diagnostics_popout = Rc::clone(&diagnostics_popout);
widgets.diagnostics_popout_button.connect_clicked(move |_| {
open_diagnostics_popout(
&app,
&diagnostics_popout,
&widgets.diagnostics_popout_label,
&widgets.diagnostics_popout_scroll,
&widgets.diagnostics_rendered_text,
);
widgets
.status_label
.set_text("Diagnostics report moved into its own window.");
});
}
{
let widgets = widgets.clone();
widgets.console_level_combo.connect_changed(move |combo| {
let level = combo
.active_id()
.as_deref()
.and_then(ConsoleLogLevel::from_id)
.unwrap_or_default();
*widgets.session_log_level.borrow_mut() = level;
widgets.status_label.set_text(&format!(
"Console now shows {} relay logs and higher.",
level.label()
));
});
}
{
let widgets = widgets.clone();
widgets.console_copy_button.connect_clicked(move |_| {
if let Err(err) = copy_session_log(&widgets.session_log_buffer) {
widgets
.status_label
.set_text(&format!("Could not copy the session log: {err}"));
} else {
widgets
.status_label
.set_text("Session log copied to the local clipboard.");
}
});
}
{
let app = app.clone();
let widgets = widgets.clone();
let log_popout = Rc::clone(&log_popout);
widgets.console_popout_button.connect_clicked(move |_| {
open_session_log_popout(&app, &log_popout, &widgets.session_log_buffer);
widgets
.status_label
.set_text("Session log moved into its own window.");
});
}
}
Reference in New Issue View Git Blame Copy Permalink