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     SENF_CHECK_NO_THROW( p->init_rate()             =          12u   );
 141     SENF_CHECK_NO_THROW( p->init_dbmAntennaSignal() =         -61    );
 142     SENF_CHECK_NO_THROW( p->init_dbmAntennaNoise()  =         -96    );
 143     SENF_CHECK_NO_THROW( p->init_antenna()          =           2u   );
 144     SENF_CHECK_NO_THROW( p->init_dbAntennaSignal()  =          35    );
 145
 146     SENF_CHECK_NO_THROW( p->init_flags());
 147     SENF_CHECK_NO_THROW( p->flags().shortPreamble() = true);
 148
 149     SENF_CHECK_NO_THROW( p->init_channelOptions());
 150     SENF_CHECK_NO_THROW( p->channelOptions().freq() = 5320u)
 151     SENF_CHECK_NO_THROW( p->channelOptions().ofdm() = true);
 152     SENF_CHECK_NO_THROW( p->channelOptions().flag5ghz() = true);
 153
 154     SENF_CHECK_NO_THROW( p->init_fcs() );
 155
 156     p.finalizeAll();
 157
 158     BOOST_CHECK_EQUAL( p->length(), 26u );
 159     BOOST_CHECK_EQUAL( p.size(), 30u );
 160
 161     std::stringstream ss;
 162     p.dump(ss);
 163     BOOST_CHECK_EQUAL( ss.str(),
 164                        "Radiotap:\n"
 165                        "  version                 : 0\n"
 166                        "  length                  : 26\n"
 167                        "  MAC timestamp           : 81059833346\n"
 168                        "  flags                   : FCSatEnd ShortPreamble \n"
 169                        "  rate                    : 12\n"
 170                        "  channel frequency       : 5320\n"
 171                        "  channel flags           : OFDM 5GHz \n"
 172                        "  antenna signal (dBm)    : -61\n"
 173                        "  antenna noise (dBm)     : -96\n"
 174                        "  antenna                 : 2\n"
 175                        "  antenna signal (dB)     : 35\n"
 176                        "  fcs                     : 0\n" );
 177
 178     {
 179         unsigned char data[] = {
 180             /*  0 */ 0x00,                                           // version
 181             /*    */ 0x00,
 182             /*  2 */ 0x1a, 0x00,                                     // length
 183             /*  4 */ 0x6f, 0x18, 0x00, 0x00,                         // presentFlags
 184             /*  8 */ 0x02, 0xe6, 0x8a, 0xdf, 0x12, 0x00, 0x00, 0x00, // tsft
 185             /* 16 */ 0x12,                                           // flags
 186             /* 17 */ 0x0c,                                           // rate
 187             /* 18 */ 0xc8, 0x14,                                     // channel frequency
 188             /* 20 */ 0x40, 0x01,                                     // channel flags
 189             /* 22 */ 0xc3,                                           // dbmAntennaSignal
 190             /* 23 */ 0xa0,                                           // dbmAntennaNoise
 191             /* 24 */ 0x02,                                           // antenna
 192             /* 25 */ 0x23,                                           // dbAntennaSignal
 193             /* 26 */ 0x0, 0x0, 0x0, 0x0                              // FCS
 194         };
 195
 196         BOOST_CHECK_EQUAL_COLLECTIONS( p.data().begin(), p.data().end(),
 197                                        data, data+sizeof(data)/sizeof(data[0]) );
 198     }
 199
 200     SENF_CHECK_NO_THROW( p->disable_flags() );
 201     SENF_CHECK_NO_THROW( p->disable_dbmAntennaSignal() );
 202
 203     p.finalizeAll();
 204
 205     {
 206         unsigned char data[] = {
 207             /*  0 */ 0x00,                                           // version
 208             /*    */ 0x00,
 209             /*  2 */ 0x19, 0x00,                                     // length
 210             /*  4 */ 0x4d, 0x18, 0x00, 0x00,                         // presentFlags
 211             /*  8 */ 0x02, 0xe6, 0x8a, 0xdf, 0x12, 0x00, 0x00, 0x00, // tsft
 212             /* 16 */ 0x0c,                                           // rate
 213             /*    */ 0x00,
 214             /* 18 */ 0xc8, 0x14,                                     // channel frequency
 215             /* 20 */ 0x40, 0x01,                                     // channel flags
 216             /* 22 */ 0xa0,                                           // dbmAntennaNoise
 217             /* 23 */ 0x02,                                           // antenna
 218             /* 24 */ 0x23                                            // dbAntennaSignal
 219         };
 220         BOOST_CHECK_EQUAL_COLLECTIONS( p.data().begin(), p.data().end(),
 221                                        data, data+sizeof(data)/sizeof(data[0]) );
 222     }
 223 }
 224
 225 SENF_AUTO_UNIT_TEST(RadiotapPacket_packet_ath9k)
 226 {
 227     /* radiotap packet from ath9k with atheros card*/
 228     unsigned char data[] = {
 229             0x00, 0x00, 0x20, 0x00, 0x6f, 0x48, 0x00, 0x00,
 230             0x87, 0xbb, 0x91, 0x7c, 0x3b, 0x00, 0x00, 0x00,
 231             0x00, 0x04, 0x85, 0x09, 0x80, 0x04, 0xb2, 0xa1,
 232             0x00, 0x00, 0x00, 0x00, 0xd5, 0x1a, 0xf7, 0x94,
 233             0x00, 0x00, 0x00, 0x00,
 234     };
 235     senf::RadiotapPacket p (senf::RadiotapPacket::create(data));
 236
 237     /* mandatory fields*/
 238     BOOST_CHECK_EQUAL( p->version(), 0u);
 239     BOOST_CHECK_EQUAL( p->length(), 32u);
 240
 241     BOOST_CHECK_EQUAL( p->dbmAntennaSignal(), -78);
 242     BOOST_CHECK_EQUAL( p->dbmAntennaNoise(), -95);
 243 #if 0
 244     // The standard defines this field as RXFlags / TXFLags, so using the
 245     // 'official' radiotap parser, this test fails ...
 246     // Why is this field parsed using MSB byteorder ??
 247     BOOST_CHECK_EQUAL( p->headerFcs(), 0xd51af794);
 248 #endif
 249     BOOST_CHECK_EQUAL( p->antenna(), 0u);
 250 }
 251
 252 SENF_AUTO_UNIT_TEST(RadiotapPacket_parsetest)
 253 {
 254     unsigned char data[] = {
 255         '\x00', '\x00', '\x20', '\x00', '\x2f', '\x48', '\x00', '\x00',
 256         '\xbe', '\xa5', '\xaf', '\x00', '\x00', '\x00', '\x00', '\x00',
 257         '\x10', '\x04', '\x6c', '\x09', '\xa0', '\x00', '\xb6', '\x01',
 258         '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
 259         '\x80', '\x00', '\x00', '\x00', '\xff', '\xff', '\xff', '\xff',
 260         '\xff', '\xff', '\x00', '\x0b', '\x0e', '\x26', '\xab', '\xc0',
 261         '\x00', '\x0b', '\x0e', '\x26', '\xab', '\xc0', '\xe0', '\xec',
 262         '\x81', '\x31', '\x0d', '\x1c', '\x72', '\x0a', '\x00', '\x00',
 263         '\x64', '\x00', '\x31', '\x04', '\x00', '\x05', '\x46', '\x4f',
 264         '\x4b', '\x55', '\x53', '\x01', '\x08', '\x82', '\x84', '\x8b',
 265         '\x0c', '\x12', '\x96', '\x18', '\x24', '\x03', '\x01', '\x01',
 266         '\x05', '\x04', '\x00', '\x01', '\x00', '\x00', '\x07', '\x06',
 267         '\x44', '\x45', '\x20', '\x01', '\x0d', '\x12', '\x0b', '\x05',
 268         '\x01', '\x00', '\x07', '\x00', '\x00', '\x43', '\x02', '\x00',
 269         '\x00', '\x2a', '\x01', '\x00', '\x30', '\x14', '\x01', '\x00',
 270         '\x00', '\x0f', '\xac', '\x04', '\x01', '\x00', '\x00', '\x0f',
 271         '\xac', '\x04', '\x01', '\x00', '\x00', '\x0f', '\xac', '\x02',
 272         '\x00', '\x00', '\x32', '\x04', '\x30', '\x48', '\x60', '\x6c',
 273         '\xdd', '\x05', '\x00', '\x0b', '\x0e', '\x04', '\x00', '\xdd',
 274         '\x22', '\x00', '\x0b', '\x0e', '\x02', '\x00', '\x00', '\x00',
 275         '\x00', '\x12', '\x0c', '\x02', '\xa1', '\x04', '\xa2', '\x0b',
 276         '\xa3', '\x0c', '\xa5', '\x12', '\xa6', '\x16', '\xa6', '\x18',
 277         '\xa7', '\x24', '\xa8', '\x30', '\xab', '\x48', '\xae', '\x60',
 278         '\xb5', '\x6c', '\xb8', '\xdd', '\x2e', '\x00', '\x0b', '\x0e',
 279         '\x03', '\x00', '\xad', '\x67', '\x20', '\xc2', '\xc2', '\x14',
 280         '\x0e', '\x36', '\xde', '\x3f', '\xbb', '\x2e', '\x4e', '\x02',
 281         '\x70', '\x8a', '\x5b', '\x66', '\x59', '\x3c', '\xdb', '\xbb',
 282         '\xc9', '\x65', '\x16', '\x99', '\x16', '\x84', '\x43', '\xaa',
 283         '\x00', '\xa2', '\x45', '\xbc', '\xbc', '\x58', '\x9b', '\xd4',
 284         '\x3e', '\xef', '\xca', '\xdd', '\x07', '\x00', '\x50', '\xf2',
 285         '\x02', '\x00', '\x01', '\x01', '\xdd', '\x18', '\x00', '\x50',
 286         '\xf2', '\x02', '\x01', '\x01', '\x01', '\x00', '\x03', '\xa4',
 287         '\x00', '\x00', '\x27', '\xa4', '\x00', '\x00', '\x42', '\x43',
 288         '\x5e', '\x00', '\x62', '\x32', '\x2f', '\x00', '\x0e', '\x58',
 289         '\xcd', '\xa0'
 290     };
 291     senf::RadiotapPacket p (senf::RadiotapPacket::create(data));
 292
 293     std::stringstream ss;
 294     p.dump(ss);
 295
 296     BOOST_CHECK_EQUAL(ss.str(),
 297                       "Radiotap:\n"
 298                       "  version                 : 0\n"
 299                       "  length                  : 32\n"
 300                       "  MAC timestamp           : 11511230\n"
 301                       "  flags                   : FCSatEnd \n"
 302                       "  rate                    : 4\n"
 303                       "  channel frequency       : 2412\n"
 304                       "  channel flags           : 2GHz CCK \n"
 305                       "  antenna signal (dBm)    : -74\n"
 306                       "  antenna                 : 1\n"
 307                       "  rx flags                : \n"
 308                       "  fcs                     : 240700832\n"
 309                       "802.11 MAC Management Frame:\n"
 310                       "  version                 : 0\n"
 311                       "  type                    : 0\n"
 312                       "  subtype                 : 8\n"
 313                       "  flags                   : none\n"
 314                       "  duration                : 0\n"
 315                       "  destination             : ff:ff:ff:ff:ff:ff\n"
 316                       "  source                  : 00:0b:0e:26:ab:c0\n"
 317                       "  bss id                  : 00:0b:0e:26:ab:c0\n"
 318                       "  sequence number         : 3790\n"
 319                       "  fragment number         : 0\n");
 320 }
 321
 322
 323 \f
 324 // Local Variables:
 325 // mode: c++
 326 // fill-column: 100
 327 // c-file-style: "senf"
 328 // indent-tabs-mode: nil
 329 // ispell-local-dictionary: "american"
 330 // compile-command: "scons -u test"
 331 // comment-column: 40
 332 // End: