diff options
| -rw-r--r-- | vnet/test/lisp-cp/test_lisp_types.c | 158 | ||||
| -rw-r--r-- | vnet/vnet/lisp-cp/lisp_cp_messages.h | 19 | ||||
| -rw-r--r-- | vnet/vnet/lisp-cp/lisp_types.c | 474 | ||||
| -rw-r--r-- | vnet/vnet/lisp-cp/lisp_types.h | 65 |
4 files changed, 623 insertions, 93 deletions
diff --git a/vnet/test/lisp-cp/test_lisp_types.c b/vnet/test/lisp-cp/test_lisp_types.c index 4291bbebb20..24443e99565 100644 --- a/vnet/test/lisp-cp/test_lisp_types.c +++ b/vnet/test/lisp-cp/test_lisp_types.c @@ -113,7 +113,7 @@ static clib_error_t * test_gid_parse_mac () u8 data[] = { - 0x00, 0x06, /* AFI = MAC address */ + 0x40, 0x05, /* AFI = MAC address */ 0x10, 0xbb, 0xcc, 0xdd, /* MAC */ 0x77, 0x99, }; @@ -320,7 +320,7 @@ static clib_error_t * test_mac_address_write (void) u8 expected[] = { - 0x00, 0x06, /* AFI = MAC */ + 0x40, 0x05, /* AFI = MAC */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 /* MAC */ }; @@ -330,6 +330,156 @@ done: return error; } +static clib_error_t * +test_src_dst_with_vni_serdes (void) +{ + clib_error_t * error = 0; + u8 * b = clib_mem_alloc (500); + memset (b, 0, 500); + + fid_address_t src = + { + .type = FID_ADDR_IP_PREF, + .ippref = + { + .len = 24, + .addr = + { + .version = IP4, + .ip.v4.data = { 0x1, 0x2, 0x3, 0x0 } + } + } + }; + + fid_address_t dst = + { + .type = FID_ADDR_IP_PREF, + .ippref = + { + .len = 16, + .addr = + { + .version = IP4, + .ip.v4.data = { 0x9, 0x8, 0x0, 0x0 } + } + } + }; + + source_dest_t sd = + { + .src = src, + .dst = dst + }; + + gid_address_t g = + { + .sd = sd, + .type = GID_ADDR_SRC_DST, + .vni = 0x12345678, + .vni_mask = 0x9 + }; + + u16 size_to_put = gid_address_size_to_put(&g); + _assert (36 == size_to_put); + _assert (0 == gid_address_len(&g)); + + u16 write_len = gid_address_put (b, &g); + printf("sizetoput %d; writelen %d\n", size_to_put, write_len); + _assert (size_to_put == write_len); + + u8 expected_data[] = + { + 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF, reserved1, flags */ + 0x02, 0x09, 0x00, 0x1c, /* LCAF type = IID, IID mask-len, length */ + 0x12, 0x34, 0x56, 0x78, /* reserved; source-ML, Dest-ML */ + + 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF, reserved1, flags */ + 0x0c, 0x00, 0x00, 0x14, /* LCAF type = source/dest key, rsvd, length */ + 0x00, 0x00, 0x18, 0x10, /* reserved; source-ML, Dest-ML */ + + 0x00, 0x01, /* AFI = ip4 */ + 0x01, 0x02, 0x03, 0x00, /* source */ + + 0x00, 0x01, /* AFI = ip4 */ + 0x09, 0x08, 0x00, 0x00, /* destination */ + }; + _assert (0 == memcmp (expected_data, b, sizeof (expected_data))); + + gid_address_t p; + memset (&p, 0, sizeof (p)); + _assert (write_len == gid_address_parse (b, &p)); + _assert (0 == gid_address_cmp (&g, &p)); +done: + clib_mem_free (b); + return error; +} + +static clib_error_t * +test_src_dst_serdes (void) +{ + clib_error_t * error = 0; + + u8 * b = clib_mem_alloc (500); + memset (b, 0, 500); + + fid_address_t src = + { + .type = FID_ADDR_MAC, + .mac = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 } + }; + + fid_address_t dst = + { + .type = FID_ADDR_MAC, + .mac = { 0x10, 0x21, 0x32, 0x43, 0x54, 0x65 } + }; + + source_dest_t sd = + { + .src = src, + .dst = dst + }; + + gid_address_t g = + { + .sd = sd, + .type = GID_ADDR_SRC_DST, + .vni = 0x0, + .vni_mask = 0x0 + }; + + u16 size_to_put = gid_address_size_to_put(&g); + _assert (28 == size_to_put); + _assert (0 == gid_address_len(&g)); + + u16 write_len = gid_address_put (b, &g); + _assert (size_to_put == write_len); + + u8 expected_data[] = + { + 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF, reserved1, flags */ + 0x0c, 0x00, 0x00, 0x18, /* LCAF type = source/dest key, rsvd, length */ + 0x00, 0x00, 0x00, 0x00, /* reserved; source-ML, Dest-ML */ + + 0x40, 0x05, /* AFI = MAC */ + 0x11, 0x22, 0x33, 0x44, + 0x55, 0x66, /* source */ + + 0x40, 0x05, /* AFI = MAC */ + 0x10, 0x21, 0x32, 0x43, + 0x54, 0x65, /* destination */ + }; + _assert (0 == memcmp (expected_data, b, sizeof (expected_data))); + + gid_address_t p; + memset (&p, 0, sizeof (p)); + _assert (write_len == gid_address_parse (b, &p)); + _assert (0 == gid_address_cmp (&g, &p)); +done: + clib_mem_free (b); + return error; +} + static clib_error_t * test_gid_address_write (void) { clib_error_t * error = 0; @@ -382,7 +532,9 @@ done: _(gid_parse_mac) \ _(gid_parse_lcaf) \ _(mac_address_write) \ - _(gid_address_write) + _(gid_address_write) \ + _(src_dst_serdes) \ + _(src_dst_with_vni_serdes) int run_tests (void) { diff --git a/vnet/vnet/lisp-cp/lisp_cp_messages.h b/vnet/vnet/lisp-cp/lisp_cp_messages.h index 8ed1b6c0bd2..1de62d6ff47 100644 --- a/vnet/vnet/lisp-cp/lisp_cp_messages.h +++ b/vnet/vnet/lisp-cp/lisp_cp_messages.h @@ -451,4 +451,23 @@ typedef struct _lcaf_hdr_t #define LCAF_FLAGS(h) ((lcaf_hdr_t *)(h))->flags #define LCAF_PAYLOAD(h) (u8 *)(h)+sizeof(lcaf_hdr_t) +/* + * Source/Dest Key Canonical Address Format: + * + * 0 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Reserved | Source-ML | Dest-ML | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + */ +typedef struct _lcaf_src_dst_hdr_t +{ + u16 reserved; + u8 src_mask_len; + u8 dst_mask_len; +} __attribute__ ((__packed__)) lcaf_src_dst_hdr_t; + +#define LCAF_SD_SRC_ML(_h) (_h)->src_mask_len +#define LCAF_SD_DST_ML(_h) (_h)->dst_mask_len + #endif /* VNET_LISP_GPE_LISP_CP_MESSAGES_H_ */ diff --git a/vnet/vnet/lisp-cp/lisp_types.c b/vnet/vnet/lisp-cp/lisp_types.c index ad420a46c7c..48049d33d03 100644 --- a/vnet/vnet/lisp-cp/lisp_types.c +++ b/vnet/vnet/lisp-cp/lisp_types.c @@ -17,6 +17,9 @@ static u16 gid_address_put_no_vni (u8 * b, gid_address_t * gid); static u16 gid_address_size_to_put_no_vni (gid_address_t * gid); +static u16 fid_addr_size_to_write (fid_address_t * a); + +u32 mac_parse (u8 * offset, u8 * a); typedef u16 (*size_to_write_fct)(void *); typedef void * (*cast_fct)(gid_address_t *); @@ -26,80 +29,106 @@ typedef void (*copy_fct)(void *, void *); typedef void (*free_fct)(void *); typedef int (*cmp_fct)(void *, void *); -u16 vni_write (u8 * p, void * a); -u16 vni_parse (u8 * p, void * a); -u16 vni_size_to_write (void * a); -void vni_free (void * a); -void vni_copy (void * dst, void * src); -u16 vni_length (void * a); -int vni_cmp (void *, void *); - -u16 no_addr_size_to_write (void *); -u16 no_addr_write (u8 * p, void * a); -u16 no_addr_parse (u8 * p, void * a); -void no_addr_free (void * a); -void no_addr_copy (void *, void *); -u16 no_addr_length (void * a); -int no_addr_cmp (void * a1, void * a2); - size_to_write_fct size_to_write_fcts[GID_ADDR_TYPES] = - { ip_prefix_size_to_write, lcaf_size_to_write, mac_size_to_write }; + { ip_prefix_size_to_write, lcaf_size_to_write, mac_size_to_write, + sd_size_to_write }; serdes_fct write_fcts[GID_ADDR_TYPES] = - { ip_prefix_write, lcaf_write, mac_write }; + { ip_prefix_write, lcaf_write, mac_write, sd_write }; cast_fct cast_fcts[GID_ADDR_TYPES] = - { ip_prefix_cast, lcaf_cast, mac_cast }; + { ip_prefix_cast, lcaf_cast, mac_cast, sd_cast }; addr_len_fct addr_len_fcts[GID_ADDR_TYPES] = - { ip_prefix_length, lcaf_length, mac_length }; + { ip_prefix_length, lcaf_length, mac_length, sd_length }; copy_fct copy_fcts[GID_ADDR_TYPES] = - { ip_prefix_copy, lcaf_copy, mac_copy }; + { ip_prefix_copy, lcaf_copy, mac_copy, sd_copy }; + +#define foreach_lcaf_type \ + _(1, no_addr) \ + _(0, NULL) \ + _(1, vni) \ + _(0, NULL) \ + _(0, NULL) \ + _(0, NULL) \ + _(0, NULL) \ + _(0, NULL) \ + _(0, NULL) \ + _(0, NULL) \ + _(0, NULL) \ + _(0, NULL) \ + _(1, sd) + +#define _(cond, name) \ + u16 name ## _write (u8 * p, void * a); \ + u16 name ## _parse (u8 * p, void * a); \ + u16 name ## _size_to_write (void * a); \ + void name ## _free (void * a); \ + void name ## _copy (void * dst, void * src); \ + u8 name ## _length (void * a); \ + int name ## _cmp (void *, void *); +foreach_lcaf_type +#undef _ + +#define CONCAT(a,b) a##_##b +#define IF(c, t, e) CONCAT(IF, c)(t, e) +#define IF_0(t, e) e +#define IF_1(t, e) t + +#define EXPAND_FCN(cond, fcn) \ + IF(cond, fcn, NULL) cmp_fct lcaf_cmp_fcts[LCAF_TYPES] = { - no_addr_cmp, - NULL, - vni_cmp +#define _(cond, name) \ + EXPAND_FCN(cond, name##_cmp), +foreach_lcaf_type +#undef _ }; -size_to_write_fct lcaf_body_length_fcts[LCAF_TYPES] = +addr_len_fct lcaf_body_length_fcts[LCAF_TYPES] = { - no_addr_length, - NULL, - vni_length +#define _(cond, name) \ + EXPAND_FCN(cond, name##_length), +foreach_lcaf_type +#undef _ }; copy_fct lcaf_copy_fcts[LCAF_TYPES] = { - no_addr_copy, - NULL, - vni_copy +#define _(cond, name) \ + EXPAND_FCN(cond, name##_copy), +foreach_lcaf_type +#undef _ }; free_fct lcaf_free_fcts[LCAF_TYPES] = { - no_addr_free, - NULL, - vni_free +#define _(cond, name) \ + EXPAND_FCN(cond, name##_free), +foreach_lcaf_type +#undef _ }; size_to_write_fct lcaf_size_to_write_fcts[LCAF_TYPES] = { - no_addr_size_to_write, - NULL, - vni_size_to_write +#define _(cond, name) \ + EXPAND_FCN(cond, name##_size_to_write), +foreach_lcaf_type +#undef _ }; serdes_fct lcaf_write_fcts[LCAF_TYPES] = { - no_addr_write, - NULL, - vni_write +#define _(cond, name) \ + EXPAND_FCN(cond, name##_write), +foreach_lcaf_type +#undef _ }; serdes_fct lcaf_parse_fcts[LCAF_TYPES] = { - no_addr_parse, - NULL, - vni_parse +#define _(cond, name) \ + EXPAND_FCN(cond, name##_parse), +foreach_lcaf_type +#undef _ }; u8 * @@ -179,6 +208,26 @@ format_mac_address (u8 * s, va_list * args) } u8 * +format_fid_address (u8 * s, va_list * args) +{ + fid_address_t * a = va_arg(*args, fid_address_t *); + + switch (fid_addr_type (a)) + { + 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_ip_prefix, &fid_addr_mac (a)); + + default: + clib_warning ("Can't format fid address type %d!", fid_addr_type (a)); + return 0; + } + return 0; +} + +u8 * format_gid_address (u8 * s, va_list * args) { gid_address_t * a = va_arg(*args, gid_address_t *); @@ -190,8 +239,8 @@ format_gid_address (u8 * s, va_list * args) &gid_address_ippref(a)); case GID_ADDR_SRC_DST: return format (s, "[%d] %U|%U", gid_address_vni(a), - format_ip_prefix, &gid_address_sd_source_pref(a), - format_ip_prefix, &gid_address_sd_dest_pref(a)); + format_fid_address, &gid_address_sd_src(a), + format_fid_address, &gid_address_sd_dst(a)); case GID_ADDR_MAC: return format (s, "[%d] %U", gid_address_vni(a), format_mac_address, &gid_address_mac(a)); @@ -199,19 +248,52 @@ format_gid_address (u8 * s, va_list * args) clib_warning("Can't format gid type %d", type); return 0; } + return 0; +} + +uword +unformat_fid_address (unformat_input_t * i, va_list * args) +{ + fid_address_t * a = va_arg (*args, fid_address_t *); + ip_prefix_t ippref; + u8 mac[6] = {0}; + + if (unformat (i, "%U", unformat_ip_prefix, &ippref)) + { + fid_addr_type (a) = FID_ADDR_IP_PREF; + ip_prefix_copy (&fid_addr_ippref (a), &ippref); + } + else if (unformat (i, "%U", unformat_mac_address, mac)) + { + fid_addr_type (a) = FID_ADDR_MAC; + mac_copy (fid_addr_mac (a), mac); + } + else + return 0; + + return 1; } uword unformat_gid_address (unformat_input_t * input, va_list * args) { - u32 vni; gid_address_t * a = va_arg(*args, gid_address_t *); u8 mac[6] = {0}; ip_prefix_t ippref; + fid_address_t sim1, sim2; memset (&ippref, 0, sizeof (ippref)); + memset (&sim1, 0, sizeof (sim1)); + memset (&sim2, 0, sizeof (sim2)); - if (unformat (input, "%U", unformat_ip_prefix, &ippref)) + if (unformat (input, "%U|%U", unformat_fid_address, &sim1, + unformat_fid_address, &sim2)) + { + gid_address_sd_src(a) = sim1; + gid_address_sd_dst(a) = sim2; + gid_address_type(a) = GID_ADDR_SRC_DST; + } + else if (unformat (input, "%U", unformat_ip_prefix, &ippref)) { ip_prefix_copy (&gid_address_ippref(a), &ippref); gid_address_type(a) = GID_ADDR_IP_PREFIX; @@ -221,8 +303,6 @@ unformat_gid_address (unformat_input_t * input, va_list * args) mac_copy (gid_address_mac(a), mac); gid_address_type(a) = GID_ADDR_MAC; } - else if (unformat (input, "[%d]", &vni)) - gid_address_vni(a) = vni; else return 0; @@ -417,6 +497,84 @@ lcaf_hdr_parse (void * offset, lcaf_t * lcaf) return sizeof (lh[0]); } +static u8 +iana_afi_to_fid_addr_type (u16 type) +{ + switch (type) + { + case LISP_AFI_IP: + case LISP_AFI_IP6: + return FID_ADDR_IP_PREF; + + case LISP_AFI_MAC: + return FID_ADDR_MAC; + } + return ~0; +} + +static u16 +fid_addr_parse (u8 * p, fid_address_t * a) +{ + u16 afi = clib_net_to_host_u16 ( *(u16 *) p); + fid_addr_type (a) = iana_afi_to_fid_addr_type (afi); + ip_address_t * ip_addr = &ip_prefix_addr (&fid_addr_ippref (a)); + + switch (fid_addr_type (a)) + { + case FID_ADDR_MAC: + return mac_parse (p, fid_addr_mac (a)); + + case FID_ADDR_IP_PREF: + return ip_address_parse (p, afi, ip_addr); + } + return ~0; +} + +u16 +sd_parse (u8 * p, void * a) +{ + lcaf_src_dst_hdr_t * sd_hdr; + gid_address_t * g = a; + u16 size = 0; + fid_address_t * src = &gid_address_sd_src (g); + fid_address_t * dst = &gid_address_sd_dst (g); + + gid_address_type (g) = GID_ADDR_SRC_DST; + + 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); + + if (fid_addr_type (src) == FID_ADDR_IP_PREF) + { + ip_prefix_t * ippref = &fid_addr_ippref (src); + ip_prefix_len(ippref) = LCAF_SD_SRC_ML(sd_hdr); + } + if (fid_addr_type (dst) == FID_ADDR_IP_PREF) + { + ip_prefix_t * ippref = &fid_addr_ippref (dst); + ip_prefix_len(ippref) = LCAF_SD_DST_ML(sd_hdr); + } + return size; +} + +u16 +try_parse_src_dst_lcaf (u8 * p, gid_address_t * a) +{ + lcaf_t lcaf; + u16 size = sizeof (u16); /* skip AFI */ + + size += lcaf_hdr_parse (p + size, &lcaf); + + if (LCAF_SOURCE_DEST != lcaf_type (&lcaf)) + return ~0; + + size += sd_parse (p + size, a); + return size; +} + u16 vni_parse (u8 * p, void * a) { @@ -428,9 +586,19 @@ vni_parse (u8 * p, void * a) size += sizeof (u32); gid_address_vni_mask (g) = lcaf_vni_len (lcaf); - /* nested LCAFs are not supported - it is expected that nested AFI type is - IP address */ - size += gid_address_parse (p + size, g); + /* nested LCAFs are not supported except of src/dst with vni - to handle + * such case look at the next AFI and process src/dest LCAF separately */ + 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; + } + else + size += gid_address_parse (p + size, g); + return size; } @@ -475,6 +643,12 @@ no_addr_free (void * a) } void +sd_free (void * a) +{ + /* nothing */ +} + +void gid_address_free (gid_address_t *a) { if (gid_address_type (a) != GID_ADDR_LCAF) @@ -642,6 +816,12 @@ mac_copy (void * dst , void * src) clib_memcpy (dst, src, 6); } +void +sd_copy (void * dst , void * src) +{ + clib_memcpy (dst, src, sizeof (source_dest_t)); +} + int ip_prefix_cmp(ip_prefix_t * p1, ip_prefix_t * p2) { @@ -705,6 +885,11 @@ mac_length (void *a) return 0; } +u8 sd_length (void * a) +{ + return 0; +} + void * lcaf_cast (gid_address_t * a) { @@ -717,13 +902,19 @@ mac_cast (gid_address_t * a) return &gid_address_mac (a); } -u16 +void * +sd_cast (gid_address_t * a) +{ + return &gid_address_sd (a); +} + +u8 no_addr_length (void * a) { return 0; } -u16 +u8 vni_length (void * a) { vni_t * v = a; @@ -764,6 +955,75 @@ mac_write (u8 * p, void * a) return mac_size_to_write (a); } +static u16 +fid_addr_write (u8 * p, fid_address_t * a) +{ + switch (fid_addr_type (a)) + { + case FID_ADDR_IP_PREF: + return ip_prefix_write (p, &fid_addr_ippref (a)); + + case FID_ADDR_MAC: + return mac_write (p, &fid_addr_mac (a)); + + default: + return ~0; + } + return ~0; +} + +static u8 +fid_address_length (fid_address_t * a) +{ + switch (fid_addr_type (a)) + { + case FID_ADDR_IP_PREF: + return ip_prefix_length (&fid_addr_ippref (a)); + case FID_ADDR_MAC: + return 0; + } + return 0; +} + +u16 +sd_write (u8 * p, void * a) +{ + source_dest_t * sd = a; + u16 size = 0; + lcaf_hdr_t _h, *h = &_h; + lcaf_src_dst_hdr_t sd_hdr; + + *(u16 *) p = clib_host_to_net_u16 (LISP_AFI_LCAF); + size += sizeof (u16); + memset (h, 0, sizeof (h[0])); + LCAF_TYPE (h) = LCAF_SOURCE_DEST; + u16 lcaf_len = 4 + sizeof (lcaf_src_dst_hdr_t) + + fid_addr_size_to_write (&sd_src (sd)) + + fid_addr_size_to_write (&sd_dst (sd)); + LCAF_LENGTH (h) = clib_host_to_net_u16 (lcaf_len); + + clib_memcpy (p + size, h, sizeof (h[0])); + size += sizeof (h[0]); + + memset (&sd_hdr, 0, sizeof (sd_hdr)); + LCAF_SD_SRC_ML(&sd_hdr) = fid_address_length (&sd_src (sd)); + LCAF_SD_DST_ML(&sd_hdr) = fid_address_length (&sd_dst (sd)); + clib_memcpy (p + size, &sd_hdr, sizeof (sd_hdr)); + size += sizeof (sd_hdr); + + u16 len = fid_addr_write (p + size, &sd_src (sd)); + if ((u16)~0 == len) + return ~0; + size += len; + + len = fid_addr_write (p + size, &sd_dst (sd)); + if ((u16)~0 == len) + return ~0; + size += len; + + return size; +} + u16 vni_write (u8 * p, void * a) { @@ -789,8 +1049,16 @@ vni_write (u8 * p, void * a) afip[0] = clib_host_to_net_u32 (gid_address_vni (g)); size += sizeof (u32); - /* write the actual address */ - len = gid_address_put_no_vni (p + size, g); + if (GID_ADDR_SRC_DST == gid_address_type (g)) + /* write src/dst LCAF */ + { + len = sd_write (p + size, g); + if ((u16)~0 == len) + return ~0; + } + else + /* write the actual address */ + len = gid_address_put_no_vni (p + size, g); if ((u16)~0 == len) return ~0; @@ -811,14 +1079,38 @@ no_addr_size_to_write (void * a) return sizeof (u16); /* AFI field length */ } +static u16 +fid_addr_size_to_write (fid_address_t * a) +{ + switch (fid_addr_type (a)) + { + case FID_ADDR_IP_PREF: + return ip_prefix_size_to_write (a); + + case FID_ADDR_MAC: + return mac_size_to_write (a); + + default: + break; + } + return 0; +} + u16 vni_size_to_write (void * a) { gid_address_t * g = a; - return (sizeof (u32) /* vni size */ - + sizeof (u16) /* LCAF AFI field size */ - + sizeof (lcaf_hdr_t) - + gid_address_size_to_put_no_vni (g)); + + u16 lcaf_size = sizeof (u32) + + sizeof (u16) /* LCAF AFI field size */ + + sizeof (lcaf_hdr_t); + + if (gid_address_type (g) == GID_ADDR_SRC_DST) + /* special case where nested LCAF is supported */ + return lcaf_size + sd_size_to_write (g); + else + return lcaf_size + + gid_address_size_to_put_no_vni (g); } u16 @@ -838,6 +1130,17 @@ lcaf_size_to_write (void * a) } u16 +sd_size_to_write (void * a) +{ + source_dest_t * sd = a; + return sizeof (u16) + + sizeof (lcaf_hdr_t) + + sizeof (lcaf_src_dst_hdr_t) + + fid_addr_size_to_write (&sd_src (sd)) + + fid_addr_size_to_write (&sd_dst (sd)); +} + +u16 mac_size_to_write (void * a) { return sizeof (u16) + 6; @@ -899,13 +1202,13 @@ gid_address_copy(gid_address_t * dst, gid_address_t * src) } u32 -mac_parse (u8 * offset, gid_address_t * a) +mac_parse (u8 * offset, u8 * a) { /* skip AFI field */ offset += sizeof (u16); - clib_memcpy (gid_address_mac (a), offset, sizeof (gid_address_mac (a))); - return (sizeof (u16) + sizeof (gid_address_mac (a))); + clib_memcpy (a, offset, 6); + return sizeof (u16) + 6; } u32 @@ -917,7 +1220,7 @@ gid_address_parse (u8 * offset, gid_address_t *a) if (!a) return 0; - /* NOTE: since gid_adress_parse may be called by vni_parse, we can't 0 + /* NOTE: since gid_address_parse may be called by vni_parse, we can't 0 * the gid address here */ afi = clib_net_to_host_u16 (*((u16 *) offset)); @@ -944,7 +1247,7 @@ gid_address_parse (u8 * offset, gid_address_t *a) len = lcaf_parse (offset, a); break; case LISP_AFI_MAC: - len = mac_parse (offset, a); + len = mac_parse (offset, gid_address_mac (a)); gid_address_type(a) = GID_ADDR_MAC; break; default: @@ -979,6 +1282,42 @@ vni_cmp (void * a1, void * a2) return gid_address_cmp (vni_gid (v1), vni_gid (v2)); } +static int +fid_addr_cmp (fid_address_t * a1, + fid_address_t * a2) +{ + if (fid_addr_type (a1) != fid_addr_type (a2)) + return -1; + + switch (fid_addr_type (a1)) + { + case FID_ADDR_IP_PREF: + return ip_prefix_cmp (&fid_addr_ippref (a1), + &fid_addr_ippref (a2)); + + case FID_ADDR_MAC: + return memcmp (&fid_addr_mac (a1), + &fid_addr_mac (a2), 6); + + default: + return -1; + } + return -1; +} + +int +sd_cmp (void * a1, void * a2) +{ + source_dest_t * sd1 = a1; + source_dest_t * sd2 = a2; + + if (fid_addr_cmp (&sd_dst(sd1), &sd_dst(sd2))) + return -1; + if (fid_addr_cmp (&sd_src(sd1), &sd_src(sd2))) + return -1; + return 0; +} + /* Compare two gid_address_t. * Returns: * -1: If they are from different afi @@ -1021,6 +1360,10 @@ gid_address_cmp (gid_address_t * a1, gid_address_t * a2) cmp = memcmp (gid_address_mac (a1), gid_address_mac (a2), sizeof (gid_address_mac (a1))); break; + + case GID_ADDR_SRC_DST: + cmp = sd_cmp (&gid_address_sd (a1), &gid_address_sd (a2)); + break; default: break; } @@ -1028,7 +1371,6 @@ gid_address_cmp (gid_address_t * a1, gid_address_t * a2) return cmp; } - u32 locator_parse (void * b, locator_t * loc) { diff --git a/vnet/vnet/lisp-cp/lisp_types.h b/vnet/vnet/lisp-cp/lisp_types.h index 6542b009ffd..2587fce526b 100644 --- a/vnet/vnet/lisp-cp/lisp_types.h +++ b/vnet/vnet/lisp-cp/lisp_types.h @@ -77,22 +77,45 @@ typedef enum LCAF_NULL_BODY = 0, LCAF_AFI_LIST_TYPE, LCAF_INSTANCE_ID, + LCAF_SOURCE_DEST = 12, LCAF_TYPES } lcaf_type_t; -struct _gid_address_t; +typedef enum +{ + FID_ADDR_IP_PREF, + FID_ADDR_MAC +} fid_addr_type_t; +/* flat address type */ typedef struct { - u8 src_len; - u8 dst_len; - struct _gid_address_t *src; - struct _gid_address_t *dst; + union + { + ip_prefix_t ippref; + u8 mac[6]; + }; + u8 type; /* fid_addr_type_t */ +} fid_address_t; + +typedef fid_address_t dp_address_t; + +#define fid_addr_ippref(_a) (_a)->ippref +#define fid_addr_mac(_a) (_a)->mac +#define fid_addr_type(_a) (_a)->type + +typedef struct +{ + fid_address_t src; + fid_address_t dst; } source_dest_t; -#define SD_CAST (source_dest_t *) -#define sd_dst_gid(_a) (SD_CAST _a)->dst -#define sd_src_gid(_a) (SD_CAST _a)->src +#define sd_dst(_a) (_a)->dst +#define sd_src(_a) (_a)->src +#define sd_src_ippref(_a) fid_addr_ippref(&sd_src(_a)) +#define sd_dst_ippref(_a) fid_addr_ippref(&sd_dst(_a)) +#define sd_src_mac(_a) fid_addr_mac(&sd_src(_a)) +#define sd_dst_mac(_a) fid_addr_mac(&sd_dst(_a)) typedef struct { @@ -128,6 +151,7 @@ typedef struct _gid_address_t ip_prefix_t ippref; lcaf_t lcaf; u8 mac[6]; + source_dest_t sd; }; u8 type; u32 vni; @@ -182,16 +206,20 @@ void gid_address_ip_set(gid_address_t * dst, void * src, u8 version); #define gid_address_mac(_a) (_a)->mac #define gid_address_vni(_a) (_a)->vni #define gid_address_vni_mask(_a) (_a)->vni_mask -#define gid_address_sd_dest_pref(_a) \ - gid_address_ippref(sd_dst_gid(_a)) -#define gid_address_sd_source_pref(_a) \ - gid_address_ippref(sd_src_gid(_a)) +#define gid_address_sd_dst_ippref(_a) sd_dst_ippref(&(_a)->sd) +#define gid_address_sd_src_ippref(_a) sd_src_ippref(&(_a)->sd) +#define gid_address_sd_dst_mac(_a) sd_dst_mac(&(_a)->sd) +#define gid_address_sd_src_mac(_a) sd_src_mac(&(_a)->sd) +#define gid_address_sd(_a) (_a)->sd +#define gid_address_sd_src(_a) sd_src(&gid_address_sd(_a)) +#define gid_address_sd_dst(_a) sd_dst(&gid_address_sd(_a)) /* 'sub'address functions */ #define foreach_gid_address_type_fcns \ _(ip_prefix) \ _(lcaf) \ - _(mac) + _(mac) \ + _(sd) #define _(_n) \ u16 _n ## _size_to_write (void * pref); \ @@ -252,17 +280,6 @@ typedef struct uword unformat_negative_mapping_action (unformat_input_t * input, va_list * args); -/* dp works with a subset of ids */ -typedef struct lisp_dp_address -{ - union - { - ip_prefix_t ippref; - u8 mac[6]; - }; - u8 type; -} dp_address_t; - typedef struct locator_pair { /* local and remote locators (underlay attachment points) */ |