include/wipal/phy/phy.hxx

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

# include <iostream>

# include <wipal/phy/phy.hh>

namespace wpl
{

  namespace phy
  {

    /*----------.
      | phy::time |
      `----------*/

    template <class B>
    typename time<B>::impl_type
    time<B>::get() const
    {
      return this->exact().get_impl();
    }

    template <class B>
    typename time<B>::exact_type&
    time<B>::operator += (tool::microseconds microseconds)
    {
      return this->increment(microseconds);
    }

    template <class B>
    typename time<B>::exact_type
    time<B>::operator + (tool::microseconds microseconds) const
    {
      exact_type        r (this->exact());

      r.increment(microseconds);
      return r;
    }

    template <class B>
    time<B>::~time()
    {
    }


    /*-----------------.
    | phy::uint64_time |
    `-----------------*/

    template <class Bottom>
    typename uint64_time<Bottom>::impl_type
    uint64_time<Bottom>::get_impl() const
    {
      return ms_count_;
    }

    template <class Bottom>
    typename uint64_time<Bottom>::exact_type&
    uint64_time<Bottom>::increment(const tool::microseconds& microseconds)
    {
      const tool::microseconds  base   (ms_count_);
      const tool::microseconds  result (base + microseconds);

      ms_count_ = result.get_uint64();

      return this->exact();
    }

    template <class Bottom>
    uint64_time<Bottom>::uint64_time(): ms_count_ (0)
    {
    }

    template <class Bottom>
    uint64_time<Bottom>::uint64_time(uint64_t tsft): ms_count_ (tsft)
    {
    }


    /*------------.
      | phy::header |
      `------------*/

    template <class B>
    size_t
    header<B>::len(size_t caplen, bool swapped) const
    {
      return this->exact().len_impl(caplen, swapped);
    }

    template <class B>
    const void*
    header<B>::decapsulate(size_t caplen, bool swapped) const
    {
      const size_t len = this->exact().len_impl(caplen, swapped);

      return len > caplen ? 0 : reinterpret_cast<const uint8_t*> (this) + len;
    }

    template <class B>
    typename header<B>::time_type
    header<B>::time_get(bool swapped) const
    {
      return this->exact().time_get_impl(swapped);
    }

    template <class B>
    void
    header<B>::time_set(const time_type& time, bool swapped)
    {
      this->exact().time_set_impl(time, swapped);
    }

    template <class B>
    template <class S1, class S2>
    bool
    header<B>::eq_80211(const pkt::packet<S1>&  lhs,
                        const pkt::packet<S2>&  rhs,
                        tool::end::endianness   phy_end)
    {
      using tool::need_swap;

      const pkt::metadata&      lhs_meta = lhs.meta();
      const pkt::metadata&      rhs_meta = rhs.meta();

      const bool                lhs_sw = need_swap(phy_end, lhs.swapped());
      const bool                rhs_sw = need_swap(phy_end, rhs.swapped());

      const exact_type* const   lhs_phy = (static_cast<const exact_type*>
                                           (lhs.bytes()));
      const exact_type* const   rhs_phy = (static_cast<const exact_type*>
                                           (rhs.bytes()));

      const void* const         lhs_ieee = lhs_phy->decapsulate(lhs_meta.caplen,
                                                                lhs_sw);
      const void* const         rhs_ieee = rhs_phy->decapsulate(rhs_meta.caplen,
                                                                rhs_sw);

      const ssize_t             lhs_caplen = (lhs_meta.caplen -
                                              lhs_phy->len(lhs_meta.caplen,
                                                           lhs_sw));
      const ssize_t             rhs_caplen = (rhs_meta.caplen -
                                              rhs_phy->len(rhs_meta.caplen,
                                                           rhs_sw));

      const ssize_t             caplen = std::min(lhs_caplen, rhs_caplen);

      return caplen <= 0 ? false : 0 == memcmp(lhs_ieee, rhs_ieee, caplen);
    }

    template <class B>
    template <class S1, class S2>
    bool
    header<B>::eq_time_and_80211(const pkt::packet<S1>&         lhs,
                                 const pkt::packet<S2>&         rhs,
                                 const unsigned                 prec,
                                 const tool::end::endianness    phy_end)
    {
      return (exact_type::eq_time(lhs, rhs, prec, phy_end) and
              eq_80211(lhs, rhs, phy_end));
    }

    template <class B>
    header<B>::~header()
    {
    }

  } // End of namespace wpl::phy.

} // End of namespace wpl.

#endif // ! PHY_PHY_HXX_

---