ip6flowid.hh

// -*- c-basic-offset: 2; related-file-name: "../../lib/ip6flowid.cc" -*-
#ifndef CLICK_IP6FLOWID_HH
#define CLICK_IP6FLOWID_HH
#include <click/ip6address.hh>
#include <click/ipflowid.hh>
#include <click/hashcode.hh>
CLICK_DECLS
class Packet;
 
class IP6FlowID { public:
 
    typedef uninitialized_type uninitialized_t;
 
  inline IP6FlowID();
 
  inline IP6FlowID(const IP6Address &, uint16_t, const IP6Address &, uint16_t);
 
  inline IP6FlowID(const IPAddress &, uint16_t, const IPAddress &, uint16_t);
 
  explicit IP6FlowID(const Packet *, bool reverse = false);
 
  explicit IP6FlowID(const click_ip6 *ip6h, bool reverse = false);
 
  explicit IP6FlowID(const click_ip *iph, bool reverse = false);
 
  explicit IP6FlowID(const IPFlowID &);
 
 
  inline IP6FlowID(const uninitialized_type &unused) {
    (void) unused;
  }
 
  typedef const IP6Address &(IP6FlowID::*unspecified_bool_type)() const;
  inline operator unspecified_bool_type() const;
 
  const IP6Address &saddr() const       { return _saddr; }
  const IP6Address &daddr() const       { return _daddr; }
  IPAddress saddr4() const              { return _saddr.ip4_address(); }
  IPAddress daddr4() const              { return _daddr.ip4_address(); }
  uint16_t sport() const                { return _sport; }
  uint16_t dport() const                { return _dport; }
 
  void set_saddr(const IP6Address &a)   { _saddr = a; }
  void set_daddr(const IP6Address &a)   { _daddr = a; }
  void set_saddr(const IPAddress a)     { _saddr = a; }
  void set_daddr(const IPAddress a)     { _daddr = a; }
  void set_sport(uint16_t p)            { _sport = p; }
  void set_dport(uint16_t p)            { _dport = p; }
 
  void assign(const IP6Address &saddr, uint16_t sport, const IP6Address &daddr, uint16_t dport) {
    _saddr = saddr;
    _daddr = daddr;
    _sport = sport;
    _dport = dport;
  }
 
  void assign(IPAddress saddr, uint16_t sport, IPAddress daddr, uint16_t dport) {
    _saddr = saddr;
    _daddr = daddr;
    _sport = sport;
    _dport = dport;
  }
 
  inline IP6FlowID reverse() const;
  inline IP6FlowID rev() const CLICK_DEPRECATED;
 
  inline bool is_ip4_mapped() const { return _saddr.is_ip4_mapped(); }
 
  IPFlowID flow_id4() const;
 
  IP6FlowID flow_id6() const;
 
  inline IP6FlowID &operator=(const IPFlowID &);
 
  inline hashcode_t hashcode() const;
 
  String unparse() const;
  operator String() const               { return unparse(); }
  String s() const                      { return unparse(); }
 
 protected:
 
  // note: several functions depend on this field order!
  IP6Address _saddr;
  IP6Address _daddr;
  uint16_t _sport;                      // network byte order
  uint16_t _dport;                      // network byte order
 
};
 
inline
IP6FlowID::IP6FlowID()
  : _saddr(), _daddr(), _sport(0), _dport(0)
{
}
 
inline
IP6FlowID::IP6FlowID(const IP6Address &saddr, uint16_t sport,
                     const IP6Address &daddr, uint16_t dport)
  : _saddr(saddr), _daddr(daddr), _sport(sport), _dport(dport)
{
}
 
inline
IP6FlowID::IP6FlowID(const IPAddress &saddr, uint16_t sport,
                     const IPAddress &daddr, uint16_t dport)
  : _saddr(saddr), _daddr(daddr), _sport(sport), _dport(dport)
{
}
 
inline
IP6FlowID::IP6FlowID(const IPFlowID &flow)
{
  *this = flow;
}
 
inline
IP6FlowID::operator unspecified_bool_type() const
{
  return _saddr || _daddr ? &IP6FlowID::saddr : 0;
}
 
inline IP6FlowID
IP6FlowID::reverse() const
{
  return IP6FlowID(_daddr, _dport, _saddr, _sport);
}
 
inline IP6FlowID
IP6FlowID::rev() const
{
  return reverse();
}
 
inline IP6FlowID &
IP6FlowID::operator=(const IPFlowID &f)
{
  assign(f.saddr(), f.sport(), f.daddr(), f.dport());
  return *this;
}
 
#define ROT(v, r) ((v)<<(r) | ((unsigned)(v))>>(32-(r)))
 
#if 0
inline hashcode_t
IP6FlowID::hashcode() const
{
  return (ROT(_saddr.hashcode(), 13)
          ^ ROT(_daddr.hashcode(), 23) ^ (_sport | (_dport<<16)));
}
#endif
 
inline hashcode_t IP6FlowID::hashcode() const
{
  // more complicated hashcode, but causes less collision
  uint16_t s = ntohs(sport());
  uint16_t d = ntohs(dport());
  hashcode_t sx = CLICK_NAME(hashcode)(saddr());
  hashcode_t dx = CLICK_NAME(hashcode)(daddr());
  return (ROT(sx, s%16)
          ^ ROT(dx, 31-d%16))
          ^ ((d << 16) | s);
}
 
#undef ROT
 
StringAccum &operator<<(StringAccum &sa, const IP6FlowID &flow_id);
 
inline bool
operator==(const IP6FlowID &a, const IP6FlowID &b)
{
  return a.dport() == b.dport() && a.sport() == b.sport()
    && a.daddr() == b.daddr() && a.saddr() == b.saddr();
}
 
inline bool
operator!=(const IP6FlowID &a, const IP6FlowID &b)
{
  return !(a == b);
}
 
CLICK_ENDDECLS
#endif