open_net/api/net_status/
interface_events.rs1use super::NetworkEventOptions;
3use crate::NetError;
4use std::time::SystemTime;
5use tokio::sync::Semaphore;
6
7#[non_exhaustive]
10#[derive(Clone, Copy, Debug)]
11pub struct InterfaceEventOptions {
12 pub wlan: bool,
14 pub default_route: bool,
16 pub capacity: usize,
18 pub max_bytes: usize,
20}
21
22impl Default for InterfaceEventOptions {
23 fn default() -> Self {
24 let queue = NetworkEventOptions::default();
25 Self {
26 wlan: true,
27 default_route: true,
28 capacity: queue.capacity,
29 max_bytes: queue.max_bytes,
30 }
31 }
32}
33
34impl InterfaceEventOptions {
35 pub(crate) fn validate(&self) -> Result<(), NetError> {
36 if !self.wlan && !self.default_route {
37 return Err(NetError::config(
38 "interface_events.sources",
39 "select at least one source",
40 ));
41 }
42 if self.capacity == 0 || self.capacity > Semaphore::MAX_PERMITS {
43 return Err(NetError::config(
44 "interface_events.capacity",
45 "must be a positive supported capacity",
46 ));
47 }
48 if self.max_bytes == 0
49 || self.max_bytes > Semaphore::MAX_PERMITS
50 || self.max_bytes > u32::MAX as usize
51 {
52 return Err(NetError::config(
53 "interface_events.max_bytes",
54 "must be a positive supported byte allowance",
55 ));
56 }
57 Ok(())
58 }
59}
60
61#[non_exhaustive]
63#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
64pub enum InterfaceEventSource {
65 Wlan,
67 DefaultRoute,
69}
70
71#[non_exhaustive]
73#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
74pub enum InterfaceAddressFamily {
75 Ipv4,
76 Ipv6,
77}
78
79#[non_exhaustive]
81#[derive(Clone, Debug, Eq, PartialEq)]
82pub enum DefaultRouteState {
83 NoRoute,
85 Ambiguous,
87 Unique { interface_id: String },
89}
90
91#[non_exhaustive]
93#[derive(Clone, Debug)]
94pub enum InterfaceEventKind {
95 SourceReady,
97 SourceUnavailable {
99 error: NetError,
100 native_code: Option<i64>,
101 },
102 SourceGap {
104 error: NetError,
105 native_code: Option<i64>,
106 },
107 WlanConnected {
110 interface_id: String,
111 native_code: u32,
112 reason_code: Option<u32>,
113 },
114 WlanDisconnected {
116 interface_id: String,
117 native_code: u32,
118 reason_code: Option<u32>,
119 },
120 DefaultRouteObserved {
122 family: InterfaceAddressFamily,
123 state: DefaultRouteState,
124 },
125 DefaultRouteChanged {
127 family: InterfaceAddressFamily,
128 previous: String,
129 current: String,
130 },
131 DefaultRouteQueryFailed {
133 family: InterfaceAddressFamily,
134 error: NetError,
135 native_code: Option<i64>,
136 },
137}
138
139#[derive(Clone, Debug)]
143pub struct InterfaceEvent {
144 pub sequence: u64,
146 pub observed_at: SystemTime,
148 pub native_time: Option<SystemTime>,
150 pub source: InterfaceEventSource,
152 pub kind: InterfaceEventKind,
154}
155
156#[cfg(windows)]
157impl InterfaceEvent {
158 pub(crate) fn accounted_bytes(&self) -> usize {
159 use InterfaceEventKind::*;
160 let extra = match &self.kind {
161 WlanConnected { interface_id, .. }
162 | WlanDisconnected { interface_id, .. }
163 | DefaultRouteObserved {
164 state: DefaultRouteState::Unique { interface_id },
165 ..
166 } => interface_id.capacity(),
167 DefaultRouteChanged {
168 previous, current, ..
169 } => previous.capacity().saturating_add(current.capacity()),
170 #[cfg(feature = "ws-client")]
172 SourceUnavailable { .. } | SourceGap { .. } | DefaultRouteQueryFailed { .. } => {
173 std::mem::size_of::<crate::error::ErrorContext>()
174 }
175 _ => 0,
176 };
177 std::mem::size_of::<Self>().saturating_add(extra)
178 }
179}