clib_error_t * error = 0;
gid_address_t la, ra;
vlib_buffer_t * b = 0;
- u32 buff_len = 500;
+ u32 buff_len = 900;
int lp = 0x15, rp = 0x14;
b = clib_mem_alloc (buff_len);
b->current_data = sizeof(udp_header_t) + sizeof(ip4_header_t) +
sizeof(ecm_hdr_t) + 1;
- la.type = IP_PREFIX;
+ la.type = GID_ADDR_IP_PREFIX;
la.ippref.addr.ip.v4.as_u32 = 0xa1b2c3d4;
la.ippref.addr.version = IP4;
- ra.type = IP_PREFIX;
+ ra.type = GID_ADDR_IP_PREFIX;
ra.ippref.addr.ip.v4.as_u32 = 0x90817263;
ra.ippref.addr.version = IP4;
u8 expected_ip4_hdr[] = {
0x45, /* version; IHL */
0x00, /* services */
- 0x02, 0x10, /* total length */
+ 0x03, 0xa0, /* total length */
0x00, 0x00, /* identification */
0x40, 0x00, /* flags; fragment offset*/
0xff, /* TTL */
u8 expected_udp_hdr[] = {
0x00, 0x15, /* src port */
0x00, 0x14, /* dst port */
- 0x01, 0xfc, /* length */
+ 0x03, 0x8c, /* length */
0x00, 0x00, /* checksum */
};
_assert(0 == memcmp(uh, expected_udp_hdr, sizeof(expected_udp_hdr)));
_assert(eid.ippref.addr.ip.v4.as_u32 == 0x66554433);
_assert(locs[0].local == 0);
_assert(locs[0].address.ippref.addr.ip.v4.as_u32 == 0xddccbbaa);
- _assert(locs[0].address.type == IP_PREFIX);
+ _assert(locs[0].address.type == GID_ADDR_IP_PREFIX);
_assert(locs[0].priority == 0xa);
_assert(locs[0].weight == 0xb);
_assert(locs[0].mpriority == 0xc);
}
static map_request_hdr_t *
-build_map_request (lisp_cp_main_t * lcm, vlib_buffer_t * b)
+build_map_request (lisp_cp_main_t * lcm, vlib_buffer_t * b,
+ gid_address_t * rlocs)
{
gid_address_t _seid, * seid = &_seid;
gid_address_t _deid, * deid = &_deid;
u8 is_smr_invoked = 1;
u64 nonce = 0;
- map_request_hdr_t *h;
- ip_address_t * rlocs = 0;
- ip_address_t _addr, * addr = &_addr;
+ map_request_hdr_t * h = 0;
- gid_address_type(seid) = IP_PREFIX;
- gid_address_ip(seid).ip.v4.as_u32 = 0x12345678;
+ gid_address_type (seid) = GID_ADDR_IP_PREFIX;
+ ip_address_t * ip_addr = &gid_address_ip (seid);
+ ip_addr_v4 (ip_addr).as_u32 = 0x12345678;
seid->ippref.addr.version = IP4;
- gid_address_type(deid) = IP_PREFIX;
- gid_address_ip(deid).ip.v4.as_u32 = 0x9abcdef0;
+ gid_address_type (deid) = GID_ADDR_IP_PREFIX;
+ ip_address_t * ip_addr2 = &gid_address_ip (deid);
+ ip_addr_v4 (ip_addr2).as_u32 = 0x9abcdef0;
deid->ippref.addr.version = IP4;
- gid_address_ippref_len(deid) = 24;
-
- ip_addr_version(addr) = IP4;
- ip_addr_v4(addr).data_u32 = 0x10203040;
- vec_add1(rlocs, addr[0]);
-
- ip_addr_v6(addr).as_u32[0] = 0xffeeddcc;
- ip_addr_v6(addr).as_u32[1] = 0xbbaa9988;
- ip_addr_v6(addr).as_u32[2] = 0x77665544;
- ip_addr_v6(addr).as_u32[3] = 0x33221100;
- ip_addr_version(addr) = IP6;
- vec_add1(rlocs, addr[0]);
+ gid_address_ippref_len (deid) = 24;
h = lisp_msg_put_mreq (lcm, b, seid, deid, rlocs,
is_smr_invoked, &nonce);
return h;
}
+static void
+generate_rlocs (gid_address_t **rlocs, u32 * count)
+{
+ gid_address_t gid_addr_data, * gid_addr = &gid_addr_data;
+ ip_address_t * addr = &gid_address_ip (gid_addr);
+
+ gid_address_type (gid_addr) = GID_ADDR_IP_PREFIX;
+
+ ip_addr_version (addr) = IP4;
+ ip_addr_v4 (addr).data_u32 = 0x10203040;
+ vec_add1 (rlocs[0], gid_addr[0]);
+
+ ip_addr_v6 (addr).as_u32[0] = 0xffeeddcc;
+ ip_addr_v6 (addr).as_u32[1] = 0xbbaa9988;
+ ip_addr_v6 (addr).as_u32[2] = 0x77665544;
+ ip_addr_v6 (addr).as_u32[3] = 0x33221100;
+ ip_addr_version (addr) = IP6;
+ vec_add1 (rlocs[0], gid_addr[0]);
+}
+
static clib_error_t * test_lisp_msg_parse ()
{
gid_address_t eid;
gid_address_t gid;
clib_error_t * error = 0;
vlib_buffer_t * b;
- gid_address_t * rlocs = 0;
+ gid_address_t * rlocs_decode = 0, * rlocs = 0;
+ u32 rloc_count_parse = 0;
u8 * data = clib_mem_alloc(500);
memset(data, 0, 500);
b = (vlib_buffer_t *) data;
- h = build_map_request (lcm, b);
+ generate_rlocs (&rlocs_decode, &rloc_count_parse);
+ h = build_map_request (lcm, b, rlocs_decode);
vlib_buffer_pull(b, sizeof(*h));
u32 len = lisp_msg_parse_addr(b, &gid);
return error;
}
+static clib_error_t * test_lisp_msg_put_mreq_with_lcaf ()
+{
+ lisp_cp_main_t * lcm = vnet_lisp_cp_get_main ();
+ clib_error_t * error = 0;
+ map_request_hdr_t *h = 0;
+ gid_address_t * rlocs = 0;
+ gid_address_t rloc;
+
+ ip_prefix_t ippref;
+ ip_prefix_version (&ippref) = IP4;
+ ip4_address_t * ip = &ip_prefix_v4 (&ippref);
+ ip->as_u32 = 0x11223344;
+
+ gid_address_t gid1 =
+ {
+ .type = GID_ADDR_IP_PREFIX,
+ .ippref = ippref
+ };
+
+ lcaf_t lcaf1 =
+ {
+ .type = LCAF_INSTANCE_ID,
+ .uni =
+ {
+ .vni_mask_len = 0x17,
+ .vni = 0x90919293,
+ .gid_addr = &gid1
+ }
+ };
+
+ gid_address_type (&rloc) = GID_ADDR_LCAF;
+ gid_address_lcaf (&rloc) = lcaf1;
+
+ vec_add1 (rlocs, rloc);
+
+ u8 * data = clib_mem_alloc (500);
+ memset (data, 0, 500);
+
+ h = build_map_request (lcm, (vlib_buffer_t *) data, rlocs);
+
+ /* clear Nonce to simplify comparison */
+ memset ((u8 *)h + 4, 0, 8);
+
+ u8 expected_data[] =
+ {
+ 0x10, 0x40, 0x00, 0x01, /* type; flags; IRC; REC count */
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, /* nonce */
+ 0x00, 0x01, /* Source-EID-AFI */
+ 0x78, 0x56, 0x34, 0x12, /* Source EID Address */
+
+ /* RLOCs */
+ 0x40, 0x03, /* AFI = LCAF*/
+ /* LCAF header*/
+ 0x00, 0x00, /* reserved1, flags */
+ 0x02, /* type = Instance ID */
+ 0x17, /* IID mask-len */
+ 0x00, 0x0a, /* iid length + next AFI lenght */
+ 0x90, 0x91, 0x92, 0x93, /* IID / VNI */
+
+ 0x00, 0x01, /* AFI = ipv4 */
+ 0x44, 0x33, 0x22, 0x11, /* ITR-RLOC Address 1 */
+
+ /* record */
+ 0x00, /* reserved */
+ 0x18, /* EID mask-len */
+ 0x00, 0x01, /* EID-prefix-AFI */
+ 0xf0, 0xde, 0xbc, 0x9a, /* EID-prefix */
+ };
+
+ _assert (0 == memcmp (expected_data, (u8 *) h, sizeof (expected_data)));
+done:
+ clib_mem_free (data);
+ return error;
+}
+
static clib_error_t * test_lisp_msg_put_mreq ()
{
lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
clib_error_t * error = 0;
map_request_hdr_t *h;
+ gid_address_t * rlocs = 0;
+ u32 rloc_count = 0;
u8 * data = clib_mem_alloc(500);
memset(data, 0, 500);
- h = build_map_request (lcm, (vlib_buffer_t *)data);
+ generate_rlocs (&rlocs, &rloc_count);
+ h = build_map_request (lcm, (vlib_buffer_t *) data, rlocs);
/* clear Nonce to simplify comparison */
memset((u8 *)h + 4, 0, 8);
0x00, 0x01, /* EID-prefix-AFI */
0xf0, 0xde, 0xbc, 0x9a, /* EID-prefix */
};
+ _assert (0 == memcmp (expected_data, (u8 *) h, sizeof (expected_data)));
+
+done:
+ clib_mem_free (data);
+ return error;
+}
+
+static clib_error_t *
+test_lisp_parse_lcaf ()
+{
+ int i;
+ clib_error_t * error = 0;
+ gid_address_t eid;
+ locator_t * locs = 0;
+ locator_t probed;
+ vlib_buffer_t * b = 0;
+ u32 buff_len = 500;
+
+ b = clib_mem_alloc (buff_len);
+ memset ((u8 *)b, 0, buff_len);
+
+ u8 map_reply_records[] =
+ {
+ /* 1. record */
+ 0x01, 0x02, 0x03, 0x04, /* record TTL */
+ 0x03, /* locator count */
+ 0x00, 0x00, 0x00, /* eid-mask-len; ... */
+ 0x00, 0x00, /* reserved; map-version num */
+ 0x00, 0x01, /* EID-Prefix-AFI */
+ 0x33, 0x44, 0x55, 0x66, /* eid-prefix */
+
+ /* 1st locator */
+ 0x0a, /* prority */
+ 0x0b, /* weight */
+ 0x0c, /* m-prority */
+ 0x0d, /* m-weight */
+ 0x00, 0x00, /* unused flags */
+ 0x40, 0x03, /* Loc-AFI = LCAF*/
+
+ /* LCAF header*/
+ 0x00, 0x00, /* reserved1, flags */
+ 0x02, /* type = Instance ID */
+ 0x18, /* IID mask-len */
+ 0x0a, 0x00, /* iid length + next AFI lenght */
+ /* LCAF Instance ID */
+ 0x00, 0x00, 0x00, 0x09, /* iid */
+ 0x00, 0x01, /* AFI = ipv4 */
+ 0x10, 0xbb, 0xcc, 0xdd, /* ipv4 loator address */
+
+ /* 2nd locator */
+ 0x07, /* prority */
+ 0x06, /* weight */
+ 0x05, /* m-prority */
+ 0x04, /* m-weight */
+ 0x00, 0x00, /* unused flags */
+ 0x40, 0x03, /* Loc-AFI = LCAF*/
+
+ /* LCAF header*/
+ 0x00, 0x00, /* reserved1, flags */
+ 0x02, /* type = Instance ID */
+ 0x18, /* IID mask-len */
+ 0x00, 0x16, /* iid length + next AFI lenght */
+ /* LCAF Instance ID */
+ 0x22, 0x44, 0x66, 0x88, /* iid */
+ 0x00, 0x02, /* AFI = ipv6 */
+ 0xcc, 0xdd, 0xee, 0xff,
+ 0x88, 0x99, 0xaa, 0xbb,
+ 0x44, 0x55, 0x66, 0x77,
+ 0x00, 0x11, 0x22, 0x33, /* ipv6 locator address */
+
+ /* 3rd locator */
+ 0x0a, /* prority */
+ 0x0b, /* weight */
+ 0x0c, /* m-prority */
+ 0x0d, /* m-weight */
+ 0x00, 0x00, /* unused flags */
+ 0x00, 0x01, /* Loc-AFI */
+ 0xaa, 0xbb, 0xcc, 0xdd, /* Loator */
+ };
+
+ b->current_length = buff_len;
+ memcpy (b->data, map_reply_records, sizeof (map_reply_records));
- int r = memcmp(expected_data, (u8 *)h, sizeof(expected_data));
- error = CLIB_ERROR_ASSERT (r == 0);
+ lisp_msg_parse_mapping_record (b, &eid, &locs, &probed);
+ _assert (vec_len (locs) == 3);
+ _assert (eid.ippref.addr.ip.v4.as_u32 == 0x66554433);
+
+ /* check 1st locator - an LCAF with ipv4 */
+ _assert (locs[0].local == 0);
+ _assert (locs[0].priority == 0xa);
+ _assert (locs[0].weight == 0xb);
+ _assert (locs[0].mpriority == 0xc);
+ _assert (locs[0].mweight == 0xd);
+
+ /* check LCAF header data */
+ lcaf_t * lcaf = &gid_address_lcaf (&locs[0].address);
+ _assert (gid_address_type (&locs[0].address) == GID_ADDR_LCAF);
+ _assert (lcaf_type (lcaf) == LCAF_INSTANCE_ID);
+ vni_t * v = (vni_t *) lcaf;
+ _assert (vni_vni (v) == 0x09);
+
+ gid_address_t * nested_gid = vni_gid (v);
+ _assert (GID_ADDR_IP_PREFIX == gid_address_type (nested_gid));
+ ip_prefix_t * ip_pref = &gid_address_ippref (nested_gid);
+ _assert (IP4 == ip_prefix_version (ip_pref));
+
+ /* 2nd locator - LCAF entry with ipv6 address */
+ _assert (locs[1].local == 0);
+ _assert (locs[1].priority == 0x7);
+ _assert (locs[1].weight == 0x6);
+ _assert (locs[1].mpriority == 0x5);
+ _assert (locs[1].mweight == 0x4);
+
+ /* LCAF header */
+ _assert (gid_address_type (&locs[1].address) == GID_ADDR_LCAF);
+ lcaf = &gid_address_lcaf (&locs[1].address);
+ _assert (lcaf_type (lcaf) == LCAF_INSTANCE_ID);
+ v = (vni_t *) lcaf;
+ _assert (vni_vni (v) == 0x22446688);
+
+ nested_gid = vni_gid (v);
+ _assert (GID_ADDR_IP_PREFIX == gid_address_type (nested_gid));
+ ip_pref = &gid_address_ippref (nested_gid);
+ _assert (IP6 == ip_prefix_version (ip_pref));
+
+ /* 3rd locator - simple ipv4 address */
+ _assert (gid_address_type (&locs[2].address) == GID_ADDR_IP_PREFIX);
+done:
+ clib_mem_free (b);
- clib_mem_free(data);
+ for (i = 0; i < 3; i++)
+ locator_free (&locs[i]);
+ vec_free (locs);
return error;
}
#define foreach_test_case \
_(lisp_msg_put_mreq) \
+ _(lisp_msg_put_mreq_with_lcaf) \
_(lisp_msg_push_ecm) \
_(lisp_msg_parse) \
- _(lisp_msg_parse_mapping_record)
+ _(lisp_msg_parse_mapping_record) \
+ _(lisp_parse_lcaf)
int run_tests (void)
{
static clib_error_t * test_locator_type (void)
{
clib_error_t * error = 0;
- gid_address_t _gid_addr, * gid_addr = &_gid_addr;
- gid_address_type(gid_addr) = IP_PREFIX;
- gid_address_ippref_len(gid_addr) = 24;
- ip_prefix_version(&gid_addr->ippref) = IP4;
- gid_addr->ippref.addr.ip.v4.as_u32 = 0x20304050;
+ gid_address_t _gid_addr, * gid = &_gid_addr;
+ ip_prefix_t * ippref;
+ gid_address_type (gid) = GID_ADDR_IP_PREFIX;
+ gid_address_ippref_len (gid) = 24;
+ ippref = &gid_address_ippref (gid);
+ ip_prefix_version (ippref) = IP4;
+ ip_prefix_len (ippref) = 0;
+ ip4_address_t * ip4 = &ip_prefix_v4 (ippref);
+ ip4->as_u32 = 0x20304050;
/* local locator */
locator_t loc1, loc2 = {
/* remote locator */
loc2.local = 0;
- loc2.address = gid_addr[0];
+
+ ip_prefix_t nested_ippref;
+ ip_prefix_version (&nested_ippref) = IP4;
+ ip_prefix_len (&nested_ippref) = 0;
+ ip4 = &ip_prefix_v4 (&nested_ippref);
+ ip4->as_u32 = 0x33882299;
+ gid_address_t nested_gid =
+ {
+ .type = GID_ADDR_IP_PREFIX,
+ .ippref = nested_ippref
+ };
+
+ lcaf_t lcaf =
+ {
+ .type = LCAF_INSTANCE_ID,
+ .uni =
+ {
+ .vni_mask_len = 5,
+ .vni = 0xa1b2c3d4,
+ .gid_addr = &nested_gid
+ }
+ };
+ gid_address_type (gid) = GID_ADDR_LCAF;
+ gid_address_lcaf (gid) = lcaf;
+
+ loc2.address = gid[0];
locator_copy(&loc1, &loc2);
_assert (0 == locator_cmp (&loc1, &loc2));
+done:
+ locator_free (&loc1);
+ return error;
+}
+
+static clib_error_t * test_gid_parse_ip_pref ()
+{
+ clib_error_t * error = 0;
+ gid_address_t _gid_addr, * gid_addr = &_gid_addr;
+ gid_address_t _gid_addr_copy, * gid_addr_copy = &_gid_addr_copy;
+ u8 data[] =
+ {
+ 0x00, 0x01, /* AFI = IPv4 */
+ 0x10, 0xbb, 0xcc, 0xdd, /* ipv4 address */
+ };
+
+ u32 len = gid_address_parse (data, gid_addr);
+ _assert (6 == len);
+ gid_address_copy (gid_addr_copy, gid_addr);
+ _assert (0 == gid_address_cmp (gid_addr_copy, gid_addr));
done:
return error;
}
-static clib_error_t * test_gid_parse ()
+static clib_error_t * test_gid_parse_lcaf ()
{
clib_error_t * error = 0;
+ gid_address_t _gid_addr, * gid_addr = &_gid_addr;
+ gid_address_t _gid_addr_copy, * gid_addr_copy = &_gid_addr_copy;
+
+ memset (gid_addr, 0, sizeof (gid_addr[0]));
+ memset (gid_addr_copy, 0, sizeof (gid_addr_copy[0]));
+
+ u8 data[] =
+ {
+ 0x40, 0x03, /* AFI = LCAF*/
+
+ /* LCAF header*/
+ 0x00, 0x00, /* reserved1, flags */
+ 0x02, /* type = Instance ID */
+ 0x18, /* IID mask-len */
+ 0x00, 0x0a, /* iid length + next AFI lenght */
+ /* LCAF Instance ID */
+ 0x00, 0x00, 0x00, 0x09, /* iid */
+ 0x00, 0x01, /* AFI = ipv4 */
+ 0x10, 0xbb, 0xcc, 0xdd, /* ipv4 address */
+ };
+ u32 len = gid_address_parse (data, gid_addr);
+ _assert (18 == len);
+ gid_address_copy (gid_addr_copy, gid_addr);
+ _assert (0 == gid_address_cmp (gid_addr_copy, gid_addr));
+
+ lcaf_t * lcaf = &gid_address_lcaf (gid_addr_copy);
+ vni_t * vni = (vni_t *) lcaf;
+ _assert (lcaf->type == LCAF_INSTANCE_ID);
+ _assert (vni->vni == 9);
+ _assert (vni->vni_mask_len == 0x18);
+
+ gid_address_t * g = vni_gid (vni);
+ _assert (gid_address_type (g) == GID_ADDR_IP_PREFIX);
+done:
+ gid_address_free (gid_addr);
+ gid_address_free (gid_addr_copy);
+ return error;
+}
+
+static clib_error_t * test_gid_parse_lcaf_complex ()
+{
+ clib_error_t * error = 0;
+ gid_address_t _gid_addr, * gid_addr = &_gid_addr;
+ gid_address_t _gid_addr_copy, * gid_addr_copy = &_gid_addr_copy;
+
+ memset (gid_addr, 0, sizeof (gid_addr[0]));
+ memset (gid_addr_copy, 0, sizeof (gid_addr_copy[0]));
+
+ u8 data[] =
+ {
+ 0x40, 0x03, /* AFI = LCAF*/
+
+ /* LCAF header*/
+ 0x00, 0x00, /* reserved1, flags */
+ 0x02, /* type = Instance ID */
+ 0x18, /* IID mask-len */
+ 0x00, 0x0a, /* iid length + next AFI lenght */
+ /* LCAF Instance ID */
+ 0x00, 0x00, 0x00, 0x0b, /* iid */
+
+ 0x40, 0x03, /* AFI = LCAF*/
+ /* LCAF header*/
+ 0x00, 0x00, /* reserved1, flags */
+ 0x02, /* type = Instance ID */
+ 0x17, /* IID mask-len */
+ 0x00, 0x0a, /* iid length + next AFI lenght */
+ /* LCAF Instance ID */
+ 0x00, 0x00, 0x00, 0x0c, /* iid */
+
+ 0x40, 0x03, /* AFI = LCAF*/
+ /* LCAF header*/
+ 0x00, 0x00, /* reserved1, flags */
+ 0x02, /* type = Instance ID */
+ 0x16, /* IID mask-len */
+ 0x00, 0x16, /* iid length + next AFI lenght */
+ /* LCAF Instance ID */
+ 0x00, 0x00, 0x00, 0x0d, /* iid */
+
+ 0x00, 0x02, /* AFI = IPv6 */
+
+ 0x10, 0xbb, 0xcc, 0xdd,
+ 0x10, 0xbb, 0xcc, 0xdd,
+ 0x10, 0xbb, 0xcc, 0xdd,
+ 0x10, 0xbb, 0xcc, 0xdd, /* ipv6 address */
+ };
+ u32 len = gid_address_parse (data, gid_addr);
+ _assert (54 == len);
+ _assert (gid_addr->type == GID_ADDR_LCAF);
+ gid_address_copy (gid_addr_copy, gid_addr);
+ _assert (0 == gid_address_cmp (gid_addr_copy, gid_addr));
+ _assert (gid_addr_copy->type == GID_ADDR_LCAF);
+
+ lcaf_t * lcaf = &gid_address_lcaf (gid_addr_copy);
+ _assert (lcaf->type == LCAF_INSTANCE_ID);
+ vni_t * v = (vni_t *) lcaf;
+ _assert (v->vni == 0x0b);
+ _assert (v->vni_mask_len == 0x18);
+
+ gid_address_t * tmp = vni_gid (v);
+ _assert (gid_address_type (tmp) == GID_ADDR_LCAF);
+ lcaf = &gid_address_lcaf (tmp);
+ _assert (lcaf->type == LCAF_INSTANCE_ID);
+
+ v = (vni_t *) lcaf;
+ _assert (v->vni == 0x0c);
+ _assert (v->vni_mask_len == 0x17);
+
+ tmp = vni_gid (v);
+ _assert (gid_address_type (tmp) == GID_ADDR_LCAF);
+ lcaf = &gid_address_lcaf (tmp);
+
+ _assert (lcaf->type == LCAF_INSTANCE_ID);
+ v = (vni_t *) lcaf;
+ _assert (v->vni == 0x0d);
+ _assert (v->vni_mask_len == 0x16);
+
+ tmp = vni_gid (v);
+ _assert (gid_address_type (tmp) == GID_ADDR_IP_PREFIX);
+
+ ip_prefix_t * ip_pref = &gid_address_ippref (tmp);
+ ip6_address_t * ip6 = &ip_prefix_v6 (ip_pref);
+ _assert (ip6->as_u32[0] == 0xddccbb10);
+ _assert (ip6->as_u32[1] == 0xddccbb10);
+ _assert (ip6->as_u32[2] == 0xddccbb10);
+ _assert (ip6->as_u32[3] == 0xddccbb10);
+ _assert (ip_prefix_version (ip_pref) == IP6);
+
+done:
+ gid_address_free (gid_addr);
+ gid_address_free (gid_addr_copy);
return error;
}
gid_address_t unformated_gid;
/* format/unformat IPv4 global ID address */
- gid_address_type(gid_addr) = IP_PREFIX;
+ gid_address_type(gid_addr) = GID_ADDR_IP_PREFIX;
gid_address_ippref_len(gid_addr) = 24;
ip_prefix_version(&gid_addr->ippref) = IP4;
gid_addr->ippref.addr.ip.v4.as_u32 = 0x20304050;
s = 0;
/* format/unformat IPv6 global ID address */
- gid_address_type(gid_addr) = IP_PREFIX;
+ gid_address_type(gid_addr) = GID_ADDR_IP_PREFIX;
gid_address_ippref_len(gid_addr) = 64;
ip_prefix_version(&gid_addr->ippref) = IP6;
u8 ipv6[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
return error;
}
+static clib_error_t * test_gid_address_write (void)
+{
+ clib_error_t * error = 0;
+ ip_prefix_t ippref_data, * ippref = &ippref_data;
+
+ u8 * b = clib_mem_alloc(500);
+ memset(b, 0, 500);
+
+ ip_prefix_version (ippref) = IP4;
+ ip4_address_t * ip4 = &ip_prefix_v4 (ippref);
+ ip4->as_u32 = 0xaabbccdd;
+
+ gid_address_t nested_gid =
+ {
+ .ippref = ippref[0],
+ .type = GID_ADDR_IP_PREFIX,
+ };
+
+ lcaf_t lcaf =
+ {
+ .type = LCAF_INSTANCE_ID,
+ .uni =
+ {
+ .vni_mask_len = 0x18,
+ .vni = 0x01020304,
+ .gid_addr = &nested_gid
+ }
+ };
+
+ gid_address_t gid =
+ {
+ .type = GID_ADDR_LCAF,
+ .lcaf = lcaf
+ };
+ _assert (18 == gid_address_size_to_put (&gid));
+
+ u16 write_len = gid_address_put (b, &gid);
+ _assert (18 == write_len);
+
+ u8 expected_gid_data[] =
+ {
+ 0x40, 0x03, /* AFI = LCAF */
+ 0x00, /* reserved1 */
+ 0x00, /* flags */
+ 0x02, /* LCAF type = Instance ID */
+ 0x18, /* IID/VNI mask len */
+ 0x00, 0x0a, /* length */
+ 0x01, 0x02, 0x03, 0x04, /* Instance ID / VNI */
+
+ 0x00, 0x01, /* AFI = IPv4 */
+ 0xdd, 0xcc, 0xbb, 0xaa, /* ipv4 addr */
+ };
+ _assert (0 == memcmp (expected_gid_data, b, sizeof (expected_gid_data)));
+done:
+ clib_mem_free (b);
+ return error;
+}
+
#define foreach_test_case \
_(format_unformat_gid_address) \
_(locator_type) \
- _(gid_parse)
+ _(gid_parse_ip_pref) \
+ _(gid_parse_lcaf) \
+ _(gid_parse_lcaf_complex) \
+ _(gid_address_write)
int run_tests (void)
{
uword * p;
vnet_lisp_add_del_mapping_args_t _a, * a = &_a;
- gid_address_type (&eid) = IP_PREFIX;
+ gid_address_type (&eid) = GID_ADDR_IP_PREFIX;
/* Get a line of input. */
if (! unformat_user (input, unformat_line_input, line_input))
}
-static ip_address_t *
+static gid_address_t *
build_itr_rloc_list (lisp_cp_main_t * lcm, locator_set_t * loc_set)
{
ip4_address_t * l4;
locator_t * loc;
u32 * loc_indexp;
ip_interface_address_t * ia = 0;
- ip_address_t * rlocs = 0;
- ip_address_t _rloc, * rloc = &_rloc;
+ gid_address_t gid_data, * gid = &gid_data;
+ gid_address_t * rlocs = 0;
+ ip_prefix_t * ippref = &gid_address_ippref (gid);
+ ip_address_t * rloc = &ip_prefix_addr (ippref);
+ gid_address_type (gid) = GID_ADDR_IP_PREFIX;
for (i = 0; i < vec_len(loc_set->locator_indices); i++)
{
loc_indexp = vec_elt_at_index(loc_set->locator_indices, i);
loc->sw_if_index, 1 /* unnumbered */,
({
l4 = ip_interface_address_get_address (&lcm->im4->lookup_main, ia);
- ip_addr_v4(rloc) = l4[0];
- vec_add1(rlocs, rloc[0]);
+ ip_addr_v4 (rloc) = l4[0];
+ vec_add1 (rlocs, gid[0]);
}));
ip_addr_version(rloc) = IP6;
foreach_ip_interface_address (&lcm->im6->lookup_main, ia,
loc->sw_if_index, 1 /* unnumbered */,
({
- l6 = ip_interface_address_get_address (&lcm->im6->lookup_main, ia);
- ip_addr_v6(rloc) = l6[0];
- vec_add1(rlocs, rloc[0]);
+ l6 = ip_interface_address_get_address (&lcm->im6->lookup_main, ia);
+ ip_addr_v6 (rloc) = l6[0];
+ vec_add1 (rlocs, gid[0]);
}));
}
return rlocs;
vlib_buffer_t * b;
u32 bi;
ip_address_t * mr_ip, sloc;
- ip_address_t * rlocs = 0;
+ gid_address_t * rlocs = 0;
if (vlib_buffer_alloc (vm, &bi, 1) != 1)
{
gid_address_t src, dst;
ip_prefix_t * spref, * dpref;
- gid_address_type (&src) = IP_PREFIX;
+ gid_address_type (&src) = GID_ADDR_IP_PREFIX;
spref = &gid_address_ippref(&src);
- gid_address_type (&dst) = IP_PREFIX;
+ gid_address_type (&dst) = GID_ADDR_IP_PREFIX;
dpref = &gid_address_ippref(&dst);
pi0 = from[0];
{
u32 li = vec_elt (dst_ls->locator_indices, i);
locator_t * l = pool_elt_at_index (lcm->locator_pool, li);
- if (l->priority < minp && gid_address_type(&l->address) == IP_PREFIX)
+ if (l->priority < minp && gid_address_type(&l->address)
+ == GID_ADDR_IP_PREFIX)
{
minp = l->priority;
dl = l;
void
process_map_reply (lisp_cp_main_t * lcm, vlib_buffer_t * b)
{
+ locator_t * loc;
u32 len = 0, i, ls_index = 0;
void * h;
vnet_lisp_add_del_locator_set_args_t _ls_arg, * ls_arg = &_ls_arg;
if (len == ~0)
{
clib_warning ("Failed to parse mapping record!");
+ vec_foreach (loc, ls_arg->locators)
+ {
+ locator_free (loc);
+ }
vec_free(ls_arg->locators);
return;
}
gid_address_t src, dst;
// u64 nonce;
u32 i, len = 0;
- gid_address_t * itr_rlocs = 0;
+ gid_address_t * itr_rlocs = 0, * rloc;
mreq_hdr = vlib_buffer_get_current (b);
vlib_buffer_pull (b, sizeof(*mreq_hdr));
if (len == ~0)
return;
+ /* TODO: RLOCs are currently unused, so free them for now */
+ vec_foreach (rloc, itr_rlocs)
+ {
+ gid_address_free (rloc);
+ }
+
/* parse eid records and send SMR-invoked map-requests */
for (i = 0; i < MREQ_REC_COUNT(mreq_hdr); i++)
{
/* XXX for now this only works with ip-prefixes, no lcafs */
switch (gid_address_type (key))
{
- case IP_PREFIX:
+ case GID_ADDR_IP_PREFIX:
return ip_lookup (db, 0, &gid_address_ippref(key));
break;
default:
/* XXX for now this only works with ip-prefixes, no lcafs */
switch (gid_address_type (key))
{
- case IP_PREFIX:
+ case GID_ADDR_IP_PREFIX:
return gid_dictionary_add_del_ip (db, 0, &gid_address_ippref(key), value,
is_add);
break;
A_AUTHORITATIVE
} lisp_authoritative_e;
+/*
+ * LISP Canonical Address Format Encodings
+ *
+ * 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
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | AFI = 16387 | Rsvd1 | Flags |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | Type | Rsvd2 | Length |
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ */
+
+typedef struct _lcaf_hdr_t
+{
+ u8 reserved1;
+ u8 flags;
+ u8 type;
+ u8 reserved2;
+ u16 len;
+} __attribute__ ((__packed__)) lcaf_hdr_t;
+
+#define LCAF_TYPE(h) ((lcaf_hdr_t *)(h))->type
+#define LCAF_LENGTH(h) ((lcaf_hdr_t *)(h))->len
+#define LCAF_RES2(h) ((lcaf_hdr_t *)(h))->reserved2
+#define LCAF_FLAGS(h) ((lcaf_hdr_t *)(h))->flags
+#define LCAF_PAYLOAD(h) (u8 *)(h)+sizeof(lcaf_hdr_t)
+
#endif /* VNET_LISP_GPE_LISP_CP_MESSAGES_H_ */
return p;
}
-void *
+static void *
lisp_msg_put_itr_rlocs (lisp_cp_main_t * lcm, vlib_buffer_t * b,
- ip_address_t * rlocs, u8 * locs_put)
+ gid_address_t * rlocs, u8 * locs_put)
{
- u8 * p, * bp, count = 0;
+ u8 * bp, count = 0;
u32 i;
- ip_address_t * addr;
- bp = vlib_buffer_get_current(b);
- for (i = 0; i < vec_len(rlocs); i++)
- {
- addr = &rlocs[i];
- switch (ip_addr_version(addr))
+ bp = vlib_buffer_get_current (b);
+ for (i = 0; i < vec_len (rlocs); i++)
{
- case IP4:
- p = vlib_buffer_put_uninit (b, ip4_address_size_to_put());
- ip4_address_put (p, &ip_addr_v4(addr));
- count++;
- break;
- case IP6:
- p = vlib_buffer_put_uninit (b, ip6_address_size_to_put());
- ip6_address_put (p, &ip_addr_v6(addr));
+ lisp_msg_put_gid (b, &rlocs[i]);
count++;
- break;
}
- }
*locs_put = count-1;
return bp;
void *
lisp_msg_put_mreq (lisp_cp_main_t * lcm, vlib_buffer_t * b,
- gid_address_t * seid, gid_address_t * deid,
- ip_address_t * rlocs, u8 is_smr_invoked, u64 * nonce)
+ gid_address_t * seid, gid_address_t * deid,
+ gid_address_t * rlocs, u8 is_smr_invoked, u64 * nonce)
{
u8 loc_count = 0;
gid_address_t *la, gid_address_t *ra)
{
ecm_hdr_t *h;
- ASSERT(gid_address_type(la) == IP_PREFIX);
+ ASSERT(gid_address_type(la) == GID_ADDR_IP_PREFIX);
/* Push inner ip and udp */
pkt_push_udp_and_ip (vm, b, lp, rp, &gid_address_ip(la),
void *
lisp_msg_put_mreq (lisp_cp_main_t * lcm, vlib_buffer_t * b,
gid_address_t * seid, gid_address_t * deid,
- ip_address_t * rlocs, u8 is_smr_invoked, u64 * nonce);
+ gid_address_t * rlocs, u8 is_smr_invoked, u64 * nonce);
void *
lisp_msg_push_ecm (vlib_main_t * vm, vlib_buffer_t *b, int lp, int rp,
typedef u16 (*size_to_write_fct)(void *);
typedef void * (*cast_fct)(gid_address_t *);
-typedef u16 (*write_fct)(u8 *, void *);
+typedef u16 (*serdes_fct)(u8 *, void *);
typedef u8 (*addr_len_fct)(void *);
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 };
-write_fct write_fcts[GID_ADDR_TYPES] =
- { ip_prefix_write };
+ { ip_prefix_size_to_write, lcaf_size_to_write };
+serdes_fct write_fcts[GID_ADDR_TYPES] =
+ { ip_prefix_write, lcaf_write };
cast_fct cast_fcts[GID_ADDR_TYPES] =
- { ip_prefix_cast };
+ { ip_prefix_cast, lcaf_cast };
addr_len_fct addr_len_fcts[GID_ADDR_TYPES] =
- { ip_prefix_length };
+ { ip_prefix_length, lcaf_prefix_length };
copy_fct copy_fcts[GID_ADDR_TYPES] =
- { ip_prefix_copy };
+ { ip_prefix_copy, lcaf_copy };
+
+cmp_fct lcaf_cmp_fcts[LCAF_TYPES] =
+ {
+ no_addr_cmp,
+ NULL,
+ vni_cmp
+ };
+
+size_to_write_fct lcaf_body_length_fcts[LCAF_TYPES] =
+ {
+ no_addr_length,
+ NULL,
+ vni_length
+ };
+
+copy_fct lcaf_copy_fcts[LCAF_TYPES] =
+ {
+ no_addr_copy,
+ NULL,
+ vni_copy
+ };
+
+free_fct lcaf_free_fcts[LCAF_TYPES] =
+ {
+ no_addr_free,
+ NULL,
+ vni_free
+ };
+
+size_to_write_fct lcaf_size_to_write_fcts[LCAF_TYPES] =
+ {
+ no_addr_size_to_write,
+ NULL,
+ vni_size_to_write
+ };
+
+serdes_fct lcaf_write_fcts[LCAF_TYPES] =
+ {
+ no_addr_write,
+ NULL,
+ vni_write
+ };
+
+serdes_fct lcaf_parse_fcts[LCAF_TYPES] =
+ {
+ no_addr_parse,
+ NULL,
+ vni_parse
+ };
u8 *
format_ip_address (u8 * s, va_list * args)
u8 type = gid_address_type(a);
switch (type)
{
- case IP_PREFIX:
+ case GID_ADDR_IP_PREFIX:
return format (s, "%U", format_ip_prefix, &gid_address_ippref(a));
default:
clib_warning("Can't format gid type %d", type);
{
gid_address_t * a = va_arg(*args, gid_address_t *);
if (unformat (input, "%U", unformat_ip_prefix, &gid_address_ippref(a)))
- gid_address_type(a) = IP_PREFIX;
+ gid_address_type(a) = GID_ADDR_IP_PREFIX;
else
return 0;
return 1;
return(sizeof(u16) + size);
}
+u32
+lcaf_hdr_parse (void * offset, lcaf_t * lcaf)
+{
+ lcaf_hdr_t * lh = offset;
+ lcaf->type = lh->type;
+
+ /* this is a bit of hack: since the LCAF Instance ID is the
+ only message that uses reserved2 field, we can set it here.
+ If any LCAF format starts using reserved2 field as well this needs
+ to be moved elsewhere */
+ lcaf_vni_len (lcaf) = lh->reserved2;
+
+ return sizeof (lh[0]);
+}
+
+u16
+vni_parse (u8 * p, void * a)
+{
+ vni_t * v = a;
+ u16 size = 0;
+ vni_vni (v) = clib_net_to_host_u32 ( *(u32 *) p);
+ size += sizeof (u32);
+
+ vni_gid (v) = clib_mem_alloc (sizeof (gid_address_t));
+ gid_address_t * gid = vni_gid (v);
+ memset (gid, 0, sizeof (gid[0]));
+
+ size += gid_address_parse (p + size, gid);
+ return size;
+}
+
+u16
+no_addr_parse (u8 * p, void * a)
+{
+ /* do nothing */
+ return 0;
+}
+
+u32
+lcaf_parse (void * offset, gid_address_t *addr)
+{
+ /* skip AFI type */
+ offset += sizeof (u16);
+ lcaf_t * lcaf = &gid_address_lcaf (addr);
+
+ u32 size = lcaf_hdr_parse (offset, lcaf);
+ u8 type = lcaf_type (lcaf);
+
+ if (!lcaf_parse_fcts[type])
+ {
+ clib_warning ("Unsupported LCAF type: %u", type);
+ return ~0;
+ }
+ size += (*lcaf_parse_fcts[type])(offset + size, lcaf);
+ return sizeof (u16) + size;
+}
+
+void
+vni_free (void * a)
+{
+ vni_t * v = a;
+ gid_address_free (vni_gid (v));
+ clib_mem_free (vni_gid (v));
+}
+
+void
+no_addr_free (void * a)
+{
+ /* nothing to do */
+}
+
+void
+gid_address_free (gid_address_t *a)
+{
+ if (gid_address_type (a) != GID_ADDR_LCAF)
+ return;
+
+ lcaf_t * lcaf = &gid_address_lcaf (a);
+ u8 lcaf_type = lcaf_type (lcaf);
+ (*lcaf_free_fcts[lcaf_type])(lcaf);
+}
+
int
ip_address_cmp (ip_address_t * ip1, ip_address_t * ip2)
{
return cmp;
}
+void
+no_addr_copy (void * dst, void * src)
+{
+ /* nothing to do */
+}
+
+void
+vni_copy (void * dst, void * src)
+{
+ vni_t * vd = dst;
+ vni_t * vs = src;
+
+ clib_memcpy (vd, vs, sizeof (vd[0]));
+ vni_gid (vd) = clib_mem_alloc (sizeof (gid_address_t));
+ gid_address_copy (vni_gid (vd), vni_gid (vs));
+}
+
+void
+lcaf_copy (void * dst , void * src)
+{
+ lcaf_t * lcaf_dst = dst;
+ lcaf_t * lcaf_src = src;
+
+ lcaf_type (lcaf_dst) = lcaf_type (lcaf_src);
+ (*lcaf_copy_fcts[lcaf_type (lcaf_src)])(dst, src);
+}
+
+u8
+lcaf_prefix_length (void *a)
+{
+ return 0;
+}
+
+void *
+lcaf_cast (gid_address_t * a)
+{
+ return &gid_address_lcaf (a);
+}
+
+u16
+no_addr_length (void * a)
+{
+ return 0;
+}
+
+u16
+vni_length (void * a)
+{
+ vni_t * v = a;
+ return (sizeof (u32) /* VNI size */
+ + gid_address_size_to_put (vni_gid (v)) /* vni body size*/);
+}
+
+u16
+lcaf_write (u8 * p, void * a)
+{
+ u16 size = 0, len;
+ lcaf_t * lcaf = a;
+ u8 type = lcaf_type (lcaf);
+ lcaf_hdr_t _h, *h = &_h;
+
+ *(u16 *) p = clib_host_to_net_u16 (LISP_AFI_LCAF);
+ size += sizeof (u16);
+ memset (h, 0, sizeof (h[0]));
+ LCAF_TYPE (h) = type;
+ u16 lcaf_len = (*lcaf_body_length_fcts[type])(lcaf);
+ LCAF_LENGTH (h) = clib_host_to_net_u16 (lcaf_len);
+
+ if (LCAF_INSTANCE_ID == type)
+ LCAF_RES2 (h) = lcaf_vni_len(lcaf);
+
+ clib_memcpy (p + size, h, sizeof (h[0]));
+ size += sizeof (h[0]);
+ len = (*lcaf_write_fcts[type])(p + size, lcaf);
+
+ if (~0 == len)
+ return ~0;
+
+ return size + len;
+}
+
+u16
+vni_write (u8 * p, void * a)
+{
+ vni_t * v = a;
+ u16 size = 0, len;
+
+ *(u32 *)p = clib_host_to_net_u32 (vni_vni (v));
+ size += sizeof (u32);
+ len = gid_address_put (p + size, vni_gid (v));
+
+ if (~0 == len)
+ return ~0;
+
+ return size + len;
+}
+
+u16
+no_addr_write (u8 * p, void * a)
+{
+ /* do nothing; return AFI field size */
+ return sizeof (u16);
+}
+
+u16
+no_addr_size_to_write (void * a)
+{
+ return sizeof (u16); /* AFI field length */
+}
+
+u16
+vni_size_to_write (void * a)
+{
+ vni_t * v = a;
+ u16 size = sizeof (vni_vni (v));
+
+ gid_address_t * gid = vni_gid (v);
+ return (size + sizeof (lcaf_hdr_t)
+ + gid_address_size_to_put (gid));
+}
+
+u16
+lcaf_size_to_write (void * a)
+{
+ lcaf_t * lcaf = (lcaf_t *) a;
+ u32 size = 0, len;
+ u8 type = lcaf_type (lcaf);
+
+ size += sizeof (u16); /* AFI size */
+
+ len = (*lcaf_size_to_write_fcts[type])(lcaf);
+ if (~0 == len)
+ return ~0;
+
+ return size + len;
+}
+
u8
gid_address_len (gid_address_t *a)
{
{
case LISP_AFI_NO_ADDR:
len = sizeof(u16);
- gid_address_type(a) = NO_ADDRESS;
+ gid_address_type(a) = GID_ADDR_NO_ADDRESS;
break;
case LISP_AFI_IP:
len = ip_address_parse (offset, afi, &gid_address_ip(a));
- gid_address_type(a) = IP_PREFIX;
+ gid_address_type(a) = GID_ADDR_IP_PREFIX;
/* this should be modified outside if needed*/
gid_address_ippref_len(a) = 32;
break;
case LISP_AFI_IP6:
len = ip_address_parse (offset, afi, &gid_address_ip(a));
- gid_address_type(a) = IP_PREFIX;
+ gid_address_type(a) = GID_ADDR_IP_PREFIX;
/* this should be modified outside if needed*/
gid_address_ippref_len(a) = 128;
break;
case LISP_AFI_LCAF:
+ len = lcaf_parse (offset, a);
+ gid_address_type(a) = GID_ADDR_LCAF;
+ break;
default:
clib_warning("LISP AFI %d not supported!", afi);
return ~0;
return len;
}
+int
+no_addr_cmp (void * a1, void * a2)
+{
+ return 0;
+}
+
+int
+vni_cmp (void * a1, void * a2)
+{
+ vni_t * v1 = a1;
+ vni_t * v2 = a2;
+
+ if (vni_mask_len (v1) != vni_mask_len (v2))
+ return -1;
+ if (vni_vni (v1) != vni_vni (v2))
+ return -1;
+ return gid_address_cmp (vni_gid (v1), vni_gid (v2));
+}
+
/* Compare two gid_address_t.
* Returns:
* -1: If they are from different afi
int
gid_address_cmp (gid_address_t * a1, gid_address_t * a2)
{
+ lcaf_t * lcaf1, * lcaf2;
int cmp = -1;
if (!a1 || !a2)
return -1;
switch (gid_address_type(a1))
{
- case NO_ADDRESS:
+ case GID_ADDR_NO_ADDRESS:
if (a1 == a2)
cmp = 0;
else
cmp = 2;
break;
- case IP_PREFIX:
+ case GID_ADDR_IP_PREFIX:
cmp = ip_prefix_cmp (&gid_address_ippref(a1), &gid_address_ippref(a2));
break;
+ case GID_ADDR_LCAF:
+ lcaf1 = &gid_address_lcaf (a1);
+ lcaf2 = &gid_address_lcaf (a2);
+ if (lcaf_type (lcaf1) == lcaf_type (lcaf2))
+ cmp = (*lcaf_cmp_fcts[lcaf_type (lcaf1)])(lcaf1, lcaf2);
+ break;
default:
break;
}
{
/* TODO if gid become more complex, this will need to be changed! */
clib_memcpy (dst, src, sizeof(*dst));
+ if (!src->local)
+ gid_address_copy (&dst->address, &src->address);
}
u32
return 1;
return 0;
}
+
+void
+locator_free (locator_t * l)
+{
+ if (!l->local)
+ gid_address_free (&l->address);
+}
{
/* NOTE: ip addresses are left out on purpose. Use max masked ip-prefixes
* instead */
- IP_PREFIX,
- NO_ADDRESS,
+ GID_ADDR_IP_PREFIX,
+ GID_ADDR_LCAF,
+ GID_ADDR_NO_ADDRESS,
GID_ADDR_TYPES
} gid_address_type_t;
-/* might want to expand this in the future :) */
+typedef enum
+{
+ /* make sure that values corresponds with RFC */
+ LCAF_NULL_BODY = 0,
+ LCAF_AFI_LIST_TYPE,
+ LCAF_INSTANCE_ID,
+ LCAF_TYPES
+} lcaf_type_t;
+
+struct _gid_address_t;
+
typedef struct
+{
+ u8 vni_mask_len;
+ u32 vni;
+ struct _gid_address_t *gid_addr;
+} vni_t;
+
+#define vni_vni(_a) (_a)->vni
+#define vni_mask_len(_a) (_a)->vni_mask_len
+#define vni_gid(_a) (_a)->gid_addr
+
+typedef struct
+{
+ u8 src_len;
+ u8 dst_len;
+ struct _gid_address_t *src;
+ struct _gid_address_t *dst;
+} source_dest_t;
+
+typedef struct
+{
+ /* the union needs to be at the beginning! */
+ union
+ {
+ source_dest_t sd;
+ vni_t uni;
+ };
+ u8 type;
+} lcaf_t;
+
+#define lcaf_type(_a) (_a)->type
+#define lcaf_vni(_a) vni_vni(& (_a)->uni)
+#define lcaf_vni_len(_a) vni_mask_len(& (_a)->uni)
+#define lcaf_gid (_a) vni_gid(& (_a)->uni)
+
+/* might want to expand this in the future :) */
+typedef struct _gid_address_t
{
union
{
ip_prefix_t ippref;
+ lcaf_t lcaf;
};
u8 type;
} gid_address_t;
u8 *format_gid_address (u8 * s, va_list * args);
uword unformat_gid_address (unformat_input_t * input, va_list * args);
int gid_address_cmp (gid_address_t * a1, gid_address_t * a2);
+void gid_address_free (gid_address_t *a);
u16 gid_address_size_to_put (gid_address_t * a);
u16 gid_address_put (u8 * b, gid_address_t * gid);
#define gid_address_ippref(_a) (_a)->ippref
#define gid_address_ippref_len(_a) (_a)->ippref.len
#define gid_address_ip(_a) ip_prefix_addr(&gid_address_ippref(_a))
+#define gid_address_lcaf(_a) (_a)->lcaf
+#define gid_address_vni(_a) ( (GID_ADDR_LCAF == gid_address_type(_a)) ? \
+ lcaf_vni(&gid_address_lcaf(_a)) : 0)
/* 'sub'address functions */
u16 ip_prefix_size_to_write (void * pref);
void *ip_prefix_cast (gid_address_t * a);
void ip_prefix_copy (void * dst , void * src);
+int lcaf_cmp (lcaf_t * lcaf1, lcaf_t * lcaf2);
+u16 lcaf_size_to_write (void * pref);
+u16 lcaf_write (u8 * p, void * pref);
+u8 lcaf_prefix_length (void *a);
+void *lcaf_cast (gid_address_t * a);
+void lcaf_copy (void * dst , void * src);
+
typedef struct
{
/* mark locator as local as opposed to remote */
u32 locator_parse (void * ptr, locator_t * loc);
void locator_copy (locator_t * dst, locator_t * src);
u32 locator_cmp (locator_t * l1, locator_t * l2);
+void locator_free (locator_t * l);
typedef struct
{
vec_foreach(tunnel, tunnels) {
memset(at, 0, sizeof(at[0]));
at->is_add = 0;
- gid_address_type(&at->deid) = IP_PREFIX;
+ gid_address_type(&at->deid) = GID_ADDR_IP_PREFIX;
ip_prefix_copy(&gid_address_ippref(&at->deid), &tunnel->eid);
ip_address_copy(&at->dlocator, &tunnel->dst_loc);
vnet_lisp_gpe_add_del_fwd_entry (at, 0);
prefp = &gid_address_ippref(&eid);
ip_eid = &ip_prefix_addr(prefp);
- gid_address_type (&eid) = IP_PREFIX;
+ gid_address_type (&eid) = GID_ADDR_IP_PREFIX;
if (mp->is_ipv6) {
clib_memcpy(&ip_addr_v6(ip_eid), mp->ip_address,
gid = &mapit->eid;
type = gid_address_type(gid);
- if (type != IP_PREFIX) {
+ if (type != GID_ADDR_IP_PREFIX) {
return;
}
Code Review / vpp.git / commitdiff