massping 0.5.2

ICMP ping library for sending batches of ICMP echo request packets and measuring the roundtrip time
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

use std::{
    net::{Ipv4Addr, Ipv6Addr},
    sync::Arc,
    time::Duration,
};

use massping::{
    packet::EchoRequestPacket,
    raw_pinger::{RawV4Pinger, RawV6Pinger},
};
use tokio::time;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let localhost_v4: Ipv4Addr = "127.0.0.1".parse().unwrap();
    let one_one_one_one_v4: Ipv4Addr = "1.1.1.1".parse().unwrap();
    let not_answering_v4: Ipv4Addr = "0.0.0.1".parse().unwrap();
    let localhost_v6: Ipv6Addr = "::1".parse().unwrap();
    let one_one_one_one_v6: Ipv6Addr = "2606:4700:4700::1111".parse().unwrap();

    let v4_pinger = Arc::new(RawV4Pinger::new().expect("setup Ipv4 pinger"));
    let v6_pinger = Arc::new(RawV6Pinger::new().expect("setup Ipv6 pinger"));

    {
        let v4_pinger = Arc::clone(&v4_pinger);
        let v6_pinger = Arc::clone(&v6_pinger);

        tokio::spawn(async move {
            for addr in [localhost_v4, one_one_one_one_v4, not_answering_v4] {
                let payload = rand::random::<[u8; 256]>();

                let packet = EchoRequestPacket::new(1, 1, &payload);
                println!("Send ICMP v4 ping to {}", addr);
                v4_pinger
                    .send_to(addr, &packet)
                    .await
                    .expect("send v4 ping");

                //println!("Payload: {:?}", &packet[packet.len() - 256..]);
            }
        });

        tokio::spawn(async move {
            for addr in [localhost_v6, one_one_one_one_v6] {
                let payload = rand::random::<[u8; 256]>();

                let packet = EchoRequestPacket::new(1, 1, &payload);
                println!("Send ICMP v6 ping to {}", addr);
                v6_pinger
                    .send_to(addr, &packet)
                    .await
                    .expect("send v6 ping");

                //println!("Payload: {:?}", &packet[packet.len() - 256..]);
            }
        });
    }

    let handle_v4 = tokio::spawn(async move {
        loop {
            let packet = v4_pinger.recv().await.unwrap();
            println!(
                "Recv: {} | Identifier: {} | Sequence number {}",
                packet.source(),
                packet.identifier(),
                packet.sequence_number()
            );
            //println!("Payload: {:?}", &packet[packet.len() - 256..]);
        }
    });

    let handle_v6 = tokio::spawn(async move {
        loop {
            let packet = v6_pinger.recv().await.unwrap();
            println!(
                "Recv: {} | Identifier: {} | Sequence number {}",
                packet.source(),
                packet.identifier(),
                packet.sequence_number()
            );
            //println!("Payload: {:?}", &packet[packet.len() - 256..]);
        }
    });

    time::sleep(Duration::from_secs(5)).await;
    handle_v4.abort();
    handle_v6.abort();
}