wlan_frame_writer/
lib.rs

1// Copyright 2021 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5pub use wlan_frame_writer_macro::{
6    append_frame_to, write_frame, write_frame_to_vec, write_frame_with_fixed_slice,
7};
8
9pub use fdf::Arena as __Arena;
10pub use {wlan_common as __wlan_common, zerocopy as __zerocopy};
11
12#[cfg(test)]
13extern crate self as wlan_frame_writer;
14
15#[cfg(test)]
16mod tests {
17    use super::*;
18    use fidl_fuchsia_wlan_ieee80211 as fidl_ieee80211;
19    use ieee80211::MacAddr;
20    use wlan_common::append::VecCursor;
21    use wlan_common::error::FrameWriteError;
22    use wlan_common::ie::rsn::akm::{Akm, PSK};
23    use wlan_common::ie::rsn::cipher::{CCMP_128, Cipher, TKIP};
24    use wlan_common::ie::rsn::rsne;
25    use wlan_common::ie::{self, wpa};
26    use wlan_common::mac::*;
27    use wlan_common::organization::Oui;
28
29    fn make_mgmt_hdr() -> MgmtHdr {
30        MgmtHdr {
31            frame_ctrl: FrameControl(0x4321),
32            duration: 42,
33            addr1: MacAddr::from([7; 6]),
34            addr2: MacAddr::from([6; 6]),
35            addr3: MacAddr::from([5; 6]),
36            seq_ctrl: SequenceControl(0x8765),
37        }
38    }
39
40    #[test]
41    fn write_emit_offset_default_source() {
42        let mut offset = 0;
43        write_frame!({
44            ies: {
45                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8],
46                offset @ extended_supported_rates: &[1u8, 2, 3, 4]
47            }
48        })
49        .expect("frame construction failed");
50        assert_eq!(offset, 10);
51    }
52
53    #[test]
54    fn write_emit_offset_fixed_buffer() {
55        let mut buffer = [0u8; 30];
56        let mut offset = 0;
57        let (frame_start, frame_end) = write_frame_with_fixed_slice!(&mut buffer[..], {
58            ies: {
59                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8],
60                offset @ extended_supported_rates: &[1u8, 2, 3, 4]
61            }
62        })
63        .expect("frame construction failed");
64        assert_eq!(frame_start, 0);
65        assert_eq!(frame_end, 16);
66        assert_eq!(offset, 10);
67    }
68
69    #[test]
70    fn write_emit_offset_fixed_buffer_fill_zeroes() {
71        let mut buffer = [0u8; 30];
72        let mut offset = 0;
73        let (frame_start, frame_end) = write_frame_with_fixed_slice!(&mut buffer[..], {
74            fill_zeroes: (),
75            ies: {
76                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8],
77                offset @ extended_supported_rates: &[1u8, 2, 3, 4]
78            }
79        })
80        .expect("frame construction failed");
81        assert_eq!(frame_start, 14);
82        assert_eq!(frame_end, 30);
83        assert_eq!(offset, 24);
84    }
85
86    #[test]
87    fn write_emit_offset_tracked_append() {
88        let mut offset = 0;
89        append_frame_to!(VecCursor::new(), {
90            ies: {
91                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8],
92                offset @ extended_supported_rates: &[1u8, 2, 3, 4]
93            }
94        })
95        .expect("frame construction failed");
96        assert_eq!(offset, 10);
97    }
98
99    #[test]
100    fn write_emit_offset_vec() {
101        let mut offset = 0;
102        write_frame_to_vec!({
103            ies: {
104                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8],
105                offset @ extended_supported_rates: &[1u8, 2, 3, 4]
106            }
107        })
108        .expect("frame construction failed");
109        assert_eq!(offset, 10);
110    }
111
112    #[test]
113    fn write_buf_empty_vec() {
114        let buffer = write_frame_to_vec!({
115            ies: { ssid: &b"foobar"[..] }
116        })
117        .expect("frame construction failed");
118        assert_eq!(buffer.len(), 8);
119        assert_eq!(&[0, 6, 102, 111, 111, 98, 97, 114,][..], &buffer[..]);
120    }
121
122    #[test]
123    fn write_fixed_buffer() {
124        let mut buffer = [0u8; 10];
125        let (frame_start, frame_end) = write_frame_with_fixed_slice!(&mut buffer[..], {
126            ies: { ssid: &b"foobar"[..] }
127        })
128        .expect("frame construction failed");
129        assert_eq!(frame_start, 0);
130        assert_eq!(frame_end, 8);
131        assert_eq!(&[0, 6, 102, 111, 111, 98, 97, 114,][..], &buffer[frame_start..frame_end]);
132    }
133
134    #[test]
135    fn write_fixed_buffer_with_fill_zeroes() {
136        let mut buffer = [0u8; 10];
137        let (frame_start, frame_end) = write_frame_with_fixed_slice!(&mut buffer[..], {
138            fill_zeroes: (),
139            ies: { ssid: &b"foobar"[..] },
140        })
141        .expect("frame construction failed");
142        assert_eq!(frame_start, 2);
143        assert_eq!(frame_end, 10);
144        assert_eq!(&[0, 6, 102, 111, 111, 98, 97, 114,][..], &buffer[frame_start..frame_end]);
145        // Also check the macro filled the beginning with zeroes.
146        assert_eq!(&[0, 0, 0, 6, 102, 111, 111, 98, 97, 114,][..], &buffer[..frame_end]);
147    }
148
149    #[test]
150    fn write_ssid() {
151        let buffer = write_frame!({
152            ies: { ssid: &b"foobar"[..] }
153        })
154        .expect("frame construction failed");
155        assert_eq!(buffer.len(), 8);
156        assert_eq!(&[0, 6, 102, 111, 111, 98, 97, 114,][..], &buffer[..]);
157    }
158
159    #[test]
160    fn write_ssid_empty() {
161        let buffer = write_frame!({
162            ies: { ssid: [0u8; 0] }
163        })
164        .expect("frame construction failed");
165        assert_eq!(buffer.len(), 2);
166        assert_eq!(&[0, 0][..], &buffer[..]);
167    }
168
169    #[test]
170    fn write_ssid_max() {
171        let buffer = write_frame!({
172            ies: { ssid: [2u8; (fidl_ieee80211::MAX_SSID_BYTE_LEN as usize)] }
173        })
174        .expect("frame construction failed");
175        assert_eq!(buffer.len(), 34);
176        #[rustfmt::skip]
177        assert_eq!(
178            &[
179                0, 32,
180                2, 2, 2, 2, 2, 2, 2, 2,
181                2, 2, 2, 2, 2, 2, 2, 2,
182                2, 2, 2, 2, 2, 2, 2, 2,
183                2, 2, 2, 2, 2, 2, 2, 2,
184            ][..],
185            &buffer[..]
186        );
187    }
188
189    #[test]
190    fn write_ssid_too_large() {
191        assert!(matches!(
192            write_frame!({
193                ies: { ssid: [2u8; 33] }
194            }),
195            Err(FrameWriteError::InvalidData(_))
196        ));
197    }
198
199    #[test]
200    fn write_tim() {
201        let buffer = write_frame_to_vec!({
202            ies: {
203                tim: ie::TimView {
204                    header: ie::TimHeader {
205                        dtim_count: 1,
206                        dtim_period: 2,
207                        bmp_ctrl: ie::BitmapControl(3)
208                    },
209                    bitmap: &[4, 5, 6][..],
210                }
211            }
212        })
213        .expect("failed to write frame");
214        assert_eq!(buffer.len(), 8);
215        assert_eq!(&[5, 6, 1, 2, 3, 4, 5, 6][..], &buffer[..]);
216    }
217
218    #[test]
219    fn write_tim_empty_bitmap() {
220        assert!(matches!(
221            write_frame_to_vec!({
222                ies: {
223                    tim: ie::TimView {
224                        header: ie::TimHeader {
225                            dtim_count: 1,
226                            dtim_period: 2,
227                            bmp_ctrl: ie::BitmapControl(3)
228                        },
229                        bitmap: &[][..],
230                    }
231                }
232            }),
233            Err(FrameWriteError::InvalidData(_))
234        ));
235    }
236
237    #[test]
238    fn write_tim_bitmap_too_long() {
239        assert!(matches!(
240            write_frame_to_vec!({
241                ies: {
242                    tim: ie::TimView {
243                        header: ie::TimHeader {
244                            dtim_count: 1,
245                            dtim_period: 2,
246                            bmp_ctrl: ie::BitmapControl(3)
247                        },
248                        bitmap: &[0xFF_u8; 252][..],
249                    }
250                }
251            }),
252            Err(FrameWriteError::InvalidData(_))
253        ));
254    }
255
256    #[test]
257    fn write_rates() {
258        let buffer = write_frame!({
259            ies: { supported_rates: &[1u8, 2, 3, 4, 5] }
260        })
261        .expect("frame construction failed");
262        assert_eq!(buffer.len(), 7);
263        assert_eq!(&[1, 5, 1, 2, 3, 4, 5,][..], &buffer[..]);
264    }
265
266    #[test]
267    fn write_rates_too_large() {
268        let buffer = write_frame!({
269            ies: { supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8, 9] }
270        })
271        .expect("frame construction failed");
272        assert_eq!(buffer.len(), 10);
273        assert_eq!(&[1, 8, 1, 2, 3, 4, 5, 6, 7, 8][..], &buffer[..]);
274    }
275
276    #[test]
277    fn write_rates_empty() {
278        assert!(matches!(
279            write_frame!({
280                ies: { supported_rates: &[] }
281            }),
282            Err(FrameWriteError::InvalidData(_))
283        ));
284    }
285
286    #[test]
287    fn write_extended_supported_rates_too_few_rates() {
288        assert!(matches!(
289            write_frame!({
290                ies: {
291                    supported_rates: &[1u8, 2, 3, 4, 5, 6],
292                    extended_supported_rates: &[1u8, 2, 3, 4]
293                }
294            }),
295            Err(FrameWriteError::InvalidData(_))
296        ));
297    }
298
299    #[test]
300    fn write_extended_supported_rates_too_many_rates() {
301        assert!(matches!(
302            write_frame!({
303                ies: {
304                    supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8, 9],
305                    extended_supported_rates: &[1u8, 2, 3, 4]
306                }
307            }),
308            Err(FrameWriteError::InvalidData(_))
309        ));
310    }
311
312    #[test]
313    fn write_extended_supported_rates_continued() {
314        let buffer = write_frame!({
315            ies: {
316                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8, 9],
317                extended_supported_rates: {/* continue rates */}
318            }
319        })
320        .expect("frame construction failed");
321        assert_eq!(buffer.len(), 13);
322        assert_eq!(&[1, 8, 1, 2, 3, 4, 5, 6, 7, 8, 50, 1, 9][..], &buffer[..]);
323    }
324
325    #[test]
326    fn write_extended_supported_rates_separate() {
327        let buffer = write_frame!({
328            ies: {
329                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8],
330                extended_supported_rates: &[11u8, 12, 13],
331            }
332        })
333        .expect("frame construction failed");
334        assert_eq!(buffer.len(), 15);
335        assert_eq!(&[1, 8, 1, 2, 3, 4, 5, 6, 7, 8, 50, 3, 11, 12, 13][..], &buffer[..]);
336    }
337
338    #[test]
339    fn write_rsne() {
340        let rsne = rsne::Rsne::wpa2_rsne();
341
342        let buffer = write_frame!({
343            ies: { rsne: &rsne, }
344        })
345        .expect("frame construction failed");
346        assert_eq!(buffer.len(), 20);
347        assert_eq!(
348            &[
349                48, 18, // Element header
350                1, 0, // Version
351                0x00, 0x0F, 0xAC, 4, // Group Cipher: CCMP-128
352                1, 0, 0x00, 0x0F, 0xAC, 4, // 1 Pairwise Cipher: CCMP-128
353                1, 0, 0x00, 0x0F, 0xAC, 2, // 1 AKM: PSK
354            ][..],
355            &buffer[..]
356        );
357    }
358
359    #[test]
360    fn write_wpa1() {
361        let wpa_ie = wpa::WpaIe {
362            multicast_cipher: Cipher { oui: Oui::MSFT, suite_type: TKIP },
363            unicast_cipher_list: vec![Cipher { oui: Oui::MSFT, suite_type: TKIP }],
364            akm_list: vec![Akm { oui: Oui::MSFT, suite_type: PSK }],
365        };
366
367        let buffer = write_frame!({
368            ies: { wpa1: &wpa_ie, }
369        })
370        .expect("frame construction failed");
371        assert_eq!(buffer.len(), 24);
372        assert_eq!(
373            &[
374                0xdd, 0x16, // Vendor IE header
375                0x00, 0x50, 0xf2, // MSFT OUI
376                0x01, 0x01, 0x00, // WPA IE header
377                0x00, 0x50, 0xf2, 0x02, // multicast cipher: TKIP
378                0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 unicast cipher: TKIP
379                0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 AKM: PSK
380            ][..],
381            &buffer[..]
382        );
383    }
384
385    #[test]
386    fn write_match_optional_positive() {
387        let wpa_ie = wpa::WpaIe {
388            multicast_cipher: Cipher { oui: Oui::MSFT, suite_type: TKIP },
389            unicast_cipher_list: vec![Cipher { oui: Oui::MSFT, suite_type: TKIP }],
390            akm_list: vec![Akm { oui: Oui::MSFT, suite_type: PSK }],
391        };
392
393        let buffer = write_frame!({
394            ies: {
395                wpa1?: match 2u8 {
396                    1 => None,
397                    2 => Some(&wpa_ie),
398                    _ => None,
399                },
400            }
401        })
402        .expect("frame construction failed");
403        assert_eq!(buffer.len(), 24);
404        assert_eq!(
405            &[
406                0xdd, 0x16, // Vendor IE header
407                0x00, 0x50, 0xf2, // MSFT OUI
408                0x01, 0x01, 0x00, // WPA IE header
409                0x00, 0x50, 0xf2, 0x02, // multicast cipher: TKIP
410                0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 unicast cipher: TKIP
411                0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 AKM: PSK
412            ][..],
413            &buffer[..]
414        );
415    }
416
417    #[test]
418    fn write_match_optional_negative() {
419        let wpa_ie = wpa::WpaIe {
420            multicast_cipher: Cipher { oui: Oui::MSFT, suite_type: TKIP },
421            unicast_cipher_list: vec![Cipher { oui: Oui::MSFT, suite_type: TKIP }],
422            akm_list: vec![Akm { oui: Oui::MSFT, suite_type: PSK }],
423        };
424
425        let buffer = write_frame!({
426            ies: {
427                // Add another field that is present since write_frame!() will
428                // return an error if no bytes are buffer.len().
429                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8],
430                wpa1?: match 1u8 {
431                    1 => None,
432                    2 => Some(&wpa_ie),
433                    _ => None,
434                },
435            }
436        })
437        .expect("frame construction failed");
438
439        // Only supported rates are written.
440        assert_eq!(buffer.len(), 10);
441        assert_eq!(&[1, 8, 1, 2, 3, 4, 5, 6, 7, 8][..], &buffer[..]);
442    }
443
444    #[test]
445    fn write_match_required() {
446        let wpa_ie_first = wpa::WpaIe {
447            multicast_cipher: Cipher { oui: Oui::MSFT, suite_type: TKIP },
448            unicast_cipher_list: vec![Cipher { oui: Oui::MSFT, suite_type: TKIP }],
449            akm_list: vec![Akm { oui: Oui::MSFT, suite_type: PSK }],
450        };
451        let wpa_ie_second = wpa::WpaIe {
452            multicast_cipher: Cipher { oui: Oui::MSFT, suite_type: CCMP_128 },
453            unicast_cipher_list: vec![Cipher { oui: Oui::MSFT, suite_type: CCMP_128 }],
454            akm_list: vec![Akm { oui: Oui::MSFT, suite_type: PSK }],
455        };
456
457        let buffer = write_frame!({
458            ies: {
459                wpa1: match 1u8 {
460                    1 => &wpa_ie_first,
461                    _ => &wpa_ie_second,
462                },
463            }
464        })
465        .expect("frame construction failed");
466        assert_eq!(buffer.len(), 24);
467        assert_eq!(
468            &[
469                0xdd, 0x16, // Vendor IE header
470                0x00, 0x50, 0xf2, // MSFT OUI
471                0x01, 0x01, 0x00, // WPA IE header
472                0x00, 0x50, 0xf2, 0x02, // multicast cipher: TKIP
473                0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 unicast cipher: TKIP
474                0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 AKM: PSK
475            ][..],
476            &buffer[..]
477        );
478
479        let buffer = write_frame!({
480            ies: {
481                wpa1: match 2u8 {
482                    1 => &wpa_ie_first,
483                    _ => &wpa_ie_second,
484                },
485            }
486        })
487        .expect("frame construction failed");
488        assert_eq!(buffer.len(), 24);
489        assert_eq!(
490            &[
491                0xdd, 0x16, // Vendor IE header
492                0x00, 0x50, 0xf2, // MSFT OUI
493                0x01, 0x01, 0x00, // WPA IE header
494                0x00, 0x50, 0xf2, 0x04, // multicast cipher: CCMP_128
495                0x01, 0x00, 0x00, 0x50, 0xf2, 0x04, // 1 unicast cipher: CCMP_128
496                0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 AKM: PSK
497            ][..],
498            &buffer[..]
499        );
500    }
501
502    #[test]
503    fn write_ht_caps() {
504        let buffer = write_frame!({
505            ies: {
506                ht_cap: &ie::HtCapabilities {
507                    ht_cap_info: ie::HtCapabilityInfo(0x1234),
508                    ampdu_params: ie::AmpduParams(42),
509                    mcs_set: ie::SupportedMcsSet(0x1200_3400_5600_7800_9000_1200_3400_5600),
510                    ht_ext_cap: ie::HtExtCapabilities(0x1234),
511                    txbf_cap: ie::TxBfCapability(0x12345678),
512                    asel_cap: ie::AselCapability(43),
513                },
514            }
515        })
516        .expect("frame construction failed");
517        assert_eq!(buffer.len(), 28);
518        assert_eq!(
519            &[
520                45, 26, // Element header
521                0x34, 0x12, // ht_cap_info
522                42,   // ampdu_params
523                0, 0x56, 0, 0x34, 0, 0x12, 0, 0x90, 0, 0x78, 0, 0x56, 0, 0x34, 0,
524                0x12, // mcs_set
525                0x34, 0x12, // ht_ext_cap
526                0x78, 0x56, 0x34, 0x12, // txbf_cap
527                43,   // asel_cap
528            ][..],
529            &buffer[..]
530        );
531    }
532
533    #[test]
534    fn write_vht_caps() {
535        let buffer = write_frame!({
536            ies: {
537                vht_cap: &ie::VhtCapabilities {
538                    vht_cap_info: ie::VhtCapabilitiesInfo(0x1200_3400),
539                    vht_mcs_nss: ie::VhtMcsNssSet(0x1200_3400_5600_7800),
540                },
541            }
542        })
543        .expect("frame construction failed");
544        assert_eq!(buffer.len(), 14);
545        assert_eq!(
546            &[
547                191, 12, // Element header
548                0, 0x34, 0, 0x12, // vht_cap_info
549                0, 0x78, 0, 0x56, 0, 0x34, 0, 0x12, // vht_mcs_nss
550            ][..],
551            &buffer[..]
552        );
553    }
554
555    #[test]
556    fn write_dsss_param_set() {
557        let buffer = write_frame!({
558            ies: {
559                dsss_param_set: &ie::DsssParamSet {
560                    current_channel: 42
561                },
562            }
563        })
564        .expect("frame construction failed");
565        assert_eq!(buffer.len(), 3);
566        assert_eq!(&[3, 1, 42][..], &buffer[..]);
567    }
568
569    #[test]
570    fn write_bss_max_idle_period() {
571        let buffer = write_frame!({
572            ies: {
573                bss_max_idle_period: &ie::BssMaxIdlePeriod {
574                    max_idle_period: 42,
575                    idle_options: ie::IdleOptions(8),
576                },
577            }
578        })
579        .expect("frame construction failed");
580        assert_eq!(buffer.len(), 5);
581        assert_eq!(&[90, 3, 42, 0, 8,][..], &buffer[..]);
582    }
583
584    #[test]
585    fn write_fields() {
586        // Some expression which can't be statically evaluated but always returns true.
587        let v = vec![5; 5];
588        let always_true = v.len() < 6;
589        let mut ht_capabilities = None;
590        if !always_true {
591            ht_capabilities = Some(ie::HtCapabilities {
592                ht_cap_info: ie::HtCapabilityInfo(0x1234),
593                ampdu_params: ie::AmpduParams(42),
594                mcs_set: ie::SupportedMcsSet(0x1200_3400_5600_7800_9000_1200_3400_5600),
595                ht_ext_cap: ie::HtExtCapabilities(0x1234),
596                txbf_cap: ie::TxBfCapability(0x12345678),
597                asel_cap: ie::AselCapability(43),
598            });
599        }
600
601        let buffer = write_frame!({
602            ies: {
603                ssid: if always_true { &[2u8; 2][..] } else { &[2u8; 33][..] },
604                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8, 9],
605                ht_cap?: ht_capabilities,
606                vht_cap?: if always_true {
607                    &ie::VhtCapabilities {
608                        vht_cap_info: ie::VhtCapabilitiesInfo(0x1200_3400),
609                        vht_mcs_nss: ie::VhtMcsNssSet(0x1200_3400_5600_7800),
610                    }
611                },
612                extended_supported_rates: {},
613            }
614        })
615        .expect("frame construction failed");
616        assert_eq!(buffer.len(), 31);
617        #[rustfmt::skip]
618        assert_eq!(
619            &[
620                0, 2, 2, 2, // SSID
621                1, 8, 1, 2, 3, 4, 5, 6, 7, 8, // rates
622                191, 12, // VHT Element header
623                0, 0x34, 0, 0x12, // vht_cap_info
624                0, 0x78, 0, 0x56, 0, 0x34, 0, 0x12, // vht_mcs_nss
625                50, 1, 9, // extended rates
626            ][..],
627            &buffer[..]
628        );
629    }
630
631    #[test]
632    fn write_headers() {
633        let buffer = write_frame!({
634            headers: {
635                // Struct expressions:
636                MgmtHdr: &MgmtHdr {
637                    frame_ctrl: FrameControl(0x1234),
638                    duration: 42,
639                    addr1: MacAddr::from([7; 6]),
640                    addr2: MacAddr::from([6; 6]),
641                    addr3: MacAddr::from([5; 6]),
642                    seq_ctrl: SequenceControl(0x5678),
643                },
644                // Block expression:
645                DeauthHdr: &DeauthHdr { reason_code: fidl_ieee80211::ReasonCode::MicFailure.into() },
646                // Repeat and literal expressions:
647                MacAddr: &MacAddr::from([2u8; 6]),
648                u8: &42u8,
649                // Function invocation:
650                MgmtHdr: &make_mgmt_hdr(),
651            }
652        })
653        .expect("frame construction failed");
654        assert_eq!(buffer.len(), 57);
655        #[rustfmt::skip]
656        assert_eq!(
657            &[
658                // Struct expression: MgmtHdr
659                0x34, 0x12, 42, 0, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 0x78, 0x56,
660                // Struct expression: DeauthHdr
661                14, 0,
662                // Repeat and literal expressions:
663                2, 2, 2, 2, 2, 2,
664                42,
665                // Function call: MgmtHdr
666                0x21, 0x43, 42, 0, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 0x65, 0x87,
667            ][..],
668            &buffer[..]
669        );
670    }
671
672    #[test]
673    fn write_body() {
674        let buffer = write_frame!({
675            body: &[9u8; 9],
676        })
677        .expect("frame construction failed");
678        assert_eq!(buffer.len(), 9);
679        assert_eq!(&[9, 9, 9, 9, 9, 9, 9, 9, 9][..], &buffer[..]);
680    }
681
682    #[test]
683    fn write_payload() {
684        let buffer = write_frame!({
685            payload: &[9u8; 9],
686        })
687        .expect("frame construction failed");
688        assert_eq!(buffer.len(), 9);
689        assert_eq!(&[9, 9, 9, 9, 9, 9, 9, 9, 9][..], &buffer[..]);
690    }
691
692    #[test]
693    fn write_complex() {
694        let buffer = write_frame!({
695            headers: {
696                MgmtHdr: &MgmtHdr {
697                    frame_ctrl: FrameControl(0x1234),
698                    duration: 42,
699                    addr1: MacAddr::from([7; 6]),
700                    addr2: MacAddr::from([6; 6]),
701                    addr3: MacAddr::from([5; 6]),
702                    seq_ctrl: SequenceControl(0x5678),
703                },
704                DeauthHdr: &DeauthHdr { reason_code: fidl_ieee80211::ReasonCode::MicFailure.into() },
705                MacAddr: &MacAddr::from([2u8; 6]),
706                u8: &42u8,
707                MgmtHdr: &make_mgmt_hdr(),
708            },
709            body: vec![41u8; 3],
710            ies: {
711                ssid: &[2u8; 2][..],
712                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8, 9],
713                vht_cap: &ie::VhtCapabilities {
714                    vht_cap_info: ie::VhtCapabilitiesInfo(0x1200_3400),
715                    vht_mcs_nss: ie::VhtMcsNssSet(0x1200_3400_5600_7800),
716                },
717                extended_supported_rates: {},
718            },
719            payload: vec![42u8; 5]
720        })
721        .expect("frame construction failed");
722        assert_eq!(buffer.len(), 96);
723        #[rustfmt::skip]
724        assert_eq!(
725            &[
726                // Headers:
727                0x34, 0x12, 42, 0, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 0x78, 0x56,
728                14, 0,
729                2, 2, 2, 2, 2, 2,
730                42,
731                0x21, 0x43, 42, 0, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 0x65, 0x87,
732                // Body:
733                41, 41, 41,
734                // Fields:
735                0, 2, 2, 2, // SSID
736                1, 8, 1, 2, 3, 4, 5, 6, 7, 8, // rates
737                191, 12, // VHT Element header
738                0, 0x34, 0, 0x12, // vht_cap_info
739                0, 0x78, 0, 0x56, 0, 0x34, 0, 0x12, // vht_mcs_nss
740                50, 1, 9, // extended rates
741                // Payload:
742                42, 42, 42, 42, 42,
743            ][..],
744            &buffer[..]
745        );
746    }
747
748    #[test]
749    fn write_complex_verify_order() {
750        let buffer = write_frame!({
751            payload: vec![42u8; 5],
752            ies: {
753                ssid: &[2u8; 2][..],
754                supported_rates: &[1u8, 2, 3, 4, 5, 6, 7, 8, 9],
755                vht_cap: &ie::VhtCapabilities {
756                    vht_cap_info: ie::VhtCapabilitiesInfo(0x1200_3400),
757                    vht_mcs_nss: ie::VhtMcsNssSet(0x1200_3400_5600_7800),
758                },
759                extended_supported_rates: {},
760            },
761            body: vec![41u8; 3],
762            headers: {
763                MgmtHdr: &MgmtHdr {
764                    frame_ctrl: FrameControl(0x1234),
765                    duration: 42,
766                    addr1: MacAddr::from([7; 6]),
767                    addr2: MacAddr::from([6; 6]),
768                    addr3: MacAddr::from([5; 6]),
769                    seq_ctrl: SequenceControl(0x5678),
770                },
771                DeauthHdr: &DeauthHdr { reason_code: fidl_ieee80211::ReasonCode::MicFailure.into() },
772                MacAddr: &MacAddr::from([2u8; 6]),
773                u8: &42u8,
774                MgmtHdr: &make_mgmt_hdr(),
775            },
776        })
777        .expect("frame construction failed");
778        assert_eq!(buffer.len(), 96);
779        #[rustfmt::skip]
780        assert_eq!(
781            &[
782                // Headers:
783                0x34, 0x12, 42, 0, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 0x78, 0x56,
784                14, 0,
785                2, 2, 2, 2, 2, 2,
786                42,
787                0x21, 0x43, 42, 0, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 0x65, 0x87,
788                // Body:
789                41, 41, 41,
790                // Fields:
791                0, 2, 2, 2, // SSID
792                1, 8, 1, 2, 3, 4, 5, 6, 7, 8, // rates
793                191, 12, // VHT Element header
794                0, 0x34, 0, 0x12, // vht_cap_info
795                0, 0x78, 0, 0x56, 0, 0x34, 0, 0x12, // vht_mcs_nss
796                50, 1, 9, // extended rates
797                // Payload:
798                42, 42, 42, 42, 42,
799            ][..],
800            &buffer[..]
801        );
802    }
803
804    #[test]
805    fn write_nothing() {
806        let buffer = write_frame!({}).expect("frame construction failed");
807        assert_eq!(0, buffer.len());
808        assert_eq!(&[0u8; 0], &buffer[..]);
809    }
810}
wlan_frame_writer/lib.rs

wlan_frame_writer/
lib.rs
