etheraddress.hh

Go to the documentation of this file.

// -*- related-file-name: "../../lib/etheraddress.cc" -*-
#ifndef CLICK_ETHERADDRESS_HH
#define CLICK_ETHERADDRESS_HH
#include <click/string.hh>
#include <click/glue.hh>
#include <click/type_traits.hh>
CLICK_DECLS
 
class EtherAddress { public:
 
    typedef uninitialized_type uninitialized_t;
 
    inline EtherAddress() {
        _data[0] = _data[1] = _data[2] = 0;
    }
 
    explicit inline EtherAddress(const unsigned char *data) {
        memcpy(_data, data, 6);
    }
 
    inline EtherAddress(const uninitialized_type &unused) {
        (void) unused;
    }
 
    static EtherAddress make_broadcast() {
        return EtherAddress(0xFFFF);
    }
 
    static inline EtherAddress broadcast() CLICK_DEPRECATED;
 
 
    typedef bool (EtherAddress::*unspecified_bool_type)() const;
    inline operator unspecified_bool_type() const {
        return _data[0] || _data[1] || _data[2] ? &EtherAddress::is_group : 0;
    }
 
    inline bool is_group() const {
        return data()[0] & 1;
    }
 
    inline bool is_local() const {
        return data()[0] & 2;
    }
 
    inline bool is_broadcast() const {
        return _data[0] + _data[1] + _data[2] == 0x2FFFD;
    }
 
    static inline bool is_broadcast(const unsigned char *data) {
#if HAVE_INDIFFERENT_ALIGNMENT
        return reinterpret_cast<const EtherAddress *>(data)->is_broadcast();
#else
        return data[0] + data[1] + data[2] + data[3] + data[4] + data[5] == 0x5FA;
#endif
    }
 
    inline unsigned char *data() {
        return reinterpret_cast<unsigned char *>(_data);
    }
 
    inline const unsigned char *data() const {
        return reinterpret_cast<const unsigned char *>(_data);
    }
 
#if __GNUC__ >= 9
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Waddress-of-packed-member"
#endif
    inline const uint16_t *sdata() const {
        return _data;
    }
#if __GNUC__ >= 9
# pragma GCC diagnostic pop
#endif
 
    inline size_t hashcode() const {
        return (_data[2] | ((size_t) _data[1] << 16))
            ^ ((size_t) _data[0] << 9);
    }
 
    // bool operator==(EtherAddress, EtherAddress);
    // bool operator!=(EtherAddress, EtherAddress);
 
    inline String unparse() const {
        return unparse_dash();
    }
 
    String unparse_colon() const;
 
    String unparse_dash() const;
 
    inline String s() const CLICK_DEPRECATED;
 
    inline operator String() const CLICK_DEPRECATED;
 
    typedef const EtherAddress &parameter_type;
 
 private:
 
    uint16_t _data[3];
 
    EtherAddress(uint16_t m) {
        _data[0] = _data[1] = _data[2] = m;
    }
 
} CLICK_SIZE_PACKED_ATTRIBUTE;
 
inline EtherAddress EtherAddress::broadcast() {
    return make_broadcast();
}
 
inline
EtherAddress::operator String() const
{
    return unparse();
}
 
inline String
EtherAddress::s() const
{
    return unparse();
}
 
inline bool
operator==(const EtherAddress &a, const EtherAddress &b)
{
    return (a.sdata()[0] == b.sdata()[0]
            && a.sdata()[1] == b.sdata()[1]
            && a.sdata()[2] == b.sdata()[2]);
}
 
inline bool
operator!=(const EtherAddress &a, const EtherAddress &b)
{
    return !(a == b);
}
 
class StringAccum;
StringAccum &operator<<(StringAccum &, const EtherAddress &);
 
 
class ArgContext;
class Args;
extern const ArgContext blank_args;
 
class EtherAddressArg { public:
    typedef void enable_direct_parse;
    EtherAddressArg(int flags = 0) : flags_(flags) {}
    inline bool parse(const String& str, EtherAddress& value, const ArgContext& args = blank_args) {
        return parse(str, value, args, flags_);
    }
    inline bool parse(const String& str, unsigned char* value, const ArgContext& args = blank_args) {
        return parse(str, *reinterpret_cast<EtherAddress *>(value), args);
    }
    inline bool direct_parse(const String& str, EtherAddress& value, Args& args) {
        return direct_parse(str, value, args, flags_);
    }
    inline bool direct_parse(const String& str, unsigned char* value, Args& args) {
        return direct_parse(str, *reinterpret_cast<EtherAddress *>(value), args);
    }
    static bool parse(const String &str, Vector<EtherAddress> &result,
                      const ArgContext &args = blank_args);
  private:
    int flags_;
    static bool parse(const String& str, EtherAddress& value, const ArgContext& args, int flags);
    static bool direct_parse(const String& str, EtherAddress& value, Args& args, int flags);
};
 
template<> struct DefaultArg<EtherAddress> : public EtherAddressArg {};
template<> struct has_trivial_copy<EtherAddress> : public true_type {};
template<> struct DefaultArg<Vector<EtherAddress> > : public EtherAddressArg {};
 
CLICK_ENDDECLS
#endif