4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
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
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.
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.
19 // The Original Code is Fraunhofer FOKUS code.
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.
26 // Stefan Bund <g0dil@berlios.de>
27 // Christian Niephaus <cni@berlios.de>
30 // Definition of RadiotapPacket non-inline non-template functions
32 #include "RadiotapPacket.hh"
33 //#include "RadiotapPacket.ih"
36 #include "WLANPacket.hh"
37 #include <boost/io/ios_state.hpp>
41 # include "radiotap/radiotap_iter.h"
45 //-/////////////////////////////////////////////////////////////////////////////////////////////////
47 //-/////////////////////////////////////////////////////////////////////////////////////////////////
48 // Offset table management
50 prefix_ senf::RadiotapPacketParser::OffsetTable &
51 senf::RadiotapPacketParser::offsetTable(boost::uint32_t presentFlags)
53 typedef std::map<boost::uint32_t, OffsetTable> OffsetMap;
54 static OffsetMap offsetMap;
56 OffsetMap::iterator i (offsetMap.find(presentFlags));
57 if (i == offsetMap.end())
58 i = offsetMap.insert(std::make_pair(presentFlags, OffsetTable())).first;
62 prefix_ void senf::RadiotapPacketParser::parseOffsetTable(boost::uint8_t * data, int maxLength,
65 struct ieee80211_radiotap_iterator iter;
66 ieee80211_radiotap_iterator_init(&iter,
67 (struct ieee80211_radiotap_header *)data,
71 while (ieee80211_radiotap_iterator_next(&iter) == 0) {
72 if (iter.is_radiotap_ns &&
73 iter.this_arg_index <= int(RadiotapPacketParser::MAX_INDEX))
74 table[iter.this_arg_index] = iter.this_arg - data;
75 // We need to set size here in the loop since the iter fields are only valid
76 // when at least one present bit is set ...
77 size = iter.this_arg - data + iter.this_arg_size;
79 table[MAX_INDEX+1] = size;
82 prefix_ void senf::RadiotapPacketParser::buildOffsetTable(boost::uint32_t presentFlags,
85 SENF_ASSERT(!(presentFlags & ( (1<<IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE) |
86 (1<<IEEE80211_RADIOTAP_VENDOR_NAMESPACE) |
87 (1<<IEEE80211_RADIOTAP_EXT) )),
88 "Extended or vendor fields not supported");
90 struct ieee80211_radiotap_header header;
91 memset(&header, 0, sizeof(header));
92 // header.it_version = 0;
94 // Iterating this packet will generate invalid addresses but we don't care since neither
95 // radiotap.c nor we will ever dereference those pointers, we just calculate the offsets.
96 // This works, as long as we don't support extension headers ...
97 header.it_len = 0xFFFF;
98 header.it_present = presentFlags;
100 parseOffsetTable((boost::uint8_t*)&header, header.it_len, table);
103 //-/////////////////////////////////////////////////////////////////////////////////////////////////
104 // senf::RadiotapPacketParser
106 unsigned const senf::RadiotapPacketParser_Header::FIELD_SIZE[] = {
107 8, 1, 1, 4, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 2, 2, 1, 1 };
109 prefix_ senf::UInt32Parser senf::RadiotapPacketParser::init_fcs()
112 protect(), data().insert(data().end(), 4u, 0u);
113 init_flags().fcsAtEnd_() = true;
118 prefix_ void senf::RadiotapPacketParser::disable_fcs()
121 validate(RadiotapPacketParser_Header::fixed_bytes+4);
122 data().erase(data().end()-4, data().end());
123 flags().fcsAtEnd_() = false;
127 prefix_ senf::RadiotapPacketParser::OffsetTable const &
128 senf::RadiotapPacketParser::getTable(boost::uint32_t presentFlags)
131 OffsetTable & table(offsetTable(presentFlags));
132 if (! table[MAX_INDEX+1])
133 buildOffsetTable(presentFlags, table);
137 prefix_ void senf::RadiotapPacketParser::insertRemoveBytes(unsigned from , unsigned to, int bytes)
139 data_iterator b (i() + from);
140 data_iterator e (i() + to);
142 // Insert some bytes cleaning the old bytes to 0 first
145 // need to protect the parser since data().insert() invalidates iterators
146 protect(), data().insert(e, bytes, 0u);
149 // Remove some bytes ...
150 // remember: bytes is negative ...
152 std::fill(b, e + bytes, 0u);
153 data().erase(e + bytes, e);
157 prefix_ void senf::RadiotapPacketParser::updatePresentFlags(boost::uint32_t flags)
159 if (flags == presentFlags())
163 OffsetTable const & oldTable (currentTable());
164 OffsetTable const & newTable (getTable(flags));
165 unsigned b (RadiotapPacketParser_Header::fixed_bytes);
166 int cumulativeNewBytes (0);
168 for (unsigned index (0); index <= MAX_INDEX; ++index) {
169 // Skip any unchanged fields
170 for (; index <= MAX_INDEX+1
171 && ((oldTable[index] == 0 && newTable[index] == 0)
172 || (oldTable[index]+cumulativeNewBytes == newTable[index])); ++index)
173 if (newTable[index] != 0)
174 b = newTable[index] + FIELD_SIZE[index];
175 if (index > MAX_INDEX+1)
177 // Now skip over all changed fields
178 // (The condition index <= MAX_INDEX is not needed here since the last
179 // table entry MAX_INDEX+1 is always != 0 in both tables)
180 for (; ! (oldTable[index]!=0 && newTable[index]!=0); ++index) ;
181 // index now either points to
182 // a) an entry set in both tables
183 // b) at the end of the table which contains the total length
184 // (remember: the table has a size of MAX_INDEX+2 entries !!)
185 // in both cases, the difference between the new and old size
186 // is found from the difference between the old and the new table
188 int newBytes (newTable[index] - oldTable[index] - cumulativeNewBytes);
189 insertRemoveBytes(b, oldTable[index] + cumulativeNewBytes, newBytes);
190 cumulativeNewBytes += newBytes;
191 b = newTable[index] + FIELD_SIZE[index];
193 length() += cumulativeNewBytes;
194 presentFlags() = flags;
195 currentTable_ = &newTable;
198 //-/////////////////////////////////////////////////////////////////////////////////////////////////
199 // senf::RadiotapPacketType
201 prefix_ void senf::RadiotapPacketType::dump(packet p, std::ostream & os)
203 boost::io::ios_all_saver ias(os);
205 << senf::fieldName("version") << unsigned(p->version()) << '\n'
206 << senf::fieldName("length") << unsigned(p->length()) << '\n';
208 # define FIELD(name, sign, desc) \
209 if (p->name ## Present()) \
210 os << senf::fieldName(desc) << sign(p->name()) << '\n';
212 # define ENTER(name) \
213 if (p->name ## Present()) { \
214 packet::Parser::name ## _t subparser (p->name());
216 # define SUBFIELD(name, sign, desc) \
217 os << senf::fieldName(desc) << sign(subparser.name()) << '\n';
222 # define START_FLAGS(desc) \
223 os << senf::fieldName(desc);
225 # define FLAG(name, desc) \
226 if (subparser.name()) os << desc " "
228 # define END_FLAGS() \
231 FIELD ( tsft, boost::uint64_t, "MAC timestamp" );
233 START_FLAGS ( "flags" );
234 FLAG ( shortGI, "ShortGI" );
235 FLAG ( badFCS, "BadFCS" );
236 FLAG ( fcsAtEnd, "FCSatEnd" );
237 FLAG ( fragmentation, "Frag" );
239 FLAG ( shortPreamble, "ShortPreamble" );
243 FIELD ( rate, unsigned, "rate" );
244 ENTER ( channelOptions );
245 SUBFIELD ( freq, unsigned, "channel frequency" );
246 START_FLAGS ( "channel flags" );
247 FLAG ( flag2ghz, "2GHz" );
248 FLAG ( ofdm, "OFDM" );
250 FLAG ( turbo, "Turbo" );
251 FLAG ( quarterRateChannel, "Rate/4" );
252 FLAG ( halfRateChannel, "Rate/2" );
254 FLAG ( staticTurbo, "StaticTurbo" );
255 FLAG ( gfsk, "GFSK" );
256 FLAG ( cckOfdm, "CCK+OFDM" );
257 FLAG ( passive, "Passive" );
258 FLAG ( flag5ghz, "5GHz" );
261 FIELD ( fhss, unsigned, "FHSS" );
262 FIELD ( dbmAntennaSignal, signed, "antenna signal (dBm)" );
263 FIELD ( dbmAntennaNoise, signed, "antenna noise (dBm)" );
264 FIELD ( lockQuality, unsigned, "lock quality" );
265 FIELD ( txAttenuation, unsigned, "tx attenuation" );
266 FIELD ( dbTxAttenuation, unsigned, "tx attenuation (dB)" );
267 FIELD ( dbmTxAttenuation, signed, "tx attenuation (dBm)" );
268 FIELD ( antenna, unsigned, "antenna" );
269 FIELD ( dbAntennaSignal, unsigned, "antenna signal (dB)" );
270 FIELD ( dbAntennaNoise, unsigned, "antenna noise (dB)" );
272 START_FLAGS ( "rx flags" );
273 FLAG ( badPlcp, "BadPLCP" );
277 START_FLAGS ( "tx flags" );
278 FLAG ( fail, "Fail" );
279 FLAG ( txRts, "RTS" );
280 FLAG ( txCts, "CTS" );
283 FIELD ( rtsRetries, unsigned, "rts retries" );
284 FIELD ( dataRetries, unsigned, "data retries" );
286 if (p->flagsPresent() && p->flags().fcsAtEnd())
287 os << senf::fieldName("fcs") << unsigned(p->fcs()) << '\n';
298 prefix_ void senf::RadiotapPacketType::init(packet p)
300 // ?? Why the heck do we need the +0? Otherwise we get an
301 // 'undefined reference to 'RadiotapPacketParser_Header::fixed_bytes'
302 p->length() << RadiotapPacketParser_Header::fixed_bytes+0;
305 prefix_ senf::PacketInterpreterBase::factory_t senf::RadiotapPacketType::nextPacketType(packet p)
307 static factory_t frameTypeFactory[] = { WLANPacket_MgtFrame::factory(),
308 WLANPacket_CtrlFrame::factory(),
309 WLANPacket_DataFrame::factory(),
311 return frameTypeFactory[p->frameType()];
314 prefix_ senf::RadiotapPacketType::optional_range
315 senf::RadiotapPacketType::nextPacketRange(packet const & p)
317 parser rtParser (p.parser());
318 size_type h (senf::bytes(rtParser));
319 size_type t (rtParser.flagsPresent() && rtParser.flags().fcsAtEnd() ? 4 : 0);
320 return p.size() <= h+t
322 : optional_range( range(p.data().begin() + h, p.data().end() - t) );
325 //-/////////////////////////////////////////////////////////////////////////////////////////////////
332 // c-file-style: "senf"
333 // indent-tabs-mode: nil
334 // ispell-local-dictionary: "american"
335 // compile-command: "scons -u test"
336 // comment-column: 40