libicmp 0.1.2

ICMP protocol support and implementations
Documentation 
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::{time, thread};

pub use icmp::Icmp;

const DEFAULT_NUM_PINGS: u64 = 5;
const DEFAULT_INTERVAL_SECS: u64 = 1;
const DEFAULT_TIMEOUT_SECS: u64 = 10;

/// Used for configuring a Ping operation.
pub struct PingBuilder<'a> {
    host: &'a str,
    num_pings: u64,
    interval_secs: u64,
    timeout_secs: u64,
    debug: bool,
}

impl<'a> PingBuilder<'a> {

    /// Returns a new PingBuilder for configuring a Ping operation.
    pub fn new() -> PingBuilder<'a> {
        PingBuilder {
            host: "127.0.0.1",
            num_pings: DEFAULT_NUM_PINGS,
            interval_secs: DEFAULT_INTERVAL_SECS,
            timeout_secs: DEFAULT_TIMEOUT_SECS,
            debug: false,
        }
    }

    /// Sets the host that will be pinged.
    pub fn host(self, host: &'a str) -> PingBuilder<'a> {
        PingBuilder { host: host, .. self }
    }

    /// Sets the number of echo requests to be issued.
    pub fn num_pings(self, num_pings: u64) -> PingBuilder<'a> {
        PingBuilder { num_pings: num_pings, .. self }
    }

    /// Sets the interval in seconds between echo requests.
    pub fn interval_secs(self, interval_secs: u64) -> PingBuilder<'a> {
        PingBuilder { interval_secs: interval_secs, .. self }
    }

    /// Sets the time in seconds before the ping operation times out.
    pub fn timeout_secs(self, timeout_secs: u64) -> PingBuilder<'a> {
        PingBuilder { timeout_secs: timeout_secs, .. self }
    }

    /// Prints debug information to standard out if set to `true`.
    pub fn debug(self, debug: bool) -> PingBuilder<'a> {
        PingBuilder { debug: debug, .. self }
    }

    /// Returns a new Ping object.
    pub fn build(self) -> Ping<'a> {
        Ping {
            host: self.host,
            num_pings: self.num_pings,
            interval_secs: self.interval_secs,
            timeout_secs: self.timeout_secs,
            debug: self.debug,
        }
    }
}

/// Used for pinging a host.
pub struct Ping<'a> {
    host: &'a str,
    num_pings: u64,
    interval_secs: u64,
    timeout_secs: u64,
    debug: bool,
}

impl<'a> Ping<'a> {
    /// Sends a series of pings to a host.
    pub fn ping(&self) {
        let started = time::Instant::now();
        let timeout = time::Duration::from_secs(self.timeout_secs);
        let time_between_pings = time::Duration::from_secs(self.interval_secs);

        let mut icmp = Icmp::new(self.host);
        if self.debug {
            println!("PING {}", self.host);
        }

        let mut i = 1;
        let mut last_ping_sent = started;
        icmp.echo_request();
        loop {
            // check for timeout
            if time::Instant::now() > started + timeout {
                return;
            }

            // poll for new messages
            match icmp.poll() {
                Some(ready) => if !ready { continue; },
                _ => continue,
            }

            // check for replies
            if let Some((reply, dur)) = icmp.get_echo_reply() {
                let time = (dur.as_secs() * 1000) as f64 + dur.subsec_nanos() as f64 / 1e6;
                if self.debug {
                    println!("{} bytes from {}: icmp_seq={} time={:.1} ms", reply.len(), self.host, reply.seq(), time);
                }
            }

            // exit after we've made enough
            if i > self.num_pings {
                break;
            }

            // sleep until it's time to send a new ping
            thread::sleep(((last_ping_sent + time_between_pings) as time::Instant).duration_since(time::Instant::now()));

            // send a new echo request
            icmp.echo_request();
            last_ping_sent = time::Instant::now();
            i += 1;
        }
    }
}