trippy-core 0.13.0

A network tracing library
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use serde::Deserialize;
use std::net::IpAddr;
use trippy_core::Port;

/// A simulated trace.
#[derive(Debug, Deserialize)]
pub struct Simulation {
    pub name: String,
    pub rounds: Option<usize>,
    #[serde(default)]
    pub privilege_mode: PrivilegeMode,
    pub target: IpAddr,
    pub protocol: Protocol,
    #[serde(default)]
    pub port_direction: PortDirection,
    #[serde(default)]
    pub multipath_strategy: MultipathStrategy,
    #[serde(default)]
    pub icmp_identifier: u16,
    pub initial_sequence: Option<u16>,
    pub packet_size: Option<u16>,
    pub payload_pattern: Option<u8>,
    pub tos: Option<u8>,
    pub min_round_duration: Option<u64>,
    pub max_round_duration: Option<u64>,
    pub grace_duration: Option<u64>,
    pub hops: Vec<Hop>,
}

impl Simulation {
    pub fn latest_ttl(&self) -> u8 {
        if self.hops.is_empty() {
            0
        } else {
            self.hops[self.hops.len() - 1].ttl
        }
    }
}

/// A simulated hop.
#[derive(Debug, Deserialize)]
pub struct Hop {
    /// The simulated time-to-live (TTL).
    pub ttl: u8,
    /// The simulated probe response.
    pub resp: Response,
}

/// A simulated probe response.
#[derive(Debug, Deserialize)]
#[serde(tag = "tag")]
pub enum Response {
    /// Simulate a hop which does not response to probes.
    NoResponse,
    /// Simulate a hop which responds to probes from a single host.
    SingleHost(SingleHost),
}

/// A simulated probe response with a single addr and fixed ttl.
#[derive(Debug, Deserialize)]
pub struct SingleHost {
    /// The simulated host responding to the probe.
    pub addr: IpAddr,
    /// The simulated round trim time (RTT) in ms.
    pub rtt_ms: u16,
}

#[derive(Copy, Clone, Debug, Default, Deserialize)]
pub enum PrivilegeMode {
    #[default]
    Privileged,
    Unprivileged,
}

impl From<PrivilegeMode> for trippy_core::PrivilegeMode {
    fn from(value: PrivilegeMode) -> Self {
        match value {
            PrivilegeMode::Privileged => Self::Privileged,
            PrivilegeMode::Unprivileged => Self::Unprivileged,
        }
    }
}

#[derive(Copy, Clone, Debug, Deserialize)]
pub enum Protocol {
    Icmp,
    Udp,
    Tcp,
}

impl From<Protocol> for trippy_core::Protocol {
    fn from(value: Protocol) -> Self {
        match value {
            Protocol::Icmp => Self::Icmp,
            Protocol::Udp => Self::Udp,
            Protocol::Tcp => Self::Tcp,
        }
    }
}

#[derive(Copy, Clone, Debug, Default, Deserialize)]
#[serde(tag = "tag", content = "value")]
pub enum PortDirection {
    #[default]
    None,
    FixedSrc(u16),
    FixedDest(u16),
    FixedBoth(FixedBoth),
}

#[derive(Copy, Clone, Debug, Default, Deserialize)]
pub struct FixedBoth {
    pub src: u16,
    pub dest: u16,
}

impl From<PortDirection> for trippy_core::PortDirection {
    fn from(value: PortDirection) -> Self {
        match value {
            PortDirection::None => Self::None,
            PortDirection::FixedSrc(src) => Self::FixedSrc(Port(src)),
            PortDirection::FixedDest(dest) => Self::FixedDest(Port(dest)),
            PortDirection::FixedBoth(FixedBoth { src, dest }) => {
                Self::FixedBoth(Port(src), Port(dest))
            }
        }
    }
}

#[derive(Copy, Clone, Debug, Default, Deserialize)]
pub enum MultipathStrategy {
    #[default]
    Classic,
    Paris,
    Dublin,
}

impl From<MultipathStrategy> for trippy_core::MultipathStrategy {
    fn from(value: MultipathStrategy) -> Self {
        match value {
            MultipathStrategy::Classic => Self::Classic,
            MultipathStrategy::Paris => Self::Paris,
            MultipathStrategy::Dublin => Self::Dublin,
        }
    }
}