Packets/80211Bundle/WLANPacket.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 WLANPacket unit tests */
  25
  26 // Custom includes
  27 #include "WLANPacket.hh"
  28 #include "../../Packets/Packets.hh"
  29 #include "../DefaultBundle/LlcSnapPacket.hh"
  30
  31 #include "../../Utils/auto_unit_test.hh"
  32 #include <boost/test/test_tools.hpp>
  33
  34 ///////////////////////////////cc.p////////////////////////////////////////
  35 /* test parser with a data frame */
  36 BOOST_AUTO_UNIT_TEST(WLANPacket_dataFrame_packet)
  37 {
  38     unsigned char data[] = {
  39             0x88, 0x01, 0x00, 0x00, 0x00, 0x1a,             //header
  40             0x4d, 0x3e, 0xc7, 0x5c, 0x00, 0x0b, 0x6b, 0x57,
  41             0x06, 0xb0, 0x00, 0x18, 0x4d, 0x6e, 0x78, 0x48,
  42             0x30, 0x00, 0x01, 0x00,
  43             0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00,  //llc header
  44             0x38, 0x39, 0x30, 0x31                          //trailer
  45     };
  46
  47
  48     senf::WLANPacket p (senf::WLANPacket::create(data));
  49
  50     BOOST_CHECK_EQUAL( p->version(),        0u    );
  51     BOOST_CHECK_EQUAL( p->type(),           2u    );
  52     BOOST_CHECK_EQUAL( p->subtype(),        8u    );
  53     BOOST_CHECK_EQUAL( p->toDS(),           true  );
  54     BOOST_CHECK_EQUAL( p->fromDS(),         false );
  55     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
  56     BOOST_CHECK_EQUAL( p->retry(),          false );
  57     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
  58     BOOST_CHECK_EQUAL( p->moreData(),       false );
  59     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
  60     BOOST_CHECK_EQUAL( p->order(),          false );
  61
  62     BOOST_CHECK_EQUAL( p->duration(),       0u    );
  63
  64     BOOST_CHECK_EQUAL(
  65             p->dataFrame().destinationAddress().value(),
  66             senf::MACAddress::from_string("00:18:4d:6e:78:48") );
  67     BOOST_CHECK_EQUAL(
  68             p->dataFrame().sourceAddress().value(),
  69             senf::MACAddress::from_string("00:0b:6b:57:06:b0") );
  70     BOOST_CHECK_EQUAL(
  71             p->dataFrame().bssid().value(),
  72             senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
  73
  74     BOOST_CHECK_EQUAL(
  75             p->dataFrame().bssid().value(),
  76             p->dataFrame().receiverAddress().value() );
  77     BOOST_CHECK_EQUAL(
  78             p->dataFrame().transmitterAddress().value(),
  79             p->dataFrame().sourceAddress().value() );
  80
  81     BOOST_CHECK_EQUAL( p->dataFrame().sequenceNumber(), 3u );
  82     BOOST_CHECK_EQUAL( p->dataFrame().fragmentNumber(), 0u );
  83
  84     std::ostringstream oss (std::ostringstream::out);
  85     SENF_CHECK_NO_THROW( p.dump( oss));
  86
  87     BOOST_CHECK( p.next());
  88     BOOST_CHECK( p.next().is<senf::LlcSnapPacket>() );
  89 }
  90
  91
  92 /* test parser with creating a data frame*/
  93 BOOST_AUTO_UNIT_TEST(WLANPacket_dataFrame_create)
  94 {
  95     senf::WLANPacket p (senf::WLANPacket::create());
  96
  97     SENF_CHECK_NO_THROW( p->init_dataFrame() );
  98     SENF_CHECK_NO_THROW( p->dataFrame().bssid() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
  99     BOOST_CHECK_EQUAL( p->type(), 2u );
 100 }
 101
 102
 103 /* test parser with a beacon frame */
 104 BOOST_AUTO_UNIT_TEST(WLANPacket_beaconFrame_packet)
 105 {
 106     unsigned char data[] = {
 107             0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 108             0xff, 0xff, 0x00, 0x1a, 0x4d, 0x3e, 0xc7, 0x5c,
 109             0x00, 0x1a, 0x4d, 0x3e, 0xc7, 0x5c, 0xe0, 0x12,
 110             0x38, 0xa0, 0x86, 0x01, 0x00, 0x00, 0x00, 0x00,
 111             0x64, 0x00, 0x01, 0x05, 0x00, 0x05, 0x62, 0x6f,
 112             0x78, 0x43, 0x31, 0x01, 0x08, 0x8c, 0x12, 0x98,
 113             0x24, 0xb0, 0x48, 0x60, 0x6c, 0x03, 0x01, 0x40,
 114             0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x07, 0x2a,
 115             0x4e, 0x41, 0x49, 0x24, 0x01, 0x11, 0x28, 0x01,
 116             0x11, 0x2c, 0x01, 0x11, 0x30, 0x01, 0x11, 0x34,
 117             0x01, 0x17, 0x38, 0x01, 0x17, 0x3c, 0x01, 0x17,
 118             0x40, 0x01, 0x17, 0x95, 0x01, 0x1e, 0x99, 0x01,
 119             0x1e, 0x9d, 0x01, 0x1e, 0xa1, 0x01, 0x1e, 0xa5,
 120             0x01, 0x1e, 0x20, 0x01, 0x00, 0xdd, 0x18, 0x00,
 121             0x50, 0xf2, 0x02, 0x01, 0x01, 0x81, 0x00, 0x02,
 122             0xa3, 0x40, 0x00, 0x27, 0xa4, 0x00, 0x00, 0x42,
 123             0x43, 0x5e, 0x00, 0x62, 0x32, 0x2f, 0x00, 0xa0,
 124             0x00, 0xdd, 0x09, 0x00, 0x03, 0x7f, 0x01, 0x01,
 125             0x00, 0x24, 0xff, 0x7f, 0x87, 0x07, 0x1f, 0xf5,
 126     };
 127
 128     senf::WLANPacket p (senf::WLANPacket::create(data));
 129
 130     BOOST_CHECK_EQUAL( p->version(),        0u    );
 131     BOOST_CHECK_EQUAL( p->type(),           0u    );
 132     BOOST_CHECK_EQUAL( p->subtype(),        8u    );
 133     BOOST_CHECK_EQUAL( p->toDS(),           false );
 134     BOOST_CHECK_EQUAL( p->fromDS(),         false );
 135     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
 136     BOOST_CHECK_EQUAL( p->retry(),          false );
 137     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
 138     BOOST_CHECK_EQUAL( p->moreData(),       false );
 139     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
 140     BOOST_CHECK_EQUAL( p->order(),          false );
 141     BOOST_CHECK_EQUAL( p->duration(),       0u    );
 142
 143     BOOST_CHECK_EQUAL( p->is_mgtFrame(),    true  );
 144
 145     BOOST_CHECK_EQUAL(
 146             p->mgtFrame().destinationAddress().value(),
 147             senf::MACAddress::from_string("ff:ff:ff:ff:ff:ff") );
 148     BOOST_CHECK_EQUAL(
 149             p->mgtFrame().sourceAddress().value(),
 150             senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
 151     BOOST_CHECK_EQUAL(
 152             p->mgtFrame().bssid().value(),
 153             senf::MACAddress::from_string("00:1a:4d:3e:c7:5c") );
 154
 155     BOOST_CHECK_EQUAL( p->mgtFrame().sequenceNumber(), 302u );
 156     BOOST_CHECK_EQUAL( p->mgtFrame().fragmentNumber(), 0u   );
 157
 158     BOOST_CHECK_EQUAL( p->fcs(), 0x87071ff5 );
 159 }
 160
 161
 162 /* test parser with creating a beacon frame*/
 163 BOOST_AUTO_UNIT_TEST(WLANPacket_mgtFrame_create)
 164 {
 165     senf::WLANPacket p (senf::WLANPacket::create());
 166
 167     SENF_CHECK_NO_THROW( p->init_mgtFrame() );
 168     SENF_CHECK_NO_THROW(
 169             p->mgtFrame().destinationAddress() = senf::MACAddress::from_string("ff:ff:ff:ff:ff:ff")
 170     );
 171     SENF_CHECK_NO_THROW(
 172             p->mgtFrame().sourceAddress() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c")
 173     );
 174     SENF_CHECK_NO_THROW(
 175             p->mgtFrame().bssid() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c")
 176     );
 177
 178     BOOST_CHECK_EQUAL( p->type(), 0u );
 179 }
 180
 181
 182 /* test parser with an ACK frame*/
 183 BOOST_AUTO_UNIT_TEST(WLANPacket_ctrlFrame_packet)
 184 {
 185     unsigned char data[] = {
 186             0xd4, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x6b, 0x57,
 187             0x06, 0xb0, 0x4f, 0xda
 188     };
 189
 190     senf::WLANPacket p (senf::WLANPacket::create(data));
 191
 192     BOOST_CHECK_EQUAL( p->version(),        0u    );
 193     BOOST_CHECK_EQUAL( p->type(),           1u    );
 194     BOOST_CHECK_EQUAL( p->subtype(),        13u   );
 195     BOOST_CHECK_EQUAL( p->toDS(),           false );
 196     BOOST_CHECK_EQUAL( p->fromDS(),         false );
 197     BOOST_CHECK_EQUAL( p->moreFrag(),       false );
 198     BOOST_CHECK_EQUAL( p->retry(),          false );
 199     BOOST_CHECK_EQUAL( p->pwrMgt(),         false );
 200     BOOST_CHECK_EQUAL( p->moreData(),       false );
 201     BOOST_CHECK_EQUAL( p->protectedFrame(), false );
 202     BOOST_CHECK_EQUAL( p->order(),          false );
 203
 204     BOOST_CHECK_EQUAL( p->duration(),       0u    );
 205
 206     BOOST_CHECK_EQUAL(
 207             p->ctrlFrame().receiverAddress().value(),
 208             senf::MACAddress::from_string("00:0b:6b:57:06:b0") );
 209 }
 210
 211
 212 /* test parser with creating an ACK frame*/
 213 BOOST_AUTO_UNIT_TEST(WLANPacket_ctrlFrame_create)
 214 {
 215     senf::WLANPacket p (senf::WLANPacket::create()) ;
 216 //    std::cout << unsigned( senf::init_bytes<senf::WLANPacketParser_CtrlFrameParser>::value ) << "\n";
 217     SENF_CHECK_NO_THROW(p->init_ctrlFrame());
 218 //    std::cout << unsigned( senf::init_bytes<senf::WLANPacketParser_CtrlFrameParser>::value ) << "\n";
 219     p->ctrlFrame().receiverAddress() = senf::MACAddress::from_string("00:1a:4d:3e:c7:5c");
 220     p->ctrlFrame().set_ack();
 221     BOOST_CHECK_EQUAL( p->type(), 1u);
 222     BOOST_CHECK_EQUAL( p->subtype(), 13u);
 223 }
 224