waverave-hackrf-bin 0.0.3

Utilities for working with the HackRF SDR
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
128
129

use tokio_util::sync::CancellationToken;

static CANCEL: tokio::sync::OnceCell<CancellationToken> = tokio::sync::OnceCell::const_new();

pub struct Quit(CancellationToken);

impl Quit {
    /// Returns when the program has been asked to quit by the OS.
    pub async fn quit(&self) {
        self.0.cancelled().await
    }

    pub fn cancel(&self) {
        self.0.cancel();
    }

    pub async fn run_until_cancelled<F>(&self, fut: F) -> Option<F::Output>
    where
        F: Future,
    {
        self.0.run_until_cancelled(fut).await
    }

    pub async fn run_until_cancelled_owned<F>(self, fut: F) -> Option<F::Output>
    where
        F: Future,
    {
        self.0.run_until_cancelled_owned(fut).await
    }
}

pub async fn quit_watch() -> Quit {
    let cancel = CANCEL
        .get_or_init(|| async move {
            let cancel = CancellationToken::new();
            #[cfg(unix)]
            {
                use tokio::signal::unix;

                // SIGINT
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    unix::signal(unix::SignalKind::interrupt())
                        .unwrap()
                        .recv()
                        .await;
                    cancel_tx.cancel();
                });

                // SIGHUP
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    unix::signal(unix::SignalKind::hangup())
                        .unwrap()
                        .recv()
                        .await;
                    cancel_tx.cancel();
                });

                // SIGTERM
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    unix::signal(unix::SignalKind::terminate())
                        .unwrap()
                        .recv()
                        .await;
                    cancel_tx.cancel();
                });

                // SIGPIPE
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    unix::signal(unix::SignalKind::pipe()).unwrap().recv().await;
                    cancel_tx.cancel();
                });

                // SIGQUIT
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    unix::signal(unix::SignalKind::quit()).unwrap().recv().await;
                    cancel_tx.cancel();
                });
            }
            #[cfg(windows)]
            {
                use tokio::signal::windows;

                // ctrl-break
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    windows::ctrl_break().unwrap().recv().await;
                    cancel_tx.cancel();
                });

                // ctrl-c
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    windows::ctrl_c().unwrap().recv().await;
                    cancel_tx.cancel();
                });

                // ctrl-close
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    windows::ctrl_close().unwrap().recv().await;
                    cancel_tx.cancel();
                });

                // ctrl-logoff
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    windows::ctrl_logoff().unwrap().recv().await;
                    cancel_tx.cancel();
                });

                // ctrl-shutdown
                let cancel_tx = cancel.clone();
                tokio::spawn(async move {
                    windows::ctrl_shutdown().unwrap().recv().await;
                    cancel_tx.cancel();
                });
            }
            cancel
        })
        .await;
    let cancel = cancel.clone();

    Quit(cancel)
}