summaryrefslogtreecommitdiffhomepage
path: root/mullvad-cli/src/cmds/status.rs
blob: 0b6b7f05efed562b7b50fdc2e9532efd5cb3c782 (plain)
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
use clap;
use Command;
use Result;

use mullvad_ipc_client::DaemonRpcClient;
use mullvad_types::states::{DaemonState, SecurityState, TargetState};

const DISCONNECTED: DaemonState = DaemonState {
    state: SecurityState::Unsecured,
    target_state: TargetState::Unsecured,
};

const CONNECTED: DaemonState = DaemonState {
    state: SecurityState::Secured,
    target_state: TargetState::Secured,
};

pub struct Status;

impl Command for Status {
    fn name(&self) -> &'static str {
        "status"
    }

    fn clap_subcommand(&self) -> clap::App<'static, 'static> {
        clap::SubCommand::with_name(self.name())
            .about("View the state of the VPN tunnel")
            .subcommand(
                clap::SubCommand::with_name("listen").about("Listen for VPN tunnel state changes"),
            )
    }

    fn run(&self, matches: &clap::ArgMatches) -> Result<()> {
        let mut rpc = DaemonRpcClient::new()?;
        let state = rpc.get_state()?;

        print_state(state);
        print_location(&mut rpc)?;

        if matches.subcommand_matches("listen").is_some() {
            for new_state in rpc.new_state_subscribe()? {
                print_state(new_state);

                if new_state == CONNECTED || new_state == DISCONNECTED {
                    print_location(&mut rpc)?;
                }
            }
        }

        Ok(())
    }
}

fn print_state(state: DaemonState) {
    print!("Tunnel status: ");
    match (state.state, state.target_state) {
        (SecurityState::Unsecured, TargetState::Unsecured) => println!("Disconnected"),
        (SecurityState::Unsecured, TargetState::Secured) => println!("Connecting..."),
        (SecurityState::Secured, TargetState::Unsecured) => println!("Disconnecting..."),
        (SecurityState::Secured, TargetState::Secured) => println!("Connected"),
    }
}

fn print_location(rpc: &mut DaemonRpcClient) -> Result<()> {
    let location = rpc.get_current_location()?;
    let city_and_country = if let Some(city) = location.city {
        format!("{}, {}", city, location.country)
    } else {
        format!("{}", location.country)
    };
    println!("Location: {}", city_and_country);
    println!(
        "Position: {:.5}°N, {:.5}°W",
        location.latitude, location.longitude
    );
    println!("IP: {}", location.ip);
    Ok(())
}