fidl_fuchsia_wlan_driver__common/
fidl_fuchsia_wlan_driver__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type WlanSoftmacHardwareCapability = u32;
12
13#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
14#[repr(u8)]
15pub enum WlanProtection {
16    None = 0,
17    Rx = 1,
18    Tx = 2,
19    RxTx = 3,
20}
21
22impl WlanProtection {
23    #[inline]
24    pub fn from_primitive(prim: u8) -> Option<Self> {
25        match prim {
26            0 => Some(Self::None),
27            1 => Some(Self::Rx),
28            2 => Some(Self::Tx),
29            3 => Some(Self::RxTx),
30            _ => None,
31        }
32    }
33
34    #[inline]
35    pub const fn into_primitive(self) -> u8 {
36        self as u8
37    }
38}
39
40#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
41#[repr(u32)]
42pub enum WlanSoftmacHardwareCapabilityBit {
43    /// Short packet preamble.
44    ShortPreamble = 32,
45    /// Spectrum management.
46    SpectrumMgmt = 256,
47    Qos = 512,
48    /// Short slot times after packet collision.
49    ShortSlotTime = 1024,
50    /// Radio measurement.
51    RadioMsmt = 4096,
52    /// Supports simutaneous client-ap use
53    SimultaneousClientAp = 65536,
54}
55
56impl WlanSoftmacHardwareCapabilityBit {
57    #[inline]
58    pub fn from_primitive(prim: u32) -> Option<Self> {
59        match prim {
60            32 => Some(Self::ShortPreamble),
61            256 => Some(Self::SpectrumMgmt),
62            512 => Some(Self::Qos),
63            1024 => Some(Self::ShortSlotTime),
64            4096 => Some(Self::RadioMsmt),
65            65536 => Some(Self::SimultaneousClientAp),
66            _ => None,
67        }
68    }
69
70    #[inline]
71    pub const fn into_primitive(self) -> u32 {
72        self as u32
73    }
74}
75
76/// WFA WMM v1.2, 2.2.2
77#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
78pub struct WlanWmmAccessCategoryParameters {
79    /// Lower bound of contention window in exponential form
80    /// `cw_min = 2^(ecw_min) - 1`. The unit for contention window is "slot time", which
81    /// is different for each standard (e.g. 9 microseconds, 13 microseconds, etc.)
82    pub ecw_min: u8,
83    /// Upper bound of contention window in exponential form
84    /// `cw_max = 2^(ecw_max) - 1`. The unit for contention window is "slot time", which
85    /// is different for each standard (e.g. 9 microseconds, 13 microseconds, etc.)
86    pub ecw_max: u8,
87    /// Arbitration Interframe Spacing Number (control wait time between sending each frame)
88    pub aifsn: u8,
89    /// TXOP limit in unit of 32 microseconds
90    pub txop_limit: u16,
91    /// Whether admission control is mandatory
92    pub acm: bool,
93}
94
95impl fidl::Persistable for WlanWmmAccessCategoryParameters {}
96
97#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
98pub struct WlanWmmParameters {
99    pub apsd: bool,
100    pub ac_be_params: WlanWmmAccessCategoryParameters,
101    pub ac_bk_params: WlanWmmAccessCategoryParameters,
102    pub ac_vi_params: WlanWmmAccessCategoryParameters,
103    pub ac_vo_params: WlanWmmAccessCategoryParameters,
104}
105
106impl fidl::Persistable for WlanWmmParameters {}
107
108/// Input parameters for a join request. This definition is shared between softmac.fidl
109/// and wlantap.fidl.
110#[derive(Clone, Debug, Default, PartialEq)]
111pub struct JoinBssRequest {
112    pub bssid: Option<[u8; 6]>,
113    pub bss_type: Option<fidl_fuchsia_wlan_ieee80211__common::BssType>,
114    pub remote: Option<bool>,
115    pub beacon_period: Option<u16>,
116    #[doc(hidden)]
117    pub __source_breaking: fidl::marker::SourceBreaking,
118}
119
120impl fidl::Persistable for JoinBssRequest {}
121
122#[derive(Clone, Debug, Default, PartialEq)]
123pub struct WlanKeyConfig {
124    /// Which path to protect: None, TX, RX, or TX and RX.
125    pub protection: Option<WlanProtection>,
126    /// IEEE Cipher suite selector.
127    /// See IEEE Std 802.11-2016, 9.4.2.25.2, Table 9-131
128    /// Optional. If not specified, it's assumed that this is the IEEE OUI.
129    pub cipher_oui: Option<[u8; 3]>,
130    /// The cipher type.
131    /// Required.
132    pub cipher_type: Option<fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType>,
133    /// Whether this key is a pairwise, group or peer key.
134    /// Required.
135    pub key_type: Option<fidl_fuchsia_wlan_ieee80211__common::KeyType>,
136    /// The peer MAC address for pairwise and peer keys.
137    /// For group keys this value is always the broadcast address.
138    /// Required.
139    pub peer_addr: Option<[u8; 6]>,
140    /// Index for rotating keys, e.g. group keys.
141    /// This value is always 0 for key types which aren't rotating, e.g. pairwise keys.
142    /// Required.
143    ///
144    /// TODO(https://fxbug.dev/301104836): This is a uint8, but SetKeyDescriptor in MLME FIDL and
145    /// DeleteKeysDescriptor in Fullmac FIDL use a uint16 for key_id/key_idx. We should consider
146    /// making all these use the same type.
147    pub key_idx: Option<u8>,
148    /// They key's actual bytes.
149    /// Required.
150    pub key: Option<Vec<u8>>,
151    /// Receive Sequence Counter for group keys only.
152    /// In all other cases the RSC will be 0.
153    /// Optional.
154    pub rsc: Option<u64>,
155    #[doc(hidden)]
156    pub __source_breaking: fidl::marker::SourceBreaking,
157}
158
159impl fidl::Persistable for WlanKeyConfig {}
160
161mod internal {
162    use super::*;
163    unsafe impl fidl::encoding::TypeMarker for WlanProtection {
164        type Owned = Self;
165
166        #[inline(always)]
167        fn inline_align(_context: fidl::encoding::Context) -> usize {
168            std::mem::align_of::<u8>()
169        }
170
171        #[inline(always)]
172        fn inline_size(_context: fidl::encoding::Context) -> usize {
173            std::mem::size_of::<u8>()
174        }
175
176        #[inline(always)]
177        fn encode_is_copy() -> bool {
178            true
179        }
180
181        #[inline(always)]
182        fn decode_is_copy() -> bool {
183            false
184        }
185    }
186
187    impl fidl::encoding::ValueTypeMarker for WlanProtection {
188        type Borrowed<'a> = Self;
189        #[inline(always)]
190        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
191            *value
192        }
193    }
194
195    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanProtection {
196        #[inline]
197        unsafe fn encode(
198            self,
199            encoder: &mut fidl::encoding::Encoder<'_, D>,
200            offset: usize,
201            _depth: fidl::encoding::Depth,
202        ) -> fidl::Result<()> {
203            encoder.debug_check_bounds::<Self>(offset);
204            encoder.write_num(self.into_primitive(), offset);
205            Ok(())
206        }
207    }
208
209    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanProtection {
210        #[inline(always)]
211        fn new_empty() -> Self {
212            Self::None
213        }
214
215        #[inline]
216        unsafe fn decode(
217            &mut self,
218            decoder: &mut fidl::encoding::Decoder<'_, D>,
219            offset: usize,
220            _depth: fidl::encoding::Depth,
221        ) -> fidl::Result<()> {
222            decoder.debug_check_bounds::<Self>(offset);
223            let prim = decoder.read_num::<u8>(offset);
224
225            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
226            Ok(())
227        }
228    }
229    unsafe impl fidl::encoding::TypeMarker for WlanSoftmacHardwareCapabilityBit {
230        type Owned = Self;
231
232        #[inline(always)]
233        fn inline_align(_context: fidl::encoding::Context) -> usize {
234            std::mem::align_of::<u32>()
235        }
236
237        #[inline(always)]
238        fn inline_size(_context: fidl::encoding::Context) -> usize {
239            std::mem::size_of::<u32>()
240        }
241
242        #[inline(always)]
243        fn encode_is_copy() -> bool {
244            true
245        }
246
247        #[inline(always)]
248        fn decode_is_copy() -> bool {
249            false
250        }
251    }
252
253    impl fidl::encoding::ValueTypeMarker for WlanSoftmacHardwareCapabilityBit {
254        type Borrowed<'a> = Self;
255        #[inline(always)]
256        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
257            *value
258        }
259    }
260
261    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
262        for WlanSoftmacHardwareCapabilityBit
263    {
264        #[inline]
265        unsafe fn encode(
266            self,
267            encoder: &mut fidl::encoding::Encoder<'_, D>,
268            offset: usize,
269            _depth: fidl::encoding::Depth,
270        ) -> fidl::Result<()> {
271            encoder.debug_check_bounds::<Self>(offset);
272            encoder.write_num(self.into_primitive(), offset);
273            Ok(())
274        }
275    }
276
277    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
278        for WlanSoftmacHardwareCapabilityBit
279    {
280        #[inline(always)]
281        fn new_empty() -> Self {
282            Self::ShortPreamble
283        }
284
285        #[inline]
286        unsafe fn decode(
287            &mut self,
288            decoder: &mut fidl::encoding::Decoder<'_, D>,
289            offset: usize,
290            _depth: fidl::encoding::Depth,
291        ) -> fidl::Result<()> {
292            decoder.debug_check_bounds::<Self>(offset);
293            let prim = decoder.read_num::<u32>(offset);
294
295            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
296            Ok(())
297        }
298    }
299
300    impl fidl::encoding::ValueTypeMarker for WlanWmmAccessCategoryParameters {
301        type Borrowed<'a> = &'a Self;
302        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
303            value
304        }
305    }
306
307    unsafe impl fidl::encoding::TypeMarker for WlanWmmAccessCategoryParameters {
308        type Owned = Self;
309
310        #[inline(always)]
311        fn inline_align(_context: fidl::encoding::Context) -> usize {
312            2
313        }
314
315        #[inline(always)]
316        fn inline_size(_context: fidl::encoding::Context) -> usize {
317            8
318        }
319    }
320
321    unsafe impl<D: fidl::encoding::ResourceDialect>
322        fidl::encoding::Encode<WlanWmmAccessCategoryParameters, D>
323        for &WlanWmmAccessCategoryParameters
324    {
325        #[inline]
326        unsafe fn encode(
327            self,
328            encoder: &mut fidl::encoding::Encoder<'_, D>,
329            offset: usize,
330            _depth: fidl::encoding::Depth,
331        ) -> fidl::Result<()> {
332            encoder.debug_check_bounds::<WlanWmmAccessCategoryParameters>(offset);
333            // Delegate to tuple encoding.
334            fidl::encoding::Encode::<WlanWmmAccessCategoryParameters, D>::encode(
335                (
336                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.ecw_min),
337                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.ecw_max),
338                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.aifsn),
339                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.txop_limit),
340                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.acm),
341                ),
342                encoder,
343                offset,
344                _depth,
345            )
346        }
347    }
348    unsafe impl<
349        D: fidl::encoding::ResourceDialect,
350        T0: fidl::encoding::Encode<u8, D>,
351        T1: fidl::encoding::Encode<u8, D>,
352        T2: fidl::encoding::Encode<u8, D>,
353        T3: fidl::encoding::Encode<u16, D>,
354        T4: fidl::encoding::Encode<bool, D>,
355    > fidl::encoding::Encode<WlanWmmAccessCategoryParameters, D> for (T0, T1, T2, T3, T4)
356    {
357        #[inline]
358        unsafe fn encode(
359            self,
360            encoder: &mut fidl::encoding::Encoder<'_, D>,
361            offset: usize,
362            depth: fidl::encoding::Depth,
363        ) -> fidl::Result<()> {
364            encoder.debug_check_bounds::<WlanWmmAccessCategoryParameters>(offset);
365            // Zero out padding regions. There's no need to apply masks
366            // because the unmasked parts will be overwritten by fields.
367            unsafe {
368                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2);
369                (ptr as *mut u16).write_unaligned(0);
370            }
371            unsafe {
372                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(6);
373                (ptr as *mut u16).write_unaligned(0);
374            }
375            // Write the fields.
376            self.0.encode(encoder, offset + 0, depth)?;
377            self.1.encode(encoder, offset + 1, depth)?;
378            self.2.encode(encoder, offset + 2, depth)?;
379            self.3.encode(encoder, offset + 4, depth)?;
380            self.4.encode(encoder, offset + 6, depth)?;
381            Ok(())
382        }
383    }
384
385    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
386        for WlanWmmAccessCategoryParameters
387    {
388        #[inline(always)]
389        fn new_empty() -> Self {
390            Self {
391                ecw_min: fidl::new_empty!(u8, D),
392                ecw_max: fidl::new_empty!(u8, D),
393                aifsn: fidl::new_empty!(u8, D),
394                txop_limit: fidl::new_empty!(u16, D),
395                acm: fidl::new_empty!(bool, D),
396            }
397        }
398
399        #[inline]
400        unsafe fn decode(
401            &mut self,
402            decoder: &mut fidl::encoding::Decoder<'_, D>,
403            offset: usize,
404            _depth: fidl::encoding::Depth,
405        ) -> fidl::Result<()> {
406            decoder.debug_check_bounds::<Self>(offset);
407            // Verify that padding bytes are zero.
408            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2) };
409            let padval = unsafe { (ptr as *const u16).read_unaligned() };
410            let mask = 0xff00u16;
411            let maskedval = padval & mask;
412            if maskedval != 0 {
413                return Err(fidl::Error::NonZeroPadding {
414                    padding_start: offset + 2 + ((mask as u64).trailing_zeros() / 8) as usize,
415                });
416            }
417            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(6) };
418            let padval = unsafe { (ptr as *const u16).read_unaligned() };
419            let mask = 0xff00u16;
420            let maskedval = padval & mask;
421            if maskedval != 0 {
422                return Err(fidl::Error::NonZeroPadding {
423                    padding_start: offset + 6 + ((mask as u64).trailing_zeros() / 8) as usize,
424                });
425            }
426            fidl::decode!(u8, D, &mut self.ecw_min, decoder, offset + 0, _depth)?;
427            fidl::decode!(u8, D, &mut self.ecw_max, decoder, offset + 1, _depth)?;
428            fidl::decode!(u8, D, &mut self.aifsn, decoder, offset + 2, _depth)?;
429            fidl::decode!(u16, D, &mut self.txop_limit, decoder, offset + 4, _depth)?;
430            fidl::decode!(bool, D, &mut self.acm, decoder, offset + 6, _depth)?;
431            Ok(())
432        }
433    }
434
435    impl fidl::encoding::ValueTypeMarker for WlanWmmParameters {
436        type Borrowed<'a> = &'a Self;
437        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
438            value
439        }
440    }
441
442    unsafe impl fidl::encoding::TypeMarker for WlanWmmParameters {
443        type Owned = Self;
444
445        #[inline(always)]
446        fn inline_align(_context: fidl::encoding::Context) -> usize {
447            2
448        }
449
450        #[inline(always)]
451        fn inline_size(_context: fidl::encoding::Context) -> usize {
452            34
453        }
454    }
455
456    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WlanWmmParameters, D>
457        for &WlanWmmParameters
458    {
459        #[inline]
460        unsafe fn encode(
461            self,
462            encoder: &mut fidl::encoding::Encoder<'_, D>,
463            offset: usize,
464            _depth: fidl::encoding::Depth,
465        ) -> fidl::Result<()> {
466            encoder.debug_check_bounds::<WlanWmmParameters>(offset);
467            // Delegate to tuple encoding.
468            fidl::encoding::Encode::<WlanWmmParameters, D>::encode(
469                (
470                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.apsd),
471                    <WlanWmmAccessCategoryParameters as fidl::encoding::ValueTypeMarker>::borrow(
472                        &self.ac_be_params,
473                    ),
474                    <WlanWmmAccessCategoryParameters as fidl::encoding::ValueTypeMarker>::borrow(
475                        &self.ac_bk_params,
476                    ),
477                    <WlanWmmAccessCategoryParameters as fidl::encoding::ValueTypeMarker>::borrow(
478                        &self.ac_vi_params,
479                    ),
480                    <WlanWmmAccessCategoryParameters as fidl::encoding::ValueTypeMarker>::borrow(
481                        &self.ac_vo_params,
482                    ),
483                ),
484                encoder,
485                offset,
486                _depth,
487            )
488        }
489    }
490    unsafe impl<
491        D: fidl::encoding::ResourceDialect,
492        T0: fidl::encoding::Encode<bool, D>,
493        T1: fidl::encoding::Encode<WlanWmmAccessCategoryParameters, D>,
494        T2: fidl::encoding::Encode<WlanWmmAccessCategoryParameters, D>,
495        T3: fidl::encoding::Encode<WlanWmmAccessCategoryParameters, D>,
496        T4: fidl::encoding::Encode<WlanWmmAccessCategoryParameters, D>,
497    > fidl::encoding::Encode<WlanWmmParameters, D> for (T0, T1, T2, T3, T4)
498    {
499        #[inline]
500        unsafe fn encode(
501            self,
502            encoder: &mut fidl::encoding::Encoder<'_, D>,
503            offset: usize,
504            depth: fidl::encoding::Depth,
505        ) -> fidl::Result<()> {
506            encoder.debug_check_bounds::<WlanWmmParameters>(offset);
507            // Zero out padding regions. There's no need to apply masks
508            // because the unmasked parts will be overwritten by fields.
509            unsafe {
510                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
511                (ptr as *mut u16).write_unaligned(0);
512            }
513            // Write the fields.
514            self.0.encode(encoder, offset + 0, depth)?;
515            self.1.encode(encoder, offset + 2, depth)?;
516            self.2.encode(encoder, offset + 10, depth)?;
517            self.3.encode(encoder, offset + 18, depth)?;
518            self.4.encode(encoder, offset + 26, depth)?;
519            Ok(())
520        }
521    }
522
523    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanWmmParameters {
524        #[inline(always)]
525        fn new_empty() -> Self {
526            Self {
527                apsd: fidl::new_empty!(bool, D),
528                ac_be_params: fidl::new_empty!(WlanWmmAccessCategoryParameters, D),
529                ac_bk_params: fidl::new_empty!(WlanWmmAccessCategoryParameters, D),
530                ac_vi_params: fidl::new_empty!(WlanWmmAccessCategoryParameters, D),
531                ac_vo_params: fidl::new_empty!(WlanWmmAccessCategoryParameters, D),
532            }
533        }
534
535        #[inline]
536        unsafe fn decode(
537            &mut self,
538            decoder: &mut fidl::encoding::Decoder<'_, D>,
539            offset: usize,
540            _depth: fidl::encoding::Depth,
541        ) -> fidl::Result<()> {
542            decoder.debug_check_bounds::<Self>(offset);
543            // Verify that padding bytes are zero.
544            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
545            let padval = unsafe { (ptr as *const u16).read_unaligned() };
546            let mask = 0xff00u16;
547            let maskedval = padval & mask;
548            if maskedval != 0 {
549                return Err(fidl::Error::NonZeroPadding {
550                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
551                });
552            }
553            fidl::decode!(bool, D, &mut self.apsd, decoder, offset + 0, _depth)?;
554            fidl::decode!(
555                WlanWmmAccessCategoryParameters,
556                D,
557                &mut self.ac_be_params,
558                decoder,
559                offset + 2,
560                _depth
561            )?;
562            fidl::decode!(
563                WlanWmmAccessCategoryParameters,
564                D,
565                &mut self.ac_bk_params,
566                decoder,
567                offset + 10,
568                _depth
569            )?;
570            fidl::decode!(
571                WlanWmmAccessCategoryParameters,
572                D,
573                &mut self.ac_vi_params,
574                decoder,
575                offset + 18,
576                _depth
577            )?;
578            fidl::decode!(
579                WlanWmmAccessCategoryParameters,
580                D,
581                &mut self.ac_vo_params,
582                decoder,
583                offset + 26,
584                _depth
585            )?;
586            Ok(())
587        }
588    }
589
590    impl JoinBssRequest {
591        #[inline(always)]
592        fn max_ordinal_present(&self) -> u64 {
593            if let Some(_) = self.beacon_period {
594                return 4;
595            }
596            if let Some(_) = self.remote {
597                return 3;
598            }
599            if let Some(_) = self.bss_type {
600                return 2;
601            }
602            if let Some(_) = self.bssid {
603                return 1;
604            }
605            0
606        }
607    }
608
609    impl fidl::encoding::ValueTypeMarker for JoinBssRequest {
610        type Borrowed<'a> = &'a Self;
611        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
612            value
613        }
614    }
615
616    unsafe impl fidl::encoding::TypeMarker for JoinBssRequest {
617        type Owned = Self;
618
619        #[inline(always)]
620        fn inline_align(_context: fidl::encoding::Context) -> usize {
621            8
622        }
623
624        #[inline(always)]
625        fn inline_size(_context: fidl::encoding::Context) -> usize {
626            16
627        }
628    }
629
630    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JoinBssRequest, D>
631        for &JoinBssRequest
632    {
633        unsafe fn encode(
634            self,
635            encoder: &mut fidl::encoding::Encoder<'_, D>,
636            offset: usize,
637            mut depth: fidl::encoding::Depth,
638        ) -> fidl::Result<()> {
639            encoder.debug_check_bounds::<JoinBssRequest>(offset);
640            // Vector header
641            let max_ordinal: u64 = self.max_ordinal_present();
642            encoder.write_num(max_ordinal, offset);
643            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
644            // Calling encoder.out_of_line_offset(0) is not allowed.
645            if max_ordinal == 0 {
646                return Ok(());
647            }
648            depth.increment()?;
649            let envelope_size = 8;
650            let bytes_len = max_ordinal as usize * envelope_size;
651            #[allow(unused_variables)]
652            let offset = encoder.out_of_line_offset(bytes_len);
653            let mut _prev_end_offset: usize = 0;
654            if 1 > max_ordinal {
655                return Ok(());
656            }
657
658            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
659            // are envelope_size bytes.
660            let cur_offset: usize = (1 - 1) * envelope_size;
661
662            // Zero reserved fields.
663            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
664
665            // Safety:
666            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
667            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
668            //   envelope_size bytes, there is always sufficient room.
669            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
670                self.bssid
671                    .as_ref()
672                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
673                encoder,
674                offset + cur_offset,
675                depth,
676            )?;
677
678            _prev_end_offset = cur_offset + envelope_size;
679            if 2 > max_ordinal {
680                return Ok(());
681            }
682
683            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
684            // are envelope_size bytes.
685            let cur_offset: usize = (2 - 1) * envelope_size;
686
687            // Zero reserved fields.
688            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
689
690            // Safety:
691            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
692            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
693            //   envelope_size bytes, there is always sufficient room.
694            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::BssType, D>(
695            self.bss_type.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::BssType as fidl::encoding::ValueTypeMarker>::borrow),
696            encoder, offset + cur_offset, depth
697        )?;
698
699            _prev_end_offset = cur_offset + envelope_size;
700            if 3 > max_ordinal {
701                return Ok(());
702            }
703
704            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
705            // are envelope_size bytes.
706            let cur_offset: usize = (3 - 1) * envelope_size;
707
708            // Zero reserved fields.
709            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
710
711            // Safety:
712            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
713            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
714            //   envelope_size bytes, there is always sufficient room.
715            fidl::encoding::encode_in_envelope_optional::<bool, D>(
716                self.remote.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
717                encoder,
718                offset + cur_offset,
719                depth,
720            )?;
721
722            _prev_end_offset = cur_offset + envelope_size;
723            if 4 > max_ordinal {
724                return Ok(());
725            }
726
727            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
728            // are envelope_size bytes.
729            let cur_offset: usize = (4 - 1) * envelope_size;
730
731            // Zero reserved fields.
732            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
733
734            // Safety:
735            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
736            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
737            //   envelope_size bytes, there is always sufficient room.
738            fidl::encoding::encode_in_envelope_optional::<u16, D>(
739                self.beacon_period.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
740                encoder,
741                offset + cur_offset,
742                depth,
743            )?;
744
745            _prev_end_offset = cur_offset + envelope_size;
746
747            Ok(())
748        }
749    }
750
751    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for JoinBssRequest {
752        #[inline(always)]
753        fn new_empty() -> Self {
754            Self::default()
755        }
756
757        unsafe fn decode(
758            &mut self,
759            decoder: &mut fidl::encoding::Decoder<'_, D>,
760            offset: usize,
761            mut depth: fidl::encoding::Depth,
762        ) -> fidl::Result<()> {
763            decoder.debug_check_bounds::<Self>(offset);
764            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
765                None => return Err(fidl::Error::NotNullable),
766                Some(len) => len,
767            };
768            // Calling decoder.out_of_line_offset(0) is not allowed.
769            if len == 0 {
770                return Ok(());
771            };
772            depth.increment()?;
773            let envelope_size = 8;
774            let bytes_len = len * envelope_size;
775            let offset = decoder.out_of_line_offset(bytes_len)?;
776            // Decode the envelope for each type.
777            let mut _next_ordinal_to_read = 0;
778            let mut next_offset = offset;
779            let end_offset = offset + bytes_len;
780            _next_ordinal_to_read += 1;
781            if next_offset >= end_offset {
782                return Ok(());
783            }
784
785            // Decode unknown envelopes for gaps in ordinals.
786            while _next_ordinal_to_read < 1 {
787                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
788                _next_ordinal_to_read += 1;
789                next_offset += envelope_size;
790            }
791
792            let next_out_of_line = decoder.next_out_of_line();
793            let handles_before = decoder.remaining_handles();
794            if let Some((inlined, num_bytes, num_handles)) =
795                fidl::encoding::decode_envelope_header(decoder, next_offset)?
796            {
797                let member_inline_size =
798                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
799                        decoder.context,
800                    );
801                if inlined != (member_inline_size <= 4) {
802                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
803                }
804                let inner_offset;
805                let mut inner_depth = depth.clone();
806                if inlined {
807                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
808                    inner_offset = next_offset;
809                } else {
810                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
811                    inner_depth.increment()?;
812                }
813                let val_ref = self
814                    .bssid
815                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
816                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
817                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
818                {
819                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
820                }
821                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
822                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
823                }
824            }
825
826            next_offset += envelope_size;
827            _next_ordinal_to_read += 1;
828            if next_offset >= end_offset {
829                return Ok(());
830            }
831
832            // Decode unknown envelopes for gaps in ordinals.
833            while _next_ordinal_to_read < 2 {
834                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
835                _next_ordinal_to_read += 1;
836                next_offset += envelope_size;
837            }
838
839            let next_out_of_line = decoder.next_out_of_line();
840            let handles_before = decoder.remaining_handles();
841            if let Some((inlined, num_bytes, num_handles)) =
842                fidl::encoding::decode_envelope_header(decoder, next_offset)?
843            {
844                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::BssType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
845                if inlined != (member_inline_size <= 4) {
846                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
847                }
848                let inner_offset;
849                let mut inner_depth = depth.clone();
850                if inlined {
851                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
852                    inner_offset = next_offset;
853                } else {
854                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
855                    inner_depth.increment()?;
856                }
857                let val_ref = self.bss_type.get_or_insert_with(|| {
858                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::BssType, D)
859                });
860                fidl::decode!(
861                    fidl_fuchsia_wlan_ieee80211__common::BssType,
862                    D,
863                    val_ref,
864                    decoder,
865                    inner_offset,
866                    inner_depth
867                )?;
868                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
869                {
870                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
871                }
872                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
873                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
874                }
875            }
876
877            next_offset += envelope_size;
878            _next_ordinal_to_read += 1;
879            if next_offset >= end_offset {
880                return Ok(());
881            }
882
883            // Decode unknown envelopes for gaps in ordinals.
884            while _next_ordinal_to_read < 3 {
885                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
886                _next_ordinal_to_read += 1;
887                next_offset += envelope_size;
888            }
889
890            let next_out_of_line = decoder.next_out_of_line();
891            let handles_before = decoder.remaining_handles();
892            if let Some((inlined, num_bytes, num_handles)) =
893                fidl::encoding::decode_envelope_header(decoder, next_offset)?
894            {
895                let member_inline_size =
896                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
897                if inlined != (member_inline_size <= 4) {
898                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
899                }
900                let inner_offset;
901                let mut inner_depth = depth.clone();
902                if inlined {
903                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
904                    inner_offset = next_offset;
905                } else {
906                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
907                    inner_depth.increment()?;
908                }
909                let val_ref = self.remote.get_or_insert_with(|| fidl::new_empty!(bool, D));
910                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
911                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
912                {
913                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
914                }
915                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
916                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
917                }
918            }
919
920            next_offset += envelope_size;
921            _next_ordinal_to_read += 1;
922            if next_offset >= end_offset {
923                return Ok(());
924            }
925
926            // Decode unknown envelopes for gaps in ordinals.
927            while _next_ordinal_to_read < 4 {
928                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
929                _next_ordinal_to_read += 1;
930                next_offset += envelope_size;
931            }
932
933            let next_out_of_line = decoder.next_out_of_line();
934            let handles_before = decoder.remaining_handles();
935            if let Some((inlined, num_bytes, num_handles)) =
936                fidl::encoding::decode_envelope_header(decoder, next_offset)?
937            {
938                let member_inline_size =
939                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
940                if inlined != (member_inline_size <= 4) {
941                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
942                }
943                let inner_offset;
944                let mut inner_depth = depth.clone();
945                if inlined {
946                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
947                    inner_offset = next_offset;
948                } else {
949                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
950                    inner_depth.increment()?;
951                }
952                let val_ref = self.beacon_period.get_or_insert_with(|| fidl::new_empty!(u16, D));
953                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
954                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
955                {
956                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
957                }
958                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
959                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
960                }
961            }
962
963            next_offset += envelope_size;
964
965            // Decode the remaining unknown envelopes.
966            while next_offset < end_offset {
967                _next_ordinal_to_read += 1;
968                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
969                next_offset += envelope_size;
970            }
971
972            Ok(())
973        }
974    }
975
976    impl WlanKeyConfig {
977        #[inline(always)]
978        fn max_ordinal_present(&self) -> u64 {
979            if let Some(_) = self.rsc {
980                return 8;
981            }
982            if let Some(_) = self.key {
983                return 7;
984            }
985            if let Some(_) = self.key_idx {
986                return 6;
987            }
988            if let Some(_) = self.peer_addr {
989                return 5;
990            }
991            if let Some(_) = self.key_type {
992                return 4;
993            }
994            if let Some(_) = self.cipher_type {
995                return 3;
996            }
997            if let Some(_) = self.cipher_oui {
998                return 2;
999            }
1000            if let Some(_) = self.protection {
1001                return 1;
1002            }
1003            0
1004        }
1005    }
1006
1007    impl fidl::encoding::ValueTypeMarker for WlanKeyConfig {
1008        type Borrowed<'a> = &'a Self;
1009        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1010            value
1011        }
1012    }
1013
1014    unsafe impl fidl::encoding::TypeMarker for WlanKeyConfig {
1015        type Owned = Self;
1016
1017        #[inline(always)]
1018        fn inline_align(_context: fidl::encoding::Context) -> usize {
1019            8
1020        }
1021
1022        #[inline(always)]
1023        fn inline_size(_context: fidl::encoding::Context) -> usize {
1024            16
1025        }
1026    }
1027
1028    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WlanKeyConfig, D>
1029        for &WlanKeyConfig
1030    {
1031        unsafe fn encode(
1032            self,
1033            encoder: &mut fidl::encoding::Encoder<'_, D>,
1034            offset: usize,
1035            mut depth: fidl::encoding::Depth,
1036        ) -> fidl::Result<()> {
1037            encoder.debug_check_bounds::<WlanKeyConfig>(offset);
1038            // Vector header
1039            let max_ordinal: u64 = self.max_ordinal_present();
1040            encoder.write_num(max_ordinal, offset);
1041            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1042            // Calling encoder.out_of_line_offset(0) is not allowed.
1043            if max_ordinal == 0 {
1044                return Ok(());
1045            }
1046            depth.increment()?;
1047            let envelope_size = 8;
1048            let bytes_len = max_ordinal as usize * envelope_size;
1049            #[allow(unused_variables)]
1050            let offset = encoder.out_of_line_offset(bytes_len);
1051            let mut _prev_end_offset: usize = 0;
1052            if 1 > max_ordinal {
1053                return Ok(());
1054            }
1055
1056            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1057            // are envelope_size bytes.
1058            let cur_offset: usize = (1 - 1) * envelope_size;
1059
1060            // Zero reserved fields.
1061            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1062
1063            // Safety:
1064            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1065            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1066            //   envelope_size bytes, there is always sufficient room.
1067            fidl::encoding::encode_in_envelope_optional::<WlanProtection, D>(
1068                self.protection
1069                    .as_ref()
1070                    .map(<WlanProtection as fidl::encoding::ValueTypeMarker>::borrow),
1071                encoder,
1072                offset + cur_offset,
1073                depth,
1074            )?;
1075
1076            _prev_end_offset = cur_offset + envelope_size;
1077            if 2 > max_ordinal {
1078                return Ok(());
1079            }
1080
1081            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1082            // are envelope_size bytes.
1083            let cur_offset: usize = (2 - 1) * envelope_size;
1084
1085            // Zero reserved fields.
1086            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1087
1088            // Safety:
1089            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1090            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1091            //   envelope_size bytes, there is always sufficient room.
1092            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 3>, D>(
1093                self.cipher_oui
1094                    .as_ref()
1095                    .map(<fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow),
1096                encoder,
1097                offset + cur_offset,
1098                depth,
1099            )?;
1100
1101            _prev_end_offset = cur_offset + envelope_size;
1102            if 3 > max_ordinal {
1103                return Ok(());
1104            }
1105
1106            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1107            // are envelope_size bytes.
1108            let cur_offset: usize = (3 - 1) * envelope_size;
1109
1110            // Zero reserved fields.
1111            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1112
1113            // Safety:
1114            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1115            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1116            //   envelope_size bytes, there is always sufficient room.
1117            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType, D>(
1118            self.cipher_type.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType as fidl::encoding::ValueTypeMarker>::borrow),
1119            encoder, offset + cur_offset, depth
1120        )?;
1121
1122            _prev_end_offset = cur_offset + envelope_size;
1123            if 4 > max_ordinal {
1124                return Ok(());
1125            }
1126
1127            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1128            // are envelope_size bytes.
1129            let cur_offset: usize = (4 - 1) * envelope_size;
1130
1131            // Zero reserved fields.
1132            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1133
1134            // Safety:
1135            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1136            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1137            //   envelope_size bytes, there is always sufficient room.
1138            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::KeyType, D>(
1139            self.key_type.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::KeyType as fidl::encoding::ValueTypeMarker>::borrow),
1140            encoder, offset + cur_offset, depth
1141        )?;
1142
1143            _prev_end_offset = cur_offset + envelope_size;
1144            if 5 > max_ordinal {
1145                return Ok(());
1146            }
1147
1148            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1149            // are envelope_size bytes.
1150            let cur_offset: usize = (5 - 1) * envelope_size;
1151
1152            // Zero reserved fields.
1153            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1154
1155            // Safety:
1156            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1157            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1158            //   envelope_size bytes, there is always sufficient room.
1159            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
1160                self.peer_addr
1161                    .as_ref()
1162                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
1163                encoder,
1164                offset + cur_offset,
1165                depth,
1166            )?;
1167
1168            _prev_end_offset = cur_offset + envelope_size;
1169            if 6 > max_ordinal {
1170                return Ok(());
1171            }
1172
1173            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1174            // are envelope_size bytes.
1175            let cur_offset: usize = (6 - 1) * envelope_size;
1176
1177            // Zero reserved fields.
1178            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1179
1180            // Safety:
1181            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1182            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1183            //   envelope_size bytes, there is always sufficient room.
1184            fidl::encoding::encode_in_envelope_optional::<u8, D>(
1185                self.key_idx.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1186                encoder,
1187                offset + cur_offset,
1188                depth,
1189            )?;
1190
1191            _prev_end_offset = cur_offset + envelope_size;
1192            if 7 > max_ordinal {
1193                return Ok(());
1194            }
1195
1196            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1197            // are envelope_size bytes.
1198            let cur_offset: usize = (7 - 1) * envelope_size;
1199
1200            // Zero reserved fields.
1201            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1202
1203            // Safety:
1204            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1205            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1206            //   envelope_size bytes, there is always sufficient room.
1207            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
1208                self.key.as_ref().map(
1209                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
1210                ),
1211                encoder,
1212                offset + cur_offset,
1213                depth,
1214            )?;
1215
1216            _prev_end_offset = cur_offset + envelope_size;
1217            if 8 > max_ordinal {
1218                return Ok(());
1219            }
1220
1221            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1222            // are envelope_size bytes.
1223            let cur_offset: usize = (8 - 1) * envelope_size;
1224
1225            // Zero reserved fields.
1226            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1227
1228            // Safety:
1229            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1230            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1231            //   envelope_size bytes, there is always sufficient room.
1232            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1233                self.rsc.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1234                encoder,
1235                offset + cur_offset,
1236                depth,
1237            )?;
1238
1239            _prev_end_offset = cur_offset + envelope_size;
1240
1241            Ok(())
1242        }
1243    }
1244
1245    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanKeyConfig {
1246        #[inline(always)]
1247        fn new_empty() -> Self {
1248            Self::default()
1249        }
1250
1251        unsafe fn decode(
1252            &mut self,
1253            decoder: &mut fidl::encoding::Decoder<'_, D>,
1254            offset: usize,
1255            mut depth: fidl::encoding::Depth,
1256        ) -> fidl::Result<()> {
1257            decoder.debug_check_bounds::<Self>(offset);
1258            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1259                None => return Err(fidl::Error::NotNullable),
1260                Some(len) => len,
1261            };
1262            // Calling decoder.out_of_line_offset(0) is not allowed.
1263            if len == 0 {
1264                return Ok(());
1265            };
1266            depth.increment()?;
1267            let envelope_size = 8;
1268            let bytes_len = len * envelope_size;
1269            let offset = decoder.out_of_line_offset(bytes_len)?;
1270            // Decode the envelope for each type.
1271            let mut _next_ordinal_to_read = 0;
1272            let mut next_offset = offset;
1273            let end_offset = offset + bytes_len;
1274            _next_ordinal_to_read += 1;
1275            if next_offset >= end_offset {
1276                return Ok(());
1277            }
1278
1279            // Decode unknown envelopes for gaps in ordinals.
1280            while _next_ordinal_to_read < 1 {
1281                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1282                _next_ordinal_to_read += 1;
1283                next_offset += envelope_size;
1284            }
1285
1286            let next_out_of_line = decoder.next_out_of_line();
1287            let handles_before = decoder.remaining_handles();
1288            if let Some((inlined, num_bytes, num_handles)) =
1289                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1290            {
1291                let member_inline_size =
1292                    <WlanProtection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1293                if inlined != (member_inline_size <= 4) {
1294                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1295                }
1296                let inner_offset;
1297                let mut inner_depth = depth.clone();
1298                if inlined {
1299                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1300                    inner_offset = next_offset;
1301                } else {
1302                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1303                    inner_depth.increment()?;
1304                }
1305                let val_ref =
1306                    self.protection.get_or_insert_with(|| fidl::new_empty!(WlanProtection, D));
1307                fidl::decode!(WlanProtection, D, val_ref, decoder, inner_offset, inner_depth)?;
1308                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1309                {
1310                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1311                }
1312                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1313                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1314                }
1315            }
1316
1317            next_offset += envelope_size;
1318            _next_ordinal_to_read += 1;
1319            if next_offset >= end_offset {
1320                return Ok(());
1321            }
1322
1323            // Decode unknown envelopes for gaps in ordinals.
1324            while _next_ordinal_to_read < 2 {
1325                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1326                _next_ordinal_to_read += 1;
1327                next_offset += envelope_size;
1328            }
1329
1330            let next_out_of_line = decoder.next_out_of_line();
1331            let handles_before = decoder.remaining_handles();
1332            if let Some((inlined, num_bytes, num_handles)) =
1333                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1334            {
1335                let member_inline_size =
1336                    <fidl::encoding::Array<u8, 3> as fidl::encoding::TypeMarker>::inline_size(
1337                        decoder.context,
1338                    );
1339                if inlined != (member_inline_size <= 4) {
1340                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1341                }
1342                let inner_offset;
1343                let mut inner_depth = depth.clone();
1344                if inlined {
1345                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1346                    inner_offset = next_offset;
1347                } else {
1348                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1349                    inner_depth.increment()?;
1350                }
1351                let val_ref = self
1352                    .cipher_oui
1353                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 3>, D));
1354                fidl::decode!(fidl::encoding::Array<u8, 3>, D, val_ref, decoder, inner_offset, inner_depth)?;
1355                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1356                {
1357                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1358                }
1359                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1360                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1361                }
1362            }
1363
1364            next_offset += envelope_size;
1365            _next_ordinal_to_read += 1;
1366            if next_offset >= end_offset {
1367                return Ok(());
1368            }
1369
1370            // Decode unknown envelopes for gaps in ordinals.
1371            while _next_ordinal_to_read < 3 {
1372                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1373                _next_ordinal_to_read += 1;
1374                next_offset += envelope_size;
1375            }
1376
1377            let next_out_of_line = decoder.next_out_of_line();
1378            let handles_before = decoder.remaining_handles();
1379            if let Some((inlined, num_bytes, num_handles)) =
1380                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1381            {
1382                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1383                if inlined != (member_inline_size <= 4) {
1384                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1385                }
1386                let inner_offset;
1387                let mut inner_depth = depth.clone();
1388                if inlined {
1389                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1390                    inner_offset = next_offset;
1391                } else {
1392                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1393                    inner_depth.increment()?;
1394                }
1395                let val_ref = self.cipher_type.get_or_insert_with(|| {
1396                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType, D)
1397                });
1398                fidl::decode!(
1399                    fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType,
1400                    D,
1401                    val_ref,
1402                    decoder,
1403                    inner_offset,
1404                    inner_depth
1405                )?;
1406                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1407                {
1408                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1409                }
1410                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1411                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1412                }
1413            }
1414
1415            next_offset += envelope_size;
1416            _next_ordinal_to_read += 1;
1417            if next_offset >= end_offset {
1418                return Ok(());
1419            }
1420
1421            // Decode unknown envelopes for gaps in ordinals.
1422            while _next_ordinal_to_read < 4 {
1423                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1424                _next_ordinal_to_read += 1;
1425                next_offset += envelope_size;
1426            }
1427
1428            let next_out_of_line = decoder.next_out_of_line();
1429            let handles_before = decoder.remaining_handles();
1430            if let Some((inlined, num_bytes, num_handles)) =
1431                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1432            {
1433                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::KeyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1434                if inlined != (member_inline_size <= 4) {
1435                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1436                }
1437                let inner_offset;
1438                let mut inner_depth = depth.clone();
1439                if inlined {
1440                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1441                    inner_offset = next_offset;
1442                } else {
1443                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1444                    inner_depth.increment()?;
1445                }
1446                let val_ref = self.key_type.get_or_insert_with(|| {
1447                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::KeyType, D)
1448                });
1449                fidl::decode!(
1450                    fidl_fuchsia_wlan_ieee80211__common::KeyType,
1451                    D,
1452                    val_ref,
1453                    decoder,
1454                    inner_offset,
1455                    inner_depth
1456                )?;
1457                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1458                {
1459                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1460                }
1461                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1462                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1463                }
1464            }
1465
1466            next_offset += envelope_size;
1467            _next_ordinal_to_read += 1;
1468            if next_offset >= end_offset {
1469                return Ok(());
1470            }
1471
1472            // Decode unknown envelopes for gaps in ordinals.
1473            while _next_ordinal_to_read < 5 {
1474                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1475                _next_ordinal_to_read += 1;
1476                next_offset += envelope_size;
1477            }
1478
1479            let next_out_of_line = decoder.next_out_of_line();
1480            let handles_before = decoder.remaining_handles();
1481            if let Some((inlined, num_bytes, num_handles)) =
1482                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1483            {
1484                let member_inline_size =
1485                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
1486                        decoder.context,
1487                    );
1488                if inlined != (member_inline_size <= 4) {
1489                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1490                }
1491                let inner_offset;
1492                let mut inner_depth = depth.clone();
1493                if inlined {
1494                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1495                    inner_offset = next_offset;
1496                } else {
1497                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1498                    inner_depth.increment()?;
1499                }
1500                let val_ref = self
1501                    .peer_addr
1502                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
1503                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
1504                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1505                {
1506                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1507                }
1508                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1509                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1510                }
1511            }
1512
1513            next_offset += envelope_size;
1514            _next_ordinal_to_read += 1;
1515            if next_offset >= end_offset {
1516                return Ok(());
1517            }
1518
1519            // Decode unknown envelopes for gaps in ordinals.
1520            while _next_ordinal_to_read < 6 {
1521                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1522                _next_ordinal_to_read += 1;
1523                next_offset += envelope_size;
1524            }
1525
1526            let next_out_of_line = decoder.next_out_of_line();
1527            let handles_before = decoder.remaining_handles();
1528            if let Some((inlined, num_bytes, num_handles)) =
1529                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1530            {
1531                let member_inline_size =
1532                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1533                if inlined != (member_inline_size <= 4) {
1534                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1535                }
1536                let inner_offset;
1537                let mut inner_depth = depth.clone();
1538                if inlined {
1539                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1540                    inner_offset = next_offset;
1541                } else {
1542                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1543                    inner_depth.increment()?;
1544                }
1545                let val_ref = self.key_idx.get_or_insert_with(|| fidl::new_empty!(u8, D));
1546                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1547                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1548                {
1549                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1550                }
1551                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1552                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1553                }
1554            }
1555
1556            next_offset += envelope_size;
1557            _next_ordinal_to_read += 1;
1558            if next_offset >= end_offset {
1559                return Ok(());
1560            }
1561
1562            // Decode unknown envelopes for gaps in ordinals.
1563            while _next_ordinal_to_read < 7 {
1564                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1565                _next_ordinal_to_read += 1;
1566                next_offset += envelope_size;
1567            }
1568
1569            let next_out_of_line = decoder.next_out_of_line();
1570            let handles_before = decoder.remaining_handles();
1571            if let Some((inlined, num_bytes, num_handles)) =
1572                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1573            {
1574                let member_inline_size =
1575                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
1576                        decoder.context,
1577                    );
1578                if inlined != (member_inline_size <= 4) {
1579                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1580                }
1581                let inner_offset;
1582                let mut inner_depth = depth.clone();
1583                if inlined {
1584                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1585                    inner_offset = next_offset;
1586                } else {
1587                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1588                    inner_depth.increment()?;
1589                }
1590                let val_ref = self
1591                    .key
1592                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
1593                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
1594                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1595                {
1596                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1597                }
1598                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1599                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1600                }
1601            }
1602
1603            next_offset += envelope_size;
1604            _next_ordinal_to_read += 1;
1605            if next_offset >= end_offset {
1606                return Ok(());
1607            }
1608
1609            // Decode unknown envelopes for gaps in ordinals.
1610            while _next_ordinal_to_read < 8 {
1611                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1612                _next_ordinal_to_read += 1;
1613                next_offset += envelope_size;
1614            }
1615
1616            let next_out_of_line = decoder.next_out_of_line();
1617            let handles_before = decoder.remaining_handles();
1618            if let Some((inlined, num_bytes, num_handles)) =
1619                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1620            {
1621                let member_inline_size =
1622                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1623                if inlined != (member_inline_size <= 4) {
1624                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1625                }
1626                let inner_offset;
1627                let mut inner_depth = depth.clone();
1628                if inlined {
1629                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1630                    inner_offset = next_offset;
1631                } else {
1632                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1633                    inner_depth.increment()?;
1634                }
1635                let val_ref = self.rsc.get_or_insert_with(|| fidl::new_empty!(u64, D));
1636                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1637                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1638                {
1639                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1640                }
1641                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1642                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1643                }
1644            }
1645
1646            next_offset += envelope_size;
1647
1648            // Decode the remaining unknown envelopes.
1649            while next_offset < end_offset {
1650                _next_ordinal_to_read += 1;
1651                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1652                next_offset += envelope_size;
1653            }
1654
1655            Ok(())
1656        }
1657    }
1658}
fidl_fuchsia_wlan_driver__common/fidl_fuchsia_wlan_driver__common.rs

fidl_fuchsia_wlan_driver__common/
fidl_fuchsia_wlan_driver__common.rs
