radiotap-header.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2009 CTTC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Include., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Authors: Nicola Baldo <nbaldo@cttc.es>
 *          Sébastien Deronne <sebastien.deronne@gmail.com>
 */
 
#ifndef RADIOTAP_HEADER_H
#define RADIOTAP_HEADER_H
 
#include <ns3/header.h>
 
namespace ns3 {
 
class RadiotapHeader : public Header
{
public:
  RadiotapHeader ();
  static TypeId GetTypeId (void);
  virtual TypeId GetInstanceTypeId (void) const;
 
  virtual uint32_t GetSerializedSize (void) const;
 
  virtual void Serialize (Buffer::Iterator start) const;
 
  virtual uint32_t Deserialize (Buffer::Iterator start);
 
  virtual void Print (std::ostream &os) const;
 
  void SetTsft (uint64_t tsft);
 
  enum FrameFlag
  {
    FRAME_FLAG_NONE           = 0x00, 
    FRAME_FLAG_CFP            = 0x01, 
    FRAME_FLAG_SHORT_PREAMBLE = 0x02, 
    FRAME_FLAG_WEP            = 0x04, 
    FRAME_FLAG_FRAGMENTED     = 0x08, 
    FRAME_FLAG_FCS_INCLUDED   = 0x10, 
    FRAME_FLAG_DATA_PADDING   = 0x20, 
    FRAME_FLAG_BAD_FCS        = 0x40, 
    FRAME_FLAG_SHORT_GUARD    = 0x80  
  };
 
  void SetFrameFlags (uint8_t flags);
 
  void SetRate (uint8_t rate);
 
  enum ChannelFlags
  {
    CHANNEL_FLAG_NONE          = 0x0000, 
    CHANNEL_FLAG_TURBO         = 0x0010, 
    CHANNEL_FLAG_CCK           = 0x0020, 
    CHANNEL_FLAG_OFDM          = 0x0040, 
    CHANNEL_FLAG_SPECTRUM_2GHZ = 0x0080, 
    CHANNEL_FLAG_SPECTRUM_5GHZ = 0x0100, 
    CHANNEL_FLAG_PASSIVE       = 0x0200, 
    CHANNEL_FLAG_DYNAMIC       = 0x0400, 
    CHANNEL_FLAG_GFSK          = 0x0800  
  };
 
  void SetChannelFrequencyAndFlags (uint16_t frequency, uint16_t flags);
 
  void SetAntennaSignalPower (double signal);
 
  void SetAntennaNoisePower (double noise);
 
  enum McsKnown
  {
    MCS_KNOWN_NONE           = 0x00, 
    MCS_KNOWN_BANDWIDTH      = 0x01, 
    MCS_KNOWN_INDEX          = 0x02, 
    MCS_KNOWN_GUARD_INTERVAL = 0x04, 
    MCS_KNOWN_HT_FORMAT      = 0x08, 
    MCS_KNOWN_FEC_TYPE       = 0x10, 
    MCS_KNOWN_STBC           = 0x20, 
    MCS_KNOWN_NESS           = 0x40, 
    MCS_KNOWN_NESS_BIT_1     = 0x80, 
  };
 
  enum McsFlags
  {
    MCS_FLAGS_NONE           = 0x00, 
    MCS_FLAGS_BANDWIDTH_40   = 0x01, 
    MCS_FLAGS_BANDWIDTH_20L  = 0x02, 
    MCS_FLAGS_BANDWIDTH_20U  = 0x03, 
    MCS_FLAGS_GUARD_INTERVAL = 0x04, 
    MCS_FLAGS_HT_GREENFIELD  = 0x08, 
    MCS_FLAGS_FEC_TYPE       = 0x10, 
    MCS_FLAGS_STBC_STREAMS   = 0x60, 
    MCS_FLAGS_NESS_BIT_0     = 0x80, 
  };
 
  void SetMcsFields (uint8_t known, uint8_t flags, uint8_t mcs);
 
