• Overview
  • Examples
  • HowTos
  • Glossary
    • InformationElements.hh
    Go to the documentation of this file.
    1 //
    2 // Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
    3 // Network Research Group (NET)
    4 // Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
    5 // Contact: support@wiback.org
    6 //
    7 // This file is part of the SENF code tree.
    8 // It is licensed under the 3-clause BSD License (aka New BSD License).
    9 // See LICENSE.txt in the top level directory for details or visit
    10 // https://opensource.org/licenses/BSD-3-Clause
    11 //
    12 
    13 
    17 #ifndef HH_SENF_Packets_80211Bundle_InformationElements_
    18 #define HH_SENF_Packets_80211Bundle_InformationElements_ 1
    19 
    20 // Custom includes
    21 #include <senf/Packets/Packets.hh>
    22 
    23 //-/////////////////////////////////////////////////////////////////////////////////////////////////
    24 
    25 namespace senf {
    26 
    27  struct WLANInfoElementParser
    28  : public PacketParserBase
    29  {
    30  # include SENF_PARSER()
    31  SENF_PARSER_FIELD ( type, UInt8Parser );
    32  SENF_PARSER_FIELD ( length, UInt8Parser );
    33  SENF_PARSER_FINALIZE( WLANInfoElementParser );
    34 
    35  typedef GenericTLVParserRegistry<WLANInfoElementParser> Registry;
    36  };
    37 
    38  typedef GenericTLVParserBase<WLANInfoElementParser> WLANGenericInfoElementParser;
    39 
    40 
    41  struct WLANSSIDInfoElementParser
    42  : public WLANInfoElementParser
    43  {
    44  # include SENF_PARSER()
    45  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    46  // the StringParser includes the length field so we have to go back
    47  SENF_PARSER_GOTO ( length );
    48  SENF_PARSER_FIELD ( value, StringParser<UInt8Parser> );
    49  SENF_PARSER_FINALIZE( WLANSSIDInfoElementParser );
    50 
    51  SENF_PARSER_INIT() {
    52  type() = typeId;
    53  length() = 0u;
    54  }
    55  static const type_t::value_type typeId = 0x00u;
    56 
    57  void dump(std::ostream & os) const;
    58  };
    59 
    60 
    61  struct WLANSupportedRatesInfoElementParser
    62  : public WLANInfoElementParser
    63  {
    64  # include SENF_PARSER()
    65  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    66  // we just skip the value here. If somebody needs the information he has to implement
    67  // this strange information element himself.
    68  SENF_PARSER_SKIP ( length(), 0 );
    69  SENF_PARSER_FINALIZE( WLANSupportedRatesInfoElementParser );
    70 
    71  SENF_PARSER_INIT() {
    72  type() = typeId;
    73  }
    74  static const type_t::value_type typeId = 0x01u;
    75 
    76  void dump(std::ostream & os) const;
    77  };
    78 
    79 
    80  struct WLANPowerConstraintInfoElementParser
    81  : public WLANInfoElementParser
    82  {
    83  # include SENF_PARSER()
    84  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    85  SENF_PARSER_FIELD ( value, UInt8Parser );
    86  SENF_PARSER_FINALIZE( WLANPowerConstraintInfoElementParser );
    87 
    88  SENF_PARSER_INIT() {
    89  type() = typeId;
    90  length() = 1u;
    91  }
    92  static const type_t::value_type typeId = 0x20u;
    93 
    94  void dump(std::ostream & os) const;
    95  };
    96 
    97 
    98  struct WLANVendorSpecificInfoElementParser
    99  : public WLANInfoElementParser
    100  {
    101  # include SENF_PARSER()
    102  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    103  SENF_PARSER_FIELD ( oui, UInt24Parser );
    104  SENF_PARSER_SKIP ( length()-3, 0 );
    105  SENF_PARSER_FINALIZE( WLANVendorSpecificInfoElementParser );
    106 
    107  SENF_PARSER_INIT() {
    108  type() = typeId;
    109  length() = 3u;
    110  }
    111  static const type_t::value_type typeId = 0xddu;
    112 
    113  void dump(std::ostream & os) const;
    114  };
    115 
    116 
    117  struct WLANHTCapabilitiesInfoFieldParser
    118  : public PacketParserBase
    119  {
    120  public:
    121 # include SENF_FIXED_PARSER()
    122  // re-ordering of the fields due to the byte order
    123  SENF_PARSER_BITFIELD ( txSTBC, 1, bool );
    124  SENF_PARSER_BITFIELD ( shortGIfor40MHz, 1, bool );
    125  SENF_PARSER_BITFIELD ( shortGIfor20MHz, 1, bool );
    126  SENF_PARSER_BITFIELD ( htGreenfield, 1, bool );
    127  SENF_PARSER_BITFIELD ( smPowerSave, 2, unsigned );
    128  SENF_PARSER_BITFIELD ( supportedChannelWidth, 1, bool );
    129  SENF_PARSER_BITFIELD ( ldpcCodingCapability, 1, bool );
    130  SENF_PARSER_BITFIELD ( lSIGTXOPProtectionSupport, 1, bool );
    131  SENF_PARSER_BITFIELD ( fortyMHzIntolerant, 1, bool );
    132  SENF_PARSER_SKIP_BITS( 1 ); // reserved
    133  SENF_PARSER_BITFIELD ( dsss_cckModeIn40MHz, 1, bool );
    134  SENF_PARSER_BITFIELD ( maxAMSDULength, 1, bool );
    135  SENF_PARSER_BITFIELD ( delayedBlockAck, 1, bool );
    136  SENF_PARSER_BITFIELD ( rxSTBC, 2, unsigned );
    137  SENF_PARSER_FINALIZE ( WLANHTCapabilitiesInfoFieldParser );
    138  };
    139 
    140  struct WLANAMPDUParametersParser
    141  : public PacketParserBase
    142  {
    143  public:
    144 # include SENF_FIXED_PARSER()
    145  // re-ordering of the fields due to the byte order
    146  SENF_PARSER_SKIP_BITS( 3 ); // reserved
    147  SENF_PARSER_BITFIELD ( minMPDUStartSpacing, 3, unsigned );
    148  SENF_PARSER_BITFIELD ( maxAMPDULength, 2, unsigned );
    149  SENF_PARSER_FINALIZE ( WLANAMPDUParametersParser );
    150  };
    151 
    152  struct WLANSupportedMCSSetParser
    153  : public PacketParserBase
    154  {
    155  public:
    156 # include SENF_FIXED_PARSER()
    157  // re-ordering of the fields due to the byte order
    158  typedef BitsetParser<77, MSB0Endianness> MCSBitmaskParser;
    159  SENF_PARSER_FIELD ( rxMCSBitmask, MCSBitmaskParser ); // the remaining 3 bits are already captured by the BitsetParser
    160  SENF_PARSER_SKIP_BITS( 6 ); // reserved
    161  SENF_PARSER_BITFIELD ( rxHighestSupoortedDataRate, 10, unsigned );
    162  SENF_PARSER_SKIP_BITS( 3 ); // reserved
    163  SENF_PARSER_BITFIELD ( txUnequalModulationSupported, 1, bool );
    164  SENF_PARSER_BITFIELD ( txMaxStreamsSupported, 2, unsigned );
    165  SENF_PARSER_BITFIELD ( txRxMCSSetNotEqual, 1, bool );
    166  SENF_PARSER_BITFIELD ( txMCSSetDefined, 1, bool );
    167  SENF_PARSER_SKIP ( 3 ); // reserved
    168  SENF_PARSER_FINALIZE ( WLANSupportedMCSSetParser );
    169  };
    170 
    171  struct WLANHTExtendedCapabilitiesParser
    172  : public PacketParserBase
    173  {
    174  public:
    175 # include SENF_FIXED_PARSER()
    176  // re-ordering of the fields due to the byte order
    177  SENF_PARSER_SKIP_BITS( 5 ); // reserved
    178  SENF_PARSER_BITFIELD ( pcoTransitionTime, 2, unsigned );
    179  SENF_PARSER_BITFIELD ( pco, 1, bool );
    180  SENF_PARSER_SKIP_BITS( 4 ); // reserved
    181  SENF_PARSER_BITFIELD ( rdResponder, 1, bool );
    182  SENF_PARSER_BITFIELD ( htcSupport, 1, bool );
    183  SENF_PARSER_BITFIELD ( mcsFeedback, 2, unsigned );
    184  SENF_PARSER_FINALIZE ( WLANHTExtendedCapabilitiesParser );
    185  };
    186 
    187  struct WLANTxBeamformingCapabilitiesParser
    188  : public PacketParserBase
    189  {
    190  public:
    191 # include SENF_FIXED_PARSER()
    192  // if somebody needs the information he has to implement this himself. sorry.
    193  SENF_PARSER_SKIP( 4 );
    194  SENF_PARSER_FINALIZE( WLANTxBeamformingCapabilitiesParser );
    195  };
    196 
    197  struct WLANAntennaSelectionCapabilityParser
    198  : public PacketParserBase
    199  {
    200  public:
    201 # include SENF_FIXED_PARSER()
    202  // if somebody needs the information he has to implement this himself. sorry.
    203  SENF_PARSER_SKIP( 1 );
    204  SENF_PARSER_FINALIZE( WLANAntennaSelectionCapabilityParser );
    205  };
    206 
    207  struct WLANHTCapabilitiesInfoElementParser
    208  : public WLANInfoElementParser
    209  {
    210  # include SENF_PARSER()
    211  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    212  SENF_PARSER_FIELD ( capabilitiesInfo, WLANHTCapabilitiesInfoFieldParser );
    213  SENF_PARSER_FIELD ( aMPDUParameters, WLANAMPDUParametersParser );
    214  SENF_PARSER_FIELD ( supportedMCSSet, WLANSupportedMCSSetParser );
    215  SENF_PARSER_FIELD ( extendedCapabilities, WLANHTExtendedCapabilitiesParser );
    216  SENF_PARSER_FIELD ( txBeamformingCapabilities, WLANTxBeamformingCapabilitiesParser );
    217  SENF_PARSER_FIELD ( antennaSelectionCapability, WLANAntennaSelectionCapabilityParser );
    218  SENF_PARSER_FINALIZE( WLANHTCapabilitiesInfoElementParser );
    219 
    220  SENF_PARSER_INIT() {
    221  type() = typeId;
    222  length() = 26u;
    223  }
    224  static const type_t::value_type typeId = 0x2du;
    225 
    226  void dump(std::ostream & os) const;
    227  };
    228 
    229 
    230  struct WLANHTOperationInfoFieldParser
    231  : public PacketParserBase
    232  {
    233  public:
    234 # include SENF_FIXED_PARSER()
    235  // re-ordering of the fields due to the byte order
    236  SENF_PARSER_SKIP_BITS( 4 ); // reserved
    237  SENF_PARSER_BITFIELD ( rifsMode, 1, bool );
    238  SENF_PARSER_BITFIELD ( channelWidth, 1, bool );
    239  SENF_PARSER_BITFIELD ( secondaryChannelOffset, 2, unsigned );
    240  SENF_PARSER_SKIP_BITS( 3 ); // reserved
    241  SENF_PARSER_BITFIELD ( obssNonHTSTAsPresent, 1, bool );
    242  SENF_PARSER_SKIP_BITS( 1 ); // reserved
    243  SENF_PARSER_BITFIELD ( nonGreenfieldHTSTAsPresent, 1, bool );
    244  SENF_PARSER_BITFIELD ( htProtection, 2, unsigned );
    245  SENF_PARSER_SKIP_BITS( 8 ); // reserved
    246  SENF_PARSER_BITFIELD ( dualCTSProtection, 1, bool );
    247  SENF_PARSER_BITFIELD ( dualBeacon, 1, bool );
    248  SENF_PARSER_SKIP_BITS( 6 ); // reserved
    249  SENF_PARSER_SKIP_BITS( 4 ); // reserved
    250  SENF_PARSER_BITFIELD ( pcoPhase, 1, bool );
    251  SENF_PARSER_BITFIELD ( pcoActive, 1, bool );
    252  SENF_PARSER_BITFIELD ( lsigTXOPProtectionSupport, 1, bool );
    253  SENF_PARSER_BITFIELD ( stbcBeacon, 1, bool );
    254  SENF_PARSER_FINALIZE ( WLANHTOperationInfoFieldParser );
    255  };
    256 
    257  struct WLANHTOperationInfoElementParser
    258  : public WLANInfoElementParser
    259  {
    260  # include SENF_PARSER()
    261  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    262  SENF_PARSER_FIELD ( primaryChannel, UInt8Parser );
    263  SENF_PARSER_FIELD ( operationInfo, WLANHTOperationInfoFieldParser );
    264  SENF_PARSER_FIELD ( basicMCSSet, WLANSupportedMCSSetParser );
    265  SENF_PARSER_FINALIZE( WLANHTOperationInfoElementParser );
    266 
    267  SENF_PARSER_INIT() {
    268  type() = typeId;
    269  length() = 22u;
    270  }
    271  static const type_t::value_type typeId = 0x3du;
    272 
    273  void dump(std::ostream & os) const;
    274  };
    275 
    276 
    277  struct WLANMeshIdInfoElementParser
    278  : public WLANInfoElementParser
    279  {
    280  # include SENF_PARSER()
    281  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    282  // the StringParser includes the length field so we have to go back
    283  SENF_PARSER_GOTO ( length );
    284  SENF_PARSER_FIELD ( value, StringParser<UInt8Parser> );
    285  SENF_PARSER_FINALIZE( WLANMeshIdInfoElementParser );
    286 
    287  SENF_PARSER_INIT() {
    288  type() = typeId;
    289  length() = 0u;
    290  }
    291  static const type_t::value_type typeId = 0x72u;
    292 
    293  void dump(std::ostream & os) const;
    294  };
    295 
    296 
    297  struct WLANVHTCapabilitiesInfoFieldParser
    298  : public PacketParserBase
    299  {
    300  public:
    301 # include SENF_FIXED_PARSER()
    302  // re-ordering of the fields due to the byte order
    303  SENF_PARSER_BITFIELD ( txSTBC, 1, bool );
    304  SENF_PARSER_BITFIELD ( shortGIfor160_8080MHz, 1, bool );
    305  SENF_PARSER_BITFIELD ( shortGIfor80MHz, 1, bool );
    306  SENF_PARSER_BITFIELD ( rxLDPC, 1, bool );
    307  SENF_PARSER_BITFIELD ( supportedChannelWidthSet, 2, unsigned );
    308  SENF_PARSER_BITFIELD ( maxMPDULength, 2, unsigned );
    309 
    310  SENF_PARSER_BITFIELD ( compressedSteeringNrOfBFAntennas, 3, unsigned );
    311  SENF_PARSER_BITFIELD ( suBeamformee, 1, bool );
    312  SENF_PARSER_BITFIELD ( suBeamformer, 1, bool );
    313  SENF_PARSER_BITFIELD ( rxSTBC, 3, unsigned );
    314 
    315  SENF_PARSER_PRIVATE_BITFIELD( maxAMPDULengthExponent_1, 1, unsigned );
    316  SENF_PARSER_BITFIELD ( htc_vhtCapable, 1, bool );
    317  SENF_PARSER_BITFIELD ( vhtTxOpPowerSave, 1, bool );
    318  SENF_PARSER_BITFIELD ( muBeamformee, 1, bool );
    319  SENF_PARSER_BITFIELD ( muBeamformer, 1, bool );
    320  SENF_PARSER_BITFIELD ( nrOfSoundingDimensions, 3, unsigned );
    321 
    322  SENF_PARSER_SKIP_BITS( 2 ); // reserved
    323  SENF_PARSER_BITFIELD ( txAntennaPatternConsistency, 1, bool );
    324  SENF_PARSER_BITFIELD ( rxAntennaPatternConsistency, 1, bool );
    325  SENF_PARSER_BITFIELD ( vhtLinkAdaptationCapable, 2, unsigned );
    326  SENF_PARSER_PRIVATE_BITFIELD( maxAMPDULengthExponent_2, 2, unsigned );
    327 
    328  SENF_PARSER_FINALIZE ( WLANVHTCapabilitiesInfoFieldParser );
    329 
    330  boost::uint32_t maxAMPDULengthExponent() const {
    331  return (maxAMPDULengthExponent_1().value() << 2) | maxAMPDULengthExponent_2().value();
    332  }
    333  void maxAMPDULengthExponent(boost::uint32_t v) const {
    334  maxAMPDULengthExponent_1((v & 0x00000004) >> 2) ;
    335  maxAMPDULengthExponent_2(v & 0x00000003);
    336  }
    337  };
    338 
    339  struct WLANVHTMCSMapParser
    340  : public PacketParserBase
    341  {
    342  public:
    343 # include SENF_FIXED_PARSER()
    344  // re-ordering of the fields due to the byte order
    345  SENF_PARSER_BITFIELD( maxMCS4SS, 2, unsigned );
    346  SENF_PARSER_BITFIELD( maxMCS3SS, 2, unsigned );
    347  SENF_PARSER_BITFIELD( maxMCS2SS, 2, unsigned );
    348  SENF_PARSER_BITFIELD( maxMCS1SS, 2, unsigned );
    349  SENF_PARSER_BITFIELD( maxMCS8SS, 2, unsigned );
    350  SENF_PARSER_BITFIELD( maxMCS7SS, 2, unsigned );
    351  SENF_PARSER_BITFIELD( maxMCS6SS, 2, unsigned );
    352  SENF_PARSER_BITFIELD( maxMCS5SS, 2, unsigned );
    353  SENF_PARSER_FINALIZE( WLANVHTMCSMapParser );
    354  };
    355 
    356  struct WLANVHTHighestSupportedDataRateParser
    357  : public PacketParserBase
    358  {
    359  public:
    360 # include SENF_FIXED_PARSER()
    361  SENF_PARSER_PRIVATE_BITFIELD ( value_1, 8, unsigned );
    362  SENF_PARSER_SKIP_BITS( 3 );
    363  SENF_PARSER_PRIVATE_BITFIELD ( value_2, 5, unsigned );
    364  SENF_PARSER_FINALIZE( WLANVHTHighestSupportedDataRateParser );
    365 
    366  boost::uint32_t value() const {
    367  return (value_1().value() << 5) | value_2().value();
    368  }
    369  void value(boost::uint32_t v) const {
    370  value_1((v & 0x00000004) >> 5) ;
    371  value_2(v & 0x0000001f);
    372  }
    373  };
    374 
    375  struct WLANSupportedVHTMCSSetParser
    376  : public PacketParserBase
    377  {
    378  public:
    379 # include SENF_FIXED_PARSER()
    380  SENF_PARSER_FIELD ( rxVHTMCSMap, WLANVHTMCSMapParser );
    381  SENF_PARSER_FIELD ( rxHighestSupportedDataRate, WLANVHTHighestSupportedDataRateParser );
    382  SENF_PARSER_FIELD ( txVHTMCSMap, WLANVHTMCSMapParser );
    383  SENF_PARSER_FIELD ( txHighestSupportedDataRate, WLANVHTHighestSupportedDataRateParser );
    384  SENF_PARSER_FINALIZE( WLANSupportedVHTMCSSetParser );
    385  };
    386 
    387  struct WLANVHTCapabilitiesInfoElementParser
    388  : public WLANInfoElementParser
    389  {
    390  # include SENF_PARSER()
    391  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    392  SENF_PARSER_FIELD ( capabilitiesInfo, WLANVHTCapabilitiesInfoFieldParser );
    393  SENF_PARSER_FIELD ( supportedMCSSet, WLANSupportedVHTMCSSetParser );
    394  SENF_PARSER_FINALIZE( WLANVHTCapabilitiesInfoElementParser );
    395 
    396  SENF_PARSER_INIT() {
    397  type() = typeId;
    398  length() = 12u;
    399  }
    400  static const type_t::value_type typeId = 0xbf;
    401 
    402  void dump(std::ostream & os) const;
    403  };
    404 
    405 
    406  struct WLANVHTOperationInfoFieldParser
    407  : public PacketParserBase
    408  {
    409  # include SENF_FIXED_PARSER()
    410  SENF_PARSER_FIELD ( channelWidth, UInt8Parser );
    411  SENF_PARSER_FIELD ( channelCenterFrequency0, UInt8Parser );
    412  SENF_PARSER_FIELD ( channelCenterFrequency1, UInt8Parser );
    413  SENF_PARSER_FINALIZE( WLANVHTOperationInfoFieldParser );
    414  };
    415 
    416  struct WLANVHTOperationInfoElementParser
    417  : public WLANInfoElementParser
    418  {
    419  # include SENF_PARSER()
    420  SENF_PARSER_INHERIT ( WLANInfoElementParser );
    421  SENF_PARSER_FIELD ( operationInfo, WLANVHTOperationInfoFieldParser );
    422  SENF_PARSER_FIELD ( basicMCSSet, WLANVHTMCSMapParser );
    423  SENF_PARSER_FINALIZE( WLANVHTOperationInfoElementParser );
    424 
    425  SENF_PARSER_INIT() {
    426  type() = typeId;
    427  length() = 5u;
    428  }
    429  static const type_t::value_type typeId = 0xc0;
    430 
    431  void dump(std::ostream & os) const;
    432  };
    433 
    434 }
    435 
    436 //-/////////////////////////////////////////////////////////////////////////////////////////////////
    437 //#include "InformationElements.cci"
    438 //#include "InformationElements.ct"
    439 //#include "InformationElements.cti"
    440 #endif
    441 
    442 
    443 // Local Variables:
    444 // mode: c++
    445 // fill-column: 100
    446 // comment-column: 40
    447 // c-file-style: "senf"
    448 // indent-tabs-mode: nil
    449 // ispell-local-dictionary: "american"
    450 // compile-command: "scons -u test"
    451 // End:
    SENF_PARSER_INHERIT
    #define SENF_PARSER_INHERIT(base)
    Define parser inheritance.
    Definition: ParseHelpers.hh:354
    SENF_PARSER_BITFIELD
    #define SENF_PARSER_BITFIELD(name, bits, type)
    Define bit-field.
    Definition: ParseHelpers.hh:506
    senf::UInt8Parser
    Parse 8bit unsigned byte aligned integer.
    Definition: IntParser.hh:91
    senf::GenericTLVParserRegistry
    TLV parser registration facility.
    Definition: GenericTLV.hh:227
    senf::WLANSupportedMCSSetParser::MCSBitmaskParser
    BitsetParser< 77, MSB0Endianness > MCSBitmaskParser
    Definition: InformationElements.hh:158
    Packets.hh
    Packets public header.
    senf::GenericTLVParserBase
    Base class for generic TLV parsers.
    Definition: GenericTLV.hh:124
    SENF_PARSER_FIELD
    #define SENF_PARSER_FIELD(name, type)
    Define normal parser field.
    Definition: ParseHelpers.hh:418
    SENF_PARSER_GOTO
    #define SENF_PARSER_GOTO(name)
    Change current offset.
    Definition: ParseHelpers.hh:577
    senf::WLANVHTCapabilitiesInfoFieldParser::maxAMPDULengthExponent
    void maxAMPDULengthExponent(boost::uint32_t v) const
    Definition: InformationElements.hh:333
    SENF_PARSER_FINALIZE
    #define SENF_PARSER_FINALIZE(name)
    Generate parser control members.
    Definition: ParseHelpers.hh:378
    senf::WLANInfoElementParser::length
    UInt8Parser length() const
    dump
    void dump(std::ostream &os, DirectoryNode &dir=root())
    SENF_PARSER_INIT
    #define SENF_PARSER_INIT()
    Define parser initialization routine.
    Definition: ParseHelpers.hh:331
    senf::UInt8Parser::value_type
    boost::uint8_t value_type
    Definition: IntParser.hh:99
    SENF_PARSER_SKIP
    #define SENF_PARSER_SKIP(skip)
    Skip bytes.
    Definition: ParseHelpers.hh:551
    senf::WLANInfoElementParser::type
    UInt8Parser type() const
    senf::UInt24Parser
    Parse 24bit unsigned byte aligned integer.
    Definition: IntParser.hh:256
    SENF_PARSER_SKIP_BITS
    #define SENF_PARSER_SKIP_BITS(bits)
    Skip bits within bitfield group.
    Definition: ParseHelpers.hh:561
    senf::PacketParserBase
    Parser Base class.
    Definition: PacketParser.hh:228
    SENF_PARSER_PRIVATE_BITFIELD
    #define SENF_PARSER_PRIVATE_BITFIELD(name, bits, type)
    Define bit-field (private)
    Definition: ParseHelpers.hh:525
    senf::WLANGenericInfoElementParser
    GenericTLVParserBase< WLANInfoElementParser > WLANGenericInfoElementParser
    Definition: InformationElements.hh:38
    senf::WLANInfoElementParser::Registry
    GenericTLVParserRegistry< WLANInfoElementParser > Registry
    Definition: InformationElements.hh:32