include/wipal/wifi/stats/stats.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2008, 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 WIFI_STATS_STATS_HXX_
# define WIFI_STATS_STATS_HXX_

# include <wipal/wifi/stats/stats.hh>
# include <wipal/wifi/dissector/dissector.hh>

namespace wpl
{

  namespace wifi
  {

    namespace stats
    {

      /*-------------.
      | Constructors |
      `-------------*/

      inline
      stats::hooks::hooks(): type (type::reserved),
                             subtype (-1),
                             retx (false),
                             a1 (0),
                             a2 (0)
      {
      }

      inline
      stats::state::state(unsigned                      last_frame_id,
                          const seqctl&                 last_sc,
                          const tool::microseconds&     last_rx_stamp):
        last_frame_id (last_frame_id),
        last_sc (last_sc),
        last_rx_stamp (last_rx_stamp)
      {
      }

      /*-------.
      | Misc.  |
      `-------*/

      inline
      std::ostream&
      stats::print(std::ostream& o) const
      {
        return o << modules_;
      }

      inline
      void
      stats::restart()
      {
        states_.clear();
        aps_.clear();
        modules_.restart();
      }

      template <class M>
      const M&
      stats::get() const
      {
        return modules_.get<M>();
      }

      /*-----------------------------.
      | Frame parsing and accounting |
      `-----------------------------*/

      inline
      void
      stats::hooks::invalid_type_or_subtype_hook(const void* f, size_t,
                                                 dissector_status::status)
      {
        type = type_of(f);
        subtype = subtype_of(f);
        retx = control_flag(3, f);
      }

      inline
      void
      stats::hooks::addr_hook(const void* f, size_t, unsigned i, const addr& a)
      {
        bool    account_addr = true;

        switch (i)
          {
          case 1:
            type = type_of(f);
            subtype = subtype_of(f);
            retx = control_flag(3, f);
            a1 = &a;

            switch (type) // Do not account BSSIDs as MAC addresses.
              {
              case type::control:
                account_addr = subtype != ctl::subtype::ps_poll;        break;
              case type::data:
                account_addr = not to_ds(f) or from_ds(f);              break;
              default:                                                  break;
              }
            break;

          case 2:
            a2 = &a;

            if (type == type::management or type == type::data)
              id = seqnum_counter_id (a, addr::broadcast());

            switch (type) // Do not account BSSIDs as MAC addresses.
              {
              case type::control:
                account_addr =
                  subtype != ctl::subtype::cf_end and
                  subtype != ctl::subtype::cf_end_cf_ack;       break;
              case type::data:
                account_addr = to_ds(f) or not from_ds(f);      break;
              default:                                          break;
              }
            break;

          case 3:
            // Do not account BSSIDs as MAC addresses.
            switch (type)
              {
              case type::data:   account_addr = to_ds(f) or from_ds(f); break;
              case type::management:    account_addr = false;           break;
              default:                                                  break;
              }
            break;
          }

        if (account_addr)
          addrs.push_back(std::make_pair(i, &a));
      }

      inline
      void
      stats::hooks::seq_ctl_hook(const void*, size_t, unsigned fn, unsigned sn)
      {
        sc = seqctl (sn, fn);
      }

      inline
      void
      stats::hooks::qos_ctl_hook(const void*, size_t,
                                 unsigned tid, bool, unsigned, unsigned)
      {
        assert(a1);
        assert(id);

        if (*a1 == addr::broadcast())
          return;

        id->get<1>() = *a1;
        id->get<2>() = tid;
      }

      inline
      void
      stats::hooks::beacon_hook(const mgt::header* header, size_t caplen)
      {
        beacon = beacon_data (header, caplen);
      }

