size_to_write_fct size_to_write_fcts[GID_ADDR_TYPES] =
{ ip_prefix_size_to_write, lcaf_size_to_write, mac_size_to_write,
- sd_size_to_write
+ sd_size_to_write, nsh_size_to_write
};
serdes_fct write_fcts[GID_ADDR_TYPES] =
- { ip_prefix_write, lcaf_write, mac_write, sd_write };
+ { ip_prefix_write, lcaf_write, mac_write, sd_write, nsh_write };
cast_fct cast_fcts[GID_ADDR_TYPES] =
- { ip_prefix_cast, lcaf_cast, mac_cast, sd_cast };
+ { ip_prefix_cast, lcaf_cast, mac_cast, sd_cast, nsh_cast };
addr_len_fct addr_len_fcts[GID_ADDR_TYPES] =
- { ip_prefix_length, lcaf_length, mac_length, sd_length };
+ { ip_prefix_length, lcaf_length, mac_length, sd_length, nsh_length };
copy_fct copy_fcts[GID_ADDR_TYPES] =
- { ip_prefix_copy, lcaf_copy, mac_copy, sd_copy };
+ { ip_prefix_copy, lcaf_copy, mac_copy, sd_copy, nsh_copy };
#define foreach_lcaf_type \
_(1, no_addr) \
a[0], a[1], a[2], a[3], a[4], a[5]);
}
+uword
+unformat_nsh_address (unformat_input_t * input, va_list * args)
+{
+ nsh_t *a = va_arg (*args, nsh_t *);
+ return unformat (input, "SPI:%d SI:%d", &a->spi, &a->si);
+}
+
+u8 *
+format_nsh_address (u8 * s, va_list * args)
+{
+ nsh_t *a = va_arg (*args, nsh_t *);
+ return format (s, "SPI:%d SI:%d", a->spi, a->si);
+}
+
u8 *
format_fid_address (u8 * s, va_list * args)
{
{
case FID_ADDR_IP_PREF:
return format (s, "%U", format_ip_prefix, &fid_addr_ippref (a));
-
case FID_ADDR_MAC:
return format (s, "%U", format_mac_address, &fid_addr_mac (a));
+ case FID_ADDR_NSH:
+ return format (s, "%U", format_nsh_address, &fid_addr_nsh (a));
default:
clib_warning ("Can't format fid address type %d!", fid_addr_type (a));
case GID_ADDR_MAC:
return format (s, "[%d] %U", gid_address_vni (a), format_mac_address,
&gid_address_mac (a));
+ case GID_ADDR_NSH:
+ return format (s, "%U", format_nsh_address, &gid_address_nsh (a));
default:
clib_warning ("Can't format gid type %d", type);
return 0;
fid_address_t *a = va_arg (*args, fid_address_t *);
ip_prefix_t ippref;
u8 mac[6] = { 0 };
+ nsh_t nsh;
if (unformat (i, "%U", unformat_ip_prefix, &ippref))
{
fid_addr_type (a) = FID_ADDR_MAC;
mac_copy (fid_addr_mac (a), mac);
}
+ else if (unformat (i, "%U", unformat_nsh_address, &nsh))
+ {
+ fid_addr_type (a) = FID_ADDR_NSH;
+ nsh_copy (&fid_addr_nsh (a), mac);
+ }
else
return 0;
u8 mac[6] = { 0 };
ip_prefix_t ippref;
fid_address_t sim1, sim2;
+ nsh_t nsh;
memset (&ippref, 0, sizeof (ippref));
memset (&sim1, 0, sizeof (sim1));
mac_copy (gid_address_mac (a), mac);
gid_address_type (a) = GID_ADDR_MAC;
}
+ else if (unformat (input, "%U", unformat_nsh_address, &nsh))
+ {
+ nsh_copy (&gid_address_nsh (a), &nsh);
+ gid_address_type (a) = GID_ADDR_NSH;
+ }
else
return 0;
return (sizeof (u16) + size);
}
+void
+gid_to_dp_address (gid_address_t * g, dp_address_t * d)
+{
+ switch (gid_address_type (g))
+ {
+ case GID_ADDR_SRC_DST:
+ switch (gid_address_sd_dst_type (g))
+ {
+ case FID_ADDR_IP_PREF:
+ ip_prefix_copy (&d->ippref, &gid_address_sd_dst_ippref (g));
+ d->type = FID_ADDR_IP_PREF;
+ break;
+ case FID_ADDR_MAC:
+ mac_copy (&d->mac, &gid_address_sd_dst_mac (g));
+ d->type = FID_ADDR_MAC;
+ break;
+ default:
+ clib_warning ("Source/Dest address type %d not supported!",
+ gid_address_sd_dst_type (g));
+ break;
+ }
+ break;
+ case GID_ADDR_IP_PREFIX:
+ ip_prefix_copy (&d->ippref, &gid_address_ippref (g));
+ d->type = FID_ADDR_IP_PREF;
+ break;
+ case GID_ADDR_MAC:
+ mac_copy (&d->mac, &gid_address_mac (g));
+ d->type = FID_ADDR_MAC;
+ break;
+ case GID_ADDR_NSH:
+ default:
+ d->nsh = gid_address_nsh (g).spi << 8 | gid_address_nsh (g).si;
+ d->type = FID_ADDR_NSH;
+ break;
+ }
+}
+
u32
lcaf_hdr_parse (void *offset, lcaf_t * lcaf)
{
case FID_ADDR_IP_PREF:
return ip_address_parse (p, afi, ip_addr);
+
+ case FID_ADDR_NSH:
+ break;
}
return ~0;
}
+#define INC(dst, exp) \
+do { \
+ u16 _sum = (exp); \
+ if ((u16)~0 == _sum) \
+ return ~0; \
+ dst += _sum; \
+} while (0);
+
u16
sd_parse (u8 * p, void *a)
{
sd_hdr = (lcaf_src_dst_hdr_t *) (p + size);
size += sizeof (sd_hdr[0]);
- size += fid_addr_parse (p + size, src);
- size += fid_addr_parse (p + size, dst);
+ INC (size, fid_addr_parse (p + size, src));
+ INC (size, fid_addr_parse (p + size, dst));
if (fid_addr_type (src) == FID_ADDR_IP_PREF)
{
if (LCAF_SOURCE_DEST != lcaf_type (&lcaf))
return ~0;
- size += sd_parse (p + size, a);
+ INC (size, sd_parse (p + size, a));
return size;
}
u16 afi = clib_net_to_host_u16 (*((u16 *) (p + size)));
if (LISP_AFI_LCAF == afi)
{
- u16 len = try_parse_src_dst_lcaf (p + size, g);
- if ((u16) ~ 0 == len)
- return ~0;
- size += len;
+ INC (size, try_parse_src_dst_lcaf (p + size, g));
}
else
- size += gid_address_parse (p + size, g);
+ INC (size, gid_address_parse (p + size, g));
return size;
}
clib_warning ("Unsupported LCAF type: %u", type);
return ~0;
}
- size += (*lcaf_parse_fcts[type]) (offset + size, lcaf);
+ INC (size, (*lcaf_parse_fcts[type]) (offset + size, lcaf));
return sizeof (u16) + size;
}
clib_memcpy (dst, src, sizeof (source_dest_t));
}
+void
+nsh_copy (void *dst, void *src)
+{
+ clib_memcpy (dst, src, sizeof (nsh_t));
+}
+
int
ip_prefix_cmp (ip_prefix_t * p1, ip_prefix_t * p2)
{
return 0;
}
+u8
+nsh_length (void *a)
+{
+ return 0;
+}
+
void *
lcaf_cast (gid_address_t * a)
{
return &gid_address_sd (a);
}
+void *
+nsh_cast (gid_address_t * a)
+{
+ return &gid_address_nsh (a);
+}
+
u8
no_addr_length (void *a)
{
return ip_prefix_length (&fid_addr_ippref (a));
case FID_ADDR_MAC:
return 0;
+ case FID_ADDR_NSH:
+ return 0;
}
return 0;
}
return size;
}
+u16
+nsh_write (u8 * p, void *a)
+{
+ clib_warning ("not done");
+ return 0;
+}
+
u16
vni_write (u8 * p, void *a)
{
return sizeof (u16) + 6;
}
+u16
+nsh_size_to_write (void *a)
+{
+ return sizeof (u16) + 4;
+}
+
u8
gid_address_len (gid_address_t * a)
{
gid_address_parse (u8 * offset, gid_address_t * a)
{
lisp_afi_e afi;
- int len = 0;
+ u16 len = 0;
- if (!a)
- return 0;
+ ASSERT (a);
/* NOTE: since gid_address_parse may be called by vni_parse, we can't 0
* the gid address here */
clib_warning ("LISP AFI %d not supported!", afi);
return ~0;
}
- return len;
+ return (len == (u16) ~ 0) ? ~0 : len;
}
void
return -1;
if (gid_address_vni (a1) != gid_address_vni (a2))
return -1;
- if (gid_address_vni_mask (a1) != gid_address_vni_mask (a2))
- return -1;
+
+ /* TODO vni mask is not supported, disable comparing for now
+ if (gid_address_vni_mask (a1) != gid_address_vni_mask (a2))
+ return -1;
+ */
switch (gid_address_type (a1))
{