1use serde::{Deserialize, Serialize};
6use {
7 fidl_fuchsia_wlan_common as fidl_common, fidl_fuchsia_wlan_ieee80211 as fidl_ieee80211,
8 fidl_fuchsia_wlan_sme as fidl_sme,
9};
10
11#[derive(Serialize, Deserialize, Debug)]
15pub enum WlanClientState {
16 ConnectionsDisabled = 1,
17 ConnectionsEnabled = 2,
18}
19
20#[derive(Serialize, Deserialize, Debug)]
21pub enum ConnectionState {
22 Failed = 1,
23 Disconnected = 2,
24 Connecting = 3,
25 Connected = 4,
26}
27
28#[derive(Serialize, Deserialize, Debug)]
29pub enum SecurityType {
30 None = 1,
31 Wep = 2,
32 Wpa = 3,
33 Wpa2 = 4,
34 Wpa3 = 5,
35}
36
37#[derive(Serialize, Deserialize, Debug)]
38pub enum DisconnectStatus {
39 TimedOut = 1,
40 CredentialsFailed = 2,
41 ConnectionStopped = 3,
42 ConnectionFailed = 4,
43}
44
45#[derive(Serialize, Deserialize, Debug)]
46pub struct NetworkIdentifier {
47 pub ssid: Vec<u8>,
49 pub type_: SecurityType,
51}
52
53#[derive(Serialize, Deserialize, Debug)]
54pub struct NetworkState {
55 pub id: Option<NetworkIdentifier>,
57 pub state: Option<ConnectionState>,
59 pub status: Option<DisconnectStatus>,
61}
62
63#[derive(Serialize, Deserialize, Debug)]
64pub struct ClientStateSummary {
65 pub state: Option<WlanClientState>,
67
68 pub networks: Option<Vec<NetworkState>>,
70}
71
72#[derive(Serialize, Deserialize)]
73#[serde(remote = "fidl_sme::Protection")]
74pub(crate) enum ProtectionDef {
75 Unknown = 0,
76 Open = 1,
77 Wep = 2,
78 Wpa1 = 3,
79 Wpa1Wpa2PersonalTkipOnly = 4,
80 Wpa2PersonalTkipOnly = 5,
81 Wpa1Wpa2Personal = 6,
82 Wpa2Personal = 7,
83 Wpa2Wpa3Personal = 8,
84 Wpa3Personal = 9,
85 Wpa2Enterprise = 10,
86 Wpa3Enterprise = 11,
87}
88
89#[derive(Serialize, Deserialize)]
92#[repr(u32)]
93pub(crate) enum ChannelBandwidthDef {
94 Cbw20 = 0,
95 Cbw40 = 1,
96 Cbw40Below = 2,
97 Cbw80 = 3,
98 Cbw160 = 4,
99 Cbw80P80 = 5,
100 Unknown = u32::MAX,
101}
102
103impl From<fidl_ieee80211::ChannelBandwidth> for ChannelBandwidthDef {
104 fn from(fidl_type: fidl_ieee80211::ChannelBandwidth) -> Self {
105 match fidl_type {
106 fidl_ieee80211::ChannelBandwidth::Cbw20 => Self::Cbw20,
107 fidl_ieee80211::ChannelBandwidth::Cbw40 => Self::Cbw40,
108 fidl_ieee80211::ChannelBandwidth::Cbw40Below => Self::Cbw40Below,
109 fidl_ieee80211::ChannelBandwidth::Cbw80 => Self::Cbw80,
110 fidl_ieee80211::ChannelBandwidth::Cbw160 => Self::Cbw160,
111 fidl_ieee80211::ChannelBandwidth::Cbw80P80 => Self::Cbw80P80,
112 fidl_ieee80211::ChannelBandwidthUnknown!() => Self::Unknown,
113 }
114 }
115}
116
117impl From<ChannelBandwidthDef> for fidl_ieee80211::ChannelBandwidth {
118 fn from(serde_type: ChannelBandwidthDef) -> Self {
119 match serde_type {
120 ChannelBandwidthDef::Cbw20 => Self::Cbw20,
121 ChannelBandwidthDef::Cbw40 => Self::Cbw40,
122 ChannelBandwidthDef::Cbw40Below => Self::Cbw40Below,
123 ChannelBandwidthDef::Cbw80 => Self::Cbw80,
124 ChannelBandwidthDef::Cbw160 => Self::Cbw160,
125 ChannelBandwidthDef::Cbw80P80 => Self::Cbw80P80,
126 ChannelBandwidthDef::Unknown => Self::unknown(),
127 }
128 }
129}
130
131#[derive(Serialize, Deserialize)]
132pub(crate) struct WlanChannelDef {
133 pub primary: u8,
134 pub cbw: ChannelBandwidthDef,
135 pub secondary80: u8,
136}
137
138impl From<fidl_ieee80211::WlanChannel> for WlanChannelDef {
139 fn from(fidl_type: fidl_ieee80211::WlanChannel) -> Self {
140 Self {
141 primary: fidl_type.primary,
142 cbw: fidl_type.cbw.into(),
143 secondary80: fidl_type.secondary80,
144 }
145 }
146}
147
148impl From<WlanChannelDef> for fidl_ieee80211::WlanChannel {
149 fn from(serde_type: WlanChannelDef) -> Self {
150 Self {
151 primary: serde_type.primary,
152 cbw: serde_type.cbw.into(),
153 secondary80: serde_type.secondary80,
154 }
155 }
156}
157
158#[derive(Serialize, Deserialize)]
165pub(crate) enum BssTypeDef {
166 Infrastructure = 1,
167 Personal = 2,
168 Independent = 3,
169 Mesh = 4,
170 Unknown = 255,
171}
172
173impl From<BssTypeDef> for fidl_common::BssType {
174 fn from(serde_type: BssTypeDef) -> Self {
175 match serde_type {
176 BssTypeDef::Infrastructure => Self::Infrastructure,
177 BssTypeDef::Personal => Self::Personal,
178 BssTypeDef::Independent => Self::Independent,
179 BssTypeDef::Mesh => Self::Mesh,
180 BssTypeDef::Unknown => Self::unknown(),
181 }
182 }
183}
184
185impl From<fidl_common::BssType> for BssTypeDef {
186 fn from(fidl_type: fidl_common::BssType) -> Self {
187 match fidl_type {
188 fidl_common::BssType::Infrastructure => Self::Infrastructure,
189 fidl_common::BssType::Personal => Self::Personal,
190 fidl_common::BssType::Independent => Self::Independent,
191 fidl_common::BssType::Mesh => Self::Mesh,
192 _ => Self::Unknown,
193 }
194 }
195}
196
197#[derive(Serialize, Deserialize)]
198pub(crate) struct BssDescriptionDef {
199 pub bssid: [u8; 6],
200 pub bss_type: BssTypeDef,
201 pub beacon_period: u16,
202 pub capability_info: u16,
203 pub ies: Vec<u8>,
204 pub channel: WlanChannelDef,
205 pub rssi_dbm: i8,
206 pub snr_db: i8,
207}
208
209impl From<BssDescriptionDef> for fidl_common::BssDescription {
210 fn from(serde_type: BssDescriptionDef) -> Self {
211 Self {
212 bssid: serde_type.bssid,
213 bss_type: serde_type.bss_type.into(),
214 beacon_period: serde_type.beacon_period,
215 capability_info: serde_type.capability_info,
216 ies: serde_type.ies,
217 channel: serde_type.channel.into(),
218 rssi_dbm: serde_type.rssi_dbm,
219 snr_db: serde_type.snr_db,
220 }
221 }
222}
223
224impl From<fidl_common::BssDescription> for BssDescriptionDef {
225 fn from(fidl_type: fidl_common::BssDescription) -> Self {
226 Self {
227 bssid: fidl_type.bssid,
228 bss_type: fidl_type.bss_type.into(),
229 beacon_period: fidl_type.beacon_period,
230 capability_info: fidl_type.capability_info,
231 ies: fidl_type.ies,
232 channel: fidl_type.channel.into(),
233 rssi_dbm: fidl_type.rssi_dbm,
234 snr_db: fidl_type.snr_db,
235 }
236 }
237}
238
239#[derive(Serialize)]
240pub(crate) struct ServingApInfoDef {
241 pub bssid: [u8; 6],
242 pub ssid: Vec<u8>,
243 pub rssi_dbm: i8,
244 pub snr_db: i8,
245 pub channel: WlanChannelDef,
246 #[serde(with = "ProtectionDef")]
247 pub protection: fidl_sme::Protection,
248}
249
250impl From<fidl_sme::ServingApInfo> for ServingApInfoDef {
251 fn from(fidl_type: fidl_sme::ServingApInfo) -> Self {
252 Self {
253 bssid: fidl_type.bssid,
254 ssid: fidl_type.ssid,
255 rssi_dbm: fidl_type.rssi_dbm,
256 snr_db: fidl_type.snr_db,
257 channel: fidl_type.channel.into(),
258 protection: fidl_type.protection,
259 }
260 }
261}
262
263#[derive(Serialize)]
264#[serde(remote = "fidl_sme::Empty")]
265pub(crate) struct SmeEmptyDef;
266
267#[derive(Serialize)]
268pub(crate) enum ClientStatusResponseDef {
269 Connected(ServingApInfoDef),
270 Connecting(Vec<u8>),
271 Roaming(Vec<u8>),
272 #[serde(with = "SmeEmptyDef")]
273 Idle(fidl_sme::Empty),
274}
275
276impl From<fidl_sme::ClientStatusResponse> for ClientStatusResponseDef {
277 fn from(fidl_type: fidl_sme::ClientStatusResponse) -> Self {
278 match fidl_type {
279 fidl_sme::ClientStatusResponse::Connected(info) => Self::Connected(info.into()),
280 fidl_sme::ClientStatusResponse::Connecting(vec) => Self::Connecting(vec),
281 fidl_sme::ClientStatusResponse::Roaming(bssid) => Self::Roaming(bssid.to_vec()),
282 fidl_sme::ClientStatusResponse::Idle(empty) => Self::Idle(empty),
283 }
284 }
285}
286
287#[derive(Serialize)]
288pub(crate) enum WlanMacRoleDef {
289 Client = 1,
290 Ap = 2,
291 Mesh = 3,
292 Unknown = 255,
293}
294
295impl From<fidl_fuchsia_wlan_common::WlanMacRole> for WlanMacRoleDef {
296 fn from(fidl_type: fidl_fuchsia_wlan_common::WlanMacRole) -> Self {
297 match fidl_type {
298 fidl_fuchsia_wlan_common::WlanMacRole::Client => Self::Client,
299 fidl_fuchsia_wlan_common::WlanMacRole::Ap => Self::Ap,
300 fidl_fuchsia_wlan_common::WlanMacRole::Mesh => Self::Mesh,
301 fidl_fuchsia_wlan_common::WlanMacRoleUnknown!() => Self::Unknown,
302 }
303 }
304}
305
306#[derive(Serialize)]
307pub(crate) struct QueryIfaceResponseDef {
308 pub role: WlanMacRoleDef,
309 pub id: u16,
310 pub phy_id: u16,
311 pub phy_assigned_id: u16,
312 pub sta_addr: [u8; 6],
313}
314
315#[derive(Serialize)]
316pub(crate) struct QueryIfaceResponseWrapper(pub QueryIfaceResponseDef);
317
318impl From<fidl_fuchsia_wlan_device_service::QueryIfaceResponse> for QueryIfaceResponseDef {
319 fn from(resp: fidl_fuchsia_wlan_device_service::QueryIfaceResponse) -> QueryIfaceResponseDef {
320 QueryIfaceResponseDef {
321 role: resp.role.into(),
322 id: resp.id,
323 phy_id: resp.phy_id,
324 phy_assigned_id: resp.phy_assigned_id,
325 sta_addr: resp.sta_addr,
326 }
327 }
328}