banjo_fuchsia_wlan_ieee80211/

banjo_fuchsia_wlan_ieee80211.rs

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// WARNING: THIS FILE IS MACHINE GENERATED. DO NOT EDIT.
// Generated from the fuchsia.wlan.ieee80211 banjo file

#![cfg_attr(rustfmt, rustfmt_skip)]
#![allow(unused_imports, non_camel_case_types)]



pub const CCMP_128_MIC_LEN: u32 = 8;
pub const CCMP_256_MIC_LEN: u32 = 16;
pub const CCMP_HDR_LEN: u32 = 8;
pub const CCMP_PN_LEN: u32 = 6;
pub const MAX_SSID_BYTE_LEN: u8 = 32;
pub const HT_CAP_LEN: u8 = 26;
pub const HT_OP_LEN: u8 = 22;
pub const MAC_ADDR_LEN: u8 = 6;
pub const MAX_KEY_LEN: u8 = 32;
pub const MAX_MESH_ID_BYTE_LEN: u8 = 32;
pub const MAX_MGMT_FRAME_MAC_HEADER_BYTE_LEN: u8 = 28;
pub const MAX_MMPDU_BYTE_LEN: u16 = 2304;
pub const MAX_SUPPORTED_BASIC_RATES: u8 = 12;
pub const MAX_UNIQUE_CHANNEL_NUMBERS: u16 = 256;
pub const MAX_VHT_MPDU_BYTE_LEN_0: u16 = 3895;
pub const MAX_VHT_MPDU_BYTE_LEN_1: u16 = 7991;
pub const MAX_VHT_MPDU_BYTE_LEN_2: u16 = 11454;
pub const OUI_LEN: u8 = 3;
pub const SSID_LIST_MAX: u8 = 84;
pub const TIDS_MAX: u32 = 16;
pub const VHT_CAP_LEN: u8 = 12;
pub const VHT_OP_LEN: u8 = 5;
pub const WLAN_IE_BODY_MAX_LEN: u32 = 255;
pub const WLAN_IE_MAX_LEN: u32 = 257;
pub const WLAN_MSDU_MAX_LEN: u32 = 2304;
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct CSsid {
    pub len: u8,
    pub data: [u8; 32 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct HtCapabilities {
    pub bytes: [u8; 26 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct HtOperation {
    pub bytes: [u8; 22 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct VhtCapabilities {
    pub bytes: [u8; 12 as usize],
}

#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct VhtOperation {
    pub bytes: [u8; 5 as usize],
}


#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct CipherSuiteType(pub u32);

impl CipherSuiteType {
    pub const USE_GROUP: Self = Self(0);
    pub const WEP_40: Self = Self(1);
    pub const TKIP: Self = Self(2);
    pub const RESERVED_3: Self = Self(3);
    pub const CCMP_128: Self = Self(4);
    pub const WEP_104: Self = Self(5);
    pub const BIP_CMAC_128: Self = Self(6);
    pub const GROUP_ADDRESSED_NOT_ALLOWED: Self = Self(7);
    pub const GCMP_128: Self = Self(8);
    pub const GCMP_256: Self = Self(9);
    pub const CCMP_256: Self = Self(10);
    pub const BIP_GMAC_128: Self = Self(11);
    pub const BIP_GMAC_256: Self = Self(12);
    pub const BIP_CMAC_256: Self = Self(13);
    pub const RESERVED_14_TO_255: Self = Self(14);
}

impl std::ops::BitAnd for CipherSuiteType {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for CipherSuiteType {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for CipherSuiteType {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for CipherSuiteType {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for CipherSuiteType {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for CipherSuiteType {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct ReasonCode(pub u16);

impl ReasonCode {
    pub const UNSPECIFIED_REASON: Self = Self(1);
    pub const INVALID_AUTHENTICATION: Self = Self(2);
    pub const LEAVING_NETWORK_DEAUTH: Self = Self(3);
    pub const REASON_INACTIVITY: Self = Self(4);
    pub const NO_MORE_STAS: Self = Self(5);
    pub const INVALID_CLASS2_FRAME: Self = Self(6);
    pub const INVALID_CLASS3_FRAME: Self = Self(7);
    pub const LEAVING_NETWORK_DISASSOC: Self = Self(8);
    pub const NOT_AUTHENTICATED: Self = Self(9);
    pub const UNACCEPTABLE_POWER_CAPABILITY: Self = Self(10);
    pub const UNACCEPTABLE_SUPPORTED_CHANNELS: Self = Self(11);
    pub const BSS_TRANSITION_DISASSOC: Self = Self(12);
    pub const REASON_INVALID_ELEMENT: Self = Self(13);
    pub const MIC_FAILURE: Self = Self(14);
    pub const FOURWAY_HANDSHAKE_TIMEOUT: Self = Self(15);
    pub const GK_HANDSHAKE_TIMEOUT: Self = Self(16);
    pub const HANDSHAKE_ELEMENT_MISMATCH: Self = Self(17);
    pub const REASON_INVALID_GROUP_CIPHER: Self = Self(18);
    pub const REASON_INVALID_PAIRWISE_CIPHER: Self = Self(19);
    pub const REASON_INVALID_AKMP: Self = Self(20);
    pub const UNSUPPORTED_RSNE_VERSION: Self = Self(21);
    pub const INVALID_RSNE_CAPABILITIES: Self = Self(22);
    pub const IEEE802_1_X_AUTH_FAILED: Self = Self(23);
    pub const REASON_CIPHER_OUT_OF_POLICY: Self = Self(24);
    pub const TDLS_PEER_UNREACHABLE: Self = Self(25);
    pub const TDLS_UNSPECIFIED_REASON: Self = Self(26);
    pub const SSP_REQUESTED_DISASSOC: Self = Self(27);
    pub const NO_SSP_ROAMING_AGREEMENT: Self = Self(28);
    pub const BAD_CIPHER_OR_AKM: Self = Self(29);
    pub const NOT_AUTHORIZED_THIS_LOCATION: Self = Self(30);
    pub const SERVICE_CHANGE_PRECLUDES_TS: Self = Self(31);
    pub const UNSPECIFIED_QOS_REASON: Self = Self(32);
    pub const NOT_ENOUGH_BANDWIDTH: Self = Self(33);
    pub const MISSING_ACKS: Self = Self(34);
    pub const EXCEEDED_TXOP: Self = Self(35);
    pub const STA_LEAVING: Self = Self(36);
    pub const END_TS_BA_DLS: Self = Self(37);
    pub const UNKNOWN_TS_BA: Self = Self(38);
    pub const TIMEOUT: Self = Self(39);
    pub const PEERKEY_MISMATCH: Self = Self(45);
    pub const PEER_INITIATED: Self = Self(46);
    pub const AP_INITIATED: Self = Self(47);
    pub const REASON_INVALID_FT_ACTION_FRAME_COUNT: Self = Self(48);
    pub const REASON_INVALID_PMKID: Self = Self(49);
    pub const REASON_INVALID_MDE: Self = Self(50);
    pub const REASON_INVALID_FTE: Self = Self(51);
    pub const MESH_PEERING_CANCELED: Self = Self(52);
    pub const MESH_MAX_PEERS: Self = Self(53);
    pub const MESH_CONFIGURATION_POLICY_VIOLATION: Self = Self(54);
    pub const MESH_CLOSE_RCVD: Self = Self(55);
    pub const MESH_MAX_RETRIES: Self = Self(56);
    pub const MESH_CONFIRM_TIMEOUT: Self = Self(57);
    pub const MESH_INVALID_GTK: Self = Self(58);
    pub const MESH_INCONSISTENT_PARAMETERS: Self = Self(59);
    pub const MESH_INVALID_SECURITY_CAPABILITY: Self = Self(60);
    pub const MESH_PATH_ERROR_NO_PROXY_INFORMATION: Self = Self(61);
    pub const MESH_PATH_ERROR_NO_FORWARDING_INFORMATION: Self = Self(62);
    pub const MESH_PATH_ERROR_DESTINATION_UNREACHABLE: Self = Self(63);
    pub const MAC_ADDRESS_ALREADY_EXISTS_IN_MBSS: Self = Self(64);
    pub const MESH_CHANNEL_SWITCH_REGULATORY_REQUIREMENTS: Self = Self(65);
    pub const MESH_CHANNEL_SWITCH_UNSPECIFIED: Self = Self(66);
    pub const MLME_LINK_FAILED: Self = Self(128);
    pub const FW_RX_STALLED: Self = Self(129);
    pub const FW_HIGH_WME_RX_ERR_RATE: Self = Self(130);
}

impl std::ops::BitAnd for ReasonCode {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for ReasonCode {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for ReasonCode {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for ReasonCode {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for ReasonCode {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for ReasonCode {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct StatusCode(pub u16);

impl StatusCode {
    pub const SUCCESS: Self = Self(0);
    pub const REFUSED_REASON_UNSPECIFIED: Self = Self(1);
    pub const TDLS_REJECTED_ALTERNATIVE_PROVIDED: Self = Self(2);
    pub const TDLS_REJECTED: Self = Self(3);
    pub const SECURITY_DISABLED: Self = Self(5);
    pub const UNACCEPTABLE_LIFETIME: Self = Self(6);
    pub const NOT_IN_SAME_BSS: Self = Self(7);
    pub const REFUSED_CAPABILITIES_MISMATCH: Self = Self(10);
    pub const DENIED_NO_ASSOCIATION_EXISTS: Self = Self(11);
    pub const DENIED_OTHER_REASON: Self = Self(12);
    pub const UNSUPPORTED_AUTH_ALGORITHM: Self = Self(13);
    pub const TRANSACTION_SEQUENCE_ERROR: Self = Self(14);
    pub const CHALLENGE_FAILURE: Self = Self(15);
    pub const REJECTED_SEQUENCE_TIMEOUT: Self = Self(16);
    pub const DENIED_NO_MORE_STAS: Self = Self(17);
    pub const REFUSED_BASIC_RATES_MISMATCH: Self = Self(18);
    pub const DENIED_NO_SHORT_PREAMBLE_SUPPORT: Self = Self(19);
    pub const REJECTED_SPECTRUM_MANAGEMENT_REQUIRED: Self = Self(22);
    pub const REJECTED_BAD_POWER_CAPABILITY: Self = Self(23);
    pub const REJECTED_BAD_SUPPORTED_CHANNELS: Self = Self(24);
    pub const DENIED_NO_SHORT_SLOT_TIME_SUPPORT: Self = Self(25);
    pub const DENIED_NO_HT_SUPPORT: Self = Self(27);
    pub const R0KH_UNREACHABLE: Self = Self(28);
    pub const DENIED_PCO_TIME_NOT_SUPPORTED: Self = Self(29);
    pub const REFUSED_TEMPORARILY: Self = Self(30);
    pub const ROBUST_MANAGEMENT_POLICY_VIOLATION: Self = Self(31);
    pub const UNSPECIFIED_QOS_FAILURE: Self = Self(32);
    pub const DENIED_INSUFFICIENT_BANDWIDTH: Self = Self(33);
    pub const DENIED_POOR_CHANNEL_CONDITIONS: Self = Self(34);
    pub const DENIED_QOS_NOT_SUPPORTED: Self = Self(35);
    pub const REQUEST_DECLINED: Self = Self(37);
    pub const INVALID_PARAMETERS: Self = Self(38);
    pub const REJECTED_WITH_SUGGESTED_CHANGES: Self = Self(39);
    pub const STATUS_INVALID_ELEMENT: Self = Self(40);
    pub const STATUS_INVALID_GROUP_CIPHER: Self = Self(41);
    pub const STATUS_INVALID_PAIRWISE_CIPHER: Self = Self(42);
    pub const STATUS_INVALID_AKMP: Self = Self(43);
    pub const UNSUPPORTED_RSNE_VERSION: Self = Self(44);
    pub const INVALID_RSNE_CAPABILITIES: Self = Self(45);
    pub const STATUS_CIPHER_OUT_OF_POLICY: Self = Self(46);
    pub const REJECTED_FOR_DELAY_PERIOD: Self = Self(47);
    pub const DLS_NOT_ALLOWED: Self = Self(48);
    pub const NOT_PRESENT: Self = Self(49);
    pub const NOT_QOS_STA: Self = Self(50);
    pub const DENIED_LISTEN_INTERVAL_TOO_LARGE: Self = Self(51);
    pub const STATUS_INVALID_FT_ACTION_FRAME_COUNT: Self = Self(52);
    pub const STATUS_INVALID_PMKID: Self = Self(53);
    pub const STATUS_INVALID_MDE: Self = Self(54);
    pub const STATUS_INVALID_FTE: Self = Self(55);
    pub const REQUESTED_TCLAS_NOT_SUPPORTED_BY_AP: Self = Self(56);
    pub const INSUFFICIENT_TCLAS_PROCESSING_RESOURCES: Self = Self(57);
    pub const TRY_ANOTHER_BSS: Self = Self(58);
    pub const GAS_ADVERTISEMENT_PROTOCOL_NOT_SUPPORTED: Self = Self(59);
    pub const NO_OUTSTANDING_GAS_REQUEST: Self = Self(60);
    pub const GAS_RESPONSE_NOT_RECEIVED_FROM_SERVER: Self = Self(61);
    pub const GAS_QUERY_TIMEOUT: Self = Self(62);
    pub const GAS_QUERY_RESPONSE_TOO_LARGE: Self = Self(63);
    pub const REJECTED_HOME_WITH_SUGGESTED_CHANGES: Self = Self(64);
    pub const SERVER_UNREACHABLE: Self = Self(65);
    pub const REJECTED_FOR_SSP_PERMISSIONS: Self = Self(67);
    pub const REFUSED_UNAUTHENTICATED_ACCESS_NOT_SUPPORTED: Self = Self(68);
    pub const INVALID_RSNE: Self = Self(72);
    pub const U_APSD_COEXISTANCE_NOT_SUPPORTED: Self = Self(73);
    pub const U_APSD_COEX_MODE_NOT_SUPPORTED: Self = Self(74);
    pub const BAD_INTERVAL_WITH_U_APSD_COEX: Self = Self(75);
    pub const ANTI_CLOGGING_TOKEN_REQUIRED: Self = Self(76);
    pub const UNSUPPORTED_FINITE_CYCLIC_GROUP: Self = Self(77);
    pub const CANNOT_FIND_ALTERNATIVE_TBTT: Self = Self(78);
    pub const TRANSMISSION_FAILURE: Self = Self(79);
    pub const REQUESTED_TCLAS_NOT_SUPPORTED: Self = Self(80);
    pub const TCLAS_RESOURCES_EXHAUSTED: Self = Self(81);
    pub const REJECTED_WITH_SUGGESTED_BSS_TRANSITION: Self = Self(82);
    pub const REJECT_WITH_SCHEDULE: Self = Self(83);
    pub const REJECT_NO_WAKEUP_SPECIFIED: Self = Self(84);
    pub const SUCCESS_POWER_SAVE_MODE: Self = Self(85);
    pub const PENDING_ADMITTING_FST_SESSION: Self = Self(86);
    pub const PERFORMING_FST_NOW: Self = Self(87);
    pub const PENDING_GAP_IN_BA_WINDOW: Self = Self(88);
    pub const REJECT_U_PID_SETTING: Self = Self(89);
    pub const REFUSED_EXTERNAL_REASON: Self = Self(92);
    pub const REFUSED_AP_OUT_OF_MEMORY: Self = Self(93);
    pub const REJECTED_EMERGENCY_SERVICES_NOT_SUPPORTED: Self = Self(94);
    pub const QUERY_RESPONSE_OUTSTANDING: Self = Self(95);
    pub const REJECT_DSE_BAND: Self = Self(96);
    pub const TCLAS_PROCESSING_TERMINATED: Self = Self(97);
    pub const TS_SCHEDULE_CONFLICT: Self = Self(98);
    pub const DENIED_WITH_SUGGESTED_BAND_AND_CHANNEL: Self = Self(99);
    pub const MCCAOP_RESERVATION_CONFLICT: Self = Self(100);
    pub const MAF_LIMIT_EXCEEDED: Self = Self(101);
    pub const MCCA_TRACK_LIMIT_EXCEEDED: Self = Self(102);
    pub const DENIED_DUE_TO_SPECTRUM_MANAGEMENT: Self = Self(103);
    pub const DENIED_VHT_NOT_SUPPORTED: Self = Self(104);
    pub const ENABLEMENT_DENIED: Self = Self(105);
    pub const RESTRICTION_FROM_AUTHORIZED_GDB: Self = Self(106);
    pub const AUTHORIZATION_DEENABLED: Self = Self(107);
    pub const JOIN_FAILURE: Self = Self(256);
    pub const SPURIOUS_DEAUTH_OR_DISASSOC: Self = Self(257);
    pub const CANCELED: Self = Self(258);
    pub const ESTABLISH_RSNA_FAILURE: Self = Self(259);
}

impl std::ops::BitAnd for StatusCode {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for StatusCode {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for StatusCode {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for StatusCode {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for StatusCode {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for StatusCode {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanAccessCategory(pub u32);

impl WlanAccessCategory {
    pub const BACKGROUND: Self = Self(1);
    pub const BEST_EFFORT: Self = Self(2);
    pub const VIDEO: Self = Self(3);
    pub const VOICE: Self = Self(4);
}

impl std::ops::BitAnd for WlanAccessCategory {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanAccessCategory {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanAccessCategory {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanAccessCategory {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanAccessCategory {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanAccessCategory {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}
#[repr(C)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct WlanBand(pub u8);

impl WlanBand {
    pub const TWO_GHZ: Self = Self(0);
    pub const FIVE_GHZ: Self = Self(1);
}

impl std::ops::BitAnd for WlanBand {
    type Output = Self;
    fn bitand(self, rhs: Self) -> Self {
        Self(self.0 & rhs.0)
    }
}

impl std::ops::BitAndAssign for WlanBand {
    fn bitand_assign(&mut self, rhs: Self) {
        *self = Self(self.0 & rhs.0)
    }
}

impl std::ops::BitOr for WlanBand {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        Self(self.0 | rhs.0)
    }
}

impl std::ops::BitOrAssign for WlanBand {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 | rhs.0)
    }
}

impl std::ops::BitXor for WlanBand {
    type Output = Self;
    fn bitxor(self, rhs: Self) -> Self {
        Self(self.0 ^ rhs.0)
    }
}

impl std::ops::BitXorAssign for WlanBand {
    fn bitxor_assign(&mut self, rhs: Self) {
        *self = Self(self.0 ^ rhs.0)
    }
}