senf/Packets/80211Bundle/RadiotapPacket.test.cc

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Christian Niephaus <cni@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief RadiotapPacket unit tests */
  25
  26 // Custom includes
  27 #include <sstream>
  28 #include "RadiotapPacket.hh"
  29
  30 #include <senf/Utils/auto_unit_test.hh>
  31 #include <boost/test/test_tools.hpp>
  32
  33 ///////////////////////////////cc.p////////////////////////////////////////
  34
  35 SENF_AUTO_UNIT_TEST(RadiotapPacket_fieldSizes)
  36 {
  37     // This test only asserts, that nobody forgot to update the FIELD_SIZE table
  38     // when chaning MAX_INDEX
  39     BOOST_CHECK( senf::RadiotapPacketParser_Header::FIELD_SIZE[
  40                      senf::RadiotapPacketParser_Header::MAX_INDEX] != 0 );
  41 }
  42
  43 SENF_AUTO_UNIT_TEST(RadiotapPacket_packet)
  44 {
  45     /* used madwifi 0.9.4 */
  46     unsigned char data[] = {
  47             0x00 ,0x00 ,0x1a ,0x00, 0x6f, 0x18, 0x00, 0x00,
  48             0x02, 0xe6, 0x8a, 0xdf, 0x12, 0x00, 0x00, 0x00,
  49             0x12, 0x0c, 0xc8, 0x14, 0x40, 0x01, 0xc3, 0xa0,
  50             0x02, 0x23,
  51             0x00, 0x00, 0x00, 0x00,
  52     };
  53     senf::RadiotapPacket p (senf::RadiotapPacket::create(data));
  54
  55     /* mandatory fields*/
  56     BOOST_CHECK_EQUAL( p->version(), 0u);
  57     BOOST_CHECK_EQUAL( p->length(), 26u);
  58
  59     /* present flags */
  60     BOOST_CHECK_EQUAL( p->tsftPresent(), true);
  61     BOOST_CHECK_EQUAL( p->flagsPresent(), true);
  62     // BOOST_CHECK_EQUAL( p->extendedBitmaskPresent(), false);
  63     BOOST_CHECK_EQUAL( p->ratePresent(), true);
  64     BOOST_CHECK_EQUAL( p->channelOptionsPresent(), true);
  65     BOOST_CHECK_EQUAL( p->fhssPresent(), false);
  66     BOOST_CHECK_EQUAL( p->dbmAntennaSignalPresent(), true);
  67     BOOST_CHECK_EQUAL( p->dbmAntennaNoisePresent(), true);
  68     BOOST_CHECK_EQUAL( p->lockQualityPresent(), false);
  69     BOOST_CHECK_EQUAL( p->txAttenuationPresent(), false);
  70     BOOST_CHECK_EQUAL( p->dbmTxAttenuationPresent(), false);
  71     BOOST_CHECK_EQUAL( p->dbTxAttenuationPresent(), false);
  72     BOOST_CHECK_EQUAL( p->antennaPresent(), true);
  73     BOOST_CHECK_EQUAL( p->dbAntennaSignalPresent(), true);
  74     BOOST_CHECK_EQUAL( p->dbAntennaNoisePresent(), false);
  75
  76     /* data flieds */
  77     BOOST_CHECK_EQUAL( p->tsft(), 81059833346uLL);
  78     BOOST_CHECK_EQUAL( p->rate(), 12u);
  79     BOOST_CHECK_EQUAL( p->channelOptions().freq(), 5320u);
  80     BOOST_CHECK_EQUAL( p->dbmAntennaSignal(), -61);
  81     BOOST_CHECK_EQUAL( p->dbmAntennaNoise(), -96);
  82     BOOST_CHECK_EQUAL( p->antenna(), 2u);
  83     BOOST_CHECK_EQUAL( p->dbAntennaSignal(), 35u);
  84
  85     /* flags */
  86     BOOST_CHECK_EQUAL( p->flags().cfp(), false);
  87     BOOST_CHECK_EQUAL( p->flags().shortPreamble(), true);
  88     BOOST_CHECK_EQUAL( p->flags().wep(), false);
  89     BOOST_CHECK_EQUAL( p->flags().fragmentation(), false);
  90     BOOST_CHECK_EQUAL( p->flags().fcsAtEnd(), true);
  91     BOOST_CHECK_EQUAL( p->flags().padding(), false);
  92     BOOST_CHECK_EQUAL( p->flags().badFCS(), false);
  93     BOOST_CHECK_EQUAL( p->flags().shortGI(), false);
  94
  95     /* channel flags */
  96     BOOST_CHECK_EQUAL( p->channelOptions().ofdm(), true);
  97     BOOST_CHECK_EQUAL( p->channelOptions().turbo(), false);
  98     BOOST_CHECK_EQUAL( p->channelOptions().cck(), false);
  99     BOOST_CHECK_EQUAL( p->channelOptions().flag5ghz(), true);
 100     BOOST_CHECK_EQUAL( p->channelOptions().passive(), false);
 101     BOOST_CHECK_EQUAL( p->channelOptions().cckOfdm(), false);
 102     BOOST_CHECK_EQUAL( p->channelOptions().gfsk(), false);
 103     BOOST_CHECK_EQUAL( p->channelOptions().gsm(), false);
 104     BOOST_CHECK_EQUAL( p->channelOptions().staticTurbo(), false);
 105     BOOST_CHECK_EQUAL( p->channelOptions().halfRateChannel(), false);
 106     BOOST_CHECK_EQUAL( p->channelOptions().quarterRateChannel(), false);
 107
 108     /* dump */
 109     std::stringstream ss;
 110     p.dump(ss);
 111     BOOST_CHECK_EQUAL( ss.str(),
 112                        "Radiotap:\n"
 113                        "  version                 : 0\n"
 114                        "  length                  : 26\n"
 115                        "  MAC timestamp           : 81059833346\n"
 116                        "  flags                   : FCSatEnd ShortPreamble \n"
 117                        "  rate                    : 12\n"
 118                        "  channel frequency       : 5320\n"
 119                        "  channel flags           : OFDM 5GHz \n"
 120                        "  antenna signal (dBm)    : -61\n"
 121                        "  antenna noise (dBm)     : -96\n"
 122                        "  antenna                 : 2\n"
 123                        "  antenna signal (dB)     : 35\n"
 124                        "  fcs                     : 0\n" );
 125 }
 126
 127 SENF_AUTO_UNIT_TEST(RadiotapPacket_create)
 128 {
 129     senf::RadiotapPacket p (senf::RadiotapPacket::create());
 130
 131     BOOST_CHECK_EQUAL( p.size(), senf::RadiotapPacketParser_Header::fixed_bytes+0 );
 132
 133     SENF_CHECK_NO_THROW( p->init_tsft()             = 81059833346uLL );
 134     SENF_CHECK_NO_THROW( p->init_rate()             =          12u   );
 135     SENF_CHECK_NO_THROW( p->init_dbmAntennaSignal() =         -61    );
 136     SENF_CHECK_NO_THROW( p->init_dbmAntennaNoise()  =         -96    );
 137     SENF_CHECK_NO_THROW( p->init_antenna()          =           2u   );
 138     SENF_CHECK_NO_THROW( p->init_dbAntennaSignal()  =          35    );
 139
 140     SENF_CHECK_NO_THROW( p->init_flags());
 141     SENF_CHECK_NO_THROW( p->flags().shortPreamble() = true);
 142
 143     SENF_CHECK_NO_THROW( p->init_channelOptions());
 144     SENF_CHECK_NO_THROW( p->channelOptions().freq() = 5320u)
 145     SENF_CHECK_NO_THROW( p->channelOptions().ofdm() = true);
 146     SENF_CHECK_NO_THROW( p->channelOptions().flag5ghz() = true);
 147
 148     SENF_CHECK_NO_THROW( p->init_fcs() );
 149
 150     p.finalizeAll();
 151
 152     BOOST_CHECK_EQUAL( p->length(), 26u );
 153     BOOST_CHECK_EQUAL( p.size(), 30u );
 154
 155     std::stringstream ss;
 156     p.dump(ss);
 157     BOOST_CHECK_EQUAL( ss.str(),
 158                        "Radiotap:\n"
 159                        "  version                 : 0\n"
 160                        "  length                  : 26\n"
 161                        "  MAC timestamp           : 81059833346\n"
 162                        "  flags                   : FCSatEnd ShortPreamble \n"
 163                        "  rate                    : 12\n"
 164                        "  channel frequency       : 5320\n"
 165                        "  channel flags           : OFDM 5GHz \n"
 166                        "  antenna signal (dBm)    : -61\n"
 167                        "  antenna noise (dBm)     : -96\n"
 168                        "  antenna                 : 2\n"
 169                        "  antenna signal (dB)     : 35\n"
 170                        "  fcs                     : 0\n" );
 171
 172     {
 173         unsigned char data[] = {
 174             /*  0 */ 0x00,                                           // version
 175             /*    */ 0x00,
 176             /*  2 */ 0x1a, 0x00,                                     // length
 177             /*  4 */ 0x6f, 0x18, 0x00, 0x00,                         // presentFlags
 178             /*  8 */ 0x02, 0xe6, 0x8a, 0xdf, 0x12, 0x00, 0x00, 0x00, // tsft
 179             /* 16 */ 0x12,                                           // flags
 180             /* 17 */ 0x0c,                                           // rate
 181             /* 18 */ 0xc8, 0x14,                                     // channel frequency
 182             /* 20 */ 0x40, 0x01,                                     // channel flags
 183             /* 22 */ 0xc3,                                           // dbmAntennaSignal
 184             /* 23 */ 0xa0,                                           // dbmAntennaNoise
 185             /* 24 */ 0x02,                                           // antenna
 186             /* 25 */ 0x23,                                           // dbAntennaSignal
 187             /* 26 */ 0x0, 0x0, 0x0, 0x0                              // FCS
 188         };
 189
 190         BOOST_CHECK_EQUAL_COLLECTIONS( p.data().begin(), p.data().end(),
 191                                        data, data+sizeof(data)/sizeof(data[0]) );
 192     }
 193
 194     SENF_CHECK_NO_THROW( p->disable_flags() );
 195     SENF_CHECK_NO_THROW( p->disable_dbmAntennaSignal() );
 196
 197     p.finalizeAll();
 198
 199     {
 200         unsigned char data[] = {
 201             /*  0 */ 0x00,                                           // version
 202             /*    */ 0x00,
 203             /*  2 */ 0x19, 0x00,                                     // length
 204             /*  4 */ 0x4d, 0x18, 0x00, 0x00,                         // presentFlags
 205             /*  8 */ 0x02, 0xe6, 0x8a, 0xdf, 0x12, 0x00, 0x00, 0x00, // tsft
 206             /* 16 */ 0x0c,                                           // rate
 207             /*    */ 0x00,
 208             /* 18 */ 0xc8, 0x14,                                     // channel frequency
 209             /* 20 */ 0x40, 0x01,                                     // channel flags
 210             /* 22 */ 0xa0,                                           // dbmAntennaNoise
 211             /* 23 */ 0x02,                                           // antenna
 212             /* 24 */ 0x23                                            // dbAntennaSignal
 213         };
 214         BOOST_CHECK_EQUAL_COLLECTIONS( p.data().begin(), p.data().end(),
 215                                        data, data+sizeof(data)/sizeof(data[0]) );
 216     }
 217 }
 218
 219 SENF_AUTO_UNIT_TEST(RadiotapPacket_packet_ath9k)
 220 {
 221     /* radiotap packet from ath9k with atheros card*/
 222     unsigned char data[] = {
 223             0x00, 0x00, 0x20, 0x00, 0x6f, 0x48, 0x00, 0x00,
 224             0x87, 0xbb, 0x91, 0x7c, 0x3b, 0x00, 0x00, 0x00,
 225             0x00, 0x04, 0x85, 0x09, 0x80, 0x04, 0xb2, 0xa1,
 226             0x00, 0x00, 0x00, 0x00, 0xd5, 0x1a, 0xf7, 0x94,
 227             0x00, 0x00, 0x00, 0x00,
 228     };
 229     senf::RadiotapPacket p (senf::RadiotapPacket::create(data));
 230
 231     /* mandatory fields*/
 232     BOOST_CHECK_EQUAL( p->version(), 0u);
 233     BOOST_CHECK_EQUAL( p->length(), 32u);
 234
 235     BOOST_CHECK_EQUAL( p->dbmAntennaSignal(), -78);
 236     BOOST_CHECK_EQUAL( p->dbmAntennaNoise(), -95);
 237 #if 0
 238     // The standard defines this field as RXFlags / TXFLags, so using the
 239     // 'official' radiotap parser, this test fails ...
 240     // Why is this field parsed using MSB byteorder ??
 241     BOOST_CHECK_EQUAL( p->headerFcs(), 0xd51af794);
 242 #endif
 243     BOOST_CHECK_EQUAL( p->antenna(), 0u);
 244 }
 245
 246
 247 \f
 248 // Local Variables:
 249 // mode: c++
 250 // fill-column: 100
 251 // c-file-style: "senf"
 252 // indent-tabs-mode: nil
 253 // ispell-local-dictionary: "american"
 254 // compile-command: "scons -u test"
 255 // comment-column: 40
 256 // End: