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 //     Stefan Bund <g0dil@berlios.de>
   8 //
   9 // This program is free software; you can redistribute it and/or modify
  10 // it under the terms of the GNU General Public License as published by
  11 // the Free Software Foundation; either version 2 of the License, or
  12 // (at your option) any later version.
  13 //
  14 // This program is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 // GNU General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU General Public License
  20 // along with this program; if not, write to the
  21 // Free Software Foundation, Inc.,
  22 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23
  24 /** \file
  25     \brief RadiotapPacket unit tests */
  26
  27 // Custom includes
  28 #include <sstream>
  29 #include "RadiotapPacket.hh"
  30
  31 #include <senf/Utils/auto_unit_test.hh>
  32 #include <boost/test/test_tools.hpp>
  33
  34 //-/////////////////////////////////////////////////////////////////////////////////////////////////
  35
  36 SENF_AUTO_UNIT_TEST(RadiotapPacket_fieldSizes)
  37 {
  38     // This test only asserts, that nobody forgot to update the FIELD_SIZE table
  39     // when chaning MAX_INDEX
  40     BOOST_CHECK( senf::RadiotapPacketParser_Header::FIELD_SIZE[
  41                      senf::RadiotapPacketParser_Header::MAX_INDEX] != 0 );
  42 }
  43
  44 SENF_AUTO_UNIT_TEST(RadiotapPacket_packet)
  45 {
  46     /* used madwifi 0.9.4 */
  47     unsigned char data[] = {
  48             0x00 ,0x00 ,0x1a ,0x00, 0x6f, 0x18, 0x00, 0x00,
  49             0x02, 0xe6, 0x8a, 0xdf, 0x12, 0x00, 0x00, 0x00,
  50             0x12, 0x0c, 0xc8, 0x14, 0x40, 0x01, 0xc3, 0xa0,
  51             0x02, 0x23,
  52             0x00, 0x00, 0x00, 0x00,
  53     };
  54     senf::RadiotapPacket p (senf::RadiotapPacket::create(data));
  55
  56     /* mandatory fields*/
  57     BOOST_CHECK_EQUAL( p->version(), 0u);
  58     BOOST_CHECK_EQUAL( p->length(), 26u);
  59
  60     /* present flags */
  61     BOOST_CHECK_EQUAL( p->tsftPresent(), true);
  62     BOOST_CHECK_EQUAL( p->flagsPresent(), true);
  63     // BOOST_CHECK_EQUAL( p->extendedBitmaskPresent(), false);
  64     BOOST_CHECK_EQUAL( p->ratePresent(), true);
  65     BOOST_CHECK_EQUAL( p->channelOptionsPresent(), true);
  66     BOOST_CHECK_EQUAL( p->fhssPresent(), false);
  67     BOOST_CHECK_EQUAL( p->dbmAntennaSignalPresent(), true);
  68     BOOST_CHECK_EQUAL( p->dbmAntennaNoisePresent(), true);
  69     BOOST_CHECK_EQUAL( p->lockQualityPresent(), false);
  70     BOOST_CHECK_EQUAL( p->txAttenuationPresent(), false);
  71     BOOST_CHECK_EQUAL( p->dbmTxAttenuationPresent(), false);
  72     BOOST_CHECK_EQUAL( p->dbTxAttenuationPresent(), false);
  73     BOOST_CHECK_EQUAL( p->antennaPresent(), true);
  74     BOOST_CHECK_EQUAL( p->dbAntennaSignalPresent(), true);
  75     BOOST_CHECK_EQUAL( p->dbAntennaNoisePresent(), false);
  76
  77     /* data flieds */
  78     BOOST_CHECK_EQUAL( p->tsft(), 81059833346uLL);
  79     BOOST_CHECK_EQUAL( p->rate(), 12u);
  80     BOOST_CHECK_EQUAL( p->channelOptions().freq(), 5320u);
  81     BOOST_CHECK_EQUAL( p->dbmAntennaSignal(), -61);
  82     BOOST_CHECK_EQUAL( p->dbmAntennaNoise(), -96);
  83     BOOST_CHECK_EQUAL( p->antenna(), 2u);
  84     BOOST_CHECK_EQUAL( p->dbAntennaSignal(), 35u);
  85
  86     /* flags */
  87     BOOST_CHECK_EQUAL( p->flags().cfp(), false);
  88     BOOST_CHECK_EQUAL( p->flags().shortPreamble(), true);
  89     BOOST_CHECK_EQUAL( p->flags().wep(), false);
  90     BOOST_CHECK_EQUAL( p->flags().fragmentation(), false);
  91     BOOST_CHECK_EQUAL( p->flags().fcsAtEnd(), true);
  92     BOOST_CHECK_EQUAL( p->flags().padding(), false);
  93     BOOST_CHECK_EQUAL( p->flags().badFCS(), false);
  94     BOOST_CHECK_EQUAL( p->flags().shortGI(), false);
  95
  96     /* channel flags */
  97     BOOST_CHECK_EQUAL( p->channelOptions().ofdm(), true);
  98     BOOST_CHECK_EQUAL( p->channelOptions().turbo(), false);
  99     BOOST_CHECK_EQUAL( p->channelOptions().cck(), false);
 100     BOOST_CHECK_EQUAL( p->channelOptions().flag5ghz(), true);
 101     BOOST_CHECK_EQUAL( p->channelOptions().passive(), false);
 102     BOOST_CHECK_EQUAL( p->channelOptions().cckOfdm(), false);
 103     BOOST_CHECK_EQUAL( p->channelOptions().gfsk(), false);
 104     BOOST_CHECK_EQUAL( p->channelOptions().gsm(), false);
 105     BOOST_CHECK_EQUAL( p->channelOptions().staticTurbo(), false);
 106     BOOST_CHECK_EQUAL( p->channelOptions().halfRateChannel(), false);
 107     BOOST_CHECK_EQUAL( p->channelOptions().quarterRateChannel(), false);
 108
 109     /* dump */
 110     std::stringstream ss;
 111     p.dump(ss);
 112     BOOST_CHECK_EQUAL( ss.str(),
 113                        "Radiotap:\n"
 114                        "  version                 : 0\n"
 115                        "  length                  : 26\n"
 116                        "  MAC timestamp           : 81059833346\n"
 117                        "  flags                   : FCSatEnd ShortPreamble \n"
 118                        "  rate                    : 12\n"
 119                        "  channel frequency       : 5320\n"
 120                        "  channel flags           : OFDM 5GHz \n"
 121                        "  antenna signal (dBm)    : -61\n"
 122                        "  antenna noise (dBm)     : -96\n"
 123                        "  antenna                 : 2\n"
 124                        "  antenna signal (dB)     : 35\n"
 125                        "  fcs                     : 0\n" );
 126 }
 127
 128 SENF_AUTO_UNIT_TEST(RadiotapPacket_create)
 129 {
 130     senf::RadiotapPacket p (senf::RadiotapPacket::create());
 131
 132     BOOST_CHECK_EQUAL( p.size(), senf::RadiotapPacketParser_Header::fixed_bytes+0 );
 133
 134     SENF_CHECK_NO_THROW( p->init_tsft()             = 81059833346uLL );
 135     SENF_CHECK_NO_THROW( p->init_rate()             =          12u   );
 136     SENF_CHECK_NO_THROW( p->init_dbmAntennaSignal() =         -61    );
 137     SENF_CHECK_NO_THROW( p->init_dbmAntennaNoise()  =         -96    );
 138     SENF_CHECK_NO_THROW( p->init_antenna()          =           2u   );
 139     SENF_CHECK_NO_THROW( p->init_dbAntennaSignal()  =          35    );
 140
 141     SENF_CHECK_NO_THROW( p->init_flags());
 142     SENF_CHECK_NO_THROW( p->flags().shortPreamble() = true);
 143
 144     SENF_CHECK_NO_THROW( p->init_channelOptions());
 145     SENF_CHECK_NO_THROW( p->channelOptions().freq() = 5320u)
 146     SENF_CHECK_NO_THROW( p->channelOptions().ofdm() = true);
 147     SENF_CHECK_NO_THROW( p->channelOptions().flag5ghz() = true);
 148
 149     SENF_CHECK_NO_THROW( p->init_fcs() );
 150
 151     p.finalizeAll();
 152
 153     BOOST_CHECK_EQUAL( p->length(), 26u );
 154     BOOST_CHECK_EQUAL( p.size(), 30u );
 155
 156     std::stringstream ss;
 157     p.dump(ss);
 158     BOOST_CHECK_EQUAL( ss.str(),
 159                        "Radiotap:\n"
 160                        "  version                 : 0\n"
 161                        "  length                  : 26\n"
 162                        "  MAC timestamp           : 81059833346\n"
 163                        "  flags                   : FCSatEnd ShortPreamble \n"
 164                        "  rate                    : 12\n"
 165                        "  channel frequency       : 5320\n"
 166                        "  channel flags           : OFDM 5GHz \n"
 167                        "  antenna signal (dBm)    : -61\n"
 168                        "  antenna noise (dBm)     : -96\n"
 169                        "  antenna                 : 2\n"
 170                        "  antenna signal (dB)     : 35\n"
 171                        "  fcs                     : 0\n" );
 172
 173     {
 174         unsigned char data[] = {
 175             /*  0 */ 0x00,                                           // version
 176             /*    */ 0x00,
 177             /*  2 */ 0x1a, 0x00,                                     // length
 178             /*  4 */ 0x6f, 0x18, 0x00, 0x00,                         // presentFlags
 179             /*  8 */ 0x02, 0xe6, 0x8a, 0xdf, 0x12, 0x00, 0x00, 0x00, // tsft
 180             /* 16 */ 0x12,                                           // flags
 181             /* 17 */ 0x0c,                                           // rate
 182             /* 18 */ 0xc8, 0x14,                                     // channel frequency
 183             /* 20 */ 0x40, 0x01,                                     // channel flags
 184             /* 22 */ 0xc3,                                           // dbmAntennaSignal
 185             /* 23 */ 0xa0,                                           // dbmAntennaNoise
 186             /* 24 */ 0x02,                                           // antenna
 187             /* 25 */ 0x23,                                           // dbAntennaSignal
 188             /* 26 */ 0x0, 0x0, 0x0, 0x0                              // FCS
 189         };
 190
 191         BOOST_CHECK_EQUAL_COLLECTIONS( p.data().begin(), p.data().end(),
 192                                        data, data+sizeof(data)/sizeof(data[0]) );
 193     }
 194
 195     SENF_CHECK_NO_THROW( p->disable_flags() );
 196     SENF_CHECK_NO_THROW( p->disable_dbmAntennaSignal() );
 197
 198     p.finalizeAll();
 199
 200     {
 201         unsigned char data[] = {
 202             /*  0 */ 0x00,                                           // version
 203             /*    */ 0x00,
 204             /*  2 */ 0x19, 0x00,                                     // length
 205             /*  4 */ 0x4d, 0x18, 0x00, 0x00,                         // presentFlags
 206             /*  8 */ 0x02, 0xe6, 0x8a, 0xdf, 0x12, 0x00, 0x00, 0x00, // tsft
 207             /* 16 */ 0x0c,                                           // rate
 208             /*    */ 0x00,
 209             /* 18 */ 0xc8, 0x14,                                     // channel frequency
 210             /* 20 */ 0x40, 0x01,                                     // channel flags
 211             /* 22 */ 0xa0,                                           // dbmAntennaNoise
 212             /* 23 */ 0x02,                                           // antenna
 213             /* 24 */ 0x23                                            // dbAntennaSignal
 214         };
 215         BOOST_CHECK_EQUAL_COLLECTIONS( p.data().begin(), p.data().end(),
 216                                        data, data+sizeof(data)/sizeof(data[0]) );
 217     }
 218 }
 219
 220 SENF_AUTO_UNIT_TEST(RadiotapPacket_packet_ath9k)
 221 {
 222     /* radiotap packet from ath9k with atheros card*/
 223     unsigned char data[] = {
 224             0x00, 0x00, 0x20, 0x00, 0x6f, 0x48, 0x00, 0x00,
 225             0x87, 0xbb, 0x91, 0x7c, 0x3b, 0x00, 0x00, 0x00,
 226             0x00, 0x04, 0x85, 0x09, 0x80, 0x04, 0xb2, 0xa1,
 227             0x00, 0x00, 0x00, 0x00, 0xd5, 0x1a, 0xf7, 0x94,
 228             0x00, 0x00, 0x00, 0x00,
 229     };
 230     senf::RadiotapPacket p (senf::RadiotapPacket::create(data));
 231
 232     /* mandatory fields*/
 233     BOOST_CHECK_EQUAL( p->version(), 0u);
 234     BOOST_CHECK_EQUAL( p->length(), 32u);
 235
 236     BOOST_CHECK_EQUAL( p->dbmAntennaSignal(), -78);
 237     BOOST_CHECK_EQUAL( p->dbmAntennaNoise(), -95);
 238 #if 0
 239     // The standard defines this field as RXFlags / TXFLags, so using the
 240     // 'official' radiotap parser, this test fails ...
 241     // Why is this field parsed using MSB byteorder ??
 242     BOOST_CHECK_EQUAL( p->headerFcs(), 0xd51af794);
 243 #endif
 244     BOOST_CHECK_EQUAL( p->antenna(), 0u);
 245 }
 246
 247 SENF_AUTO_UNIT_TEST(RadiotapPacket_parsetest)
 248 {
 249     unsigned char data[] = {
 250         '\x00', '\x00', '\x20', '\x00', '\x2f', '\x48', '\x00', '\x00',
 251         '\xbe', '\xa5', '\xaf', '\x00', '\x00', '\x00', '\x00', '\x00',
 252         '\x10', '\x04', '\x6c', '\x09', '\xa0', '\x00', '\xb6', '\x01',
 253         '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
 254         '\x80', '\x00', '\x00', '\x00', '\xff', '\xff', '\xff', '\xff',
 255         '\xff', '\xff', '\x00', '\x0b', '\x0e', '\x26', '\xab', '\xc0',
 256         '\x00', '\x0b', '\x0e', '\x26', '\xab', '\xc0', '\xe0', '\xec',
 257         '\x81', '\x31', '\x0d', '\x1c', '\x72', '\x0a', '\x00', '\x00',
 258         '\x64', '\x00', '\x31', '\x04', '\x00', '\x05', '\x46', '\x4f',
 259         '\x4b', '\x55', '\x53', '\x01', '\x08', '\x82', '\x84', '\x8b',
 260         '\x0c', '\x12', '\x96', '\x18', '\x24', '\x03', '\x01', '\x01',
 261         '\x05', '\x04', '\x00', '\x01', '\x00', '\x00', '\x07', '\x06',
 262         '\x44', '\x45', '\x20', '\x01', '\x0d', '\x12', '\x0b', '\x05',
 263         '\x01', '\x00', '\x07', '\x00', '\x00', '\x43', '\x02', '\x00',
 264         '\x00', '\x2a', '\x01', '\x00', '\x30', '\x14', '\x01', '\x00',
 265         '\x00', '\x0f', '\xac', '\x04', '\x01', '\x00', '\x00', '\x0f',
 266         '\xac', '\x04', '\x01', '\x00', '\x00', '\x0f', '\xac', '\x02',
 267         '\x00', '\x00', '\x32', '\x04', '\x30', '\x48', '\x60', '\x6c',
 268         '\xdd', '\x05', '\x00', '\x0b', '\x0e', '\x04', '\x00', '\xdd',
 269         '\x22', '\x00', '\x0b', '\x0e', '\x02', '\x00', '\x00', '\x00',
 270         '\x00', '\x12', '\x0c', '\x02', '\xa1', '\x04', '\xa2', '\x0b',
 271         '\xa3', '\x0c', '\xa5', '\x12', '\xa6', '\x16', '\xa6', '\x18',
 272         '\xa7', '\x24', '\xa8', '\x30', '\xab', '\x48', '\xae', '\x60',
 273         '\xb5', '\x6c', '\xb8', '\xdd', '\x2e', '\x00', '\x0b', '\x0e',
 274         '\x03', '\x00', '\xad', '\x67', '\x20', '\xc2', '\xc2', '\x14',
 275         '\x0e', '\x36', '\xde', '\x3f', '\xbb', '\x2e', '\x4e', '\x02',
 276         '\x70', '\x8a', '\x5b', '\x66', '\x59', '\x3c', '\xdb', '\xbb',
 277         '\xc9', '\x65', '\x16', '\x99', '\x16', '\x84', '\x43', '\xaa',
 278         '\x00', '\xa2', '\x45', '\xbc', '\xbc', '\x58', '\x9b', '\xd4',
 279         '\x3e', '\xef', '\xca', '\xdd', '\x07', '\x00', '\x50', '\xf2',
 280         '\x02', '\x00', '\x01', '\x01', '\xdd', '\x18', '\x00', '\x50',
 281         '\xf2', '\x02', '\x01', '\x01', '\x01', '\x00', '\x03', '\xa4',
 282         '\x00', '\x00', '\x27', '\xa4', '\x00', '\x00', '\x42', '\x43',
 283         '\x5e', '\x00', '\x62', '\x32', '\x2f', '\x00', '\x0e', '\x58',
 284         '\xcd', '\xa0'
 285     };
 286     senf::RadiotapPacket p (senf::RadiotapPacket::create(data));
 287
 288     std::stringstream ss;
 289     p.dump(ss);
 290
 291     BOOST_CHECK_EQUAL(ss.str(),
 292                       "Radiotap:\n"
 293                       "  version                 : 0\n"
 294                       "  length                  : 32\n"
 295                       "  MAC timestamp           : 11511230\n"
 296                       "  flags                   : FCSatEnd \n"
 297                       "  rate                    : 4\n"
 298                       "  channel frequency       : 2412\n"
 299                       "  channel flags           : 2GHz CCK \n"
 300                       "  antenna signal (dBm)    : -74\n"
 301                       "  antenna                 : 1\n"
 302                       "  rx flags                : \n"
 303                       "  fcs                     : 240700832\n"
 304                       "802.11 MAC Management Frame:\n"
 305                       "  version                 : 0\n"
 306                       "  type                    : 0\n"
 307                       "  subtype                 : 8\n"
 308                       "  flags                   : none\n"
 309                       "  duration                : 0\n"
 310                       "  destination             : ff:ff:ff:ff:ff:ff\n"
 311                       "  source                  : 00:0b:0e:26:ab:c0\n"
 312                       "  bss id                  : 00:0b:0e:26:ab:c0\n"
 313                       "  sequence number         : 3790\n"
 314                       "  fragment number         : 0\n");
 315 }
 316
 317
 318 \f
 319 // Local Variables:
 320 // mode: c++
 321 // fill-column: 100
 322 // c-file-style: "senf"
 323 // indent-tabs-mode: nil
 324 // ispell-local-dictionary: "american"
 325 // compile-command: "scons -u test"
 326 // comment-column: 40
 327 // End: