2 * Copyright (c) 2016 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 #include <vnet/vnet.h>
17 #include <vppinfra/error.h>
18 #include <vnet/lisp-cp/lisp_types.h>
19 #include <vnet/lisp-cp/lisp_cp_messages.h>
22 error = CLIB_ERROR_ASSERT (e); \
26 static clib_error_t * test_locator_type (void)
28 clib_error_t * error = 0;
29 gid_address_t _gid_addr, * gid = &_gid_addr;
31 gid_address_type (gid) = GID_ADDR_IP_PREFIX;
32 gid_address_ippref_len (gid) = 24;
33 ippref = &gid_address_ippref (gid);
34 ip_prefix_version (ippref) = IP4;
35 ip_prefix_len (ippref) = 0;
36 ip4_address_t * ip4 = &ip_prefix_v4 (ippref);
37 ip4->as_u32 = 0x20304050;
40 locator_t loc1, loc2 = {
49 locator_copy (&loc1, &loc2);
50 _assert (0 == locator_cmp (&loc1, &loc2));
55 ip_prefix_t nested_ippref;
56 ip_prefix_version (&nested_ippref) = IP4;
57 ip_prefix_len (&nested_ippref) = 0;
58 ip4 = &ip_prefix_v4 (&nested_ippref);
59 ip4->as_u32 = 0x33882299;
60 gid_address_t nested_gid =
62 .type = GID_ADDR_IP_PREFIX,
63 .ippref = nested_ippref
68 .type = LCAF_INSTANCE_ID,
73 .gid_addr = &nested_gid
76 gid_address_type (gid) = GID_ADDR_LCAF;
77 gid_address_lcaf (gid) = lcaf;
79 loc2.address = gid[0];
80 locator_copy(&loc1, &loc2);
82 _assert (0 == locator_cmp (&loc1, &loc2));
89 static clib_error_t * test_gid_parse_ip_pref ()
91 clib_error_t * error = 0;
92 gid_address_t _gid_addr, * gid_addr = &_gid_addr;
93 gid_address_t _gid_addr_copy, * copy = &_gid_addr_copy;
96 0x00, 0x01, /* AFI = IPv4 */
97 0x10, 0xbb, 0xcc, 0xdd, /* ipv4 address */
100 u32 len = gid_address_parse (data, gid_addr);
102 gid_address_copy (copy, gid_addr);
103 _assert (0 == gid_address_cmp (copy, gid_addr));
108 static clib_error_t * test_gid_parse_mac ()
110 clib_error_t * error = 0;
111 gid_address_t _gid, * gid = &_gid;
112 gid_address_t _gid_copy, * gid_copy = &_gid_copy;
116 0x40, 0x05, /* AFI = MAC address */
117 0x10, 0xbb, 0xcc, 0xdd, /* MAC */
121 u32 len = gid_address_parse (data, gid);
123 _assert (GID_ADDR_MAC == gid_address_type (gid));
124 gid_address_copy (gid_copy, gid);
125 _assert (0 == gid_address_cmp (gid_copy, gid));
130 static clib_error_t *
131 test_gid_write_nsh (void)
133 clib_error_t * error = 0;
135 u8 * b = clib_mem_alloc(500);
136 clib_memset(b, 0, 500);
143 .type = GID_ADDR_NSH,
146 u16 len = gid_address_put (b, &g);
150 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF*/
151 0x11, 0x00, 0x00, 0x04, /* type = SPI LCAF, length = 4 */
153 /* Service Path ID, Service index */
154 0x11, 0x22, 0x33, 0x42, /* SPI, SI */
157 _assert (sizeof (expected) == len);
158 _assert (0 == memcmp (expected, b, len));
164 static clib_error_t *
165 test_gid_parse_nsh ()
167 clib_error_t * error = 0;
168 gid_address_t _gid_addr, * gid_addr = &_gid_addr;
169 gid_address_t _gid_addr_copy, * copy = &_gid_addr_copy;
171 clib_memset (gid_addr, 0, sizeof (gid_addr[0]));
172 clib_memset (copy, 0, sizeof (copy[0]));
176 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF*/
177 0x11, 0x00, 0x00, 0x04, /* type = SPI LCAF, length = 4 */
179 /* Service Path ID, Service index */
180 0x55, 0x99, 0x42, 0x09, /* SPI, SI */
183 u32 len = gid_address_parse (data, gid_addr);
184 _assert (sizeof (data) == len);
185 gid_address_copy (copy, gid_addr);
186 _assert (0 == gid_address_cmp (gid_addr, copy));
187 _assert (GID_ADDR_NSH == gid_address_type (copy));
188 _assert (0 == gid_address_vni (copy));
189 _assert (gid_address_nsh_spi (copy) == 0x559942);
190 _assert (gid_address_nsh_si (copy) == 0x09);
193 gid_address_free (copy);
194 gid_address_free (gid_addr);
198 static clib_error_t * test_gid_parse_lcaf ()
200 clib_error_t * error = 0;
201 gid_address_t _gid_addr, * gid_addr = &_gid_addr;
202 gid_address_t _gid_addr_copy, * gid_addr_copy = &_gid_addr_copy;
204 clib_memset (gid_addr, 0, sizeof (gid_addr[0]));
205 clib_memset (gid_addr_copy, 0, sizeof (gid_addr_copy[0]));
209 0x40, 0x03, /* AFI = LCAF*/
212 0x00, 0x00, /* reserved1, flags */
213 0x02, /* type = Instance ID */
214 0x18, /* IID mask-len */
215 0x00, 0x0a, /* iid length + next AFI lenght */
216 /* LCAF Instance ID */
217 0x00, 0x00, 0x00, 0x09, /* iid */
218 0x00, 0x01, /* AFI = ipv4 */
219 0x10, 0xbb, 0xcc, 0xdd, /* ipv4 address */
221 u32 len = gid_address_parse (data, gid_addr);
223 gid_address_copy (gid_addr_copy, gid_addr);
224 _assert (0 == gid_address_cmp (gid_addr_copy, gid_addr));
225 _assert (GID_ADDR_IP_PREFIX == gid_address_type (gid_addr));
226 _assert (9 == gid_address_vni (gid_addr));
227 _assert (0x18 == gid_address_vni_mask (gid_addr));
228 _assert (0xddccbb10 == gid_addr->ippref.addr.ip.v4.as_u32);
231 gid_address_free (gid_addr);
232 gid_address_free (gid_addr_copy);
236 /* recursive LCAFs are not supported */
238 static clib_error_t * test_gid_parse_lcaf_complex ()
240 clib_error_t * error = 0;
241 gid_address_t _gid_addr, * gid_addr = &_gid_addr;
242 gid_address_t _gid_addr_copy, * gid_addr_copy = &_gid_addr_copy;
244 clib_memset (gid_addr, 0, sizeof (gid_addr[0]));
245 clib_memset (gid_addr_copy, 0, sizeof (gid_addr_copy[0]));
249 0x40, 0x03, /* AFI = LCAF*/
252 0x00, 0x00, /* reserved1, flags */
253 0x02, /* type = Instance ID */
254 0x18, /* IID mask-len */
255 0x00, 0x0a, /* iid length + next AFI lenght */
256 /* LCAF Instance ID */
257 0x00, 0x00, 0x00, 0x0b, /* iid */
259 0x40, 0x03, /* AFI = LCAF*/
261 0x00, 0x00, /* reserved1, flags */
262 0x02, /* type = Instance ID */
263 0x17, /* IID mask-len */
264 0x00, 0x0a, /* iid length + next AFI lenght */
265 /* LCAF Instance ID */
266 0x00, 0x00, 0x00, 0x0c, /* iid */
268 0x40, 0x03, /* AFI = LCAF*/
270 0x00, 0x00, /* reserved1, flags */
271 0x02, /* type = Instance ID */
272 0x16, /* IID mask-len */
273 0x00, 0x16, /* iid length + next AFI lenght */
274 /* LCAF Instance ID */
275 0x00, 0x00, 0x00, 0x0d, /* iid */
277 0x00, 0x02, /* AFI = IPv6 */
279 0x10, 0xbb, 0xcc, 0xdd,
280 0x10, 0xbb, 0xcc, 0xdd,
281 0x10, 0xbb, 0xcc, 0xdd,
282 0x10, 0xbb, 0xcc, 0xdd, /* ipv6 address */
284 u32 len = gid_address_parse (data, gid_addr);
286 _assert (gid_addr->type == GID_ADDR_LCAF);
287 gid_address_copy (gid_addr_copy, gid_addr);
288 _assert (0 == gid_address_cmp (gid_addr_copy, gid_addr));
289 _assert (gid_addr_copy->type == GID_ADDR_LCAF);
291 lcaf_t * lcaf = &gid_address_lcaf (gid_addr_copy);
292 _assert (lcaf->type == LCAF_INSTANCE_ID);
293 vni_t * v = (vni_t *) lcaf;
294 _assert (v->vni == 0x0b);
295 _assert (v->vni_mask_len == 0x18);
297 gid_address_t * tmp = vni_gid (v);
298 _assert (gid_address_type (tmp) == GID_ADDR_LCAF);
299 lcaf = &gid_address_lcaf (tmp);
300 _assert (lcaf->type == LCAF_INSTANCE_ID);
303 _assert (v->vni == 0x0c);
304 _assert (v->vni_mask_len == 0x17);
307 _assert (gid_address_type (tmp) == GID_ADDR_LCAF);
308 lcaf = &gid_address_lcaf (tmp);
310 _assert (lcaf->type == LCAF_INSTANCE_ID);
312 _assert (v->vni == 0x0d);
313 _assert (v->vni_mask_len == 0x16);
316 _assert (gid_address_type (tmp) == GID_ADDR_IP_PREFIX);
318 ip_prefix_t * ip_pref = &gid_address_ippref (tmp);
319 ip6_address_t * ip6 = &ip_prefix_v6 (ip_pref);
320 _assert (ip6->as_u32[0] == 0xddccbb10);
321 _assert (ip6->as_u32[1] == 0xddccbb10);
322 _assert (ip6->as_u32[2] == 0xddccbb10);
323 _assert (ip6->as_u32[3] == 0xddccbb10);
324 _assert (ip_prefix_version (ip_pref) == IP6);
327 gid_address_free (gid_addr);
328 gid_address_free (gid_addr_copy);
333 static clib_error_t * test_write_mac_in_lcaf (void)
335 clib_error_t * error = 0;
337 u8 * b = clib_mem_alloc(500);
338 clib_memset(b, 0, 500);
342 .mac = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6},
345 .type = GID_ADDR_MAC,
348 u16 len = gid_address_put (b, &g);
352 0x40, 0x03, /* AFI = LCAF */
353 0x00, /* reserved1 */
355 0x02, /* LCAF type = Instance ID */
356 0x10, /* IID/IID mask len */
357 0x00, 0x0c, /* length */
358 0x01, 0x02, 0x03, 0x04, /* Instance ID / VNI */
360 0x40, 0x05, /* AFI = MAC */
361 0x01, 0x02, 0x03, 0x04,
364 _assert (sizeof (expected) == len);
365 _assert (0 == memcmp (expected, b, len));
371 static clib_error_t * test_mac_address_write (void)
373 clib_error_t * error = 0;
375 u8 * b = clib_mem_alloc(500);
376 clib_memset(b, 0, 500);
380 .mac = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6},
381 .type = GID_ADDR_MAC,
384 u16 len = gid_address_put (b, &g);
389 0x40, 0x05, /* AFI = MAC */
390 0x01, 0x02, 0x03, 0x04,
393 _assert (0 == memcmp (expected, b, len));
399 static clib_error_t *
400 test_src_dst_with_vni_serdes (void)
402 clib_error_t * error = 0;
403 u8 * b = clib_mem_alloc (500);
404 clib_memset (b, 0, 500);
408 .type = FID_ADDR_IP_PREF,
415 .ip.v4.data = { 0x1, 0x2, 0x3, 0x0 }
422 .type = FID_ADDR_IP_PREF,
429 .ip.v4.data = { 0x9, 0x8, 0x0, 0x0 }
443 .type = GID_ADDR_SRC_DST,
448 u16 size_to_put = gid_address_size_to_put(&g);
449 _assert (36 == size_to_put);
450 _assert (0 == gid_address_len(&g));
452 u16 write_len = gid_address_put (b, &g);
453 printf("sizetoput %d; writelen %d\n", size_to_put, write_len);
454 _assert (size_to_put == write_len);
458 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF, reserved1, flags */
459 0x02, 0x09, 0x00, 0x1c, /* LCAF type = IID, IID mask-len, length */
460 0x12, 0x34, 0x56, 0x78, /* reserved; source-ML, Dest-ML */
462 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF, reserved1, flags */
463 0x0c, 0x00, 0x00, 0x10, /* LCAF type = source/dest key, rsvd, length */
464 0x00, 0x00, 0x18, 0x10, /* reserved; source-ML, Dest-ML */
466 0x00, 0x01, /* AFI = ip4 */
467 0x01, 0x02, 0x03, 0x00, /* source */
469 0x00, 0x01, /* AFI = ip4 */
470 0x09, 0x08, 0x00, 0x00, /* destination */
472 _assert (0 == memcmp (expected_data, b, sizeof (expected_data)));
475 clib_memset (&p, 0, sizeof (p));
476 _assert (write_len == gid_address_parse (b, &p));
477 _assert (0 == gid_address_cmp (&g, &p));
483 static clib_error_t *
484 test_src_dst_deser_bad_afi (void)
486 clib_error_t * error = 0;
490 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF, reserved1, flags */
491 0x0c, 0x00, 0x00, 0x14, /* LCAF type = source/dest key, rsvd, length */
492 0x00, 0x00, 0x00, 0x00, /* reserved; source-ML, Dest-ML */
494 0xde, 0xad, /* AFI = bad value */
495 0x11, 0x22, 0x33, 0x44,
496 0x55, 0x66, /* source */
498 0x40, 0x05, /* AFI = MAC */
499 0x10, 0x21, 0x32, 0x43,
500 0x54, 0x65, /* destination */
504 _assert (~0 == gid_address_parse (expected_data, &p));
509 static clib_error_t *
510 test_src_dst_serdes (void)
512 clib_error_t * error = 0;
514 u8 * b = clib_mem_alloc (500);
515 clib_memset (b, 0, 500);
519 .type = FID_ADDR_MAC,
520 .mac = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 }
525 .type = FID_ADDR_MAC,
526 .mac = { 0x10, 0x21, 0x32, 0x43, 0x54, 0x65 }
538 .type = GID_ADDR_SRC_DST,
543 u16 size_to_put = gid_address_size_to_put(&g);
544 _assert (28 == size_to_put);
545 _assert (0 == gid_address_len(&g));
547 u16 write_len = gid_address_put (b, &g);
548 _assert (size_to_put == write_len);
552 0x40, 0x03, 0x00, 0x00, /* AFI = LCAF, reserved1, flags */
553 0x0c, 0x00, 0x00, 0x14, /* LCAF type = source/dest key, rsvd, length */
554 0x00, 0x00, 0x00, 0x00, /* reserved; source-ML, Dest-ML */
556 0x40, 0x05, /* AFI = MAC */
557 0x11, 0x22, 0x33, 0x44,
558 0x55, 0x66, /* source */
560 0x40, 0x05, /* AFI = MAC */
561 0x10, 0x21, 0x32, 0x43,
562 0x54, 0x65, /* destination */
564 _assert (0 == memcmp (expected_data, b, sizeof (expected_data)));
567 clib_memset (&p, 0, sizeof (p));
568 _assert (write_len == gid_address_parse (b, &p));
569 _assert (0 == gid_address_cmp (&g, &p));
575 static clib_error_t * test_gid_address_write (void)
577 clib_error_t * error = 0;
578 ip_prefix_t ippref_data, * ippref = &ippref_data;
580 u8 * b = clib_mem_alloc(500);
581 clib_memset(b, 0, 500);
583 ip_prefix_version (ippref) = IP4;
584 ip_prefix_len (ippref) = 9;
585 ip4_address_t * ip4 = &ip_prefix_v4 (ippref);
586 ip4->as_u32 = 0xaabbccdd;
591 .type = GID_ADDR_IP_PREFIX,
596 _assert (18 == gid_address_size_to_put (&g));
597 _assert (gid_address_len (&g) == 9);
599 u16 write_len = gid_address_put (b, &g);
600 _assert (18 == write_len);
602 u8 expected_gid_data[] =
604 0x40, 0x03, /* AFI = LCAF */
605 0x00, /* reserved1 */
607 0x02, /* LCAF type = Instance ID */
608 0x18, /* IID/VNI mask len */
609 0x00, 0x0a, /* length */
610 0x01, 0x02, 0x03, 0x04, /* Instance ID / VNI */
612 0x00, 0x01, /* AFI = IPv4 */
613 0xdd, 0xcc, 0xbb, 0xaa, /* ipv4 addr */
615 _assert (0 == memcmp (expected_gid_data, b, sizeof (expected_gid_data)));
621 #define foreach_test_case \
623 _(gid_parse_ip_pref) \
628 _(mac_address_write) \
629 _(gid_address_write) \
631 _(write_mac_in_lcaf) \
632 _(src_dst_deser_bad_afi) \
633 _(src_dst_with_vni_serdes)
637 clib_error_t * error;
639 #define _(_test_name) \
640 error = test_ ## _test_name (); \
643 clib_error_report (error); \