src/probe-stats/wifi_stats.hh

/*
 * 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 WIFI_STATS_HH_
# define WIFI_STATS_HH_

# include <ostream>
# include <vector>
# include <map>

# include <boost/date_time/posix_time/posix_time.hpp>

# include <wipal/phy/prism_header.hh>
# include <wipal/wifi/frame.hh>
# include <wipal/wifi/addr.hh>
# include <wipal/pcap/stream.hh>

namespace stats
{

  /*-------------.
  | distribution |
  `-------------*/

  struct distribution
  {
    distribution(float min, float max, float granularity);

    void                insert(float);
    std::ostream&       dump(std::ostream&) const;

  private:
    float                       min_;
    float                       max_;
    float                       gran_;
    std::vector<unsigned>       dist_;
    unsigned                    total_;
  };

  std::ostream&
  operator << (std::ostream&, const distribution&);

  /*-------------.
  | timed_events |
  `-------------*/

  struct timed_events
  {
    typedef boost::posix_time::ptime            ptime;
    typedef boost::posix_time::time_duration    time_duration;

    time_duration                               insert(const ptime&);
    const std::vector<ptime>&                   evs() const;

  private:
    std::vector<ptime>                  evs_;
  };

  template <class C>
  std::vector<boost::posix_time::time_duration>
  its(const C&);

  template <class C>
  boost::posix_time::time_duration
  mean(const C&);

  template <class C>
  boost::posix_time::time_duration
  stddev(const C&                                       its,
         const boost::posix_time::time_duration*        mean = 0);

  template <class C>
  boost::posix_time::time_duration
  median(const std::vector<boost::posix_time::time_duration>&);

  template <class C>
  distribution
  make_distribution(float       min,
                    float       max,
                    float       granularity,
                    const C&    container);

  /*-----------.
  | addr_state |
  `-----------*/

  struct addr_state
  {
    typedef boost::posix_time::ptime    ptime;

    struct presp_attr
    {
      presp_attr();

      ptime     arrival;
      ptime     ack_expected_arrival;
      ptime     ack_arrival;
      unsigned  retries;
      unsigned  acks;
    };

    typedef std::map<wpl::wifi::addr, presp_attr>       preq_answer_set;
    typedef std::vector<preq_answer_set>                pr_answers_t;

    addr_state();

    timed_events        pr_stats[3]; // [da, sa, bssid]
    pr_answers_t        pr_answers;
    presp_attr* last_presp;
    unsigned            heard_as_tmiter;
    unsigned            mentioned_as_ap;
  };

  typedef std::map<wpl::wifi::addr, addr_state> addr_state_map;

  /*---------------.
  | probe_requests |
  `---------------*/

  struct probe_requests
  {
    typedef boost::posix_time::ptime    ptime;

    probe_requests(addr_state_map&);

    void                update(const wpl::wifi::mgt::header *frame,
                               const ptime& toa);

    std::ostream&       dump(std::ostream&      ,
                             unsigned           successful_frames,
                             unsigned           distinct_transmitters,
                             const ptime&       first) const;

  protected:
    std::ostream&       dump_header(std::ostream&       ,
                                    unsigned            successful_frames)
      const;
    std::ostream&       dump_footer(std::ostream&) const;
    std::ostream&       dump_addr_stats(std::ostream&   ,
                                        unsigned        index,
                                        unsigned        distinct_transmitters)
      const;
    std::ostream&       dump_pr_events(std::ostream&    ,
                                       unsigned         index,
                                       const ptime&     ref) const;
    static
    std::ostream&       dump_it_dist(std::ostream&, const distribution&);

  private:
    unsigned                    count;  // Number of received Probe Requests.
    addr_state_map*             addrs;  // Per source address state.
    distribution                it_dist;// Interarrival times distribution.

    // Parameters related to IT distributions.
    static const float          unit;
    static const float          min;
    static const float          max;
    static const float          gran;
    static const unsigned       tic;
  };

  /*-------.
  | frames |
  `-------*/

  struct frames
  {
    frames();

    std::ostream&       dump(std::ostream&) const;

    void                update(const wpl::pkt::metadata& pcap_header,
                               const void*               ieee80211_frame);

    void                update(const wpl::pkt::metadata& pcap_header,
                               const wpl::prism::header* prism_header);

  private:
    typedef boost::posix_time::ptime    ptime;

    std::ostream&       dump_pr_answers(std::ostream&,
                                        const addr_state_map::const_iterator&)
      const;
    void                dump_all_pr_answers(const std::string& prefix,
                                            const std::string& suffix) const;

    ptime               update_counters(const wpl::pkt::metadata&);


    unsigned            frame_count;    // Number of received frames.
    unsigned            total_len;      // Cumulative length of received
                                        // frames in bytes, including
                                        // payloads.
    unsigned            total_caplen;   // Total number of captured bytes.
    unsigned            phy_error_count; // Number of incorrectly
                                         // transmitted frames
                                         // according to the prism
                                         // header noise field.
    probe_requests      pr;             // Probe Request stats.
    addr_state_map      addrs;          // Addresses states.
    ptime               first;          // First frame arrival time.
    ptime               last;           // Last frame arrival time.
  };

  std::ostream&
  operator << (std::ostream&, const frames&);

} // End of namespace stats.

# include "wifi_stats.hxx"

#endif // ! WIFI_STATS_HH_

---