ipaddress.hh

Go to the documentation of this file.

// -*- c-basic-offset: 4; related-file-name: "../../lib/ipaddress.cc" -*-
#ifndef CLICK_IPADDRESS_HH
#define CLICK_IPADDRESS_HH
#include <click/string.hh>
#include <click/glue.hh>
#include <click/type_traits.hh>
#include <click/hashcode.hh>
#include <clicknet/ip.h>
CLICK_DECLS
class StringAccum;
class ArgContext;
extern const ArgContext blank_args;
class IPAddressArg;
template <typename T, size_t ALIGNMENT> class Vector;
 
class IPAddress { public:
 
    typedef uninitialized_type uninitialized_t;
 
    inline IPAddress()
        : _addr(0) {
    }
 
    inline IPAddress(unsigned x)
        : _addr(x) {
    }
    explicit inline IPAddress(int x)
        : _addr(x) {
    }
    explicit inline IPAddress(unsigned long x)
        : _addr(x) {
    }
    explicit inline IPAddress(long x)
        : _addr(x) {
    }
 
    inline IPAddress(struct in_addr x)
        : _addr(x.s_addr) {
    }
 
    explicit IPAddress(const unsigned char *data) {
#if HAVE_INDIFFERENT_ALIGNMENT
        _addr = *(reinterpret_cast<const unsigned *>(data));
#else
        memcpy(&_addr, data, 4);
#endif
    }
 
    explicit IPAddress(const String &x);
 
    inline IPAddress(const uninitialized_type &unused) {
        (void) unused;
    }
 
    static IPAddress make_prefix(int prefix_len);
 
    static inline IPAddress make_broadcast() {
        return IPAddress(0xFFFFFFFF);
    }
 
    static inline IPAddress make_random() {
    return IPAddress(rand());
    }
 
    inline bool empty() const {
        return !_addr;
    }
 
    inline uint32_t addr() const {
        return _addr;
    }
 
    inline operator uint32_t() const {
        return _addr;
    }
 
    inline bool is_multicast() const {
        return (_addr & htonl(0xF0000000U)) == htonl(0xE0000000U);
    }
 
    inline bool is_link_local() const {
        return (_addr & htonl(0xFFFF0000)) == htonl(0xA9FE0000);
    }
 
    inline struct in_addr in_addr() const;
    inline operator struct in_addr() const;
 
    inline unsigned char* data();
    inline const unsigned char* data() const;
 
    inline uint32_t hashcode() const;
 
    int mask_to_prefix_len() const;
    inline bool matches_prefix(IPAddress addr, IPAddress mask) const;
    inline bool mask_as_specific(IPAddress mask) const;
    inline bool mask_more_specific(IPAddress mask) const;
 
    // bool operator==(IPAddress, IPAddress);
    // bool operator==(IPAddress, uint32_t);
    // bool operator!=(IPAddress, IPAddress);
    // bool operator!=(IPAddress, uint32_t);
 
    // IPAddress operator&(IPAddress, IPAddress);
    // IPAddress operator|(IPAddress, IPAddress);
    // IPAddress operator^(IPAddress, IPAddress);
    // IPAddress operator~(IPAddress);
 
    inline IPAddress& operator&=(IPAddress);
    inline IPAddress& operator|=(IPAddress);
    inline IPAddress& operator^=(IPAddress);
 
    String unparse() const;
    String unparse_mask() const;
    String unparse_with_mask(IPAddress) const;
 
    inline String s() const;
    inline operator String() const CLICK_DEPRECATED;
 
    typedef IPAddress parameter_type;
 
  private:
 
    uint32_t _addr;
 
};
 
 
inline bool
operator==(IPAddress a, IPAddress b)
{
    return a.addr() == b.addr();
}
 
inline bool
operator==(IPAddress a, uint32_t b)
{
    return a.addr() == b;
}
 
inline bool
operator!=(IPAddress a, IPAddress b)
{
    return a.addr() != b.addr();
}
 
inline bool
operator!=(IPAddress a, uint32_t b)
{
    return a.addr() != b;
}
 
inline const unsigned char*
IPAddress::data() const
{
    return reinterpret_cast<const unsigned char*>(&_addr);
}
 
inline unsigned char*
IPAddress::data()
{
    return reinterpret_cast<unsigned char*>(&_addr);
}
 
inline struct in_addr
IPAddress::in_addr() const
{
    struct in_addr ia;
    ia.s_addr = _addr;
    return ia;
}
 
inline
IPAddress::operator struct in_addr() const
{
    return in_addr();
}
 
StringAccum& operator<<(StringAccum&, IPAddress);
 
