src/wit-import/wit_importer.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2007, 2009  Universite Pierre et Marie Curie - Paris 6
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA
 *
 * Author: Thomas Claveirole <thomas.claveirole@lip6.fr>
 */
#ifndef WIT_IMPORTER_HXX_
# define WIT_IMPORTER_HXX_

# include <cassert>
# include <utility>
# include <fstream>
# include <sstream>
# include <iomanip>

# include <boost/lexical_cast.hpp>

# include <wipal/phy/prism_header.hh>
# include <wipal/wifi/timestamp.hh>
# include <wipal/wifi/dissector/dissector.hh>

# include "wit_importer.hh"

namespace wit
{

  /*----------------.
  | importer::hooks |
  `----------------*/

  inline
  importer::hooks::hooks(wpl::wifi::addr_mapping& m)
    : mapping_ (m),
      addrs_ (),
      beacon_timestamp_ (db_null),
      fragnum_ (db_null),
      seqnum_ (db_null),
      error_ (db_null)
  {
  }

  inline
  std::string
  importer::hooks::addrs() const
  {
    return addrs_;
  }

  inline
  std::string
  importer::hooks::beacon_timestamp() const
  {
    return beacon_timestamp_;
  }

  inline
  std::string
  importer::hooks::fragnum() const
  {
    return fragnum_;
  }

  inline
  std::string
  importer::hooks::seqnum() const
  {
    return seqnum_;
  }

  inline
  std::string
  importer::hooks::error() const
  {
    return error_;
  }

  inline
  void
  importer::hooks::invalid_type_or_subtype_hook(const void*, size_t, status)
  {
    error_ = boost::lexical_cast<std::string> (bad_type_subtype);
  }

  inline
  void
  importer::hooks::truncated_frame_hook(const void*, size_t, status)
  {
    error_ = boost::lexical_cast<std::string> (malformed_802);
  }

  inline
  void
  importer::hooks::addr_hook(const void*, size_t,
                             unsigned n, const wpl::wifi::addr& a)
  {
    addrs_ += boost::lexical_cast<std::string> (mapping_[a]);
    if (n < 4)
      addrs_ += '\t';
  }

  inline
  void
  importer::hooks::seq_ctl_hook(const void*, size_t,
                                unsigned fragnum, unsigned seqnum)
  {
    fragnum_ = boost::lexical_cast<std::string> (fragnum);
    seqnum_ = boost::lexical_cast<std::string> (seqnum);
  }

  inline
  void
  importer::hooks::beacon_hook(const wpl::wifi::mgt::header* h,
                               size_t caplen)
  {
    if (caplen < sizeof (*h) + sizeof (wpl::wifi::timestamp))
      {
        truncated_frame_hook(h, caplen,
                             wpl::wifi::dissector_status::valid_addr3);
        return;
      }

    std::ostringstream  output;
    output << *reinterpret_cast<const wpl::wifi::timestamp*> (h->body);
    beacon_timestamp_ = output.str();
  }

  inline
  void
  importer::hooks::end_of_frame_hook(const void*, size_t, status s)
  {
    using namespace wpl::wifi::dissector_status;

    std::ostringstream  nulls;
    switch (s)
      {
      case valid_addr4:
        break;

      case valid_seq_ctl:
      case valid_addr3:
        addrs_ += db_null;
        break;

      case valid_addr2:
        nulls << db_null << '\t' << db_null;
        break;

      case valid_addr1:
        nulls << db_null << '\t' << db_null << '\t' << db_null;
        break;

      case valid_control:
      case invalid:
        nulls << db_null << '\t' << db_null << '\t'
              << db_null << '\t' << db_null;
        break;
      }
    addrs_ += nulls.str();
  }

  /*---------.
  | importer |
  `---------*/

  inline
  std::string
  importer::frames_data_filename(const std::string& prefix, unsigned channel)
  {
    assert(0 < channel);
    assert(channel <= channels_max);

    return prefix + "_c" + boost::lexical_cast<std::string> (channel);
  }

  inline
  std::string
  importer::mapping_filename(const std::string& prefix, unsigned channel)
  {
    assert(0 < channel);
    assert(channel <= channels_max);

    return frames_data_filename(prefix, channel) + "_MACIndex";
  }

  inline
  std::string
  importer::handle_time_data(const wpl::pkt::metadata& h)
  {
    using namespace boost::gregorian;
    using namespace boost::posix_time;

    std::ostringstream  time_string;
    const ptime         toa (date(1970, Jan, 01),
                             seconds (h.ts.tv_sec) +
                             microseconds (h.ts.tv_usec));

    time_string << h.ts.tv_sec
                << '.'
                <<  std::setw (6) << std::setfill('0') << h.ts.tv_usec
                << '\t';

    if (last_frame_.is_not_a_date_time())
      time_string << db_null;
    else
      time_string << (toa - last_frame_).total_microseconds();

    last_frame_ = toa;

    return time_string.str();
  }

