include/wipal/wifi/dissector/dissector.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_DISSECTOR_DISSECTOR_HXX_
# define WIFI_DISSECTOR_DISSECTOR_HXX_

# include <wipal/tool/endianness.hh>
# include <wipal/wifi/frame.hh>
# include <wipal/wifi/data.hh>

# include "dissector.hh"

namespace wpl
{

  namespace wifi
  {

    template <class Hooks>
    dissector<Hooks>::dissector(const Hooks& hooks):
      Hooks (hooks),
      status_ (dissector_status::invalid)
    {
    }

    template <class Hooks>
    dissector<Hooks>::dissector(const void* frame,
                                size_t caplen,
                                const Hooks& hooks):
      Hooks(hooks),
      status_ (dissector_status::invalid)
    {
      (*this)(frame, caplen);
    }

    template <class Hooks>
    dissector_status::status
    dissector<Hooks>::status() const
    {
      return status_;
    }

    template <class Hooks>
    void
    dissector<Hooks>::operator () (const void* frame, size_t caplen)
    {
      this->frame_hook(frame, caplen);

      if (caplen < control)
        {
          status_ = dissector_status::invalid;
          this->truncated_unknown_frame_hook(frame, caplen);
          this->truncated_frame_hook(frame, caplen, status_);
        }
      else
        {
          status_ = dissector_status::valid_control;
          switch (type_of(frame))
            {
            case type::management: management_frame(frame, caplen);     break;
            case type::control:    control_frame(frame, caplen);        break;
            case type::data:       data_frame(frame, caplen);           break;

            default:
              this->invalid_type_hook(frame, caplen);
              this->invalid_type_or_subtype_hook(frame, caplen, status_);
              break;
            }
        }
      this->end_of_frame_hook(frame, caplen, status_);
    }

    template <class Hooks>
    Hooks&
    dissector<Hooks>::hooks()
    {
      return *static_cast<Hooks*> (this);
    }

