ethernet: add sanity checks to p2p_ethernet_add/del

[vpp.git] / src / vnet / ethernet / mac_address.h

diff --git a/src/vnet/ethernet/mac_address.h b/src/vnet/ethernet/mac_address.h
index 7b4390d..0631ec3 100644 (file)
--- a/src/vnet/ethernet/mac_address.h
+++ b/src/vnet/ethernet/mac_address.h
@@ -16,47 +16,146 @@
 #ifndef __MAC_ADDRESS_H__
 #define __MAC_ADDRESS_H__
 
-#include <vnet/ethernet/ethernet.h>
+#include <vlib/vlib.h>
 
 typedef struct mac_address_t_
 {
   union
   {
     u8 bytes[6];
-    u64 as_u64;
+    struct
+    {
+      u32 first_4;
+      u16 last_2;
+    } __clib_packed u;
   };
 } mac_address_t;
 
+STATIC_ASSERT ((sizeof (mac_address_t) == 6),
+              "MAC address must represent the on wire format");
+
 extern const mac_address_t ZERO_MAC_ADDRESS;
 
+always_inline u64
+ethernet_mac_address_u64 (const u8 * a)
+{
+  return (((u64) a[0] << (u64) (5 * 8))
+         | ((u64) a[1] << (u64) (4 * 8))
+         | ((u64) a[2] << (u64) (3 * 8))
+         | ((u64) a[3] << (u64) (2 * 8))
+         | ((u64) a[4] << (u64) (1 * 8)) | ((u64) a[5] << (u64) (0 * 8)));
+}
+
+always_inline void
+ethernet_mac_address_from_u64 (u64 u, u8 * a)
+{
+  i8 ii;
+
+  for (ii = 5; ii >= 0; ii--)
+    {
+      a[ii] = u & 0xFF;
+      u = u >> 8;
+    }
+}
+
+static inline int
+ethernet_mac_address_is_multicast_u64 (u64 a)
+{
+  return (a & (1ULL << (5 * 8))) != 0;
+}
+
+static inline int
+ethernet_mac_address_is_zero (const u8 * mac)
+{
+  return ((*((u32 *) mac) == 0) && (*((u16 *) (mac + 4)) == 0));
+}
+
+static inline void
+ethernet_mac_address_generate (u8 * mac)
+{
+  u32 rnd = clib_cpu_time_now ();
+  rnd = random_u32 (&rnd);
+
+  memcpy (mac + 2, &rnd, sizeof (rnd));
+  mac[0] = 2;
+  mac[1] = 0xfe;
+}
+
+static inline int
+ethernet_mac_address_equal (const u8 * a, const u8 * b)
+{
+  return ((*((u32 *) a) == (*((u32 *) b))) &&
+         (*((u16 *) (a + 4)) == (*((u16 *) (b + 4)))));
+}
+
 static_always_inline void
 mac_address_from_bytes (mac_address_t * mac, const u8 * bytes)
 {
   /* zero out the last 2 bytes, then copy over only 6 */
-  mac->as_u64 = 0;
-  clib_memcpy (mac->bytes, bytes, 6);
+  clib_memcpy_fast (mac->bytes, bytes, 6);
+}
+
+static_always_inline void
+mac_address_to_bytes (const mac_address_t * mac, u8 * bytes)
+{
+  /* zero out the last 2 bytes, then copy over only 6 */
+  clib_memcpy_fast (bytes, mac->bytes, 6);
 }
 
 static_always_inline int
 mac_address_is_zero (const mac_address_t * mac)
 {
-  return (0 == mac->as_u64);
+  return (0 == mac->u.first_4 && 0 == mac->u.last_2);
 }
 
 static_always_inline u64
 mac_address_as_u64 (const mac_address_t * mac)
 {
-  return (mac->as_u64);
+  volatile u64 as_u64 = 0;
+
+  clib_memcpy ((void *) &as_u64, mac->bytes, 6);
+
+  return as_u64;
+}
+
+static_always_inline void
+mac_address_from_u64 (mac_address_t * mac, u64 u)
+{
+  clib_memcpy (mac->bytes, &u, 6);
+}
+
+static_always_inline void
+mac_address_copy (mac_address_t * dst, const mac_address_t * src)
+{
+  mac_address_from_bytes (dst, src->bytes);
+}
+
+static_always_inline int
+mac_address_cmp (const mac_address_t * a, const mac_address_t * b)
+{
+  return (memcmp (a->bytes, b->bytes, 6));
+}
+
+static_always_inline int
+mac_address_equal (const mac_address_t * a, const mac_address_t * b)
+{
+  return (a->u.last_2 == b->u.last_2 && a->u.first_4 == b->u.first_4);
 }
 
 static_always_inline void
-mac_address_from_u64 (u64 u, mac_address_t * mac)
+mac_address_set_zero (mac_address_t * mac)
+{
+  mac->u.first_4 = 0;
+  mac->u.last_2 = 0;
+}
+
+static_always_inline int
+mac_address_n_bits_set (const mac_address_t * a)
 {
-  mac->as_u64 = u;
-  mac->bytes[4] = 0;
-  mac->bytes[5] = 0;
+  return (count_set_bits (mac_address_as_u64 (a)));
 }
 
+extern void mac_address_increment (mac_address_t * mac);
 extern uword unformat_mac_address_t (unformat_input_t * input,
                                     va_list * args);
 extern u8 *format_mac_address_t (u8 * s, va_list * args);