  inline
  void
  importer::handle_malformed_prism()
  {
    wpl::tool::datafile&        f = frames_data_[last_channel_ - 1];

    for (unsigned i = 0; i < 25; ++i)
      f << db_null << '\t';
    f << boost::lexical_cast<std::string> (malformed_prism)     // zErr
      << '\t' << db_null << '\t' << db_null << '\n';            // zErrDriver
                                                                // zErrPhy
  }

  inline
  const wpl::prism::header*
  importer::handle_prism_header(const std::string& time_string,
                                const void* p,
                                size_t caplen)
  {
    typedef wpl::prism::header  header;

    bool                truncated_frame = false;
    const header* const prism = static_cast<const header*> (p);

    if (caplen < sizeof (wpl::prism::header))
      {
        truncated_frame = true;
        std::cerr << "WARNING: Truncated Prism header. Unknown channel, ";
        if (not last_channel_)
          {
            last_channel_ = 1;
            std::cerr << "using default value of 1.";
          }
        else
          std::cerr << "using last value of " << last_channel_ << '.';
        std::cerr << std::endl;
      }
    else
      last_channel_ = prism->channel.get(false); // FIXME: Endianness bug!
    assert(last_channel_ > 0);
    assert(last_channel_ <= channels_max);

    wpl::tool::datafile& f = frames_data_[last_channel_ - 1];

    f << ++last_id_[last_channel_ - 1] << '\t'  // id
      << time_string << '\t';                   // aFrameTime
                                                // aTimeDelta

    if (truncated_frame)
      {
        handle_malformed_prism();
        return 0;
      }

    // FIXME: Lots of endianness bugs here!
    f << prism->channel.get(false) << '\t'              // bChannel
      << prism->hosttime.get(false) << '\t'             // bHostTime
      << prism->mactime.get(false) << '\t'              // bMACTime
      << (prism->rate.get(false) / 2.) << '\t'          // bRate
      << int16_t (prism->signal.get(false)) << '\t'     // bRssi
      << prism->frmlen.get(false) << '\t';              // bSize

    return prism;
  }

  template <class T>
  void
  importer::operator () (const wpl::pkt::packet<T>& d)
  {
    const wpl::pkt::metadata&           h = d.meta();
    const void* const                   p = d.bytes();
    const std::string                   tstr = handle_time_data(h);
    const wpl::prism::header* const     prism = handle_prism_header(tstr, p,
                                                                    h.caplen);

    if (not prism)
      return;

    wpl::tool::datafile&                f = frames_data_[last_channel_ - 1];

    /*--------------------.
    | PHY invalid frame.  |
    `--------------------*/

    // FIXME: Two endianness bugs follow.

    if (const unsigned noise = prism->noise.get(false))
      {
        for (unsigned i = 0; i < 19; ++i)
          f << db_null << '\t';
        f << driver_reported << '\t'            // zErr
          << noise << '\t';                     // zErrDriver

        /*
          Some black magic frome Wit's createRawDataDatabase.pl.
          I have absolutely no clue about the rationale.
        */
        if (noise & 8)
          f << prism->rssi.get(false) << '\n';  // zErrPhy
        else
          f << db_null << '\n';                 // zErrPhy
      }

    /*----------------------------------------------.
    | PHY valid frame, go check the 802.11 header.  |
    `----------------------------------------------*/

    else
      {
        using namespace wpl::wifi;

        const void* const        frame = static_cast<const void*> (prism + 1);
        const size_t             caplen = h.caplen - sizeof (*prism);
        wpl::wifi::addr_mapping& map = mappings_[last_channel_ - 1];
        const dissector<hooks>   dctor (frame, caplen, map);
        const unsigned           type = type_of(frame);
        const unsigned           subtype = subtype_of(frame);

        f << dctor.addrs() << '\t'              // cA1_Dest
                                                // cA2_Src
                                                // cA3
                                                // cA4
          << from_ds(frame) << '\t'             // cDSFrom
          << to_ds(frame) << '\t'               // cDSTo
          << duration_of(frame) << '\t'         // cDur
          << dctor.fragnum() << '\t'            // cFragno
          << control_flag(5, frame) << '\t'     // cMoredata
          << control_flag(2, frame) << '\t'     // cMorefrag
          << control_flag(7, frame) << '\t'     // cOrdered
          << protocol_version_of(frame) << '\t' // cProtver
          << control_flag(4, frame) << '\t'     // cPwrMgt
          << control_flag(3, frame) << '\t'     // cRetry
          << dctor.seqnum() << '\t'             // cSeqno
          << ((type << 4) | subtype) << '\t'    // cSubtype
          << type << '\t'                       // cType
          << control_flag(6, frame) << '\t'     // cWEP
          << dctor.beacon_timestamp() << '\t'   // dBeaconTimestamp
          << dctor.error() << '\t'              // zErr
          << db_null << '\t'                    // zErrDriver
          << db_null << '\n';                   // zErrPhy
      }
  }

} // End of namespace wit.

#endif // ! WIT_IMPORTER_HXX_

---