Chip Fetcher (cf)

@@ -108,6 +108,72 @@ pub fn running_version(port: u16) -> Option<String> {     } } +/// The PID listening on `port`, found through the kernel rather than through+/// process names: parse /proc/net/tcp{,6} for the LISTEN socket on that port,+/// then find the process holding that socket inode. Names and argv can lie or+/// drift (a rename, an alias, a wrapper); the socket cannot.+pub fn pid_owning_port(port: u16) -> Option<u32> {+    let mut inodes: Vec<String> = Vec::new();+    for f in ["/proc/net/tcp", "/proc/net/tcp6"] {+        let Ok(text) = std::fs::read_to_string(f) else { continue };+        for line in text.lines().skip(1) {+            let cols: Vec<&str> = line.split_whitespace().collect();+            if cols.len() < 10 {+                continue;+            }+            // local_address is "HEXADDR:HEXPORT"; state 0A is LISTEN.+            let Some((_, p)) = cols[1].split_once(':') else { continue };+            if u16::from_str_radix(p, 16).ok() != Some(port) || cols[3] != "0A" {+                continue;+            }+            inodes.push(cols[9].to_string());+        }+    }+    if inodes.is_empty() {+        return None;+    }+    let rd = std::fs::read_dir("/proc").ok()?;+    for e in rd.flatten() {+        let name = e.file_name().to_string_lossy().to_string();+        let Ok(pid) = name.parse::<u32>() else { continue };+        let Ok(fds) = std::fs::read_dir(format!("/proc/{pid}/fd")) else { continue };+        for fd in fds.flatten() {+            if let Ok(target) = std::fs::read_link(fd.path()) {+                let t = target.to_string_lossy();+                if let Some(ino) = t.strip_prefix("socket:[").and_then(|x| x.strip_suffix(']')) {+                    if inodes.iter().any(|i| i == ino) {+                        return Some(pid);+                    }+                }+            }+        }+    }+    None+}++/// Is this PID one of OUR builds? Checks the executable behind the process,+/// stripping Linux's "(deleted)" suffix, which appears the instant a package+/// update unlinks the old binary and writes a new one at the same path. Any+/// path comparison that skips this stops matching exactly when it matters.+fn pid_is_ours(pid: u32) -> bool {+    let exe = std::fs::read_link(format!("/proc/{pid}/exe"))+        .map(|p| p.to_string_lossy().to_string())+        .unwrap_or_default();+    let exe = exe.strip_suffix(" (deleted)").unwrap_or(&exe).to_string();+    let base = exe.rsplit('/').next().unwrap_or("").to_string();+    if base == "adom-chip-fetcher" || base == "chip-fetcher" {+        return true;+    }+    // Fall back to argv, which is frozen at exec and never gains "(deleted)".+    let cmd = std::fs::read(format!("/proc/{pid}/cmdline")).unwrap_or_default();+    let argv: Vec<&[u8]> = cmd.split(|b| *b == 0).collect();+    if argv.len() < 2 || argv[1] != b"serve" {+        return false;+    }+    let bin = argv[0].rsplit(|b| *b == b'/').next().unwrap_or(argv[0]);+    bin == b"adom-chip-fetcher" || bin == b"chip-fetcher"+}+ /// Retire a stale instance of a different version. Kills only processes /// whose argv is EXACTLY `[<...>/adom-chip-fetcher, serve, ...]` (or the /// `chip-fetcher` alias), never a shell whose command text merely mentions@@ -115,7 +181,15 @@ pub fn running_version(port: u16) -> Option<String> { pub fn retire_stale(port: u16, their: &str) -> bool {     eprintln!("{APP} {their} is serving on {port} but this is {VERSION}; retiring the stale instance");     let me = std::process::id();+    let parent = std::os::unix::process::parent_id();     let mut victims: Vec<u32> = Vec::new();+    // Preferred: whoever actually owns the port, confirmed to be one of ours.+    // Never ourselves, never our parent.+    if let Some(owner) = pid_owning_port(port) {+        if owner != me && owner != parent && pid_is_ours(owner) {+            victims.push(owner);+        }+    }     if let Ok(rd) = std::fs::read_dir("/proc") {         for e in rd.flatten() {             let name = e.file_name().to_string_lossy().to_string();@@ -123,7 +197,7 @@ pub fn retire_stale(port: u16, their: &str) -> bool {                 Ok(p) => p,                 Err(_) => continue,             };-            if pid == me {+            if pid == me || pid == parent || victims.contains(&pid) {                 continue;             }             let cmd = match std::fs::read(format!("/proc/{pid}/cmdline")) {