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

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