  enum AmpduFlags
  {
    A_MPDU_STATUS_NONE                = 0x00, 
    A_MPDU_STATUS_REPORT_ZERO_LENGTH  = 0x01, 
    A_MPDU_STATUS_IS_ZERO_LENGTH      = 0x02, 
    A_MPDU_STATUS_LAST_KNOWN          = 0x04, 
    A_MPDU_STATUS_LAST                = 0x08, 
    A_MPDU_STATUS_DELIMITER_CRC_ERROR = 0x10, 
    A_MPDU_STATUS_DELIMITER_CRC_KNOWN = 0x20  
  };
 
  void SetAmpduStatus (uint32_t referenceNumber, uint16_t flags, uint8_t crc);
 
  enum VhtKnown
  {
    VHT_KNOWN_NONE                         = 0x0000, 
    VHT_KNOWN_STBC                         = 0x0001, 
    VHT_KNOWN_TXOP_PS_NOT_ALLOWED          = 0x0002, 
    VHT_KNOWN_GUARD_INTERVAL               = 0x0004, 
    VHT_KNOWN_SHORT_GI_NSYM_DISAMBIGUATION = 0x0008, 
    VHT_KNOWN_LDPC_EXTRA_OFDM_SYMBOL       = 0x0010, 
    VHT_KNOWN_BEAMFORMED                   = 0x0020, 
    VHT_KNOWN_BANDWIDTH                    = 0x0040, 
    VHT_KNOWN_GROUP_ID                     = 0x0080, 
    VHT_KNOWN_PARTIAL_AID                  = 0x0100, 
  };
 
  enum VhtFlags
  {
    VHT_FLAGS_NONE                         = 0x00, 
    VHT_FLAGS_STBC                         = 0x01, 
    VHT_FLAGS_TXOP_PS_NOT_ALLOWED          = 0x02, 
    VHT_FLAGS_GUARD_INTERVAL               = 0x04, 
    VHT_FLAGS_SHORT_GI_NSYM_DISAMBIGUATION = 0x08, 
    VHT_FLAGS_LDPC_EXTRA_OFDM_SYMBOL       = 0x10, 
    VHT_FLAGS_BEAMFORMED                   = 0x20, 
  };
 
  void SetVhtFields (uint16_t known, uint8_t flags,
                     uint8_t bandwidth, uint8_t mcs_nss [4],
                     uint8_t coding, uint8_t group_id,
                     uint16_t partial_aid);
 
  enum HeData1
  {
    HE_DATA1_FORMAT_EXT_SU      = 0x0001, 
    HE_DATA1_FORMAT_MU          = 0x0002, 
    HE_DATA1_FORMAT_TRIG        = 0x0003, 
    HE_DATA1_BSS_COLOR_KNOWN    = 0x0004, 
    HE_DATA1_BEAM_CHANGE_KNOWN  = 0x0008, 
    HE_DATA1_UL_DL_KNOWN        = 0x0010, 
    HE_DATA1_DATA_MCS_KNOWN     = 0x0020, 
    HE_DATA1_DATA_DCM_KNOWN     = 0x0040, 
    HE_DATA1_CODING_KNOWN       = 0x0080, 
    HE_DATA1_LDPC_XSYMSEG_KNOWN = 0x0100, 
    HE_DATA1_STBC_KNOWN         = 0x0200, 
    HE_DATA1_SPTL_REUSE_KNOWN   = 0x0400, 
    HE_DATA1_SPTL_REUSE2_KNOWN  = 0x0800, 
    HE_DATA1_SPTL_REUSE3_KNOWN  = 0x1000, 
    HE_DATA1_SPTL_REUSE4_KNOWN  = 0x2000, 
    HE_DATA1_BW_RU_ALLOC_KNOWN  = 0x4000, 
    HE_DATA1_DOPPLER_KNOWN      = 0x8000, 
  };
 
  enum HeData2
  {
    HE_DATA2_PRISEC_80_KNOWN    = 0x0001, 
    HE_DATA2_GI_KNOWN           = 0x0002, 
    HE_DATA2_NUM_LTF_SYMS_KNOWN = 0x0004, 
    HE_DATA2_PRE_FEC_PAD_KNOWN  = 0x0008, 
    HE_DATA2_TXBF_KNOWN         = 0x0010, 
    HE_DATA2_PE_DISAMBIG_KNOWN  = 0x0020, 
    HE_DATA2_TXOP_KNOWN         = 0x0040, 
    HE_DATA2_MIDAMBLE_KNOWN     = 0x0080, 
    HE_DATA2_RU_OFFSET          = 0x3f00, 
    HE_DATA2_RU_OFFSET_KNOWN    = 0x4000, 
    HE_DATA2_PRISEC_80_SEC      = 0x8000, 
  };
 
