include/wipal/filter/anonymizer.hh

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

extern "C"
{
# include <stdint.h>
}

# include <set>

# include <wipal/tool/valued_iterator.hh>
# include <wipal/pcap/pkt.hh>
# include <wipal/wifi/addr.hh>
# include <wipal/wifi/dissector/default_hooks.hh>
# include <wipal/wifi/essid.hh>
# include <wipal/wifi/frame.hh>
# include <wipal/filter/anon_policies.hh>

namespace wpl
{

  /*---------------------.
  | Forward declarations |
  `---------------------*/

  namespace filter
  {
    template <class, class, class, class>
    struct anonymizer;

    namespace internals
    {
      template <class, class, class, class, class>
      struct anonymizer_iterator;
    } // End of namespace wifi::frame::filter::internals.
  } // End of namespace wpl::filter.


  /*--------------.
  | Virtual types |
  `--------------*/

  namespace tool
  {

    template <class I, class P, class A, class B>
    struct types< filter::anonymizer<I, P, A, B> >
    {
      typedef
      filter::internals::anonymizer_iterator<I, P, A, B, tool::bottom>
      iterator;
    };

    template <class I, class P, class A, class B1, class B2>
    struct types< filter::internals::anonymizer_iterator<I, P, A, B1, B2> >
    {
      typedef filter::anonymizer<I, P, A, B1>                   iterable_type;
      typedef pkt::packet< filter::anonymizer<I, P, A, B1> >    value_type;
    };

  } // End of namespace wpl::tool.


  /*-------------.
  | Declarations |
  `-------------*/

  namespace wifi
  {

    namespace anon
    {

      struct dummy_mac_policy
      {
        addr            operator [] (const addr& mac_addr) const;
      };

      struct dummy_essid_policy
      {
        essid           operator [] (const essid& essid) const;
      };

      template <class MACAnonPolicy, class ESSIDAnonPolicy>
      struct generic_policy: private MACAnonPolicy, private ESSIDAnonPolicy
      {
        generic_policy(const MACAnonPolicy& macp = MACAnonPolicy (),
                       const ESSIDAnonPolicy& essidp = ESSIDAnonPolicy ());

        addr            operator [] (const addr& mac_addr);
        essid           operator [] (const essid& essid);
      };

      typedef generic_policy<dummy_mac_policy, dummy_essid_policy>
              dummy_policy;

      typedef generic_policy<prefix_preserving_mac_policy,
                             prefix_preserving_essid_policy>
              prefix_preserving_policy;

      typedef prefix_preserving_policy
              default_policy;

# ifdef HAVE_OPENSSL

      typedef generic_policy<xor_mac_policy, xor_essid_policy>
              xor_policy;

# endif // HAVE_OPENSSL

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

    namespace internals
    {

      template <class AnonPolicy>
      void
      anonymize_addrs(AnonPolicy&                               anon_policy,
                      void* const                               bytes,
                      const std::set<const wifi::addr*>&        addrs);

      template <class AnonPolicy>
      size_t
      anonymize_ssid(AnonPolicy&                        anon_policy,
                     const size_t                       anon_caplen,
                     pkt::metadata&                     meta,
                     uint8_t* const                     bytes,
                     const wifi::ssid_elt* const        ssid,
                     const std::string* const           pkt_str);

      struct anon_hooks: public wifi::dissector_default_hooks
      {
        anon_hooks();

        void
        addr_hook(const void*, size_t, unsigned, const wifi::addr&);

        void
        end_of_frame_headers_hook(const void*, size_t, const void*);

        wifi::type::frame_type          ty;
        const uint8_t*                  end;
        std::set<const wifi::addr*>     addrs;
        const wifi::ssid_elt*           ssid;
      };

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

    template <class Phy, class AnonPolicy, class S>
    void
    anonymize(AnonPolicy&       anon_policy,
              pkt::packet<S>&   frm);

    template <class Phy, class AnonPolicy>
    void
    anonymize(AnonPolicy&               anon_policy,
              pkt::metadata&            meta,
              void* const               bytes,
              const bool                swapped = false,
              const std::string* const  pkt_str = 0);

  } // End of namespace wpl::wifi.

  namespace filter
  {

    namespace internals
    {

      template <class I, class P, class A, class B,
                class Bottom = tool::bottom>
      struct anonymizer_iterator: WP_INHERIT(public tool::valued_iterator,
                                             anonymizer_iterator<I, P, A, B,
                                             Bottom>),
                                  private A // Anonymization policy.
      {
        typedef WP_GET_EXACT(Bottom, anonymizer_iterator<I, P, A, B, Bottom>)
                                                        exact_type;
        typedef WP_TYPE(value_type, exact_type)         value_type;
        typedef WP_TYPE(iterable_type, exact_type)      iterable_type;

        anonymizer_iterator(const iterable_type& iterable, bool end);

        bool    equal(const anonymizer_iterator& rhs) const;
        void    increment();

      private:
        I                       next_;
        I                       last_;
      };

    } // End of namespace wpl::filter::internals.

    template <class InputIterator,
              class Phy,
              class AnonPolicy = wifi::anon::default_policy,
              class Bottom = tool::bottom>
    struct anonymizer: WP_INHERIT(public pkt::stream,
                                  anonymizer<InputIterator, Phy, AnonPolicy,
                                             Bottom>),
                       private AnonPolicy
    {
      anonymizer(const InputIterator& first, const InputIterator& last,
                 const AnonPolicy& anon_policy = AnonPolicy ());

      bool      swapped_impl() const;

    private:
      InputIterator     first_;
      InputIterator     last_;

      friend struct internals::anonymizer_iterator<InputIterator,
        Phy,
        AnonPolicy,
        Bottom, tool::bottom>;
    };

  } // End of namespace wpl::filter.
} // End of namespace wpl.

# include "anonymizer.hxx"

#endif // ! FILTER_ANONYMIZER_HH_

---