ipflowid.hh

// -*- related-file-name: "../../lib/ipflowid.cc" -*-
#ifndef CLICK_IPFLOWID_HH
#define CLICK_IPFLOWID_HH
#include <click/ipaddress.hh>
#include <click/hashcode.hh>
#include <functional>
CLICK_DECLS
class Packet;
 
class IPFlowID { public:
 
    typedef uninitialized_type uninitialized_t;
 
 
    explicit IPFlowID()
        : _saddr(), _daddr(), _sport(0), _dport(0) {
    }
 
    explicit IPFlowID(IPAddress saddr, uint16_t sport, IPAddress daddr, uint16_t dport)
        : _saddr(saddr), _daddr(daddr), _sport(sport), _dport(dport) {
    }
 
    explicit IPFlowID(const Packet *p, bool reverse = false);
 
    explicit IPFlowID(const click_ip *iph, bool reverse = false);
 
    inline IPFlowID(const uninitialized_type &unused) {
        (void) unused;
    }
 
 
    typedef IPAddress (IPFlowID::*unspecified_bool_type)() const;
    operator unspecified_bool_type() const {
        return _saddr || _daddr ? &IPFlowID::saddr : 0;
    }
 
 
    IPAddress saddr() const {
        return _saddr;
    }
    uint16_t sport() const {
        return _sport;
    }
    IPAddress daddr() const {
        return _daddr;
    }
    uint16_t dport() const {
        return _dport;
    }
 
    void set_saddr(IPAddress a) {
        _saddr = a;
    }
    void set_sport(uint16_t p) {
        _sport = p;
    }
    void set_daddr(IPAddress a) {
        _daddr = a;
    }
    void set_dport(uint16_t p) {
        _dport = p;
    }
 
    void assign(IPAddress saddr, uint16_t sport, IPAddress daddr, uint16_t dport) {
        _saddr = saddr;
        _daddr = daddr;
        _sport = sport;
        _dport = dport;
    }
 
 
    IPFlowID reverse() const {
        return IPFlowID(_daddr, _dport, _saddr, _sport);
    }
    inline IPFlowID rev() const CLICK_DEPRECATED;
 
    inline hashcode_t hashcode() const;
 
    String unparse() const;
 
    inline operator String() const CLICK_DEPRECATED;
    inline String s() const CLICK_DEPRECATED;
 
  protected:
 
    // note: several functions depend on this field order!
    IPAddress _saddr;
    IPAddress _daddr;
    uint16_t _sport;                    // network byte order
    uint16_t _dport;                    // network byte order
 
    int unparse(char *s) const;
    friend StringAccum &operator<<(StringAccum &sa, const IPFlowID &flow_id);
 
};
 
 
inline IPFlowID IPFlowID::rev() const
{
    return reverse();
}
 
 
#define ROT(v, r) ((v)<<(r) | ((unsigned)(v))>>(32-(r)))
 
inline hashcode_t IPFlowID::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) + 1) ^ ROT(dx, 31 - (d % 16)))
        ^ ((d << 16) | s);
}
 
 
inline bool operator==(const IPFlowID &a, const IPFlowID &b)
{
    return a.sport() == b.sport() && a.dport() == b.dport()
        && a.saddr() == b.saddr() && a.daddr() == b.daddr();
}
 
inline bool operator!=(const IPFlowID &a, const IPFlowID &b)
{
    return a.sport() != b.sport() || a.dport() != b.dport()
        || a.saddr() != b.saddr() || a.daddr() != b.daddr();
}
 
 
inline IPFlowID operator&(const IPFlowID &a, const IPFlowID &b)
{
    return IPFlowID(a.saddr() & b.saddr(), a.sport() & b.sport(), a.daddr() & b.daddr(), a.dport() & b.dport());
}
 
StringAccum &operator<<(StringAccum &, const IPFlowID &);
 
inline IPFlowID::operator String() const
{
    return unparse();
}
 
inline String IPFlowID::s() const
{
    return unparse();
}
 
class IPFlow5ID : public IPFlowID { public:
    explicit IPFlow5ID(const Packet *p, bool reverse = false);
 
    explicit IPFlow5ID() {
        _zero = 0;
    };
 
    uint8_t proto() const {
            return _proto;
    }
 
    inline hashcode_t hashcode() const;
 
 
    String unparse() const;
 
 
protected:
        uint8_t _proto;
    uint8_t _zero;
 
    int unparse(char *s) const;
}  CLICK_SIZE_PACKED_ATTRIBUTE ;
 
inline bool operator==(const IPFlow5ID &a, const IPFlow5ID &b)
{
    return a.sport() == b.sport() && a.dport() == b.dport()
        && a.saddr() == b.saddr() && a.daddr() == b.daddr() && a.proto() == b.proto();
}
 
 
inline hashcode_t IPFlow5ID::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) + 1) ^ ROT(dx, 31 - (d % 16)))
        ^ ((d << 16) | s) ^ proto();
}
 
#undef ROT
inline bool operator!=(const IPFlow5ID &a, const IPFlow5ID &b)
{
    return a.sport() != b.sport() || a.dport() != b.dport()
        || a.saddr() != b.saddr() || a.daddr() != b.daddr() || a.proto() != b.proto();
}
 
 
namespace std {
  template <> struct hash<IPFlow5ID>
  {
    size_t operator()(const IPFlow5ID & x) const
    {
      return x.hashcode();
    }
  };
}
 
CLICK_ENDDECLS
#endif