      inline
      stats::hooks::beacon_data::beacon_data(const mgt::header* header,
                                             size_t             caplen):
        ap (0),
        bss (0),
        ibss (false)
      {
        if (caplen < sizeof (*header))
          return;

        ap = header->addrs + mgt::header::sa;
        bss = header->addrs + mgt::header::bssid;

        const struct beacon_body
        {
          uint64_t      timestamp;
          uint16_t      beacon_interval;
          uint16_t      capability;
          ssid_elt      ssid;
        }
        *const  body = reinterpret_cast<const beacon_body*> (header + 1);

        if (caplen < sizeof (*header) + sizeof (*body) or
            body->ssid.elt_id != ssid_elt::ssid_elt_id or
            caplen < sizeof (*header) + sizeof (*body) + body->ssid.length)
          return;

        ibss = tool::extract_little_endian_short_u(body->capability) & 0x2;
        ssid = essid (body->ssid);
      }

      template <class Phy, class Frame>
      void
      stats::account(const Frame& f)
      {
        const dissector<hooks>  d = dissect<Phy, hooks>(f);

        if (d.status() == dissector_status::invalid)
          return;


        // Check whether the frame comes from an AP or not.

        bool                    from_ap = false;

        if (d.beacon and not d.beacon->ibss)
          {
            from_ap = true;
            if (d.beacon->ap)   aps_.insert(*d.beacon->ap);
            if (d.beacon->bss)  aps_.insert(*d.beacon->bss);
          }
        else if (d.a2 and aps_.find(*d.a2) != aps_.end())
          from_ap = true;

        // Compute IEEE 802.11 frame length.

        size_t                  len;
        const pkt::metadata&    meta = f.meta();
        {
          const Phy* const      phy = static_cast<const Phy*> (f.bytes());
          const size_t          phy_len = phy->len(meta.caplen, f.swapped());
          const size_t          meta_len = meta.len;

          if (phy_len > meta_len)
            {
              std::cerr << f << ": Too short to make sense.\n"
                        << f << ": Length is " << meta_len << ".\n"
                        << f << ": PHY header length should be " << phy_len
                        << '.' << std::endl;
              len = 0;
            }
          else
            len = meta_len - phy_len;
        }


        // Call modules' callbacks.

        modules_.account_frame(f, len, d.type, d.subtype,
                               d.retx, d.a1, d.a2, from_ap);
        for (size_t i = 0; i < d.addrs.size(); ++i)
          modules_.account_addr(d.addrs[i].first, *d.addrs[i].second);
        if (d.beacon)
          modules_.account_beacon(f, d.beacon->ap, d.beacon->bss,
                                  d.beacon->ssid, d.beacon->ibss);
        if (d.id)
          update_states(f, d);
      }

      template <class Frame>
      void
      stats::update_states(const Frame& f, const dissector<hooks>& d)
      {
        assert(d.id);
        assert(d.sc);

        const unsigned                  frame_id = f.meta().id;
        const tool::microseconds&       rx_stamp = f.microseconds();
        const state_map::iterator       i = states_.find(*d.id);

        state                           new_state (frame_id, *d.sc, rx_stamp);

        // First occurence of this state ID.
        if (i == states_.end())
          {
            states_.insert(std::make_pair(*d.id, new_state));
            return;
          }

        const state&                    s = i->second;
        const tool::microseconds        delta_t = rx_stamp - s.last_rx_stamp;

        if (state::lifetime < delta_t)
          modules_.account_expired();
        else if (*d.sc < s.last_sc)
          modules_.account_out_of_order();
        else if (*d.sc == s.last_sc)
          {
            if (not d.retx)
              modules_.account_duplicate();
          }
        else
          {
            assert(*d.sc > s.last_sc);

            if (d.retx) // We missed the original non-retransmitted frame.
              modules_.account_miss();

            const int   delta_s = d.sc->seqnum_get() - s.last_sc.seqnum_get();

            /* If there is a sequence number gap, *and* its value is
             * credible, account for it.
             *
             * Credible means the STA could have sent all the missed
             * frames since we last seen it.  E.g. if it takes 100us
             * to send the smallest allowed frame, and the last frame
             * we saw is 300us old, then only gaps of length 1 will be
             * credible.
             */
            if (1 < delta_s)
              {
                if (delta_s < delta_t / state::min_frame_sending_time)
                  modules_.account_gap(delta_s - 1);
                else
                  modules_.account_seq_anomaly();
              }
          }
        i->second = new_state;
      }

    } // End of namespace wpl::wifi::stats.

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_STATS_STATS_HXX_

---