Add support for LCAF Instance ID

Change-Id: Ifce3f2bdcba099157a42d0b694f3161b9f700ed2
Signed-off-by: Filip Tehlar <ftehlar@cisco.com>

2 files changed, 504 insertions, 43 deletions

diff --git a/vnet/test/lisp-cp/test_cp_serdes.c b/vnet/test/lisp-cp/test_cp_serdes.c
index d77c294d..2ca391e3 100644
--- a/vnet/test/lisp-cp/test_cp_serdes.c
+++ b/vnet/test/lisp-cp/test_cp_serdes.c
@@ -65,7 +65,7 @@ static clib_error_t * test_lisp_msg_push_ecm ()
   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);
@@ -74,11 +74,11 @@ static clib_error_t * test_lisp_msg_push_ecm ()
   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;
 
@@ -96,7 +96,7 @@ static clib_error_t * test_lisp_msg_push_ecm ()
   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 */
@@ -114,7 +114,7 @@ static clib_error_t * test_lisp_msg_push_ecm ()
   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)));
@@ -161,7 +161,7 @@ static clib_error_t * test_lisp_msg_parse_mapping_record ()
   _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);
@@ -175,35 +175,25 @@ done:
 }
 
 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);
@@ -211,6 +201,26 @@ build_map_request (lisp_cp_main_t * lcm, vlib_buffer_t * b)
   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;
@@ -219,13 +229,15 @@ static clib_error_t * test_lisp_msg_parse ()
   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);
@@ -259,16 +271,95 @@ done:
   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);
@@ -297,19 +388,149 @@ static clib_error_t * test_lisp_msg_put_mreq ()
     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)
 {
diff --git a/vnet/test/lisp-cp/test_lisp_types.c b/vnet/test/lisp-cp/test_lisp_types.c
index efd87222..b846cf64 100644
--- a/vnet/test/lisp-cp/test_lisp_types.c
+++ b/vnet/test/lisp-cp/test_lisp_types.c
@@ -26,11 +26,15 @@
 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 = {
@@ -47,18 +51,193 @@ static clib_error_t * test_locator_type (void)
 
   /* 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;
 }
 
@@ -72,7 +251,7 @@ static clib_error_t * test_format_unformat_gid_address (void)
   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;
@@ -90,7 +269,7 @@ static clib_error_t * test_format_unformat_gid_address (void)
   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};
@@ -115,10 +294,71 @@ done:
   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)
 {