Додавання вкладки для керування мережевими портами

Ми додали новий функціонал, який дозволяє бачити, які програми на вашому
комп'ютері використовують мережеві порти, та за потреби зупиняти ці
процеси.

Ось основні зміни:
- Створено інтерфейс для перегляду списку відкритих портів (вкладка
  «Ports»).
- Додано можливість завершувати роботу процесів, які займають порти,
  безпосередньо через інтерфейс програми.
- Якщо порт використовується контейнером Docker, програма дозволяє
  зупинити цей контейнер, щоб звільнити мережеве з'єднання.
- Додано фонові служби, які збирають інформацію про стан мережі та
  надсилають команди для завершення процесів (використовуючи системні
  інструменти `ss` та `kill`).

Author: vaulttec-dev

src/app/popup/ports_tab.rs

@@ -0,0 +1,76 @@
+use cosmic::Element;
+use cosmic::widget;
+use cosmic_containers::PortEntry;
+use cosmic_containers::action_icons;
+use cosmic_containers::{LIST_PAGE_SIZE, clamp_page, page_range, total_pages};
+
+use super::layout::SPACING_NONE;
+use super::layout::SPACING_XXS;
+use super::widgets::{
+    action_svg_button, empty_state, item_labels_detail, kill_confirm_row, list_row, paginated_list,
+};
+use super::{App, Message};
+use crate::app::PendingKill;
+
+pub(super) fn ports_tab<'a>(state: &'a App) -> Element<'a, Message> {
+    if state.port_list.is_empty() && !state.loading && state.error.is_none() {
+        return empty_state("No listening ports");
+    }
+
+    let total = total_pages(state.port_list.len(), LIST_PAGE_SIZE);
+    let page = clamp_page(state.tab_pages.ports, total);
+    let range = page_range(page, LIST_PAGE_SIZE, state.port_list.len());
+
+    let mut list = widget::column![].spacing(SPACING_NONE);
+    for entry in &state.port_list[range] {
+        list = list.push(port_row(
+            entry,
+            state.container_for_port(entry.port),
+            &state.pending_kill,
+        ));
+    }
+    paginated_list(list.into(), page, total)
+}
+
+fn port_row<'a>(
+    entry: &'a PortEntry,
+    container: Option<&'a str>,
+    pending_kill: &Option<PendingKill>,
+) -> Element<'a, Message> {
+    if matches!(pending_kill, Some(pending) if Some(pending.pid) == entry.pid) {
+        return kill_confirm_row(format!("Kill {}?", entry.kill_label()));
+    }
+
+    list_row(
+        item_labels_detail(
+            entry.title(),
+            entry.owner_line(container),
+            Some(entry.address_line()),
+        ),
+        port_actions(entry, container),
+    )
+}
+
+/// A published port is freed by stopping its container; anything else by signalling the PID.
+fn port_actions<'a>(entry: &PortEntry, container: Option<&str>) -> Element<'a, Message> {
+    let mut actions = widget::row![].spacing(SPACING_XXS);
+    if let Some(container) = container {
+        actions = actions.push(action_svg_button(
+            action_icons::STOP,
+            Message::StopContainerPort(container.to_string()),
+            false,
+        ));
+        return actions.into();
+    }
+    if let Some(pid) = entry.pid {
+        actions = actions.push(action_svg_button(
+            action_icons::STOP,
+            Message::RequestKill(PendingKill {
+                pid,
+                label: entry.kill_label(),
+            }),
+            false,
+        ));
+    }
+    actions.into()
+}

src/services/ports.rs

@@ -0,0 +1,67 @@
+//! Host listening ports (`ss`) and the processes holding them (`kill`).
+
+use std::time::Duration;
+
+use crate::{PortEntry, parse_ss_output};
+
+use super::docker::{run_host, stop_container};
+
+/// A signal is asynchronous; wait this long before re-reading the socket list.
+const KILL_SETTLE: Duration = Duration::from_millis(400);
+
+/// List listening TCP/UDP sockets (`ss -tulpnH`).
+///
+/// Sockets owned by other users (root, so every `docker-proxy`) are listed without a PID:
+/// `ss` only reveals process details for the current user.
+pub async fn list_ports() -> Result<Vec<PortEntry>, String> {
+    let output = run_host("ss", &["-tulpnH"]).await?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format_ss_failure(&stderr));
+    }
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    Ok(parse_ss_output(&stdout))
+}
+
+/// Signal a process by PID (`kill -TERM`, or `-KILL` when `force`).
+pub async fn kill_process(pid: u32, force: bool) -> Result<(), String> {
+    let signal = if force { "-KILL" } else { "-TERM" };
+    let pid = pid.to_string();
+    let output = run_host("kill", &[signal, &pid]).await?;
+    if output.status.success() {
+        return Ok(());
+    }
+    let stderr = String::from_utf8_lossy(&output.stderr);
+    Err(format_kill_failure(&stderr))
+}
+
+pub async fn kill_then_list(pid: u32, force: bool) -> Result<Vec<PortEntry>, String> {
+    kill_process(pid, force).await?;
+    tokio::time::sleep(KILL_SETTLE).await;
+    list_ports().await
+}
+
+/// Free a published port by stopping the container that owns it.
+pub async fn stop_container_then_list(name: String) -> Result<Vec<PortEntry>, String> {
+    stop_container(&name).await?;
+    list_ports().await
+}
+
+fn format_ss_failure(stderr: &str) -> String {
+    let stderr = stderr.trim();
+    if stderr.is_empty() {
+        return "ss failed. Install iproute2 to list listening ports.".to_string();
+    }
+    stderr.to_string()
+}
+
+fn format_kill_failure(stderr: &str) -> String {
+    let stderr = stderr.trim();
+    if stderr.is_empty() {
+        return "kill failed".to_string();
+    }
+    if stderr.contains("not permitted") {
+        return format!("{stderr}\n\nHint: this process belongs to another user.");
+    }
+    stderr.to_string()
+}