inline bool
IPAddress::matches_prefix(IPAddress addr, IPAddress mask) const
{
    return ((this->addr() ^ addr.addr()) & mask.addr()) == 0;
}
 
inline bool
IPAddress::mask_as_specific(IPAddress mask) const
{
    return (addr() & mask.addr()) == mask.addr();
}
 
inline bool
IPAddress::mask_more_specific(IPAddress mask) const
{
    return ((addr() << 1) & mask.addr()) == mask.addr();
}
 
inline IPAddress
operator&(IPAddress a, IPAddress b)
{
    return IPAddress(a.addr() & b.addr());
}
 
inline IPAddress&
IPAddress::operator&=(IPAddress a)
{
    _addr &= a._addr;
    return *this;
}
 
inline IPAddress
operator|(IPAddress a, IPAddress b)
{
    return IPAddress(a.addr() | b.addr());
}
 
inline IPAddress&
IPAddress::operator|=(IPAddress a)
{
    _addr |= a._addr;
    return *this;
}
 
inline IPAddress
operator^(IPAddress a, IPAddress b)
{
    return IPAddress(a.addr() ^ b.addr());
}
 
inline IPAddress&
IPAddress::operator^=(IPAddress a)
{
    _addr ^= a._addr;
    return *this;
}
 
inline IPAddress
operator~(IPAddress a)
{
    return IPAddress(~a.addr());
}
 
inline uint32_t
IPAddress::hashcode() const
{
    return addr();
}
 
inline
IPAddress::operator String() const
{
    return unparse();
}
 
inline String
IPAddress::s() const
{
    return unparse();
}
 
 
class IPAddressArg { public:
    static const char *basic_parse(const char *begin, const char *end,
                                   unsigned char value[4], int &nbytes);
    static bool parse(const String &str, IPAddress &result,
                      const ArgContext &args = blank_args);
    static bool parse(const String &str, struct in_addr &result,
                      const ArgContext &args = blank_args) {
        return parse(str, reinterpret_cast<IPAddress &>(result), args);
    }
    static bool parse(const String &str, Vector<IPAddress> &result,
                      const ArgContext &args = blank_args);
};
 
class IPPrefixArg { public:
    IPPrefixArg(bool allow_bare_address_ = false)
        : allow_bare_address(allow_bare_address_) {
    }
    bool parse(const String &str,
               IPAddress &result_addr, IPAddress &result_mask,
               const ArgContext &args = blank_args) const;
    bool parse(const String &str,
               struct in_addr &result_addr, struct in_addr &result_mask,
               const ArgContext &args = blank_args) const {
        return parse(str, reinterpret_cast<IPAddress &>(result_addr),
                     reinterpret_cast<IPAddress &>(result_mask), args);
    }
    bool allow_bare_address;
};
 
template<> struct DefaultArg<IPAddress> : public IPAddressArg {};
template<> struct DefaultArg<struct in_addr> : public IPAddressArg {};
template<> struct DefaultArg<Vector<IPAddress> > : public IPAddressArg {};
/* template<> struct has_trivial_copy<IPAddress> : public true_type {}; -- in type_traits.hh */
 
 
class IPPortArg { public:
    IPPortArg(int p)
        : ip_p(p) {
        assert(ip_p > 0 && ip_p < 256);
    }
    bool parse(const String &str, uint16_t &result,
               const ArgContext &args = blank_args) const;
    int ip_p;
};
 
 
class IPPair {
  public:
 
    IPAddress src;
    IPAddress dst;
    IPPair() {
        src = 0;
        dst = 0;
    }
    IPPair(IPAddress a, IPAddress b) {
        src = a;
        dst = b;
    }
 
    bool contains(IPAddress foo) const {
        return (foo == src) || (foo == dst);
    }
 
    bool other(IPAddress foo) const {
        return (src == foo) ? dst : src;
    }
 
    inline hashcode_t hashcode() const {
        return CLICK_NAME(hashcode)(src) + CLICK_NAME(hashcode)(dst);
   }
 
   inline bool operator==(IPPair other) const {
        return (other.src == src && other.dst == dst);
   }
};
 
class IPPort {
public:
    IPAddress ip;
    uint16_t port;
    IPPort(IPAddress addr, uint16_t port) : ip(addr), port(port) {
 
    }
    inline hashcode_t hashcode() const {
       return CLICK_NAME(hashcode)(ip) + CLICK_NAME(hashcode)(port);
   }
 
   inline bool operator==(IPPort other) const {
       return (other.ip == ip && other.port == port);
   }
};
 
 
CLICK_ENDDECLS
#endif