anitrack 0.1.7

CLI/TUI companion for ani-cli with watch-progress tracking
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::process::{Command as ProcessCommand, ExitStatus};

#[cfg(unix)]
use anyhow::anyhow;
use anyhow::{Context, Result};

#[cfg(unix)]
use std::os::unix::process::CommandExt;

#[cfg(unix)]
struct ScopedSigaction {
    signum: libc::c_int,
    old_action: libc::sigaction,
}

#[cfg(unix)]
impl ScopedSigaction {
    fn ignore(signum: libc::c_int) -> Result<Self> {
        unsafe {
            let mut new_action: libc::sigaction = std::mem::zeroed();
            new_action.sa_sigaction = libc::SIG_IGN;
            libc::sigemptyset(&mut new_action.sa_mask);
            new_action.sa_flags = 0;

            let mut old_action: libc::sigaction = std::mem::zeroed();
            if libc::sigaction(signum, &new_action, &mut old_action) != 0 {
                return Err(anyhow!("failed to update signal action for {signum}"));
            }

            Ok(Self { signum, old_action })
        }
    }
}

#[cfg(unix)]
impl Drop for ScopedSigaction {
    fn drop(&mut self) {
        unsafe {
            let _ = libc::sigaction(self.signum, &self.old_action, std::ptr::null_mut());
        }
    }
}

#[cfg(unix)]
struct TerminalForegroundGuard {
    stdin_fd: libc::c_int,
    parent_pgrp: libc::pid_t,
    child_foreground: bool,
}

#[cfg(unix)]
impl TerminalForegroundGuard {
    fn new(stdin_fd: libc::c_int, parent_pgrp: libc::pid_t) -> Self {
        Self {
            stdin_fd,
            parent_pgrp,
            child_foreground: false,
        }
    }

    fn handoff_to_child(&mut self, child_pgrp: libc::pid_t) {
        self.child_foreground = unsafe { libc::tcsetpgrp(self.stdin_fd, child_pgrp) == 0 };
    }
}

#[cfg(unix)]
impl Drop for TerminalForegroundGuard {
    fn drop(&mut self) {
        if !self.child_foreground {
            return;
        }
        unsafe {
            let _ = libc::tcsetpgrp(self.stdin_fd, self.parent_pgrp);
        }
    }
}

#[cfg(unix)]
pub(crate) fn with_sigint_ignored<F, R>(f: F) -> Result<R>
where
    F: FnOnce() -> Result<R>,
{
    let _sigint_guard = ScopedSigaction::ignore(libc::SIGINT)?;
    f()
}

#[cfg(not(unix))]
pub(crate) fn with_sigint_ignored<F, R>(f: F) -> Result<R>
where
    F: FnOnce() -> Result<R>,
{
    f()
}

#[cfg(unix)]
pub(crate) fn run_interactive_cmd(mut cmd: ProcessCommand) -> Result<ExitStatus> {
    let stdin_fd = libc::STDIN_FILENO;
    let parent_pgrp = unsafe { libc::tcgetpgrp(stdin_fd) };
    if parent_pgrp == -1 {
        return cmd.status().context("failed to launch ani-cli");
    }

    let _sigttou_guard = ScopedSigaction::ignore(libc::SIGTTOU)?;
    let mut terminal_guard = TerminalForegroundGuard::new(stdin_fd, parent_pgrp);

    unsafe {
        cmd.pre_exec(|| {
            libc::signal(libc::SIGINT, libc::SIG_DFL);
            libc::signal(libc::SIGQUIT, libc::SIG_DFL);
            libc::signal(libc::SIGTSTP, libc::SIG_DFL);
            if libc::setpgid(0, 0) != 0 {
                return Err(std::io::Error::last_os_error());
            }
            Ok(())
        });
    }

    let mut child = cmd.spawn().context("failed to spawn ani-cli")?;
    let child_pgid = child.id() as libc::pid_t;
    terminal_guard.handoff_to_child(child_pgid);
    child.wait().context("failed waiting on ani-cli")
}

#[cfg(not(unix))]
pub(crate) fn run_interactive_cmd(mut cmd: ProcessCommand) -> Result<ExitStatus> {
    cmd.status().context("failed to launch ani-cli")
}