openflow build environment setup

openflow/include/click/etheraddress.hh

@@ -0,0 +1,230 @@
+// -*- 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;
+
+    /** @brief Construct an EtherAddress equal to 00-00-00-00-00-00. */
+    inline EtherAddress() {
+	_data[0] = _data[1] = _data[2] = 0;
+    }
+
+    /** @brief Construct an EtherAddress from data.
+     * @param data the address data, in network byte order
+     *
+     * The bytes data[0]...data[5] are used to construct the address. */
+    explicit inline EtherAddress(const unsigned char *data) {
+	memcpy(_data, data, 6);
+    }
+
+    /** @brief Construct an uninitialized EtherAddress. */
+    inline EtherAddress(const uninitialized_type &unused) {
+	(void) unused;
+    }
+
+    /** @brief Return the broadcast EtherAddress, FF-FF-FF-FF-FF-FF. */
+    static EtherAddress make_broadcast() {
+	return EtherAddress(0xFFFF);
+    }
+
+    static inline EtherAddress broadcast() CLICK_DEPRECATED;
+
+
+    typedef bool (EtherAddress::*unspecified_bool_type)() const;
+    /** @brief Return true iff the address is not 00-00-00-00-00-00. */
+    inline operator unspecified_bool_type() const {
+	return _data[0] || _data[1] || _data[2] ? &EtherAddress::is_group : 0;
+    }
+
+    /** @brief Return true iff this address is a group address.
+     *
+     * Group addresses have the low-order bit of the first byte set to 1, as
+     * in 01-00-00-00-00-00 or 03-00-00-02-04-09. */
+    inline bool is_group() const {
+	return data()[0] & 1;
+    }
+
+    /** @brief Return true iff this address is a "local" address.
+     *
+     * Local addresses have the next-to-lowest-order bit of the first byte set
+     * to 1. */
+    inline bool is_local() const {
+	return data()[0] & 2;
+    }
+
+    /** @brief Return true iff this address is the broadcast address.
+     *
+     * The Ethernet broadcast address is FF-FF-FF-FF-FF-FF. */
+    inline bool is_broadcast() const {
+	return _data[0] + _data[1] + _data[2] == 0x2FFFD;
+    }
+
+    /** @brief Return true if @a data points to a broadcast address. */
+    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
+    }
+
+    /** @brief Return a pointer to the address data. */
+    inline unsigned char *data() {
+	return reinterpret_cast<unsigned char *>(_data);
+    }
+
+    /** @overload */
+    inline const unsigned char *data() const {
+	return reinterpret_cast<const unsigned char *>(_data);
+    }
+
+    /** @brief Return a pointer to the address data, as an array of
+     * uint16_ts. */
+    inline const uint16_t *sdata() const {
+	return _data;
+    }
+
+    /** @brief Hash function. */
+    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);
+
+    /** @brief Unparse this address into a dash-separated hex String.
+     *
+     * Examples include "00-00-00-00-00-00" and "00-05-4E-50-3C-1A".
+     *
+     * @note The IEEE standard for printing Ethernet addresses uses dashes as
+     * separators, not colons.  Use unparse_colon() to unparse into the
+     * nonstandard colon-separated form. */
+    inline String unparse() const {
+	return unparse_dash();
+    }
+
+    /** @brief Unparse this address into a colon-separated hex String.
+     *
+     * Examples include "00:00:00:00:00:00" and "00:05:4E:50:3C:1A".
+     *
+     * @note Use unparse() to create the IEEE standard dash-separated form. */
+    String unparse_colon() const;
+
+    /** @brief Unparse this address into a dash-separated hex String.
+     *
+     * Examples include "00-00-00-00-00-00" and "00-05-4E-50-3C-1A".
+     *
+     * @note This is the IEEE standard for printing Ethernet addresses.
+     * @sa unparse_colon */
+    String unparse_dash() const;
+
+    /** @brief Unparse this address into a dash-separated hex String.
+     * @deprecated The unparse() function should be preferred to s().
+     * @sa unparse */
+    inline String s() const CLICK_DEPRECATED;
+
+    /** @brief Unparse this address into a dash-separated hex String.
+     * @deprecated The unparse() function should be preferred to this cast.
+     * @sa unparse */
+    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();
+}
+
+/** @relates EtherAddress
+    @brief Compares two EtherAddress objects for equality. */
+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]);
+}
+
+/** @relates EtherAddress
+    @brief Compares two EtherAddress objects for inequality. */
+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
+  @brief Parser class for Ethernet addresses.
+
+  This is the default parser for objects of EtherAddress type. For 6-byte
+  arrays like "click_ether::ether_shost" and "click_ether::ether_dhost", you
+  must pass an EtherAddressArg() explicitly:
+
+  @code
+  struct click_ether ethh;
+  ... Args(...) ...
+      .read_mp("SRC", EtherAddressArg(), ethh.ether_shost)
+      ...
+  @endcode */
+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);
+    }
+  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 {};
+
+CLICK_ENDDECLS
+#endif