include/wipal/wifi/frame.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 WIFI_FRAME_FRAME_HXX_
# define WIFI_FRAME_FRAME_HXX_

# include "frame.hh"

# include <wipal/tool/endianness.hh>
# include <wipal/wifi/ctl.hh>
# include <wipal/wifi/mgt.hh>
# include <wipal/wifi/data.hh>
# include <wipal/wifi/dissector/dissector.hh>
# include <wipal/wifi/dissector/default_hooks.hh>

namespace wpl
{

  namespace wifi
  {

    inline
    unsigned
    protocol_version_of(const void* frame)
    {
      return tool::extract_little_endian_short_u(frame) & 0x3;
    }

    inline
    type::frame_type
    type_of(const void* frame)
    {
      const unsigned t =
        (tool::extract_little_endian_short_u(frame) >> 2) & 0x3;
      return type::frame_type (t);
    }

    inline
    unsigned
    subtype_of(const void* frame)
    {
      return (tool::extract_little_endian_short_u(frame) >> 4) & 0xF;
    }

    inline
    uint8_t
    control_flags_of(const void* frame)
    {
      return tool::extract_little_endian_short_u(frame) >> 8;
    }

    inline
    bool
    control_flag(const unsigned i, const void* frame)
    {
      const unsigned v = 1 << i;

      return (control_flags_of(frame) & v) == v;
    }

    inline
    bool
    to_ds(const void* frame)
    {
      return control_flag(0, frame);
    }

    inline
    bool
    from_ds(const void* frame)
    {
      return control_flag(1, frame);
    }

    inline
    unsigned
    duration_of(const void* frame)
    {
      return tool::
	extract_little_endian_short_u(static_cast<const uint16_t*> (frame) + 1);
    }

    namespace
    {

      struct seqnum_fragnum_hooks: public dissector_default_hooks
      {
        seqnum_fragnum_hooks(): valid_ (false)
        {
        }

        void    seq_ctl_hook(const void*, size_t,
                             unsigned   frag,
                             unsigned   seqno)
        {
          valid_ = true;
          frag_ = frag;
          seqno_ = seqno;
        }

        operator bool () const
        {
          return valid_;
        }

        bool            operator not () const
        {
          return not operator bool ();
        }

        unsigned        frag() const
        {
          assert(*this);

          return frag_;
        }

        unsigned        seqno() const
        {
          assert(*this);

          return seqno_;
        }

      private:
        bool    valid_;
        unsigned        frag_;
        unsigned        seqno_;
      };

    } // End of wifi::frame::<anonymous namespace>.

    inline
    boost::optional<unsigned>
    fragment_number_of(const void* frame, size_t caplen)
    {
      dissector<seqnum_fragnum_hooks>   d (frame, caplen);

      if (not d)
        return boost::none_t ();
      return d.frag();
    }

    inline
    boost::optional<unsigned>
    sequence_number_of(const void* frame, size_t caplen)
    {
      dissector<seqnum_fragnum_hooks>   d (frame, caplen);

      if (not d)
        return boost::none_t ();
      return d.seqno();
    }

    inline
    const addr*
    transmitter_address(const void* frame)
    {
      switch (type_of(frame))
        {
        case type::management:
          return & static_cast<const mgt::header*> (frame)
            ->addrs[mgt::header::sa];

        case type::control:
          {
            switch (subtype_of(frame))
              {
              case ctl::subtype::ps_poll:
                return & static_cast<const ctl::ps_poll::header*> (frame)
                  ->addrs[ctl::ps_poll::header::ta];

              case ctl::subtype::rts:
                return & static_cast<const ctl::rts::header*> (frame)
                  ->addrs[ctl::rts::header::ta];

              default:
                return 0;
              }
          }

        case type::data:
          {
            typedef data::header_3addr  header;

            return & static_cast<const header*> (frame)->addrs[1];
          }

        default:
          return 0;
        }
    }

    struct bssid_address_hooks: public dissector_default_hooks
    {
                        bssid_address_hooks()   { res_ = 0;     }

      const addr*       result() const          { return res_;  }

# ifndef DOXYGEN
#  define WP_bssid_address_hooks_define_hook(Type, Name)                \
      void      Name ## _hook(const Type::Name::header* h, size_t)      \
      {                                                                 \
        res_ = & h->addrs[Type::Name::header::bssid];                   \
      }

    protected:
      WP_bssid_address_hooks_define_hook(ctl, ps_poll)
      WP_bssid_address_hooks_define_hook(ctl, cf_end)
      WP_bssid_address_hooks_define_hook(ctl, cf_end_cf_ack)
      WP_bssid_address_hooks_define_hook(data, within_ibss)
      WP_bssid_address_hooks_define_hook(data, from_ds)
      WP_bssid_address_hooks_define_hook(data, to_ds)

#  undef WP_bssid_address_hooks_define_hook

    protected:
      void      ap_to_ap_hook(const data::ap_to_ap::header* h, size_t)
      {
        // FIXME: Actually, this frame holds two bssid addresses.
        res_ = & h->addrs[data::ap_to_ap::header::ta];
      }

      void      management_addr3_hook(const mgt::header* h, size_t)
      {
        res_ = & h->addrs[mgt::header::bssid];
      }

# endif // ! DOXYGEN

    private:
      const addr*       res_;
    };

    inline
    const addr*
    bssid_address(const void* frame, size_t caplen)
    {
      return dissector<bssid_address_hooks> (frame, caplen).result();
    }

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_FRAME_FRAME_HXX

---