include/wipal/wifi/stats/bss_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_BSS_STATS_HXX_
# define WIFI_STATS_BSS_STATS_HXX_

# include <set>

# include <boost/foreach.hpp>

# include <wipal/wifi/stats/bss_stats.hh>
# include <wipal/wifi/essid.hh>
# include <wipal/tool/less.hh>

namespace wpl
{

  namespace wifi
  {

    namespace stats
    {

      inline
      bss_stats::bss_stats(const void*): beacon_count_ (0), ap_count_ (0)
      {
      }

      template <class Frame>
      void
      bss_stats::account_beacon(const Frame&            ,
                                const addr* const&      ap,
                                const addr* const&      bss,
                                const optional_string&  essid,
                                const bool&             ibss)
      {
        if (not ap or not bss)
          return;

        single_bss_stats&       b = bss_stats_[*bss];
        single_sta_stats&       s = b.sta_stats_[*ap];

        ++beacon_count_;
        ++b.total_;
        if (ibss)
          ++s.independent;
        else if (s.total == s.independent) // New AP discovered!
          ++ap_count_;
        ++s.total;
        if (essid)
          ++s.essids[*essid];
      }

      inline
      std::ostream&
      bss_stats::print(std::ostream& o) const
      {
        typedef std::set<internal_stats::const_iterator,
                         tool::less_using_second>               sorted_type;

        sorted_type     sorted;

        for (internal_stats::const_iterator i = bss_stats_.begin();
             i != bss_stats_.end();
             ++i)
          sorted.insert(i);

        o << "begin BSS figures\n"
          << "  total beacon count: " << beacon_count_ << '\n'
          << "  distinct BSSIDs: " << bss_stats_.size() << '\n'
          << "  distinct APs: " << ap_count_ << '\n';

        BOOST_FOREACH(const internal_stats::const_iterator& i, sorted)
          {
            typedef single_bss_stats::sta_stats::value_type     sta_stats;
            typedef single_sta_stats::essid_stats::value_type   essid;

            const single_bss_stats::sta_stats&  s = i->second.sta_stats_;

            o << '\n'
              << "  begin BSS: " << i->first << '\n'
              << "    beacon count: " << i->second.total_ << '\n'
              << "    beacon ratio: "
              <<   (double (i->second.total_) / beacon_count_) << '\n'
              << "    distinct beacon senders: " << s.size() << '\n';

            assert(not s.empty());
            if (s.size() == 1 and s.begin()->first == i->first)
              {
                // Only one STA emits this BSSID, and its address is
                // equal to the BSSID.  Most probably an access point.

                const sta_stats&        p = *s.begin();
                const unsigned&         total = p.second.total;
                const unsigned&         idpt = p.second.independent;

                assert(total == i->second.total_);

                o << "    IBSS beacons: " << idpt << '\n'
                  << "    IBSS beacons ratio (this BSS): "
                  <<                           (double (idpt) / total) << '\n'
                  << "    begin ESSID list for " << p.first << '\n';
                BOOST_FOREACH(const essid& e, p.second.essids)
                  o << "      " << e.first.escape(65)
                    <<     '\t' << e.second << '\n';
                o << "    end ESSID list for " << p.first << '\n';
              }
            else
              {
                // Multiple STA emit this BSSID, or only one STA which
                // address is different to the BSSID.  Most probably
                // STA's belonging to an independent BSS

                BOOST_FOREACH(const sta_stats& p, s)
                  {
                    const unsigned&     total = p.second.total;
                    const unsigned&     idpt = p.second.independent;

                    o << '\n'
                      << "    begin beacon sender: (" << i->first << ") "
                      <<                                       p.first << '\n'
                      << "      beacon count: " << total << '\n'
                      << "      beacon count ratio (total): "
                      <<              (double (total) / beacon_count_) << '\n'
                      << "      beacon count ratio (this BSS): "
                      <<           (double (total) / i->second.total_) << '\n'
                      << "      IBSS beacons: " << idpt << '\n'
                      << "      IBSS beacons ratio (this sender): "
                      <<                       (double (idpt) / total) << '\n'
                      << "      begin ESSID list for " << p.first << '\n';
                    BOOST_FOREACH(const essid& e, p.second.essids)
                      o << "        " << e.first.escape(65)
                        <<       '\t' << (double (e.second) / total)
                        <<       '\t' << e.second << '\n';
                    o << "      end ESSID list for " << p.first << '\n'
                      << "    end beacon sender: (" << i->first << ") "
                      <<                                       p.first << '\n';
                  }
              }
            o << "  end BSS: " << i->first << '\n';
          }
        return o << "end BSS figures" << std::endl;
      }

      inline
      bss_stats::single_sta_stats::single_sta_stats(): total (0),
                                                       independent (0)
      {
      }

      inline
      bss_stats::single_bss_stats::single_bss_stats(): total_ (0)
      {
      }

      inline
      bool
      bss_stats::
      single_bss_stats::operator < (const single_bss_stats& rhs) const
      {
        return total_ < rhs.total_;
      }

      inline
      bool
      bss_stats::
      single_bss_stats::operator == (const single_bss_stats& rhs) const
      {
        return total_ == rhs.total_;
      }

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

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_STATS_BSS_STATS_HXX_

---