  enum HeData5
  {
    HE_DATA5_DATA_BW_RU_ALLOC_40MHZ  = 0x0001, 
    HE_DATA5_DATA_BW_RU_ALLOC_80MHZ  = 0x0002, 
    HE_DATA5_DATA_BW_RU_ALLOC_160MHZ = 0x0003, 
    HE_DATA5_DATA_BW_RU_ALLOC_26T    = 0x0004, 
    HE_DATA5_DATA_BW_RU_ALLOC_52T    = 0x0005, 
    HE_DATA5_DATA_BW_RU_ALLOC_106T   = 0x0006, 
    HE_DATA5_DATA_BW_RU_ALLOC_242T   = 0x0007, 
    HE_DATA5_DATA_BW_RU_ALLOC_484T   = 0x0008, 
    HE_DATA5_DATA_BW_RU_ALLOC_996T   = 0x0009, 
    HE_DATA5_DATA_BW_RU_ALLOC_2x996T = 0x000a, 
    HE_DATA5_GI_1_6                  = 0x0010, 
    HE_DATA5_GI_3_2                  = 0x0020, 
    HE_DATA5_LTF_SYM_SIZE            = 0x00c0, 
    HE_DATA5_NUM_LTF_SYMS            = 0x0700, 
    HE_DATA5_PRE_FEC_PAD             = 0x3000, 
    HE_DATA5_TXBF                    = 0x4000, 
    HE_DATA5_PE_DISAMBIG             = 0x8000, 
  };
 
  void SetHeFields (uint16_t data1,
                    uint16_t data2,
                    uint16_t data3,
                    uint16_t data4,
                    uint16_t data5,
                    uint16_t data6);
 
  enum HeMuFlags1
  {
    HE_MU_FLAGS1_SIGB_MCS                = 0x000f, 
    HE_MU_FLAGS1_SIGB_MCS_KNOWN          = 0x0010, 
    HE_MU_FLAGS1_SIGB_DCM                = 0x0020, 
    HE_MU_FLAGS1_SIGB_DCM_KNOWN          = 0x0040, 
    HE_MU_FLAGS1_CH2_CENTER_26T_RU_KNOWN = 0x0080, 
    HE_MU_FLAGS1_CH1_RUS_KNOWN           = 0x0100, 
    HE_MU_FLAGS1_CH2_RUS_KNOWN           = 0x0200, 
    HE_MU_FLAGS1_CH1_CENTER_26T_RU_KNOWN = 0x1000, 
    HE_MU_FLAGS1_CH1_CENTER_26T_RU       = 0x2000, 
    HE_MU_FLAGS1_SIGB_COMPRESSION_KNOWN  = 0x4000, 
    HE_MU_FLAGS1_NUM_SIGB_SYMBOLS_KNOWN  = 0x8000, 
  };
 
  enum HeMuFlags2
  {
    HE_MU_FLAGS2_BW_FROM_SIGA                                 = 0x0003, 
    HE_MU_FLAGS2_BW_FROM_SIGA_KNOWN                           = 0x0004, 
    HE_MU_FLAGS2_SIGB_COMPRESSION_FROM_SIGA                   = 0x0008, 
    HE_MU_FLAGS2_NUM_SIGB_SYMBOLS_FROM_SIGA                   = 0x00f0, 
    HE_MU_FLAGS2_PREAMBLE_PUNCTURING_FROM_SIGA_BW_FIELD       = 0x0300, 
    HE_MU_FLAGS2_PREAMBLE_PUNCTURING_FROM_SIGA_BW_FIELD_KNOWN = 0x0400, 
    HE_MU_FLAGS2_CH2_CENTER_26T_RU                            = 0x0800, 
  };
 
  void SetHeMuFields (uint16_t flags1, uint16_t flags2, const std::array<uint8_t, 4> &ruChannel1, const std::array<uint8_t, 4> &ruChannel2);
 
