hussh 0.2.2

Memory-safe SSH daemon for restricted TCP forwarding
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

use crate::args::Args;
use crate::errors::*;
use crate::shared::Shared;
use std::future;
use std::sync::Arc;
use tokio::task::JoinSet;

// Handle shutdown signals so we can run this as pid1
pub async fn sigterm() {
    let mut set = JoinSet::new();

    // On ctrl-c, shutdown
    set.spawn(async {
        let _ = tokio::signal::ctrl_c().await;
    });

    #[cfg(unix)]
    {
        // On SIGTERM, shutdown
        use tokio::signal::unix;
        if let Ok(mut signal) = unix::signal(unix::SignalKind::terminate()) {
            set.spawn(async move {
                signal.recv().await;
            });
        }
    }

    set.join_next().await;
}

pub async fn sighup(shared: Arc<Shared>, args: Args) {
    #[cfg(unix)]
    {
        use tokio::signal::unix;

        if let Ok(mut signals) = unix::signal(unix::SignalKind::hangup()) {
            while signals.recv().await.is_some() {
                info!("Received SIGHUP, reloading configuration");

                match args.config().await {
                    Ok(config) => {
                        shared.replace_config(config);
                        info!("Configuration reloaded");
                    }
                    Err(err) => {
                        error!("Failed to reload configuration: {err:#}");
                    }
                }
            }
        }
    }

    // Reload signals not supported, wait indefinitely
    future::pending().await
}