| // Copyright 2014 Google, Inc. All rights reserved. |
| // |
| // Use of this source code is governed by a BSD-style license |
| // that can be found in the LICENSE file in the root of the source |
| // tree. |
| |
| // See http://standards.ieee.org/findstds/standard/802.11-2012.html for info on |
| // all of the layers in this file. |
| |
| package layers |
| |
| import ( |
| "bytes" |
| "encoding/binary" |
| "fmt" |
| "hash/crc32" |
| "net" |
| |
| "github.com/google/gopacket" |
| ) |
| |
| // Dot11Flags contains the set of 8 flags in the IEEE 802.11 frame control |
| // header, all in one place. |
| type Dot11Flags uint8 |
| |
| const ( |
| Dot11FlagsToDS Dot11Flags = 1 << iota |
| Dot11FlagsFromDS |
| Dot11FlagsMF |
| Dot11FlagsRetry |
| Dot11FlagsPowerManagement |
| Dot11FlagsMD |
| Dot11FlagsWEP |
| Dot11FlagsOrder |
| ) |
| |
| func (d Dot11Flags) ToDS() bool { |
| return d&Dot11FlagsToDS != 0 |
| } |
| func (d Dot11Flags) FromDS() bool { |
| return d&Dot11FlagsFromDS != 0 |
| } |
| func (d Dot11Flags) MF() bool { |
| return d&Dot11FlagsMF != 0 |
| } |
| func (d Dot11Flags) Retry() bool { |
| return d&Dot11FlagsRetry != 0 |
| } |
| func (d Dot11Flags) PowerManagement() bool { |
| return d&Dot11FlagsPowerManagement != 0 |
| } |
| func (d Dot11Flags) MD() bool { |
| return d&Dot11FlagsMD != 0 |
| } |
| func (d Dot11Flags) WEP() bool { |
| return d&Dot11FlagsWEP != 0 |
| } |
| func (d Dot11Flags) Order() bool { |
| return d&Dot11FlagsOrder != 0 |
| } |
| |
| // String provides a human readable string for Dot11Flags. |
| // This string is possibly subject to change over time; if you're storing this |
| // persistently, you should probably store the Dot11Flags value, not its string. |
| func (a Dot11Flags) String() string { |
| var out bytes.Buffer |
| if a.ToDS() { |
| out.WriteString("TO-DS,") |
| } |
| if a.FromDS() { |
| out.WriteString("FROM-DS,") |
| } |
| if a.MF() { |
| out.WriteString("MF,") |
| } |
| if a.Retry() { |
| out.WriteString("Retry,") |
| } |
| if a.PowerManagement() { |
| out.WriteString("PowerManagement,") |
| } |
| if a.MD() { |
| out.WriteString("MD,") |
| } |
| if a.WEP() { |
| out.WriteString("WEP,") |
| } |
| if a.Order() { |
| out.WriteString("Order,") |
| } |
| |
| if length := out.Len(); length > 0 { |
| return string(out.Bytes()[:length-1]) // strip final comma |
| } |
| return "" |
| } |
| |
| type Dot11Reason uint16 |
| |
| // TODO: Verify these reasons, and append more reasons if necessary. |
| |
| const ( |
| Dot11ReasonReserved Dot11Reason = 1 |
| Dot11ReasonUnspecified Dot11Reason = 2 |
| Dot11ReasonAuthExpired Dot11Reason = 3 |
| Dot11ReasonDeauthStLeaving Dot11Reason = 4 |
| Dot11ReasonInactivity Dot11Reason = 5 |
| Dot11ReasonApFull Dot11Reason = 6 |
| Dot11ReasonClass2FromNonAuth Dot11Reason = 7 |
| Dot11ReasonClass3FromNonAss Dot11Reason = 8 |
| Dot11ReasonDisasStLeaving Dot11Reason = 9 |
| Dot11ReasonStNotAuth Dot11Reason = 10 |
| ) |
| |
| // String provides a human readable string for Dot11Reason. |
| // This string is possibly subject to change over time; if you're storing this |
| // persistently, you should probably store the Dot11Reason value, not its string. |
| func (a Dot11Reason) String() string { |
| switch a { |
| case Dot11ReasonReserved: |
| return "Reserved" |
| case Dot11ReasonUnspecified: |
| return "Unspecified" |
| case Dot11ReasonAuthExpired: |
| return "Auth. expired" |
| case Dot11ReasonDeauthStLeaving: |
| return "Deauth. st. leaving" |
| case Dot11ReasonInactivity: |
| return "Inactivity" |
| case Dot11ReasonApFull: |
| return "Ap. full" |
| case Dot11ReasonClass2FromNonAuth: |
| return "Class2 from non auth." |
| case Dot11ReasonClass3FromNonAss: |
| return "Class3 from non ass." |
| case Dot11ReasonDisasStLeaving: |
| return "Disass st. leaving" |
| case Dot11ReasonStNotAuth: |
| return "St. not auth." |
| default: |
| return "Unknown reason" |
| } |
| } |
| |
| type Dot11Status uint16 |
| |
| const ( |
| Dot11StatusSuccess Dot11Status = 0 |
| Dot11StatusFailure Dot11Status = 1 // Unspecified failure |
| Dot11StatusCannotSupportAllCapabilities Dot11Status = 10 // Cannot support all requested capabilities in the Capability Information field |
| Dot11StatusInabilityExistsAssociation Dot11Status = 11 // Reassociation denied due to inability to confirm that association exists |
| Dot11StatusAssociationDenied Dot11Status = 12 // Association denied due to reason outside the scope of this standard |
| Dot11StatusAlgorithmUnsupported Dot11Status = 13 // Responding station does not support the specified authentication algorithm |
| Dot11StatusOufOfExpectedSequence Dot11Status = 14 // Received an Authentication frame with authentication transaction sequence number out of expected sequence |
| Dot11StatusChallengeFailure Dot11Status = 15 // Authentication rejected because of challenge failure |
| Dot11StatusTimeout Dot11Status = 16 // Authentication rejected due to timeout waiting for next frame in sequence |
| Dot11StatusAPUnableToHandle Dot11Status = 17 // Association denied because AP is unable to handle additional associated stations |
| Dot11StatusRateUnsupported Dot11Status = 18 // Association denied due to requesting station not supporting all of the data rates in the BSSBasicRateSet parameter |
| ) |
| |
| // String provides a human readable string for Dot11Status. |
| // This string is possibly subject to change over time; if you're storing this |
| // persistently, you should probably store the Dot11Status value, not its string. |
| func (a Dot11Status) String() string { |
| switch a { |
| case Dot11StatusSuccess: |
| return "success" |
| case Dot11StatusFailure: |
| return "failure" |
| case Dot11StatusCannotSupportAllCapabilities: |
| return "cannot-support-all-capabilities" |
| case Dot11StatusInabilityExistsAssociation: |
| return "inability-exists-association" |
| case Dot11StatusAssociationDenied: |
| return "association-denied" |
| case Dot11StatusAlgorithmUnsupported: |
| return "algorithm-unsupported" |
| case Dot11StatusOufOfExpectedSequence: |
| return "out-of-expected-sequence" |
| case Dot11StatusChallengeFailure: |
| return "challenge-failure" |
| case Dot11StatusTimeout: |
| return "timeout" |
| case Dot11StatusAPUnableToHandle: |
| return "ap-unable-to-handle" |
| case Dot11StatusRateUnsupported: |
| return "rate-unsupported" |
| default: |
| return "unknown status" |
| } |
| } |
| |
| type Dot11AckPolicy uint8 |
| |
| const ( |
| Dot11AckPolicyNormal Dot11AckPolicy = 0 |
| Dot11AckPolicyNone Dot11AckPolicy = 1 |
| Dot11AckPolicyNoExplicit Dot11AckPolicy = 2 |
| Dot11AckPolicyBlock Dot11AckPolicy = 3 |
| ) |
| |
| // String provides a human readable string for Dot11AckPolicy. |
| // This string is possibly subject to change over time; if you're storing this |
| // persistently, you should probably store the Dot11AckPolicy value, not its string. |
| func (a Dot11AckPolicy) String() string { |
| switch a { |
| case Dot11AckPolicyNormal: |
| return "normal-ack" |
| case Dot11AckPolicyNone: |
| return "no-ack" |
| case Dot11AckPolicyNoExplicit: |
| return "no-explicit-ack" |
| case Dot11AckPolicyBlock: |
| return "block-ack" |
| default: |
| return "unknown-ack-policy" |
| } |
| } |
| |
| type Dot11Algorithm uint16 |
| |
| const ( |
| Dot11AlgorithmOpen Dot11Algorithm = 0 |
| Dot11AlgorithmSharedKey Dot11Algorithm = 1 |
| ) |
| |
| // String provides a human readable string for Dot11Algorithm. |
| // This string is possibly subject to change over time; if you're storing this |
| // persistently, you should probably store the Dot11Algorithm value, not its string. |
| func (a Dot11Algorithm) String() string { |
| switch a { |
| case Dot11AlgorithmOpen: |
| return "open" |
| case Dot11AlgorithmSharedKey: |
| return "shared-key" |
| default: |
| return "unknown-algorithm" |
| } |
| } |
| |
| type Dot11InformationElementID uint8 |
| |
| const ( |
| Dot11InformationElementIDSSID Dot11InformationElementID = 0 |
| Dot11InformationElementIDRates Dot11InformationElementID = 1 |
| Dot11InformationElementIDFHSet Dot11InformationElementID = 2 |
| Dot11InformationElementIDDSSet Dot11InformationElementID = 3 |
| Dot11InformationElementIDCFSet Dot11InformationElementID = 4 |
| Dot11InformationElementIDTIM Dot11InformationElementID = 5 |
| Dot11InformationElementIDIBSSSet Dot11InformationElementID = 6 |
| Dot11InformationElementIDCountryInfo Dot11InformationElementID = 7 |
| Dot11InformationElementIDHoppingPatternParam Dot11InformationElementID = 8 |
| Dot11InformationElementIDHoppingPatternTable Dot11InformationElementID = 9 |
| Dot11InformationElementIDRequest Dot11InformationElementID = 10 |
| Dot11InformationElementIDQBSSLoadElem Dot11InformationElementID = 11 |
| Dot11InformationElementIDEDCAParamSet Dot11InformationElementID = 12 |
| Dot11InformationElementIDTrafficSpec Dot11InformationElementID = 13 |
| Dot11InformationElementIDTrafficClass Dot11InformationElementID = 14 |
| Dot11InformationElementIDSchedule Dot11InformationElementID = 15 |
| Dot11InformationElementIDChallenge Dot11InformationElementID = 16 |
| Dot11InformationElementIDPowerConst Dot11InformationElementID = 32 |
| Dot11InformationElementIDPowerCapability Dot11InformationElementID = 33 |
| Dot11InformationElementIDTPCRequest Dot11InformationElementID = 34 |
| Dot11InformationElementIDTPCReport Dot11InformationElementID = 35 |
| Dot11InformationElementIDSupportedChannels Dot11InformationElementID = 36 |
| Dot11InformationElementIDSwitchChannelAnnounce Dot11InformationElementID = 37 |
| Dot11InformationElementIDMeasureRequest Dot11InformationElementID = 38 |
| Dot11InformationElementIDMeasureReport Dot11InformationElementID = 39 |
| Dot11InformationElementIDQuiet Dot11InformationElementID = 40 |
| Dot11InformationElementIDIBSSDFS Dot11InformationElementID = 41 |
| Dot11InformationElementIDERPInfo Dot11InformationElementID = 42 |
| Dot11InformationElementIDTSDelay Dot11InformationElementID = 43 |
| Dot11InformationElementIDTCLASProcessing Dot11InformationElementID = 44 |
| Dot11InformationElementIDHTCapabilities Dot11InformationElementID = 45 |
| Dot11InformationElementIDQOSCapability Dot11InformationElementID = 46 |
| Dot11InformationElementIDERPInfo2 Dot11InformationElementID = 47 |
| Dot11InformationElementIDRSNInfo Dot11InformationElementID = 48 |
| Dot11InformationElementIDESRates Dot11InformationElementID = 50 |
| Dot11InformationElementIDAPChannelReport Dot11InformationElementID = 51 |
| Dot11InformationElementIDNeighborReport Dot11InformationElementID = 52 |
| Dot11InformationElementIDRCPI Dot11InformationElementID = 53 |
| Dot11InformationElementIDMobilityDomain Dot11InformationElementID = 54 |
| Dot11InformationElementIDFastBSSTrans Dot11InformationElementID = 55 |
| Dot11InformationElementIDTimeoutInt Dot11InformationElementID = 56 |
| Dot11InformationElementIDRICData Dot11InformationElementID = 57 |
| Dot11InformationElementIDDSERegisteredLoc Dot11InformationElementID = 58 |
| Dot11InformationElementIDSuppOperatingClass Dot11InformationElementID = 59 |
| Dot11InformationElementIDExtChanSwitchAnnounce Dot11InformationElementID = 60 |
| Dot11InformationElementIDHTInfo Dot11InformationElementID = 61 |
| Dot11InformationElementIDSecChanOffset Dot11InformationElementID = 62 |
| Dot11InformationElementIDBSSAverageAccessDelay Dot11InformationElementID = 63 |
| Dot11InformationElementIDAntenna Dot11InformationElementID = 64 |
| Dot11InformationElementIDRSNI Dot11InformationElementID = 65 |
| Dot11InformationElementIDMeasurePilotTrans Dot11InformationElementID = 66 |
| Dot11InformationElementIDBSSAvailAdmCapacity Dot11InformationElementID = 67 |
| Dot11InformationElementIDBSSACAccDelayWAPIParam Dot11InformationElementID = 68 |
| Dot11InformationElementIDTimeAdvertisement Dot11InformationElementID = 69 |
| Dot11InformationElementIDRMEnabledCapabilities Dot11InformationElementID = 70 |
| Dot11InformationElementIDMultipleBSSID Dot11InformationElementID = 71 |
| Dot11InformationElementID2040BSSCoExist Dot11InformationElementID = 72 |
| Dot11InformationElementID2040BSSIntChanReport Dot11InformationElementID = 73 |
| Dot11InformationElementIDOverlapBSSScanParam Dot11InformationElementID = 74 |
| Dot11InformationElementIDRICDescriptor Dot11InformationElementID = 75 |
| Dot11InformationElementIDManagementMIC Dot11InformationElementID = 76 |
| Dot11InformationElementIDEventRequest Dot11InformationElementID = 78 |
| Dot11InformationElementIDEventReport Dot11InformationElementID = 79 |
| Dot11InformationElementIDDiagnosticRequest Dot11InformationElementID = 80 |
| Dot11InformationElementIDDiagnosticReport Dot11InformationElementID = 81 |
| Dot11InformationElementIDLocationParam Dot11InformationElementID = 82 |
| Dot11InformationElementIDNonTransBSSIDCapability Dot11InformationElementID = 83 |
| Dot11InformationElementIDSSIDList Dot11InformationElementID = 84 |
| Dot11InformationElementIDMultipleBSSIDIndex Dot11InformationElementID = 85 |
| Dot11InformationElementIDFMSDescriptor Dot11InformationElementID = 86 |
| Dot11InformationElementIDFMSRequest Dot11InformationElementID = 87 |
| Dot11InformationElementIDFMSResponse Dot11InformationElementID = 88 |
| Dot11InformationElementIDQOSTrafficCapability Dot11InformationElementID = 89 |
| Dot11InformationElementIDBSSMaxIdlePeriod Dot11InformationElementID = 90 |
| Dot11InformationElementIDTFSRequest Dot11InformationElementID = 91 |
| Dot11InformationElementIDTFSResponse Dot11InformationElementID = 92 |
| Dot11InformationElementIDWNMSleepMode Dot11InformationElementID = 93 |
| Dot11InformationElementIDTIMBroadcastRequest Dot11InformationElementID = 94 |
| Dot11InformationElementIDTIMBroadcastResponse Dot11InformationElementID = 95 |
| Dot11InformationElementIDCollInterferenceReport Dot11InformationElementID = 96 |
| Dot11InformationElementIDChannelUsage Dot11InformationElementID = 97 |
| Dot11InformationElementIDTimeZone Dot11InformationElementID = 98 |
| Dot11InformationElementIDDMSRequest Dot11InformationElementID = 99 |
| Dot11InformationElementIDDMSResponse Dot11InformationElementID = 100 |
| Dot11InformationElementIDLinkIdentifier Dot11InformationElementID = 101 |
| Dot11InformationElementIDWakeupSchedule Dot11InformationElementID = 102 |
| Dot11InformationElementIDChannelSwitchTiming Dot11InformationElementID = 104 |
| Dot11InformationElementIDPTIControl Dot11InformationElementID = 105 |
| Dot11InformationElementIDPUBufferStatus Dot11InformationElementID = 106 |
| Dot11InformationElementIDInterworking Dot11InformationElementID = 107 |
| Dot11InformationElementIDAdvertisementProtocol Dot11InformationElementID = 108 |
| Dot11InformationElementIDExpBWRequest Dot11InformationElementID = 109 |
| Dot11InformationElementIDQOSMapSet Dot11InformationElementID = 110 |
| Dot11InformationElementIDRoamingConsortium Dot11InformationElementID = 111 |
| Dot11InformationElementIDEmergencyAlertIdentifier Dot11InformationElementID = 112 |
| Dot11InformationElementIDMeshConfiguration Dot11InformationElementID = 113 |
| Dot11InformationElementIDMeshID Dot11InformationElementID = 114 |
| Dot11InformationElementIDMeshLinkMetricReport Dot11InformationElementID = 115 |
| Dot11InformationElementIDCongestionNotification Dot11InformationElementID = 116 |
| Dot11InformationElementIDMeshPeeringManagement Dot11InformationElementID = 117 |
| Dot11InformationElementIDMeshChannelSwitchParam Dot11InformationElementID = 118 |
| Dot11InformationElementIDMeshAwakeWindows Dot11InformationElementID = 119 |
| Dot11InformationElementIDBeaconTiming Dot11InformationElementID = 120 |
| Dot11InformationElementIDMCCAOPSetupRequest Dot11InformationElementID = 121 |
| Dot11InformationElementIDMCCAOPSetupReply Dot11InformationElementID = 122 |
| Dot11InformationElementIDMCCAOPAdvertisement Dot11InformationElementID = 123 |
| Dot11InformationElementIDMCCAOPTeardown Dot11InformationElementID = 124 |
| Dot11InformationElementIDGateAnnouncement Dot11InformationElementID = 125 |
| Dot11InformationElementIDRootAnnouncement Dot11InformationElementID = 126 |
| Dot11InformationElementIDExtCapability Dot11InformationElementID = 127 |
| Dot11InformationElementIDAgereProprietary Dot11InformationElementID = 128 |
| Dot11InformationElementIDPathRequest Dot11InformationElementID = 130 |
| Dot11InformationElementIDPathReply Dot11InformationElementID = 131 |
| Dot11InformationElementIDPathError Dot11InformationElementID = 132 |
| Dot11InformationElementIDCiscoCCX1CKIPDeviceName Dot11InformationElementID = 133 |
| Dot11InformationElementIDCiscoCCX2 Dot11InformationElementID = 136 |
| Dot11InformationElementIDProxyUpdate Dot11InformationElementID = 137 |
| Dot11InformationElementIDProxyUpdateConfirmation Dot11InformationElementID = 138 |
| Dot11InformationElementIDAuthMeshPerringExch Dot11InformationElementID = 139 |
| Dot11InformationElementIDMIC Dot11InformationElementID = 140 |
| Dot11InformationElementIDDestinationURI Dot11InformationElementID = 141 |
| Dot11InformationElementIDUAPSDCoexistence Dot11InformationElementID = 142 |
| Dot11InformationElementIDWakeupSchedule80211ad Dot11InformationElementID = 143 |
| Dot11InformationElementIDExtendedSchedule Dot11InformationElementID = 144 |
| Dot11InformationElementIDSTAAvailability Dot11InformationElementID = 145 |
| Dot11InformationElementIDDMGTSPEC Dot11InformationElementID = 146 |
| Dot11InformationElementIDNextDMGATI Dot11InformationElementID = 147 |
| Dot11InformationElementIDDMSCapabilities Dot11InformationElementID = 148 |
| Dot11InformationElementIDCiscoUnknown95 Dot11InformationElementID = 149 |
| Dot11InformationElementIDVendor2 Dot11InformationElementID = 150 |
| Dot11InformationElementIDDMGOperating Dot11InformationElementID = 151 |
| Dot11InformationElementIDDMGBSSParamChange Dot11InformationElementID = 152 |
| Dot11InformationElementIDDMGBeamRefinement Dot11InformationElementID = 153 |
| Dot11InformationElementIDChannelMeasFeedback Dot11InformationElementID = 154 |
| Dot11InformationElementIDAwakeWindow Dot11InformationElementID = 157 |
| Dot11InformationElementIDMultiBand Dot11InformationElementID = 158 |
| Dot11InformationElementIDADDBAExtension Dot11InformationElementID = 159 |
| Dot11InformationElementIDNEXTPCPList Dot11InformationElementID = 160 |
| Dot11InformationElementIDPCPHandover Dot11InformationElementID = 161 |
| Dot11InformationElementIDDMGLinkMargin Dot11InformationElementID = 162 |
| Dot11InformationElementIDSwitchingStream Dot11InformationElementID = 163 |
| Dot11InformationElementIDSessionTransmission Dot11InformationElementID = 164 |
| Dot11InformationElementIDDynamicTonePairReport Dot11InformationElementID = 165 |
| Dot11InformationElementIDClusterReport Dot11InformationElementID = 166 |
| Dot11InformationElementIDRelayCapabilities Dot11InformationElementID = 167 |
| Dot11InformationElementIDRelayTransferParameter Dot11InformationElementID = 168 |
| Dot11InformationElementIDBeamlinkMaintenance Dot11InformationElementID = 169 |
| Dot11InformationElementIDMultipleMacSublayers Dot11InformationElementID = 170 |
| Dot11InformationElementIDUPID Dot11InformationElementID = 171 |
| Dot11InformationElementIDDMGLinkAdaptionAck Dot11InformationElementID = 172 |
| Dot11InformationElementIDSymbolProprietary Dot11InformationElementID = 173 |
| Dot11InformationElementIDMCCAOPAdvertOverview Dot11InformationElementID = 174 |
| Dot11InformationElementIDQuietPeriodRequest Dot11InformationElementID = 175 |
| Dot11InformationElementIDQuietPeriodResponse Dot11InformationElementID = 177 |
| Dot11InformationElementIDECPACPolicy Dot11InformationElementID = 182 |
| Dot11InformationElementIDClusterTimeOffset Dot11InformationElementID = 183 |
| Dot11InformationElementIDAntennaSectorID Dot11InformationElementID = 190 |
| Dot11InformationElementIDVHTCapabilities Dot11InformationElementID = 191 |
| Dot11InformationElementIDVHTOperation Dot11InformationElementID = 192 |
| Dot11InformationElementIDExtendedBSSLoad Dot11InformationElementID = 193 |
| Dot11InformationElementIDWideBWChannelSwitch Dot11InformationElementID = 194 |
| Dot11InformationElementIDVHTTxPowerEnvelope Dot11InformationElementID = 195 |
| Dot11InformationElementIDChannelSwitchWrapper Dot11InformationElementID = 196 |
| Dot11InformationElementIDOperatingModeNotification Dot11InformationElementID = 199 |
| Dot11InformationElementIDUPSIM Dot11InformationElementID = 200 |
| Dot11InformationElementIDReducedNeighborReport Dot11InformationElementID = 201 |
| Dot11InformationElementIDTVHTOperation Dot11InformationElementID = 202 |
| Dot11InformationElementIDDeviceLocation Dot11InformationElementID = 204 |
| Dot11InformationElementIDWhiteSpaceMap Dot11InformationElementID = 205 |
| Dot11InformationElementIDFineTuningMeasureParams Dot11InformationElementID = 206 |
| Dot11InformationElementIDVendor Dot11InformationElementID = 221 |
| ) |
| |
| // String provides a human readable string for Dot11InformationElementID. |
| // This string is possibly subject to change over time; if you're storing this |
| // persistently, you should probably store the Dot11InformationElementID value, |
| // not its string. |
| func (a Dot11InformationElementID) String() string { |
| switch a { |
| case Dot11InformationElementIDSSID: |
| return "SSID parameter set" |
| case Dot11InformationElementIDRates: |
| return "Supported Rates" |
| case Dot11InformationElementIDFHSet: |
| return "FH Parameter set" |
| case Dot11InformationElementIDDSSet: |
| return "DS Parameter set" |
| case Dot11InformationElementIDCFSet: |
| return "CF Parameter set" |
| case Dot11InformationElementIDTIM: |
| return "Traffic Indication Map (TIM)" |
| case Dot11InformationElementIDIBSSSet: |
| return "IBSS Parameter set" |
| case Dot11InformationElementIDCountryInfo: |
| return "Country Information" |
| case Dot11InformationElementIDHoppingPatternParam: |
| return "Hopping Pattern Parameters" |
| case Dot11InformationElementIDHoppingPatternTable: |
| return "Hopping Pattern Table" |
| case Dot11InformationElementIDRequest: |
| return "Request" |
| case Dot11InformationElementIDQBSSLoadElem: |
| return "QBSS Load Element" |
| case Dot11InformationElementIDEDCAParamSet: |
| return "EDCA Parameter Set" |
| case Dot11InformationElementIDTrafficSpec: |
| return "Traffic Specification" |
| case Dot11InformationElementIDTrafficClass: |
| return "Traffic Classification" |
| case Dot11InformationElementIDSchedule: |
| return "Schedule" |
| case Dot11InformationElementIDChallenge: |
| return "Challenge text" |
| case Dot11InformationElementIDPowerConst: |
| return "Power Constraint" |
| case Dot11InformationElementIDPowerCapability: |
| return "Power Capability" |
| case Dot11InformationElementIDTPCRequest: |
| return "TPC Request" |
| case Dot11InformationElementIDTPCReport: |
| return "TPC Report" |
| case Dot11InformationElementIDSupportedChannels: |
| return "Supported Channels" |
| case Dot11InformationElementIDSwitchChannelAnnounce: |
| return "Channel Switch Announcement" |
| case Dot11InformationElementIDMeasureRequest: |
| return "Measurement Request" |
| case Dot11InformationElementIDMeasureReport: |
| return "Measurement Report" |
| case Dot11InformationElementIDQuiet: |
| return "Quiet" |
| case Dot11InformationElementIDIBSSDFS: |
| return "IBSS DFS" |
| case Dot11InformationElementIDERPInfo: |
| return "ERP Information" |
| case Dot11InformationElementIDTSDelay: |
| return "TS Delay" |
| case Dot11InformationElementIDTCLASProcessing: |
| return "TCLAS Processing" |
| case Dot11InformationElementIDHTCapabilities: |
| return "HT Capabilities (802.11n D1.10)" |
| case Dot11InformationElementIDQOSCapability: |
| return "QOS Capability" |
| case Dot11InformationElementIDERPInfo2: |
| return "ERP Information-2" |
| case Dot11InformationElementIDRSNInfo: |
| return "RSN Information" |
| case Dot11InformationElementIDESRates: |
| return "Extended Supported Rates" |
| case Dot11InformationElementIDAPChannelReport: |
| return "AP Channel Report" |
| case Dot11InformationElementIDNeighborReport: |
| return "Neighbor Report" |
| case Dot11InformationElementIDRCPI: |
| return "RCPI" |
| case Dot11InformationElementIDMobilityDomain: |
| return "Mobility Domain" |
| case Dot11InformationElementIDFastBSSTrans: |
| return "Fast BSS Transition" |
| case Dot11InformationElementIDTimeoutInt: |
| return "Timeout Interval" |
| case Dot11InformationElementIDRICData: |
| return "RIC Data" |
| case Dot11InformationElementIDDSERegisteredLoc: |
| return "DSE Registered Location" |
| case Dot11InformationElementIDSuppOperatingClass: |
| return "Supported Operating Classes" |
| case Dot11InformationElementIDExtChanSwitchAnnounce: |
| return "Extended Channel Switch Announcement" |
| case Dot11InformationElementIDHTInfo: |
| return "HT Information (802.11n D1.10)" |
| case Dot11InformationElementIDSecChanOffset: |
| return "Secondary Channel Offset (802.11n D1.10)" |
| case Dot11InformationElementIDBSSAverageAccessDelay: |
| return "BSS Average Access Delay" |
| case Dot11InformationElementIDAntenna: |
| return "Antenna" |
| case Dot11InformationElementIDRSNI: |
| return "RSNI" |
| case Dot11InformationElementIDMeasurePilotTrans: |
| return "Measurement Pilot Transmission" |
| case Dot11InformationElementIDBSSAvailAdmCapacity: |
| return "BSS Available Admission Capacity" |
| case Dot11InformationElementIDBSSACAccDelayWAPIParam: |
| return "BSS AC Access Delay/WAPI Parameter Set" |
| case Dot11InformationElementIDTimeAdvertisement: |
| return "Time Advertisement" |
| case Dot11InformationElementIDRMEnabledCapabilities: |
| return "RM Enabled Capabilities" |
| case Dot11InformationElementIDMultipleBSSID: |
| return "Multiple BSSID" |
| case Dot11InformationElementID2040BSSCoExist: |
| return "20/40 BSS Coexistence" |
| case Dot11InformationElementID2040BSSIntChanReport: |
| return "20/40 BSS Intolerant Channel Report" |
| case Dot11InformationElementIDOverlapBSSScanParam: |
| return "Overlapping BSS Scan Parameters" |
| case Dot11InformationElementIDRICDescriptor: |
| return "RIC Descriptor" |
| case Dot11InformationElementIDManagementMIC: |
| return "Management MIC" |
| case Dot11InformationElementIDEventRequest: |
| return "Event Request" |
| case Dot11InformationElementIDEventReport: |
| return "Event Report" |
| case Dot11InformationElementIDDiagnosticRequest: |
| return "Diagnostic Request" |
| case Dot11InformationElementIDDiagnosticReport: |
| return "Diagnostic Report" |
| case Dot11InformationElementIDLocationParam: |
| return "Location Parameters" |
| case Dot11InformationElementIDNonTransBSSIDCapability: |
| return "Non Transmitted BSSID Capability" |
| case Dot11InformationElementIDSSIDList: |
| return "SSID List" |
| case Dot11InformationElementIDMultipleBSSIDIndex: |
| return "Multiple BSSID Index" |
| case Dot11InformationElementIDFMSDescriptor: |
| return "FMS Descriptor" |
| case Dot11InformationElementIDFMSRequest: |
| return "FMS Request" |
| case Dot11InformationElementIDFMSResponse: |
| return "FMS Response" |
| case Dot11InformationElementIDQOSTrafficCapability: |
| return "QoS Traffic Capability" |
| case Dot11InformationElementIDBSSMaxIdlePeriod: |
| return "BSS Max Idle Period" |
| case Dot11InformationElementIDTFSRequest: |
| return "TFS Request" |
| case Dot11InformationElementIDTFSResponse: |
| return "TFS Response" |
| case Dot11InformationElementIDWNMSleepMode: |
| return "WNM-Sleep Mode" |
| case Dot11InformationElementIDTIMBroadcastRequest: |
| return "TIM Broadcast Request" |
| case Dot11InformationElementIDTIMBroadcastResponse: |
| return "TIM Broadcast Response" |
| case Dot11InformationElementIDCollInterferenceReport: |
| return "Collocated Interference Report" |
| case Dot11InformationElementIDChannelUsage: |
| return "Channel Usage" |
| case Dot11InformationElementIDTimeZone: |
| return "Time Zone" |
| case Dot11InformationElementIDDMSRequest: |
| return "DMS Request" |
| case Dot11InformationElementIDDMSResponse: |
| return "DMS Response" |
| case Dot11InformationElementIDLinkIdentifier: |
| return "Link Identifier" |
| case Dot11InformationElementIDWakeupSchedule: |
| return "Wakeup Schedule" |
| case Dot11InformationElementIDChannelSwitchTiming: |
| return "Channel Switch Timing" |
| case Dot11InformationElementIDPTIControl: |
| return "PTI Control" |
| case Dot11InformationElementIDPUBufferStatus: |
| return "PU Buffer Status" |
| case Dot11InformationElementIDInterworking: |
| return "Interworking" |
| case Dot11InformationElementIDAdvertisementProtocol: |
| return "Advertisement Protocol" |
| case Dot11InformationElementIDExpBWRequest: |
| return "Expedited Bandwidth Request" |
| case Dot11InformationElementIDQOSMapSet: |
| return "QoS Map Set" |
| case Dot11InformationElementIDRoamingConsortium: |
| return "Roaming Consortium" |
| case Dot11InformationElementIDEmergencyAlertIdentifier: |
| return "Emergency Alert Identifier" |
| case Dot11InformationElementIDMeshConfiguration: |
| return "Mesh Configuration" |
| case Dot11InformationElementIDMeshID: |
| return "Mesh ID" |
| case Dot11InformationElementIDMeshLinkMetricReport: |
| return "Mesh Link Metric Report" |
| case Dot11InformationElementIDCongestionNotification: |
| return "Congestion Notification" |
| case Dot11InformationElementIDMeshPeeringManagement: |
| return "Mesh Peering Management" |
| case Dot11InformationElementIDMeshChannelSwitchParam: |
| return "Mesh Channel Switch Parameters" |
| case Dot11InformationElementIDMeshAwakeWindows: |
| return "Mesh Awake Windows" |
| case Dot11InformationElementIDBeaconTiming: |
| return "Beacon Timing" |
| case Dot11InformationElementIDMCCAOPSetupRequest: |
| return "MCCAOP Setup Request" |
| case Dot11InformationElementIDMCCAOPSetupReply: |
| return "MCCAOP SETUP Reply" |
| case Dot11InformationElementIDMCCAOPAdvertisement: |
| return "MCCAOP Advertisement" |
| case Dot11InformationElementIDMCCAOPTeardown: |
| return "MCCAOP Teardown" |
| case Dot11InformationElementIDGateAnnouncement: |
| return "Gate Announcement" |
| case Dot11InformationElementIDRootAnnouncement: |
| return "Root Announcement" |
| case Dot11InformationElementIDExtCapability: |
| return "Extended Capabilities" |
| case Dot11InformationElementIDAgereProprietary: |
| return "Agere Proprietary" |
| case Dot11InformationElementIDPathRequest: |
| return "Path Request" |
| case Dot11InformationElementIDPathReply: |
| return "Path Reply" |
| case Dot11InformationElementIDPathError: |
| return "Path Error" |
| case Dot11InformationElementIDCiscoCCX1CKIPDeviceName: |
| return "Cisco CCX1 CKIP + Device Name" |
| case Dot11InformationElementIDCiscoCCX2: |
| return "Cisco CCX2" |
| case Dot11InformationElementIDProxyUpdate: |
| return "Proxy Update" |
| case Dot11InformationElementIDProxyUpdateConfirmation: |
| return "Proxy Update Confirmation" |
| case Dot11InformationElementIDAuthMeshPerringExch: |
| return "Auhenticated Mesh Perring Exchange" |
| case Dot11InformationElementIDMIC: |
| return "MIC (Message Integrity Code)" |
| case Dot11InformationElementIDDestinationURI: |
| return "Destination URI" |
| case Dot11InformationElementIDUAPSDCoexistence: |
| return "U-APSD Coexistence" |
| case Dot11InformationElementIDWakeupSchedule80211ad: |
| return "Wakeup Schedule 802.11ad" |
| case Dot11InformationElementIDExtendedSchedule: |
| return "Extended Schedule" |
| case Dot11InformationElementIDSTAAvailability: |
| return "STA Availability" |
| case Dot11InformationElementIDDMGTSPEC: |
| return "DMG TSPEC" |
| case Dot11InformationElementIDNextDMGATI: |
| return "Next DMG ATI" |
| case Dot11InformationElementIDDMSCapabilities: |
| return "DMG Capabilities" |
| case Dot11InformationElementIDCiscoUnknown95: |
| return "Cisco Unknown 95" |
| case Dot11InformationElementIDVendor2: |
| return "Vendor Specific" |
| case Dot11InformationElementIDDMGOperating: |
| return "DMG Operating" |
| case Dot11InformationElementIDDMGBSSParamChange: |
| return "DMG BSS Parameter Change" |
| case Dot11InformationElementIDDMGBeamRefinement: |
| return "DMG Beam Refinement" |
| case Dot11InformationElementIDChannelMeasFeedback: |
| return "Channel Measurement Feedback" |
| case Dot11InformationElementIDAwakeWindow: |
| return "Awake Window" |
| case Dot11InformationElementIDMultiBand: |
| return "Multi Band" |
| case Dot11InformationElementIDADDBAExtension: |
| return "ADDBA Extension" |
| case Dot11InformationElementIDNEXTPCPList: |
| return "NEXTPCP List" |
| case Dot11InformationElementIDPCPHandover: |
| return "PCP Handover" |
| case Dot11InformationElementIDDMGLinkMargin: |
| return "DMG Link Margin" |
| case Dot11InformationElementIDSwitchingStream: |
| return "Switching Stream" |
| case Dot11InformationElementIDSessionTransmission: |
| return "Session Transmission" |
| case Dot11InformationElementIDDynamicTonePairReport: |
| return "Dynamic Tone Pairing Report" |
| case Dot11InformationElementIDClusterReport: |
| return "Cluster Report" |
| case Dot11InformationElementIDRelayCapabilities: |
| return "Relay Capabilities" |
| case Dot11InformationElementIDRelayTransferParameter: |
| return "Relay Transfer Parameter" |
| case Dot11InformationElementIDBeamlinkMaintenance: |
| return "Beamlink Maintenance" |
| case Dot11InformationElementIDMultipleMacSublayers: |
| return "Multiple MAC Sublayers" |
| case Dot11InformationElementIDUPID: |
| return "U-PID" |
| case Dot11InformationElementIDDMGLinkAdaptionAck: |
| return "DMG Link Adaption Acknowledgment" |
| case Dot11InformationElementIDSymbolProprietary: |
| return "Symbol Proprietary" |
| case Dot11InformationElementIDMCCAOPAdvertOverview: |
| return "MCCAOP Advertisement Overview" |
| case Dot11InformationElementIDQuietPeriodRequest: |
| return "Quiet Period Request" |
| case Dot11InformationElementIDQuietPeriodResponse: |
| return "Quiet Period Response" |
| case Dot11InformationElementIDECPACPolicy: |
| return "ECPAC Policy" |
| case Dot11InformationElementIDClusterTimeOffset: |
| return "Cluster Time Offset" |
| case Dot11InformationElementIDAntennaSectorID: |
| return "Antenna Sector ID" |
| case Dot11InformationElementIDVHTCapabilities: |
| return "VHT Capabilities (IEEE Std 802.11ac/D3.1)" |
| case Dot11InformationElementIDVHTOperation: |
| return "VHT Operation (IEEE Std 802.11ac/D3.1)" |
| case Dot11InformationElementIDExtendedBSSLoad: |
| return "Extended BSS Load" |
| case Dot11InformationElementIDWideBWChannelSwitch: |
| return "Wide Bandwidth Channel Switch" |
| case Dot11InformationElementIDVHTTxPowerEnvelope: |
| return "VHT Tx Power Envelope (IEEE Std 802.11ac/D5.0)" |
| case Dot11InformationElementIDChannelSwitchWrapper: |
| return "Channel Switch Wrapper" |
| case Dot11InformationElementIDOperatingModeNotification: |
| return "Operating Mode Notification" |
| case Dot11InformationElementIDUPSIM: |
| return "UP SIM" |
| case Dot11InformationElementIDReducedNeighborReport: |
| return "Reduced Neighbor Report" |
| case Dot11InformationElementIDTVHTOperation: |
| return "TVHT Op" |
| case Dot11InformationElementIDDeviceLocation: |
| return "Device Location" |
| case Dot11InformationElementIDWhiteSpaceMap: |
| return "White Space Map" |
| case Dot11InformationElementIDFineTuningMeasureParams: |
| return "Fine Tuning Measure Parameters" |
| case Dot11InformationElementIDVendor: |
| return "Vendor" |
| default: |
| return "Unknown information element id" |
| } |
| } |
| |
| // Dot11 provides an IEEE 802.11 base packet header. |
| // See http://standards.ieee.org/findstds/standard/802.11-2012.html |
| // for excruciating detail. |
| type Dot11 struct { |
| BaseLayer |
| Type Dot11Type |
| Proto uint8 |
| Flags Dot11Flags |
| DurationID uint16 |
| Address1 net.HardwareAddr |
| Address2 net.HardwareAddr |
| Address3 net.HardwareAddr |
| Address4 net.HardwareAddr |
| SequenceNumber uint16 |
| FragmentNumber uint16 |
| Checksum uint32 |
| QOS *Dot11QOS |
| HTControl *Dot11HTControl |
| DataLayer gopacket.Layer |
| } |
| |
| type Dot11QOS struct { |
| TID uint8 /* Traffic IDentifier */ |
| EOSP bool /* End of service period */ |
| AckPolicy Dot11AckPolicy |
| TXOP uint8 |
| } |
| |
| type Dot11HTControl struct { |
| ACConstraint bool |
| RDGMorePPDU bool |
| |
| VHT *Dot11HTControlVHT |
| HT *Dot11HTControlHT |
| } |
| |
| type Dot11HTControlHT struct { |
| LinkAdapationControl *Dot11LinkAdapationControl |
| CalibrationPosition uint8 |
| CalibrationSequence uint8 |
| CSISteering uint8 |
| NDPAnnouncement bool |
| DEI bool |
| } |
| |
| type Dot11HTControlVHT struct { |
| MRQ bool |
| UnsolicitedMFB bool |
| MSI *uint8 |
| MFB Dot11HTControlMFB |
| CompressedMSI *uint8 |
| STBCIndication bool |
| MFSI *uint8 |
| GID *uint8 |
| CodingType *Dot11CodingType |
| FbTXBeamformed bool |
| } |
| |
| type Dot11HTControlMFB struct { |
| NumSTS uint8 |
| VHTMCS uint8 |
| BW uint8 |
| SNR int8 |
| } |
| |
| type Dot11LinkAdapationControl struct { |
| TRQ bool |
| MRQ bool |
| MSI uint8 |
| MFSI uint8 |
| ASEL *Dot11ASEL |
| MFB *uint8 |
| } |
| |
| type Dot11ASEL struct { |
| Command uint8 |
| Data uint8 |
| } |
| |
| type Dot11CodingType uint8 |
| |
| const ( |
| Dot11CodingTypeBCC = 0 |
| Dot11CodingTypeLDPC = 1 |
| ) |
| |
| func (a Dot11CodingType) String() string { |
| switch a { |
| case Dot11CodingTypeBCC: |
| return "BCC" |
| case Dot11CodingTypeLDPC: |
| return "LDPC" |
| default: |
| return "Unknown coding type" |
| } |
| } |
| |
| func (m *Dot11HTControlMFB) NoFeedBackPresent() bool { |
| return m.VHTMCS == 15 && m.NumSTS == 7 |
| } |
| |
| func decodeDot11(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11{} |
| err := d.DecodeFromBytes(data, p) |
| if err != nil { |
| return err |
| } |
| p.AddLayer(d) |
| if d.DataLayer != nil { |
| p.AddLayer(d.DataLayer) |
| } |
| return p.NextDecoder(d.NextLayerType()) |
| } |
| |
| func (m *Dot11) LayerType() gopacket.LayerType { return LayerTypeDot11 } |
| func (m *Dot11) CanDecode() gopacket.LayerClass { return LayerTypeDot11 } |
| func (m *Dot11) NextLayerType() gopacket.LayerType { |
| if m.DataLayer != nil { |
| if m.Flags.WEP() { |
| return LayerTypeDot11WEP |
| } |
| return m.DataLayer.(gopacket.DecodingLayer).NextLayerType() |
| } |
| return m.Type.LayerType() |
| } |
| |
| func createU8(x uint8) *uint8 { |
| return &x |
| } |
| |
| var dataDecodeMap = map[Dot11Type]func() gopacket.DecodingLayer{ |
| Dot11TypeData: func() gopacket.DecodingLayer { return &Dot11Data{} }, |
| Dot11TypeDataCFAck: func() gopacket.DecodingLayer { return &Dot11DataCFAck{} }, |
| Dot11TypeDataCFPoll: func() gopacket.DecodingLayer { return &Dot11DataCFPoll{} }, |
| Dot11TypeDataCFAckPoll: func() gopacket.DecodingLayer { return &Dot11DataCFAckPoll{} }, |
| Dot11TypeDataNull: func() gopacket.DecodingLayer { return &Dot11DataNull{} }, |
| Dot11TypeDataCFAckNoData: func() gopacket.DecodingLayer { return &Dot11DataCFAckNoData{} }, |
| Dot11TypeDataCFPollNoData: func() gopacket.DecodingLayer { return &Dot11DataCFPollNoData{} }, |
| Dot11TypeDataCFAckPollNoData: func() gopacket.DecodingLayer { return &Dot11DataCFAckPollNoData{} }, |
| Dot11TypeDataQOSData: func() gopacket.DecodingLayer { return &Dot11DataQOSData{} }, |
| Dot11TypeDataQOSDataCFAck: func() gopacket.DecodingLayer { return &Dot11DataQOSDataCFAck{} }, |
| Dot11TypeDataQOSDataCFPoll: func() gopacket.DecodingLayer { return &Dot11DataQOSDataCFPoll{} }, |
| Dot11TypeDataQOSDataCFAckPoll: func() gopacket.DecodingLayer { return &Dot11DataQOSDataCFAckPoll{} }, |
| Dot11TypeDataQOSNull: func() gopacket.DecodingLayer { return &Dot11DataQOSNull{} }, |
| Dot11TypeDataQOSCFPollNoData: func() gopacket.DecodingLayer { return &Dot11DataQOSCFPollNoData{} }, |
| Dot11TypeDataQOSCFAckPollNoData: func() gopacket.DecodingLayer { return &Dot11DataQOSCFAckPollNoData{} }, |
| } |
| |
| func (m *Dot11) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 10 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11 length %v too short, %v required", len(data), 10) |
| } |
| m.Type = Dot11Type((data[0])&0xFC) >> 2 |
| |
| m.Proto = uint8(data[0]) & 0x0003 |
| m.Flags = Dot11Flags(data[1]) |
| m.DurationID = binary.LittleEndian.Uint16(data[2:4]) |
| m.Address1 = net.HardwareAddr(data[4:10]) |
| |
| offset := 10 |
| |
| mainType := m.Type.MainType() |
| |
| switch mainType { |
| case Dot11TypeCtrl: |
| switch m.Type { |
| case Dot11TypeCtrlRTS, Dot11TypeCtrlPowersavePoll, Dot11TypeCtrlCFEnd, Dot11TypeCtrlCFEndAck: |
| if len(data) < offset+6 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+6) |
| } |
| m.Address2 = net.HardwareAddr(data[offset : offset+6]) |
| offset += 6 |
| } |
| case Dot11TypeMgmt, Dot11TypeData: |
| if len(data) < offset+14 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+14) |
| } |
| m.Address2 = net.HardwareAddr(data[offset : offset+6]) |
| offset += 6 |
| m.Address3 = net.HardwareAddr(data[offset : offset+6]) |
| offset += 6 |
| |
| m.SequenceNumber = (binary.LittleEndian.Uint16(data[offset:offset+2]) & 0xFFF0) >> 4 |
| m.FragmentNumber = (binary.LittleEndian.Uint16(data[offset:offset+2]) & 0x000F) |
| offset += 2 |
| } |
| |
| if mainType == Dot11TypeData && m.Flags.FromDS() && m.Flags.ToDS() { |
| if len(data) < offset+6 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+6) |
| } |
| m.Address4 = net.HardwareAddr(data[offset : offset+6]) |
| offset += 6 |
| } |
| |
| if m.Type.QOS() { |
| if len(data) < offset+2 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+6) |
| } |
| m.QOS = &Dot11QOS{ |
| TID: (uint8(data[offset]) & 0x0F), |
| EOSP: (uint8(data[offset]) & 0x10) == 0x10, |
| AckPolicy: Dot11AckPolicy((uint8(data[offset]) & 0x60) >> 5), |
| TXOP: uint8(data[offset+1]), |
| } |
| offset += 2 |
| } |
| if m.Flags.Order() && (m.Type.QOS() || mainType == Dot11TypeMgmt) { |
| if len(data) < offset+4 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+6) |
| } |
| |
| htc := &Dot11HTControl{ |
| ACConstraint: data[offset+3]&0x40 != 0, |
| RDGMorePPDU: data[offset+3]&0x80 != 0, |
| } |
| m.HTControl = htc |
| |
| if data[offset]&0x1 != 0 { // VHT Variant |
| vht := &Dot11HTControlVHT{} |
| htc.VHT = vht |
| vht.MRQ = data[offset]&0x4 != 0 |
| vht.UnsolicitedMFB = data[offset+3]&0x20 != 0 |
| vht.MFB = Dot11HTControlMFB{ |
| NumSTS: uint8(data[offset+1] >> 1 & 0x7), |
| VHTMCS: uint8(data[offset+1] >> 4 & 0xF), |
| BW: uint8(data[offset+2] & 0x3), |
| SNR: int8((-(data[offset+2] >> 2 & 0x20))+data[offset+2]>>2&0x1F) + 22, |
| } |
| |
| if vht.UnsolicitedMFB { |
| if !vht.MFB.NoFeedBackPresent() { |
| vht.CompressedMSI = createU8(data[offset] >> 3 & 0x3) |
| vht.STBCIndication = data[offset]&0x20 != 0 |
| vht.CodingType = (*Dot11CodingType)(createU8(data[offset+3] >> 3 & 0x1)) |
| vht.FbTXBeamformed = data[offset+3]&0x10 != 0 |
| vht.GID = createU8( |
| data[offset]>>6 + |
| (data[offset+1] & 0x1 << 2) + |
| data[offset+3]&0x7<<3) |
| } |
| } else { |
| if vht.MRQ { |
| vht.MSI = createU8((data[offset] >> 3) & 0x07) |
| } |
| vht.MFSI = createU8(data[offset]>>6 + (data[offset+1] & 0x1 << 2)) |
| } |
| |
| } else { // HT Variant |
| ht := &Dot11HTControlHT{} |
| htc.HT = ht |
| |
| lac := &Dot11LinkAdapationControl{} |
| ht.LinkAdapationControl = lac |
| lac.TRQ = data[offset]&0x2 != 0 |
| lac.MFSI = data[offset]>>6&0x3 + data[offset+1]&0x1<<3 |
| if data[offset]&0x3C == 0x38 { // ASEL |
| lac.ASEL = &Dot11ASEL{ |
| Command: data[offset+1] >> 1 & 0x7, |
| Data: data[offset+1] >> 4 & 0xF, |
| } |
| } else { |
| lac.MRQ = data[offset]&0x4 != 0 |
| if lac.MRQ { |
| lac.MSI = data[offset] >> 3 & 0x7 |
| } |
| lac.MFB = createU8(data[offset+1] >> 1) |
| } |
| ht.CalibrationPosition = data[offset+2] & 0x3 |
| ht.CalibrationSequence = data[offset+2] >> 2 & 0x3 |
| ht.CSISteering = data[offset+2] >> 6 & 0x3 |
| ht.NDPAnnouncement = data[offset+3]&0x1 != 0 |
| if mainType != Dot11TypeMgmt { |
| ht.DEI = data[offset+3]&0x20 != 0 |
| } |
| } |
| |
| offset += 4 |
| } |
| |
| if len(data) < offset+4 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+4) |
| } |
| |
| m.BaseLayer = BaseLayer{ |
| Contents: data[0:offset], |
| Payload: data[offset : len(data)-4], |
| } |
| |
| if mainType == Dot11TypeData { |
| l := dataDecodeMap[m.Type]() |
| err := l.DecodeFromBytes(m.BaseLayer.Payload, df) |
| if err != nil { |
| return err |
| } |
| m.DataLayer = l.(gopacket.Layer) |
| } |
| |
| m.Checksum = binary.LittleEndian.Uint32(data[len(data)-4 : len(data)]) |
| return nil |
| } |
| |
| func (m *Dot11) ChecksumValid() bool { |
| // only for CTRL and MGMT frames |
| h := crc32.NewIEEE() |
| h.Write(m.Contents) |
| h.Write(m.Payload) |
| return m.Checksum == h.Sum32() |
| } |
| |
| func (m Dot11) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(24) |
| |
| if err != nil { |
| return err |
| } |
| |
| buf[0] = (uint8(m.Type) << 2) | m.Proto |
| buf[1] = uint8(m.Flags) |
| |
| binary.LittleEndian.PutUint16(buf[2:4], m.DurationID) |
| |
| copy(buf[4:10], m.Address1) |
| |
| offset := 10 |
| |
| switch m.Type.MainType() { |
| case Dot11TypeCtrl: |
| switch m.Type { |
| case Dot11TypeCtrlRTS, Dot11TypeCtrlPowersavePoll, Dot11TypeCtrlCFEnd, Dot11TypeCtrlCFEndAck: |
| copy(buf[offset:offset+6], m.Address2) |
| offset += 6 |
| } |
| case Dot11TypeMgmt, Dot11TypeData: |
| copy(buf[offset:offset+6], m.Address2) |
| offset += 6 |
| copy(buf[offset:offset+6], m.Address3) |
| offset += 6 |
| |
| binary.LittleEndian.PutUint16(buf[offset:offset+2], (m.SequenceNumber<<4)|m.FragmentNumber) |
| offset += 2 |
| } |
| |
| if m.Type.MainType() == Dot11TypeData && m.Flags.FromDS() && m.Flags.ToDS() { |
| copy(buf[offset:offset+6], m.Address4) |
| offset += 6 |
| } |
| |
| return nil |
| } |
| |
| // Dot11Mgmt is a base for all IEEE 802.11 management layers. |
| type Dot11Mgmt struct { |
| BaseLayer |
| } |
| |
| func (m *Dot11Mgmt) NextLayerType() gopacket.LayerType { return gopacket.LayerTypePayload } |
| func (m *Dot11Mgmt) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| m.Contents = data |
| return nil |
| } |
| |
| // Dot11Ctrl is a base for all IEEE 802.11 control layers. |
| type Dot11Ctrl struct { |
| BaseLayer |
| } |
| |
| func (m *Dot11Ctrl) NextLayerType() gopacket.LayerType { return gopacket.LayerTypePayload } |
| |
| func (m *Dot11Ctrl) LayerType() gopacket.LayerType { return LayerTypeDot11Ctrl } |
| func (m *Dot11Ctrl) CanDecode() gopacket.LayerClass { return LayerTypeDot11Ctrl } |
| func (m *Dot11Ctrl) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| m.Contents = data |
| return nil |
| } |
| |
| func decodeDot11Ctrl(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11Ctrl{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| // Dot11WEP contains WEP encrpted IEEE 802.11 data. |
| type Dot11WEP struct { |
| BaseLayer |
| } |
| |
| func (m *Dot11WEP) NextLayerType() gopacket.LayerType { return gopacket.LayerTypePayload } |
| |
| func (m *Dot11WEP) LayerType() gopacket.LayerType { return LayerTypeDot11WEP } |
| func (m *Dot11WEP) CanDecode() gopacket.LayerClass { return LayerTypeDot11WEP } |
| func (m *Dot11WEP) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| m.Contents = data |
| return nil |
| } |
| |
| func decodeDot11WEP(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11WEP{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| // Dot11Data is a base for all IEEE 802.11 data layers. |
| type Dot11Data struct { |
| BaseLayer |
| } |
| |
| func (m *Dot11Data) NextLayerType() gopacket.LayerType { |
| return LayerTypeLLC |
| } |
| |
| func (m *Dot11Data) LayerType() gopacket.LayerType { return LayerTypeDot11Data } |
| func (m *Dot11Data) CanDecode() gopacket.LayerClass { return LayerTypeDot11Data } |
| func (m *Dot11Data) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| m.Payload = data |
| return nil |
| } |
| |
| func decodeDot11Data(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11Data{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| type Dot11DataCFAck struct { |
| Dot11Data |
| } |
| |
| func decodeDot11DataCFAck(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataCFAck{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataCFAck) LayerType() gopacket.LayerType { return LayerTypeDot11DataCFAck } |
| func (m *Dot11DataCFAck) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataCFAck } |
| func (m *Dot11DataCFAck) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Data.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11DataCFPoll struct { |
| Dot11Data |
| } |
| |
| func decodeDot11DataCFPoll(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataCFPoll{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataCFPoll) LayerType() gopacket.LayerType { return LayerTypeDot11DataCFPoll } |
| func (m *Dot11DataCFPoll) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataCFPoll } |
| func (m *Dot11DataCFPoll) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Data.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11DataCFAckPoll struct { |
| Dot11Data |
| } |
| |
| func decodeDot11DataCFAckPoll(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataCFAckPoll{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataCFAckPoll) LayerType() gopacket.LayerType { return LayerTypeDot11DataCFAckPoll } |
| func (m *Dot11DataCFAckPoll) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataCFAckPoll } |
| func (m *Dot11DataCFAckPoll) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Data.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11DataNull struct { |
| Dot11Data |
| } |
| |
| func decodeDot11DataNull(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataNull{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataNull) LayerType() gopacket.LayerType { return LayerTypeDot11DataNull } |
| func (m *Dot11DataNull) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataNull } |
| func (m *Dot11DataNull) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Data.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11DataCFAckNoData struct { |
| Dot11Data |
| } |
| |
| func decodeDot11DataCFAckNoData(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataCFAckNoData{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataCFAckNoData) LayerType() gopacket.LayerType { return LayerTypeDot11DataCFAckNoData } |
| func (m *Dot11DataCFAckNoData) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataCFAckNoData } |
| func (m *Dot11DataCFAckNoData) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Data.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11DataCFPollNoData struct { |
| Dot11Data |
| } |
| |
| func decodeDot11DataCFPollNoData(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataCFPollNoData{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataCFPollNoData) LayerType() gopacket.LayerType { return LayerTypeDot11DataCFPollNoData } |
| func (m *Dot11DataCFPollNoData) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataCFPollNoData } |
| func (m *Dot11DataCFPollNoData) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Data.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11DataCFAckPollNoData struct { |
| Dot11Data |
| } |
| |
| func decodeDot11DataCFAckPollNoData(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataCFAckPollNoData{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataCFAckPollNoData) LayerType() gopacket.LayerType { |
| return LayerTypeDot11DataCFAckPollNoData |
| } |
| func (m *Dot11DataCFAckPollNoData) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11DataCFAckPollNoData |
| } |
| func (m *Dot11DataCFAckPollNoData) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Data.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11DataQOS struct { |
| Dot11Ctrl |
| } |
| |
| func (m *Dot11DataQOS) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| m.BaseLayer = BaseLayer{Payload: data} |
| return nil |
| } |
| |
| type Dot11DataQOSData struct { |
| Dot11DataQOS |
| } |
| |
| func decodeDot11DataQOSData(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataQOSData{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataQOSData) LayerType() gopacket.LayerType { return LayerTypeDot11DataQOSData } |
| func (m *Dot11DataQOSData) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataQOSData } |
| |
| func (m *Dot11DataQOSData) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11Data |
| } |
| |
| type Dot11DataQOSDataCFAck struct { |
| Dot11DataQOS |
| } |
| |
| func decodeDot11DataQOSDataCFAck(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataQOSDataCFAck{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataQOSDataCFAck) LayerType() gopacket.LayerType { return LayerTypeDot11DataQOSDataCFAck } |
| func (m *Dot11DataQOSDataCFAck) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataQOSDataCFAck } |
| func (m *Dot11DataQOSDataCFAck) NextLayerType() gopacket.LayerType { return LayerTypeDot11DataCFAck } |
| |
| type Dot11DataQOSDataCFPoll struct { |
| Dot11DataQOS |
| } |
| |
| func decodeDot11DataQOSDataCFPoll(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataQOSDataCFPoll{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataQOSDataCFPoll) LayerType() gopacket.LayerType { |
| return LayerTypeDot11DataQOSDataCFPoll |
| } |
| func (m *Dot11DataQOSDataCFPoll) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11DataQOSDataCFPoll |
| } |
| func (m *Dot11DataQOSDataCFPoll) NextLayerType() gopacket.LayerType { return LayerTypeDot11DataCFPoll } |
| |
| type Dot11DataQOSDataCFAckPoll struct { |
| Dot11DataQOS |
| } |
| |
| func decodeDot11DataQOSDataCFAckPoll(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataQOSDataCFAckPoll{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataQOSDataCFAckPoll) LayerType() gopacket.LayerType { |
| return LayerTypeDot11DataQOSDataCFAckPoll |
| } |
| func (m *Dot11DataQOSDataCFAckPoll) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11DataQOSDataCFAckPoll |
| } |
| func (m *Dot11DataQOSDataCFAckPoll) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11DataCFAckPoll |
| } |
| |
| type Dot11DataQOSNull struct { |
| Dot11DataQOS |
| } |
| |
| func decodeDot11DataQOSNull(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataQOSNull{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataQOSNull) LayerType() gopacket.LayerType { return LayerTypeDot11DataQOSNull } |
| func (m *Dot11DataQOSNull) CanDecode() gopacket.LayerClass { return LayerTypeDot11DataQOSNull } |
| func (m *Dot11DataQOSNull) NextLayerType() gopacket.LayerType { return LayerTypeDot11DataNull } |
| |
| type Dot11DataQOSCFPollNoData struct { |
| Dot11DataQOS |
| } |
| |
| func decodeDot11DataQOSCFPollNoData(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataQOSCFPollNoData{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataQOSCFPollNoData) LayerType() gopacket.LayerType { |
| return LayerTypeDot11DataQOSCFPollNoData |
| } |
| func (m *Dot11DataQOSCFPollNoData) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11DataQOSCFPollNoData |
| } |
| func (m *Dot11DataQOSCFPollNoData) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11DataCFPollNoData |
| } |
| |
| type Dot11DataQOSCFAckPollNoData struct { |
| Dot11DataQOS |
| } |
| |
| func decodeDot11DataQOSCFAckPollNoData(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11DataQOSCFAckPollNoData{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11DataQOSCFAckPollNoData) LayerType() gopacket.LayerType { |
| return LayerTypeDot11DataQOSCFAckPollNoData |
| } |
| func (m *Dot11DataQOSCFAckPollNoData) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11DataQOSCFAckPollNoData |
| } |
| func (m *Dot11DataQOSCFAckPollNoData) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11DataCFAckPollNoData |
| } |
| |
| type Dot11InformationElement struct { |
| BaseLayer |
| ID Dot11InformationElementID |
| Length uint8 |
| OUI []byte |
| Info []byte |
| } |
| |
| func (m *Dot11InformationElement) LayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| func (m *Dot11InformationElement) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11InformationElement |
| } |
| |
| func (m *Dot11InformationElement) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| |
| func (m *Dot11InformationElement) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 2 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11InformationElement length %v too short, %v required", len(data), 2) |
| } |
| m.ID = Dot11InformationElementID(data[0]) |
| m.Length = data[1] |
| offset := int(2) |
| |
| if len(data) < offset+int(m.Length) { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11InformationElement length %v too short, %v required", len(data), offset+int(m.Length)) |
| } |
| if m.ID == 221 { |
| // Vendor extension |
| m.OUI = data[offset : offset+4] |
| m.Info = data[offset+4 : offset+int(m.Length)] |
| } else { |
| m.Info = data[offset : offset+int(m.Length)] |
| } |
| |
| offset += int(m.Length) |
| |
| m.BaseLayer = BaseLayer{Contents: data[:offset], Payload: data[offset:]} |
| return nil |
| } |
| |
| func (d *Dot11InformationElement) String() string { |
| if d.ID == 0 { |
| return fmt.Sprintf("802.11 Information Element (ID: %v, Length: %v, SSID: %v)", d.ID, d.Length, string(d.Info)) |
| } else if d.ID == 1 { |
| rates := "" |
| for i := 0; i < len(d.Info); i++ { |
| if d.Info[i]&0x80 == 0 { |
| rates += fmt.Sprintf("%.1f ", float32(d.Info[i])*0.5) |
| } else { |
| rates += fmt.Sprintf("%.1f* ", float32(d.Info[i]&0x7F)*0.5) |
| } |
| } |
| return fmt.Sprintf("802.11 Information Element (ID: %v, Length: %v, Rates: %s Mbit)", d.ID, d.Length, rates) |
| } else if d.ID == 221 { |
| return fmt.Sprintf("802.11 Information Element (ID: %v, Length: %v, OUI: %X, Info: %X)", d.ID, d.Length, d.OUI, d.Info) |
| } else { |
| return fmt.Sprintf("802.11 Information Element (ID: %v, Length: %v, Info: %X)", d.ID, d.Length, d.Info) |
| } |
| } |
| |
| func (m Dot11InformationElement) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| length := len(m.Info) + len(m.OUI) |
| if buf, err := b.PrependBytes(2 + length); err != nil { |
| return err |
| } else { |
| buf[0] = uint8(m.ID) |
| buf[1] = uint8(length) |
| copy(buf[2:], m.OUI) |
| copy(buf[2+len(m.OUI):], m.Info) |
| } |
| return nil |
| } |
| |
| func decodeDot11InformationElement(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11InformationElement{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| type Dot11CtrlCTS struct { |
| Dot11Ctrl |
| } |
| |
| func decodeDot11CtrlCTS(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11CtrlCTS{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11CtrlCTS) LayerType() gopacket.LayerType { |
| return LayerTypeDot11CtrlCTS |
| } |
| func (m *Dot11CtrlCTS) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11CtrlCTS |
| } |
| func (m *Dot11CtrlCTS) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Ctrl.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11CtrlRTS struct { |
| Dot11Ctrl |
| } |
| |
| func decodeDot11CtrlRTS(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11CtrlRTS{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11CtrlRTS) LayerType() gopacket.LayerType { |
| return LayerTypeDot11CtrlRTS |
| } |
| func (m *Dot11CtrlRTS) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11CtrlRTS |
| } |
| func (m *Dot11CtrlRTS) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Ctrl.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11CtrlBlockAckReq struct { |
| Dot11Ctrl |
| } |
| |
| func decodeDot11CtrlBlockAckReq(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11CtrlBlockAckReq{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11CtrlBlockAckReq) LayerType() gopacket.LayerType { |
| return LayerTypeDot11CtrlBlockAckReq |
| } |
| func (m *Dot11CtrlBlockAckReq) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11CtrlBlockAckReq |
| } |
| func (m *Dot11CtrlBlockAckReq) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Ctrl.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11CtrlBlockAck struct { |
| Dot11Ctrl |
| } |
| |
| func decodeDot11CtrlBlockAck(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11CtrlBlockAck{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11CtrlBlockAck) LayerType() gopacket.LayerType { return LayerTypeDot11CtrlBlockAck } |
| func (m *Dot11CtrlBlockAck) CanDecode() gopacket.LayerClass { return LayerTypeDot11CtrlBlockAck } |
| func (m *Dot11CtrlBlockAck) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Ctrl.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11CtrlPowersavePoll struct { |
| Dot11Ctrl |
| } |
| |
| func decodeDot11CtrlPowersavePoll(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11CtrlPowersavePoll{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11CtrlPowersavePoll) LayerType() gopacket.LayerType { |
| return LayerTypeDot11CtrlPowersavePoll |
| } |
| func (m *Dot11CtrlPowersavePoll) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11CtrlPowersavePoll |
| } |
| func (m *Dot11CtrlPowersavePoll) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Ctrl.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11CtrlAck struct { |
| Dot11Ctrl |
| } |
| |
| func decodeDot11CtrlAck(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11CtrlAck{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11CtrlAck) LayerType() gopacket.LayerType { return LayerTypeDot11CtrlAck } |
| func (m *Dot11CtrlAck) CanDecode() gopacket.LayerClass { return LayerTypeDot11CtrlAck } |
| func (m *Dot11CtrlAck) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Ctrl.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11CtrlCFEnd struct { |
| Dot11Ctrl |
| } |
| |
| func decodeDot11CtrlCFEnd(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11CtrlCFEnd{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11CtrlCFEnd) LayerType() gopacket.LayerType { |
| return LayerTypeDot11CtrlCFEnd |
| } |
| func (m *Dot11CtrlCFEnd) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11CtrlCFEnd |
| } |
| func (m *Dot11CtrlCFEnd) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Ctrl.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11CtrlCFEndAck struct { |
| Dot11Ctrl |
| } |
| |
| func decodeDot11CtrlCFEndAck(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11CtrlCFEndAck{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11CtrlCFEndAck) LayerType() gopacket.LayerType { |
| return LayerTypeDot11CtrlCFEndAck |
| } |
| func (m *Dot11CtrlCFEndAck) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11CtrlCFEndAck |
| } |
| func (m *Dot11CtrlCFEndAck) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| return m.Dot11Ctrl.DecodeFromBytes(data, df) |
| } |
| |
| type Dot11MgmtAssociationReq struct { |
| Dot11Mgmt |
| CapabilityInfo uint16 |
| ListenInterval uint16 |
| } |
| |
| func decodeDot11MgmtAssociationReq(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtAssociationReq{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtAssociationReq) LayerType() gopacket.LayerType { |
| return LayerTypeDot11MgmtAssociationReq |
| } |
| func (m *Dot11MgmtAssociationReq) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11MgmtAssociationReq |
| } |
| func (m *Dot11MgmtAssociationReq) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| func (m *Dot11MgmtAssociationReq) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 4 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11MgmtAssociationReq length %v too short, %v required", len(data), 4) |
| } |
| m.CapabilityInfo = binary.LittleEndian.Uint16(data[0:2]) |
| m.ListenInterval = binary.LittleEndian.Uint16(data[2:4]) |
| m.Payload = data[4:] |
| return m.Dot11Mgmt.DecodeFromBytes(data, df) |
| } |
| |
| func (m Dot11MgmtAssociationReq) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(4) |
| |
| if err != nil { |
| return err |
| } |
| |
| binary.LittleEndian.PutUint16(buf[0:2], m.CapabilityInfo) |
| binary.LittleEndian.PutUint16(buf[2:4], m.ListenInterval) |
| |
| return nil |
| } |
| |
| type Dot11MgmtAssociationResp struct { |
| Dot11Mgmt |
| CapabilityInfo uint16 |
| Status Dot11Status |
| AID uint16 |
| } |
| |
| func decodeDot11MgmtAssociationResp(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtAssociationResp{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtAssociationResp) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11MgmtAssociationResp |
| } |
| func (m *Dot11MgmtAssociationResp) LayerType() gopacket.LayerType { |
| return LayerTypeDot11MgmtAssociationResp |
| } |
| func (m *Dot11MgmtAssociationResp) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| func (m *Dot11MgmtAssociationResp) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 6 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11MgmtAssociationResp length %v too short, %v required", len(data), 6) |
| } |
| m.CapabilityInfo = binary.LittleEndian.Uint16(data[0:2]) |
| m.Status = Dot11Status(binary.LittleEndian.Uint16(data[2:4])) |
| m.AID = binary.LittleEndian.Uint16(data[4:6]) |
| m.Payload = data[6:] |
| return m.Dot11Mgmt.DecodeFromBytes(data, df) |
| } |
| |
| func (m Dot11MgmtAssociationResp) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(6) |
| |
| if err != nil { |
| return err |
| } |
| |
| binary.LittleEndian.PutUint16(buf[0:2], m.CapabilityInfo) |
| binary.LittleEndian.PutUint16(buf[2:4], uint16(m.Status)) |
| binary.LittleEndian.PutUint16(buf[4:6], m.AID) |
| |
| return nil |
| } |
| |
| type Dot11MgmtReassociationReq struct { |
| Dot11Mgmt |
| CapabilityInfo uint16 |
| ListenInterval uint16 |
| CurrentApAddress net.HardwareAddr |
| } |
| |
| func decodeDot11MgmtReassociationReq(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtReassociationReq{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtReassociationReq) LayerType() gopacket.LayerType { |
| return LayerTypeDot11MgmtReassociationReq |
| } |
| func (m *Dot11MgmtReassociationReq) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11MgmtReassociationReq |
| } |
| func (m *Dot11MgmtReassociationReq) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| func (m *Dot11MgmtReassociationReq) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 10 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11MgmtReassociationReq length %v too short, %v required", len(data), 10) |
| } |
| m.CapabilityInfo = binary.LittleEndian.Uint16(data[0:2]) |
| m.ListenInterval = binary.LittleEndian.Uint16(data[2:4]) |
| m.CurrentApAddress = net.HardwareAddr(data[4:10]) |
| m.Payload = data[10:] |
| return m.Dot11Mgmt.DecodeFromBytes(data, df) |
| } |
| |
| func (m Dot11MgmtReassociationReq) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(10) |
| |
| if err != nil { |
| return err |
| } |
| |
| binary.LittleEndian.PutUint16(buf[0:2], m.CapabilityInfo) |
| binary.LittleEndian.PutUint16(buf[2:4], m.ListenInterval) |
| |
| copy(buf[4:10], m.CurrentApAddress) |
| |
| return nil |
| } |
| |
| type Dot11MgmtReassociationResp struct { |
| Dot11Mgmt |
| } |
| |
| func decodeDot11MgmtReassociationResp(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtReassociationResp{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtReassociationResp) LayerType() gopacket.LayerType { |
| return LayerTypeDot11MgmtReassociationResp |
| } |
| func (m *Dot11MgmtReassociationResp) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11MgmtReassociationResp |
| } |
| func (m *Dot11MgmtReassociationResp) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| |
| type Dot11MgmtProbeReq struct { |
| Dot11Mgmt |
| } |
| |
| func decodeDot11MgmtProbeReq(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtProbeReq{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtProbeReq) LayerType() gopacket.LayerType { return LayerTypeDot11MgmtProbeReq } |
| func (m *Dot11MgmtProbeReq) CanDecode() gopacket.LayerClass { return LayerTypeDot11MgmtProbeReq } |
| func (m *Dot11MgmtProbeReq) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| |
| type Dot11MgmtProbeResp struct { |
| Dot11Mgmt |
| Timestamp uint64 |
| Interval uint16 |
| Flags uint16 |
| } |
| |
| func decodeDot11MgmtProbeResp(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtProbeResp{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtProbeResp) LayerType() gopacket.LayerType { return LayerTypeDot11MgmtProbeResp } |
| func (m *Dot11MgmtProbeResp) CanDecode() gopacket.LayerClass { return LayerTypeDot11MgmtProbeResp } |
| func (m *Dot11MgmtProbeResp) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 12 { |
| df.SetTruncated() |
| |
| return fmt.Errorf("Dot11MgmtProbeResp length %v too short, %v required", len(data), 12) |
| } |
| |
| m.Timestamp = binary.LittleEndian.Uint64(data[0:8]) |
| m.Interval = binary.LittleEndian.Uint16(data[8:10]) |
| m.Flags = binary.LittleEndian.Uint16(data[10:12]) |
| m.Payload = data[12:] |
| |
| return m.Dot11Mgmt.DecodeFromBytes(data, df) |
| } |
| |
| func (m *Dot11MgmtProbeResp) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| |
| func (m Dot11MgmtProbeResp) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(12) |
| |
| if err != nil { |
| return err |
| } |
| |
| binary.LittleEndian.PutUint64(buf[0:8], m.Timestamp) |
| binary.LittleEndian.PutUint16(buf[8:10], m.Interval) |
| binary.LittleEndian.PutUint16(buf[10:12], m.Flags) |
| |
| return nil |
| } |
| |
| type Dot11MgmtMeasurementPilot struct { |
| Dot11Mgmt |
| } |
| |
| func decodeDot11MgmtMeasurementPilot(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtMeasurementPilot{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtMeasurementPilot) LayerType() gopacket.LayerType { |
| return LayerTypeDot11MgmtMeasurementPilot |
| } |
| func (m *Dot11MgmtMeasurementPilot) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11MgmtMeasurementPilot |
| } |
| |
| type Dot11MgmtBeacon struct { |
| Dot11Mgmt |
| Timestamp uint64 |
| Interval uint16 |
| Flags uint16 |
| } |
| |
| func decodeDot11MgmtBeacon(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtBeacon{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtBeacon) LayerType() gopacket.LayerType { return LayerTypeDot11MgmtBeacon } |
| func (m *Dot11MgmtBeacon) CanDecode() gopacket.LayerClass { return LayerTypeDot11MgmtBeacon } |
| func (m *Dot11MgmtBeacon) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 12 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11MgmtBeacon length %v too short, %v required", len(data), 12) |
| } |
| m.Timestamp = binary.LittleEndian.Uint64(data[0:8]) |
| m.Interval = binary.LittleEndian.Uint16(data[8:10]) |
| m.Flags = binary.LittleEndian.Uint16(data[10:12]) |
| m.Payload = data[12:] |
| return m.Dot11Mgmt.DecodeFromBytes(data, df) |
| } |
| |
| func (m *Dot11MgmtBeacon) NextLayerType() gopacket.LayerType { return LayerTypeDot11InformationElement } |
| |
| func (m Dot11MgmtBeacon) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(12) |
| |
| if err != nil { |
| return err |
| } |
| |
| binary.LittleEndian.PutUint64(buf[0:8], m.Timestamp) |
| binary.LittleEndian.PutUint16(buf[8:10], m.Interval) |
| binary.LittleEndian.PutUint16(buf[10:12], m.Flags) |
| |
| return nil |
| } |
| |
| type Dot11MgmtATIM struct { |
| Dot11Mgmt |
| } |
| |
| func decodeDot11MgmtATIM(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtATIM{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtATIM) LayerType() gopacket.LayerType { return LayerTypeDot11MgmtATIM } |
| func (m *Dot11MgmtATIM) CanDecode() gopacket.LayerClass { return LayerTypeDot11MgmtATIM } |
| |
| type Dot11MgmtDisassociation struct { |
| Dot11Mgmt |
| Reason Dot11Reason |
| } |
| |
| func decodeDot11MgmtDisassociation(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtDisassociation{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtDisassociation) LayerType() gopacket.LayerType { |
| return LayerTypeDot11MgmtDisassociation |
| } |
| func (m *Dot11MgmtDisassociation) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11MgmtDisassociation |
| } |
| func (m *Dot11MgmtDisassociation) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 2 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11MgmtDisassociation length %v too short, %v required", len(data), 2) |
| } |
| m.Reason = Dot11Reason(binary.LittleEndian.Uint16(data[0:2])) |
| return m.Dot11Mgmt.DecodeFromBytes(data, df) |
| } |
| |
| func (m Dot11MgmtDisassociation) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(2) |
| |
| if err != nil { |
| return err |
| } |
| |
| binary.LittleEndian.PutUint16(buf[0:2], uint16(m.Reason)) |
| |
| return nil |
| } |
| |
| type Dot11MgmtAuthentication struct { |
| Dot11Mgmt |
| Algorithm Dot11Algorithm |
| Sequence uint16 |
| Status Dot11Status |
| } |
| |
| func decodeDot11MgmtAuthentication(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtAuthentication{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtAuthentication) LayerType() gopacket.LayerType { |
| return LayerTypeDot11MgmtAuthentication |
| } |
| func (m *Dot11MgmtAuthentication) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11MgmtAuthentication |
| } |
| func (m *Dot11MgmtAuthentication) NextLayerType() gopacket.LayerType { |
| return LayerTypeDot11InformationElement |
| } |
| func (m *Dot11MgmtAuthentication) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 6 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11MgmtAuthentication length %v too short, %v required", len(data), 6) |
| } |
| m.Algorithm = Dot11Algorithm(binary.LittleEndian.Uint16(data[0:2])) |
| m.Sequence = binary.LittleEndian.Uint16(data[2:4]) |
| m.Status = Dot11Status(binary.LittleEndian.Uint16(data[4:6])) |
| m.Payload = data[6:] |
| return m.Dot11Mgmt.DecodeFromBytes(data, df) |
| } |
| |
| func (m Dot11MgmtAuthentication) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(6) |
| |
| if err != nil { |
| return err |
| } |
| |
| binary.LittleEndian.PutUint16(buf[0:2], uint16(m.Algorithm)) |
| binary.LittleEndian.PutUint16(buf[2:4], m.Sequence) |
| binary.LittleEndian.PutUint16(buf[4:6], uint16(m.Status)) |
| |
| return nil |
| } |
| |
| type Dot11MgmtDeauthentication struct { |
| Dot11Mgmt |
| Reason Dot11Reason |
| } |
| |
| func decodeDot11MgmtDeauthentication(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtDeauthentication{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtDeauthentication) LayerType() gopacket.LayerType { |
| return LayerTypeDot11MgmtDeauthentication |
| } |
| func (m *Dot11MgmtDeauthentication) CanDecode() gopacket.LayerClass { |
| return LayerTypeDot11MgmtDeauthentication |
| } |
| func (m *Dot11MgmtDeauthentication) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { |
| if len(data) < 2 { |
| df.SetTruncated() |
| return fmt.Errorf("Dot11MgmtDeauthentication length %v too short, %v required", len(data), 2) |
| } |
| m.Reason = Dot11Reason(binary.LittleEndian.Uint16(data[0:2])) |
| return m.Dot11Mgmt.DecodeFromBytes(data, df) |
| } |
| |
| func (m Dot11MgmtDeauthentication) SerializeTo(b gopacket.SerializeBuffer, opts gopacket.SerializeOptions) error { |
| buf, err := b.PrependBytes(2) |
| |
| if err != nil { |
| return err |
| } |
| |
| binary.LittleEndian.PutUint16(buf[0:2], uint16(m.Reason)) |
| |
| return nil |
| } |
| |
| type Dot11MgmtAction struct { |
| Dot11Mgmt |
| } |
| |
| func decodeDot11MgmtAction(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtAction{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtAction) LayerType() gopacket.LayerType { return LayerTypeDot11MgmtAction } |
| func (m *Dot11MgmtAction) CanDecode() gopacket.LayerClass { return LayerTypeDot11MgmtAction } |
| |
| type Dot11MgmtActionNoAck struct { |
| Dot11Mgmt |
| } |
| |
| func decodeDot11MgmtActionNoAck(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtActionNoAck{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtActionNoAck) LayerType() gopacket.LayerType { return LayerTypeDot11MgmtActionNoAck } |
| func (m *Dot11MgmtActionNoAck) CanDecode() gopacket.LayerClass { return LayerTypeDot11MgmtActionNoAck } |
| |
| type Dot11MgmtArubaWLAN struct { |
| Dot11Mgmt |
| } |
| |
| func decodeDot11MgmtArubaWLAN(data []byte, p gopacket.PacketBuilder) error { |
| d := &Dot11MgmtArubaWLAN{} |
| return decodingLayerDecoder(d, data, p) |
| } |
| |
| func (m *Dot11MgmtArubaWLAN) LayerType() gopacket.LayerType { return LayerTypeDot11MgmtArubaWLAN } |
| func (m *Dot11MgmtArubaWLAN) CanDecode() gopacket.LayerClass { return LayerTypeDot11MgmtArubaWLAN } |