  enum HeMuPerUserKnown
  {
    HE_MU_PER_USER_POSITION_KNOWN              = 0x01, 
    HE_MU_PER_USER_STA_ID_KNOWN                = 0x02, 
    HE_MU_PER_USER_NSTS_KNOWN                  = 0x04, 
    HE_MU_PER_USER_TX_BF_KNOWN                 = 0x08, 
    HE_MU_PER_USER_SPATIAL_CONFIGURATION_KNOWN = 0x10, 
    HE_MU_PER_USER_MCS_KNOWN                   = 0x20, 
    HE_MU_PER_USER_DCM_KNOWN                   = 0x40, 
    HE_MU_PER_USER_CODING_KNOWN                = 0x80, 
  };
 
  void SetHeMuPerUserFields (uint16_t perUser1, uint16_t perUser2, uint8_t perUserPosition, uint8_t perUserKnown);
 
private:
  enum RadiotapFlags
  {
    RADIOTAP_TSFT              = 0x00000001,
    RADIOTAP_FLAGS             = 0x00000002,
    RADIOTAP_RATE              = 0x00000004,
    RADIOTAP_CHANNEL           = 0x00000008,
    RADIOTAP_FHSS              = 0x00000010,
    RADIOTAP_DBM_ANTSIGNAL     = 0x00000020,
    RADIOTAP_DBM_ANTNOISE      = 0x00000040,
    RADIOTAP_LOCK_QUALITY      = 0x00000080,
    RADIOTAP_TX_ATTENUATION    = 0x00000100,
    RADIOTAP_DB_TX_ATTENUATION = 0x00000200,
    RADIOTAP_DBM_TX_POWER      = 0x00000400,
    RADIOTAP_ANTENNA           = 0x00000800,
    RADIOTAP_DB_ANTSIGNAL      = 0x00001000,
    RADIOTAP_DB_ANTNOISE       = 0x00002000,
    RADIOTAP_RX_FLAGS          = 0x00004000,
    RADIOTAP_MCS               = 0x00080000,
    RADIOTAP_AMPDU_STATUS      = 0x00100000,
    RADIOTAP_VHT               = 0x00200000,
    RADIOTAP_HE                = 0x00800000,
    RADIOTAP_HE_MU             = 0x01000000,
    RADIOTAP_HE_MU_OTHER_USER  = 0x02000000,
    RADIOTAP_ZERO_LEN_PSDU     = 0x04000000,
    RADIOTAP_LSIG              = 0x08000000,
    RADIOTAP_EXT               = 0x80000000
  };
 
  uint16_t m_length;        
  uint32_t m_present;       
 
  uint64_t m_tsft;          
  uint8_t m_flags;          
  uint8_t m_rate;           
  uint8_t m_channelPad;     
  uint16_t m_channelFreq;   
  uint16_t m_channelFlags;  
  int8_t m_antennaSignal;   
  int8_t m_antennaNoise;    
 
  uint8_t m_mcsKnown; 
  uint8_t m_mcsFlags; 
  uint8_t m_mcsRate;  
 
  uint8_t m_ampduStatusPad;       
  uint32_t m_ampduStatusRef;      
  uint16_t m_ampduStatusFlags;    
  uint8_t m_ampduStatusCRC;       
 
  uint8_t m_vhtPad;         
  uint16_t m_vhtKnown;      
  uint8_t m_vhtFlags;       
  uint8_t m_vhtBandwidth;   
  uint8_t m_vhtMcsNss[4];   
  uint8_t m_vhtCoding;      
  uint8_t m_vhtGroupId;     
  uint16_t m_vhtPartialAid; 
 
  uint8_t m_hePad;         
  uint16_t m_heData1;      
  uint16_t m_heData2;      
  uint16_t m_heData3;      
  uint16_t m_heData4;      
  uint16_t m_heData5;      
  uint16_t m_heData6;      
 
  uint8_t m_heMuPad;       
  uint16_t m_heMuFlags1;   
  uint16_t m_heMuFlags2;   
 
  uint8_t m_heMuOtherUserPad;    
  uint16_t m_heMuPerUser1;       
  uint16_t m_heMuPerUser2;       
  uint8_t m_heMuPerUserPosition; 
  uint8_t m_heMuPerUserKnown;    
};
 
} // namespace ns3
 
#endif /*  RADIOTAP_HEADER_H */