    template <class Hooks>
    const Hooks&
    dissector<Hooks>::hooks() const
    {
      return *static_cast<const Hooks*> (this);
    }

# define WP_dissector_get_header(Type, VarName, Frame)                  \
    const Type::header* VarName = static_cast<const Type::header*> (Frame)

# define WP_dissector_check_addr(N, Type, Header, Caplen)               \
    if (Caplen < addr ## N)                                             \
      {                                                                 \
        this->truncated_ ## Type ## _frame_hook(Header, Caplen, status_); \
        this->truncated_frame_hook(Header, Caplen, status_);            \
        return;                                                         \
      }                                                                 \
    status_ = dissector_status::valid_addr ## N;                        \
    this->Type ## _addr ## N ## _hook(Header, Caplen)

# define WP_dissector_check_addr2(N, Type, Header, Caplen)              \
    WP_dissector_check_addr(N, Type, Header, Caplen);                   \
    this->addr_hook(Header, Caplen, N, Header->addrs[N - 1])

# define WP_dissector_check_seq_ctl(Type, Header, Caplen)               \
    if (caplen < seqctl)                                                \
      {                                                                 \
        this->truncated_ ## Type ## _frame_hook(Header, Caplen, status_); \
        this->truncated_frame_hook(Header, Caplen, status_);            \
      }                                                                 \
    do                                                                  \
      {                                                                 \
        const unsigned seq_ctl =                                        \
          tool::extract_little_endian_short_u(Header->seq_ctl);         \
        const unsigned fragnum = seq_ctl & 0xF;                         \
        const unsigned seqnum =  seq_ctl >> 4;                          \
                                                                        \
        status_ = dissector_status::valid_seq_ctl;                      \
        this->Type ## _seq_ctl_hook(Header, Caplen, fragnum, seqnum);   \
        this->seq_ctl_hook(Header, Caplen, fragnum, seqnum);            \
      }                                                                 \
    while (false)

    template <class Hooks>
    void
    dissector<Hooks>::management_frame(const void* frame, size_t caplen)
    {
      WP_dissector_get_header(mgt::header, h, frame);

      this->management_hook(h, caplen);

      WP_dissector_check_addr2(1, management, h, caplen);
      WP_dissector_check_addr2(2, management, h, caplen);
      WP_dissector_check_addr2(3, management, h, caplen);
      WP_dissector_check_seq_ctl(management, h, caplen);

      management_frame_dispatch(h, caplen);
      this->end_of_frame_headers_hook(frame, caplen,
                                      static_cast<const char*> (frame) +
                                      seqctl);
    }

    template <class Hooks>
    void
    dissector<Hooks>::management_frame_dispatch(const mgt::header* h,
                                                    size_t caplen)
    {
      // FIXME: TODO: Use this to parse IEEE 802.11 elements in frame bodies.
      const void* const body = reinterpret_cast<const uint8_t*> (h) + seqctl;
      (void) body;

      switch (subtype_of(h))
        {
        case mgt::subtype::beacon:
          return this->beacon_hook(h, caplen);

        case mgt::subtype::assoc_req:
          return this->assoc_req_hook(h, caplen);

        case mgt::subtype::assoc_resp:
          return this->assoc_resp_hook(h, caplen);

        case mgt::subtype::reassoc_req:
          return this->reassoc_req_hook(h, caplen);

        case mgt::subtype::reassoc_resp:
          return this->reassoc_resp_hook(h, caplen);

        case mgt::subtype::probe_req:
          return this->probe_req_hook(h, caplen);

        case mgt::subtype::probe_resp:
          return this->probe_resp_hook(h, caplen);

        case mgt::subtype::atim:
          return this->atim_hook(h, caplen);

        case mgt::subtype::disassoc:
          return this->disassoc_hook(h, caplen);

        case mgt::subtype::auth:
          return this->auth_hook(h, caplen);

        case mgt::subtype::deauth:
          return this->deauth_hook(h, caplen);

        default:
          this->invalid_management_subtype_hook(h, caplen);
          this->invalid_subtype_hook(h, caplen, status_);
          this->invalid_type_or_subtype_hook(h, caplen, status_);
          return;
        }
    }

    template <class Hooks>
    void
    dissector<Hooks>::control_frame(const void* frame, size_t caplen)
    {
      this->control_hook(frame, caplen);

      switch (subtype_of(frame))
        {

# define WP_dissector_control_dispatch_1addr(Name, Frame, Caplen)       \
        case ctl::subtype::Name:                                        \
          {                                                             \
            WP_dissector_get_header(ctl::Name::header, h, Frame);       \
            if (Caplen < addr1)                                         \
              {                                                         \
                this->truncated_ ## Name ## _frame_hook(h, Caplen);     \
                this->truncated_frame_hook(h, Caplen, status_);         \
                return;                                                 \
              }                                                         \
            status_ = dissector_status::valid_addr1;                    \
            this->Name ## _addr1 ## _hook(h, Caplen);                   \
            this->addr_hook(h, Caplen, 1, h->ra);                       \
            this->Name ## _hook(h, Caplen);                             \
            this->end_of_frame_headers_hook(h, Caplen,                  \
                                   reinterpret_cast<const char*> (h) + addr1); \
          }                                                             \
          return

# define WP_dissector_control_dispatch_2addr(Name, Frame, Caplen)       \
        case ctl::subtype::Name:                                        \
          {                                                             \
            WP_dissector_get_header(ctl::Name::header, h, Frame);       \
            WP_dissector_check_addr2(1, Name, h, Caplen);               \
            WP_dissector_check_addr2(2, Name, h, Caplen);               \
            this->Name ## _hook(h, Caplen);                             \
            this->end_of_frame_headers_hook(h, Caplen,                  \
                                   reinterpret_cast<const char*> (h) + addr2); \
          }                                                             \
          return

          WP_dissector_control_dispatch_2addr(ps_poll, frame, caplen);
          WP_dissector_control_dispatch_2addr(rts, frame, caplen);
          WP_dissector_control_dispatch_2addr(cf_end, frame, caplen);
          WP_dissector_control_dispatch_2addr(cf_end_cf_ack, frame, caplen);

          WP_dissector_control_dispatch_1addr(cts, frame, caplen);
          WP_dissector_control_dispatch_1addr(ack, frame, caplen);

# undef WP_dissector_control_dispatch_2addr
# undef WP_dissector_control_dispatch_1addr

        default:
          this->invalid_control_subtype_hook(frame, caplen);
          this->invalid_subtype_hook(frame, caplen, status_);
          this->invalid_type_or_subtype_hook(frame, caplen, status_);
          return;
        }
    }

    template <class Hooks>
    void
    dissector<Hooks>::data_frame(const void* frame, size_t caplen)
    {
      this->data_hook(frame, caplen);

      const data::header_3addr* h3 =
        static_cast<const data::header_3addr*> (frame);

      WP_dissector_check_addr2(1, data, h3, caplen);
      WP_dissector_check_addr2(2, data, h3, caplen);
      WP_dissector_check_addr2(3, data, h3, caplen);
      WP_dissector_check_seq_ctl(data, h3, caplen);

      unsigned  offset;

      const int dir = (to_ds(frame) ? 2 : 0) | (from_ds(frame) ? 1 : 0);
      switch (dir)
        {
        case 3: // To DS: 1, From DS: 1
          {
            using data::ap_to_ap::header;

            offset = addr4;

            const header* const h = static_cast<const header*> (frame);
            WP_dissector_check_addr(4, data, h, caplen);
            this->addr_hook(h, caplen, 4, h->addrs_sa);
            this->ap_to_ap_hook(static_cast<const header*> (frame), caplen);
            break;
          }

        case 2: // To DS: 1, From DS: 0
          {
            using data::to_ds::header;

            offset = seqctl;

            this->to_ds_hook(static_cast<const header*> (frame), caplen);
            break;
          }

        case 1: // To DS: 0, From DS: 1
          {
            using data::from_ds::header;

            offset = seqctl;

            this->from_ds_hook(static_cast<const header*> (frame), caplen);
            break;
          }

        case 0: // To DS: 0, From DS: 0
          {
            using data::within_ibss::header;

            offset = seqctl;

            this->within_ibss_hook(static_cast<const header*> (frame), caplen);
            break;
          }

        default:
          throw std::logic_error ("Unreachable code reached!");
        }
      data_frame_dispatch(frame, caplen);

      const uint8_t* before_qos = static_cast<const uint8_t*> (frame) + offset;
      const unsigned qos_shift = subtype_of(frame) & 0x8 ? 2 : 0;

      if (qos_shift)
        {

          const unsigned        qosctl_lo       = *before_qos;
          const unsigned        tid             = (qosctl_lo & 0x0F);
          const bool            eosp            = (qosctl_lo & 0x10) == 0x10;
          const unsigned        ackpolicy       = (qosctl_lo >> 5) & 0x3;

          this->qos_ctl_hook(frame, caplen,
                             tid, eosp, ackpolicy, before_qos[1]);
        }

      this->end_of_frame_headers_hook(frame, caplen, before_qos + qos_shift);
    }

    template <class Hooks>
    void
    dissector<Hooks>::data_frame_dispatch(const void* frame, size_t caplen)
    {
      switch (subtype_of(frame))
        {
        case data::subtype::data:
          return this->data_only_hook(frame, caplen, status_);
        case data::subtype::data_cf_ack:
          return this->data_cf_ack_hook(frame, caplen, status_);
        case data::subtype::data_cf_poll:
          return this->data_cf_poll_hook(frame, caplen, status_);
        case data::subtype::data_cf_ack_cf_poll:
          return this->data_cf_ack_cf_poll_hook(frame, caplen, status_);
        case data::subtype::null:
          return this->null_hook(frame, caplen, status_);
        case data::subtype::cf_ack:
          return this->cf_ack_hook(frame, caplen, status_);
        case data::subtype::cf_poll:
          return this->cf_poll_hook(frame, caplen, status_);
        case data::subtype::cf_ack_cf_poll:
          return this->cf_ack_cf_poll_hook(frame, caplen, status_);
        default:
          this->invalid_data_subtype_hook(frame, caplen, status_);
          this->invalid_subtype_hook(frame, caplen, status_);
          this->invalid_type_or_subtype_hook(frame, caplen, status_);
          return;
        }
    }

# undef WP_dissector_check_seq_ctl
# undef WP_dissector_check_addr2
# undef WP_dissector_check_addr
# undef WP_dissector_get_header

    template <class PhyH, class Hooks, class Src>
    dissector<Hooks>
    dissect(const pkt::packet<Src>&     frm,
            const Hooks&                hooks = Hooks ())
    {
      dissector<Hooks>          ret (hooks);

      const pkt::metadata&      meta = frm.meta();
      const size_t              caplen = meta.caplen;
      const bool                swapped = frm.swapped();
      const PhyH* const         phy = static_cast<const PhyH*> (frm.bytes());
      const size_t              phy_len = phy->len(caplen, swapped);

      if (phy_len < caplen)
        ret(phy->decapsulate(caplen, swapped), caplen - phy_len);

      return ret;
    }

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_DISSECTOR_DISSECTOR_HXX_

---