FD.io VPP  v17.04.2-2-ga8f93f8
Vector Packet Processing
lisp_api.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * lisp_api.c - lisp api
4  *
5  * Copyright (c) 2016 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 
20 #include <vnet/vnet.h>
21 #include <vlibmemory/api.h>
22 
23 #include <vnet/interface.h>
24 #include <vnet/api_errno.h>
25 #include <vnet/lisp-cp/control.h>
26 #include <vnet/lisp-gpe/lisp_gpe.h>
27 
28 #include <vnet/vnet_msg_enum.h>
29 
30 #define vl_api_remote_locator_t_endian vl_noop_handler
31 #define vl_api_remote_locator_t_print vl_noop_handler
32 #define vl_api_local_locator_t_endian vl_noop_handler
33 #define vl_api_local_locator_t_print vl_noop_handler
34 
35 #define vl_api_lisp_add_del_locator_set_t_endian vl_noop_handler
36 #define vl_api_lisp_add_del_locator_set_t_print vl_noop_handler
37 #define vl_api_lisp_add_del_remote_mapping_t_endian vl_noop_handler
38 #define vl_api_lisp_add_del_remote_mapping_t_print vl_noop_handler
39 
40 #define vl_api_one_add_del_locator_set_t_endian vl_noop_handler
41 #define vl_api_one_add_del_locator_set_t_print vl_noop_handler
42 #define vl_api_one_add_del_remote_mapping_t_endian vl_noop_handler
43 #define vl_api_one_add_del_remote_mapping_t_print vl_noop_handler
44 
45 #define vl_typedefs /* define message structures */
46 #include <vnet/vnet_all_api_h.h>
47 #undef vl_typedefs
48 
49 #define vl_endianfun /* define message structures */
50 #include <vnet/vnet_all_api_h.h>
51 #undef vl_endianfun
52 
53 /* instantiate all the print functions we know about */
54 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
55 #define vl_printfun
56 #include <vnet/vnet_all_api_h.h>
57 #undef vl_printfun
58 
60 
61 #define foreach_vpe_api_msg \
62 _(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set) \
63 _(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator) \
64 _(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid) \
65 _(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver) \
66 _(LISP_ADD_DEL_MAP_SERVER, lisp_add_del_map_server) \
67 _(LISP_ENABLE_DISABLE, lisp_enable_disable) \
68 _(LISP_RLOC_PROBE_ENABLE_DISABLE, lisp_rloc_probe_enable_disable) \
69 _(LISP_MAP_REGISTER_ENABLE_DISABLE, lisp_map_register_enable_disable) \
70 _(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping) \
71 _(LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency) \
72 _(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set) \
73 _(LISP_MAP_REQUEST_MODE, lisp_map_request_mode) \
74 _(LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map) \
75 _(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump) \
76 _(LISP_LOCATOR_DUMP, lisp_locator_dump) \
77 _(LISP_EID_TABLE_DUMP, lisp_eid_table_dump) \
78 _(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump) \
79 _(LISP_MAP_SERVER_DUMP, lisp_map_server_dump) \
80 _(LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump) \
81 _(LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump) \
82 _(LISP_ADJACENCIES_GET, lisp_adjacencies_get) \
83 _(SHOW_LISP_RLOC_PROBE_STATE, show_lisp_rloc_probe_state) \
84 _(SHOW_LISP_MAP_REGISTER_STATE, show_lisp_map_register_state) \
85 _(SHOW_LISP_STATUS, show_lisp_status) \
86 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, \
87  lisp_add_del_map_request_itr_rlocs) \
88 _(LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs) \
89 _(SHOW_LISP_PITR, show_lisp_pitr) \
90 _(SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode) \
91 _(LISP_USE_PETR, lisp_use_petr) \
92 _(SHOW_LISP_USE_PETR, show_lisp_use_petr) \
93 
94 static locator_t *
96 {
97  u32 i;
98  locator_t *locs = 0, loc;
100 
101  for (i = 0; i < rloc_num; i++)
102  {
103  /* remote locators */
104  r = &rmt_locs[i];
105  memset (&loc, 0, sizeof (loc));
106  gid_address_ip_set (&loc.address, &r->addr, r->is_ip4 ? IP4 : IP6);
107 
108  loc.priority = r->priority;
109  loc.weight = r->weight;
110 
111  vec_add1 (locs, loc);
112  }
113  return locs;
114 }
115 
116 static void
118  mp)
119 {
121  int rv = 0;
123  locator_t locator;
124  vl_api_local_locator_t *ls_loc;
125  u32 ls_index = ~0, locator_num;
126  u8 *locator_name = NULL;
127  int i;
128 
129  memset (a, 0, sizeof (a[0]));
130 
131  locator_name = format (0, "%s", mp->locator_set_name);
132 
133  a->name = locator_name;
134  a->is_add = mp->is_add;
135  a->local = 1;
136  locator_num = clib_net_to_host_u32 (mp->locator_num);
137 
138  memset (&locator, 0, sizeof (locator));
139  for (i = 0; i < locator_num; i++)
140  {
141  ls_loc = &mp->locators[i];
142  VALIDATE_SW_IF_INDEX (ls_loc);
143 
144  locator.sw_if_index = htonl (ls_loc->sw_if_index);
145  locator.priority = ls_loc->priority;
146  locator.weight = ls_loc->weight;
147  locator.local = 1;
148  vec_add1 (a->locators, locator);
149  }
150 
151  rv = vnet_lisp_add_del_locator_set (a, &ls_index);
152 
154 
155  vec_free (locator_name);
156  vec_free (a->locators);
157 
158  /* *INDENT-OFF* */
159  REPLY_MACRO2 (VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY,
160  ({
161  rmp->ls_index = clib_host_to_net_u32 (ls_index);
162  }));
163  /* *INDENT-ON* */
164 }
165 
166 static void
168 {
170  int rv = 0;
171  locator_t locator, *locators = NULL;
173  u32 ls_index = ~0;
174  u8 *locator_name = NULL;
175 
176  memset (&locator, 0, sizeof (locator));
177  memset (a, 0, sizeof (a[0]));
178 
179  locator.sw_if_index = ntohl (mp->sw_if_index);
180  locator.priority = mp->priority;
181  locator.weight = mp->weight;
182  locator.local = 1;
183  vec_add1 (locators, locator);
184 
185  locator_name = format (0, "%s", mp->locator_set_name);
186 
187  a->name = locator_name;
188  a->locators = locators;
189  a->is_add = mp->is_add;
190  a->local = 1;
191 
192  rv = vnet_lisp_add_del_locator (a, NULL, &ls_index);
193 
194  vec_free (locators);
195  vec_free (locator_name);
196 
197  REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCATOR_REPLY);
198 }
199 
200 static int
201 unformat_lisp_eid_api (gid_address_t * dst, u32 vni, u8 type, void *src,
202  u8 len)
203 {
204  switch (type)
205  {
206  case 0: /* ipv4 */
208  gid_address_ip_set (dst, src, IP4);
209  gid_address_ippref_len (dst) = len;
211  break;
212  case 1: /* ipv6 */
214  gid_address_ip_set (dst, src, IP6);
215  gid_address_ippref_len (dst) = len;
217  break;
218  case 2: /* l2 mac */
220  clib_memcpy (&gid_address_mac (dst), src, 6);
221  break;
222  default:
223  /* unknown type */
224  return VNET_API_ERROR_INVALID_VALUE;
225  }
226 
227  gid_address_vni (dst) = vni;
228 
229  return 0;
230 }
231 
232 static void
234 {
237  int rv = 0;
238  gid_address_t _eid, *eid = &_eid;
239  uword *p = NULL;
240  u32 locator_set_index = ~0, map_index = ~0;
242  u8 *name = NULL, *key = NULL;
243  memset (a, 0, sizeof (a[0]));
244  memset (eid, 0, sizeof (eid[0]));
245 
246  rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
247  mp->eid_type, mp->eid, mp->prefix_len);
248  if (rv)
249  goto out;
250 
251  name = format (0, "%s", mp->locator_set_name);
252  p = hash_get_mem (lcm->locator_set_index_by_name, name);
253  if (!p)
254  {
255  rv = VNET_API_ERROR_INVALID_VALUE;
256  goto out;
257  }
258  locator_set_index = p[0];
259 
260  if (*mp->key)
261  key = format (0, "%s", mp->key);
262 
263  /* XXX treat batch configuration */
264  a->is_add = mp->is_add;
265  gid_address_copy (&a->eid, eid);
266  a->locator_set_index = locator_set_index;
267  a->local = 1;
268  a->key = key;
269  a->key_id = clib_net_to_host_u16 (mp->key_id);
270 
271  rv = vnet_lisp_add_del_local_mapping (a, &map_index);
272 
273 out:
274  vec_free (name);
275  vec_free (key);
276  gid_address_free (&a->eid);
277 
278  REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCAL_EID_REPLY);
279 }
280 
281 static void
284 {
286  int rv = 0;
287  rv = vnet_lisp_eid_table_map (clib_net_to_host_u32 (mp->vni),
288  clib_net_to_host_u32 (mp->dp_table),
289  mp->is_l2, mp->is_add);
290 REPLY_MACRO (VL_API_LISP_EID_TABLE_ADD_DEL_MAP_REPLY)}
291 
292 static void
294  * mp)
295 {
297  int rv = 0;
298  ip_address_t addr;
299 
300  memset (&addr, 0, sizeof (addr));
301 
302  ip_address_set (&addr, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
303  rv = vnet_lisp_add_del_map_server (&addr, mp->is_add);
304 
305  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_SERVER_REPLY);
306 }
307 
308 static void
310  * mp)
311 {
313  int rv = 0;
315 
316  memset (a, 0, sizeof (a[0]));
317 
318  a->is_add = mp->is_add;
319  ip_address_set (&a->address, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
320 
322 
323  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_RESOLVER_REPLY);
324 }
325 
326 static void
329 {
331  int rv = 0;
332 
334  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
335 }
336 
337 static void
340 {
342  int rv = 0;
343 
345  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
346 }
347 
348 static void
350 {
352  int rv = 0;
353 
355  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
356 }
357 
358 static void
361 {
362  int rv = 0;
364 
365  /* *INDENT-OFF* */
366  REPLY_MACRO2(VL_API_SHOW_LISP_MAP_REQUEST_MODE_REPLY,
367  ({
369  }));
370  /* *INDENT-ON* */
371 }
372 
373 static void
375 {
377  int rv = 0;
378 
380 
381  REPLY_MACRO (VL_API_LISP_MAP_REQUEST_MODE_REPLY);
382 }
383 
384 static void
386  * mp)
387 {
389  int rv = 0;
390  u8 *ls_name = 0;
391 
392  ls_name = format (0, "%s", mp->ls_name);
393  rv = vnet_lisp_pitr_set_locator_set (ls_name, mp->is_add);
394  vec_free (ls_name);
395 
396  REPLY_MACRO (VL_API_LISP_PITR_SET_LOCATOR_SET_REPLY);
397 }
398 
399 static void
401 {
403  int rv = 0;
404  ip_address_t addr;
405 
406  ip_address_set (&addr, &mp->address, mp->is_ip4 ? IP4 : IP6);
407  rv = vnet_lisp_use_petr (&addr, mp->is_add);
408 
409  REPLY_MACRO (VL_API_LISP_USE_PETR_REPLY);
410 }
411 
412 static void
414 {
418  mapping_t *m;
419  locator_set_t *ls = 0;
420  int rv = 0;
421  locator_t *loc = 0;
422  u8 status = 0;
424 
426  if (q == 0)
427  {
428  return;
429  }
430 
431  memset (&addr, 0, sizeof (addr));
432  status = lcm->flags & LISP_FLAG_USE_PETR;
433  if (status)
434  {
436  if (~0 != m->locator_set_index)
437  {
438  ls =
440  loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
441  gid_address_copy (&addr, &loc->address);
442  }
443  }
444 
445  /* *INDENT-OFF* */
446  REPLY_MACRO2 (VL_API_SHOW_LISP_USE_PETR_REPLY,
447  {
448  rmp->status = status;
449  ip_address_t *ip = &gid_address_ip (&addr);
450  switch (ip_addr_version (ip))
451  {
452  case IP4:
453  clib_memcpy (rmp->address, &ip_addr_v4 (ip),
454  sizeof (ip_addr_v4 (ip)));
455  break;
456 
457  case IP6:
458  clib_memcpy (rmp->address, &ip_addr_v6 (ip),
459  sizeof (ip_addr_v6 (ip)));
460  break;
461 
462  default:
463  ASSERT (0);
464  }
465  rmp->is_ip4 = (gid_address_ip_version (&addr) == IP4);
466  });
467  /* *INDENT-ON* */
468 }
469 
470 static void
473 {
475  int rv = 0;
476  u8 *locator_set_name = NULL;
478 
479  locator_set_name = format (0, "%s", mp->locator_set_name);
480 
481  a->is_add = mp->is_add;
482  a->locator_set_name = locator_set_name;
483 
485 
486  vec_free (locator_set_name);
487 
488  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY);
489 }
490 
491 static void
494 {
495  locator_t *rlocs = 0;
497  int rv = 0;
498  gid_address_t _eid, *eid = &_eid;
499  u32 rloc_num = clib_net_to_host_u32 (mp->rloc_num);
500 
501  memset (eid, 0, sizeof (eid[0]));
502 
503  rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
504  mp->eid_type, mp->eid, mp->eid_len);
505  if (rv)
506  goto send_reply;
507 
508  rlocs = unformat_lisp_locs (mp->rlocs, rloc_num);
509 
510  if (!mp->is_add)
511  {
513  gid_address_copy (&a->reid, eid);
514  a->is_add = 0;
516  if (rv)
517  {
518  goto out;
519  }
520  }
521 
522  /* NOTE: for now this works as a static remote mapping, i.e.,
523  * not authoritative and ttl infinite. */
524  rv = vnet_lisp_add_del_mapping (eid, rlocs, mp->action, 0, ~0,
525  mp->is_add, 1 /* is_static */ , 0);
526 
527  if (mp->del_all)
529 
530 out:
531  vec_free (rlocs);
532 send_reply:
533  REPLY_MACRO (VL_API_LISP_ADD_DEL_REMOTE_MAPPING_REPLY);
534 }
535 
536 static void
538 {
541 
542  int rv = 0;
543  memset (a, 0, sizeof (a[0]));
544 
545  rv = unformat_lisp_eid_api (&a->leid, clib_net_to_host_u32 (mp->vni),
546  mp->eid_type, mp->leid, mp->leid_len);
547  rv |= unformat_lisp_eid_api (&a->reid, clib_net_to_host_u32 (mp->vni),
548  mp->eid_type, mp->reid, mp->reid_len);
549 
550  if (rv)
551  goto send_reply;
552 
553  a->is_add = mp->is_add;
555 
556 send_reply:
557  REPLY_MACRO (VL_API_LISP_ADD_DEL_ADJACENCY_REPLY);
558 }
559 
560 static void
562  locator_t * loc,
563  unix_shared_memory_queue_t * q, u32 context)
564 {
566 
567  rmp = vl_msg_api_alloc (sizeof (*rmp));
568  memset (rmp, 0, sizeof (*rmp));
569  rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_DETAILS);
570  rmp->context = context;
571 
572  rmp->local = loc->local;
573  if (loc->local)
574  {
575  rmp->sw_if_index = ntohl (loc->sw_if_index);
576  }
577  else
578  {
579  rmp->is_ipv6 = gid_address_ip_version (&loc->address);
581  }
582  rmp->priority = loc->priority;
583  rmp->weight = loc->weight;
584 
585  vl_msg_api_send_shmem (q, (u8 *) & rmp);
586 }
587 
588 static void
590 {
591  u8 *ls_name = 0;
594  locator_set_t *lsit = 0;
595  locator_t *loc = 0;
596  u32 ls_index = ~0, *locit = 0;
597  uword *p = 0;
598 
600  if (q == 0)
601  {
602  return;
603  }
604 
605  if (mp->is_index_set)
606  ls_index = htonl (mp->ls_index);
607  else
608  {
609  /* make sure we get a proper C-string */
610  mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
611  ls_name = format (0, "%s", mp->ls_name);
612  p = hash_get_mem (lcm->locator_set_index_by_name, ls_name);
613  if (!p)
614  goto out;
615  ls_index = p[0];
616  }
617 
618  if (pool_is_free_index (lcm->locator_set_pool, ls_index))
619  return;
620 
621  lsit = pool_elt_at_index (lcm->locator_set_pool, ls_index);
622 
623  vec_foreach (locit, lsit->locator_indices)
624  {
625  loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
626  send_lisp_locator_details (lcm, loc, q, mp->context);
627  };
628 out:
629  vec_free (ls_name);
630 }
631 
632 static void
634  locator_set_t * lsit,
636  u32 context, u32 ls_index)
637 {
639  u8 *str = 0;
640 
641  rmp = vl_msg_api_alloc (sizeof (*rmp));
642  memset (rmp, 0, sizeof (*rmp));
643  rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_SET_DETAILS);
644  rmp->context = context;
645 
646  rmp->ls_index = htonl (ls_index);
647  if (lsit->local)
648  {
649  ASSERT (lsit->name != NULL);
650  strncpy ((char *) rmp->ls_name, (char *) lsit->name,
651  vec_len (lsit->name));
652  }
653  else
654  {
655  str = format (0, "<remote-%d>", ls_index);
656  strncpy ((char *) rmp->ls_name, (char *) str, vec_len (str));
657  vec_free (str);
658  }
659 
660  vl_msg_api_send_shmem (q, (u8 *) & rmp);
661 }
662 
663 static void
665 {
668  locator_set_t *lsit = NULL;
669  u8 filter;
670 
672  if (q == 0)
673  {
674  return;
675  }
676 
677  filter = mp->filter;
678  /* *INDENT-OFF* */
679  pool_foreach (lsit, lcm->locator_set_pool,
680  ({
681  if (filter && !((1 == filter && lsit->local) ||
682  (2 == filter && !lsit->local)))
683  {
684  continue;
685  }
686  send_lisp_locator_set_details (lcm, lsit, q, mp->context,
687  lsit - lcm->locator_set_pool);
688  }));
689  /* *INDENT-ON* */
690 }
691 
692 static void
693 lisp_fid_put_api (u8 * dst, fid_address_t * src, u8 * prefix_length)
694 {
695  ASSERT (prefix_length);
696  ip_prefix_t *ippref = &fid_addr_ippref (src);
697 
698  switch (fid_addr_type (src))
699  {
700  case FID_ADDR_IP_PREF:
701  if (ip_prefix_version (ippref) == IP4)
702  clib_memcpy (dst, &ip_prefix_v4 (ippref), 4);
703  else
704  clib_memcpy (dst, &ip_prefix_v6 (ippref), 16);
705  prefix_length[0] = ip_prefix_len (ippref);
706  break;
707 
708  case FID_ADDR_MAC:
709  prefix_length[0] = 0;
710  clib_memcpy (dst, fid_addr_mac (src), 6);
711  break;
712 
713  default:
714  clib_warning ("Unknown FID type %d!", fid_addr_type (src));
715  break;
716  }
717 }
718 
719 static u8
721 {
722  ip_prefix_t *ippref;
723 
724  switch (fid_addr_type (fid))
725  {
726  case FID_ADDR_IP_PREF:
727  ippref = &fid_addr_ippref (fid);
728  if (ip_prefix_version (ippref) == IP4)
729  return 0;
730  else if (ip_prefix_version (ippref) == IP6)
731  return 1;
732  else
733  return ~0;
734 
735  case FID_ADDR_MAC:
736  return 2;
737  case FID_ADDR_NSH:
738  return 3;
739  }
740 
741  return ~0;
742 }
743 
744 static void
747  u32 context, u8 filter)
748 {
749  fid_address_t *fid;
751  locator_set_t *ls = 0;
753  gid_address_t *gid = NULL;
754  u8 *mac = 0;
755  ip_prefix_t *ip_prefix = NULL;
756 
757  switch (filter)
758  {
759  case 0: /* all mappings */
760  break;
761 
762  case 1: /* local only */
763  if (!mapit->local)
764  return;
765  break;
766  case 2: /* remote only */
767  if (mapit->local)
768  return;
769  break;
770  default:
771  clib_warning ("Filter error, unknown filter: %d", filter);
772  return;
773  }
774 
775  /* don't send PITR generated mapping */
776  if (mapit->pitr_set)
777  return;
778 
779  gid = &mapit->eid;
780  ip_prefix = &gid_address_ippref (gid);
781  mac = gid_address_mac (gid);
782 
783  rmp = vl_msg_api_alloc (sizeof (*rmp));
784  memset (rmp, 0, sizeof (*rmp));
785  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_DETAILS);
786 
788  if (vec_len (ls->locator_indices) == 0)
789  rmp->locator_set_index = ~0;
790  else
791  rmp->locator_set_index = clib_host_to_net_u32 (mapit->locator_set_index);
792 
793  rmp->is_local = mapit->local;
794  rmp->ttl = clib_host_to_net_u32 (mapit->ttl);
795  rmp->action = mapit->action;
796  rmp->authoritative = mapit->authoritative;
797 
798  switch (gid_address_type (gid))
799  {
800  case GID_ADDR_SRC_DST:
801  rmp->is_src_dst = 1;
802  fid = &gid_address_sd_src (gid);
803  rmp->eid_type = fid_type_to_api_type (fid);
805  &rmp->seid_prefix_len);
807  &rmp->eid_prefix_len);
808  break;
809  case GID_ADDR_IP_PREFIX:
810  rmp->eid_prefix_len = ip_prefix_len (ip_prefix);
811  if (ip_prefix_version (ip_prefix) == IP4)
812  {
813  rmp->eid_type = 0; /* ipv4 type */
814  clib_memcpy (rmp->eid, &ip_prefix_v4 (ip_prefix),
815  sizeof (ip_prefix_v4 (ip_prefix)));
816  }
817  else
818  {
819  rmp->eid_type = 1; /* ipv6 type */
820  clib_memcpy (rmp->eid, &ip_prefix_v6 (ip_prefix),
821  sizeof (ip_prefix_v6 (ip_prefix)));
822  }
823  break;
824  case GID_ADDR_MAC:
825  rmp->eid_type = 2; /* l2 mac type */
826  clib_memcpy (rmp->eid, mac, 6);
827  break;
828  default:
829  ASSERT (0);
830  }
831  rmp->context = context;
832  rmp->vni = clib_host_to_net_u32 (gid_address_vni (gid));
833  rmp->key_id = clib_host_to_net_u16 (mapit->key_id);
834  memcpy (rmp->key, mapit->key, vec_len (mapit->key));
835  vl_msg_api_send_shmem (q, (u8 *) & rmp);
836 }
837 
838 static void
840 {
841  u32 mi;
844  mapping_t *mapit = NULL;
845  gid_address_t _eid, *eid = &_eid;
846 
848  if (q == 0)
849  {
850  return;
851  }
852 
853  if (mp->eid_set)
854  {
855  memset (eid, 0, sizeof (*eid));
856 
857  unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
858  mp->eid_type, mp->eid, mp->prefix_length);
859 
861  if ((u32) ~ 0 == mi)
862  return;
863 
864  mapit = pool_elt_at_index (lcm->mapping_pool, mi);
865  send_lisp_eid_table_details (mapit, q, mp->context,
866  0 /* ignore filter */ );
867  }
868  else
869  {
870  /* *INDENT-OFF* */
871  pool_foreach (mapit, lcm->mapping_pool,
872  ({
873  send_lisp_eid_table_details(mapit, q, mp->context,
874  mp->filter);
875  }));
876  /* *INDENT-ON* */
877  }
878 }
879 
880 static void
881 send_lisp_map_server_details (ip_address_t * ip,
882  unix_shared_memory_queue_t * q, u32 context)
883 {
885 
886  rmp = vl_msg_api_alloc (sizeof (*rmp));
887  memset (rmp, 0, sizeof (*rmp));
888  rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_SERVER_DETAILS);
889 
890  switch (ip_addr_version (ip))
891  {
892  case IP4:
893  rmp->is_ipv6 = 0;
894  clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
895  sizeof (ip_addr_v4 (ip)));
896  break;
897 
898  case IP6:
899  rmp->is_ipv6 = 1;
900  clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
901  sizeof (ip_addr_v6 (ip)));
902  break;
903 
904  default:
905  ASSERT (0);
906  }
907  rmp->context = context;
908 
909  vl_msg_api_send_shmem (q, (u8 *) & rmp);
910 }
911 
912 static void
914 {
917  lisp_msmr_t *mr;
918 
920  if (q == 0)
921  {
922  return;
923  }
924 
925  vec_foreach (mr, lcm->map_servers)
926  {
928  }
929 }
930 
931 static void
933  unix_shared_memory_queue_t * q, u32 context)
934 {
936 
937  rmp = vl_msg_api_alloc (sizeof (*rmp));
938  memset (rmp, 0, sizeof (*rmp));
939  rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_RESOLVER_DETAILS);
940 
941  switch (ip_addr_version (ip))
942  {
943  case IP4:
944  rmp->is_ipv6 = 0;
945  clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
946  sizeof (ip_addr_v4 (ip)));
947  break;
948 
949  case IP6:
950  rmp->is_ipv6 = 1;
951  clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
952  sizeof (ip_addr_v6 (ip)));
953  break;
954 
955  default:
956  ASSERT (0);
957  }
958  rmp->context = context;
959 
960  vl_msg_api_send_shmem (q, (u8 *) & rmp);
961 }
962 
963 static void
965 {
968  lisp_msmr_t *mr;
969 
971  if (q == 0)
972  {
973  return;
974  }
975 
976  vec_foreach (mr, lcm->map_resolvers)
977  {
979  }
980 }
981 
982 static void
984  unix_shared_memory_queue_t * q, u32 context)
985 {
987 
988  rmp = vl_msg_api_alloc (sizeof (*rmp));
989  memset (rmp, 0, sizeof (*rmp));
990  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_MAP_DETAILS);
991 
992  rmp->vni = clib_host_to_net_u32 (p->key);
993  rmp->dp_table = clib_host_to_net_u32 (p->value[0]);
994  rmp->context = context;
995  vl_msg_api_send_shmem (q, (u8 *) & rmp);
996 }
997 
998 static void
1000  mp)
1001 {
1004  hash_pair_t *p;
1005  uword *vni_table = 0;
1006 
1008  if (q == 0)
1009  {
1010  return;
1011  }
1012 
1013  if (mp->is_l2)
1014  {
1015  vni_table = lcm->bd_id_by_vni;
1016  }
1017  else
1018  {
1019  vni_table = lcm->table_id_by_vni;
1020  }
1021 
1022  /* *INDENT-OFF* */
1023  hash_foreach_pair (p, vni_table,
1024  ({
1025  send_eid_table_map_pair (p, q, mp->context);
1026  }));
1027  /* *INDENT-ON* */
1028 }
1029 
1030 static void
1032 {
1034 
1035  rmp = vl_msg_api_alloc (sizeof (*rmp));
1036  memset (rmp, 0, sizeof (*rmp));
1037  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_VNI_DETAILS);
1038  rmp->context = context;
1039  rmp->vni = clib_host_to_net_u32 (vni);
1040  vl_msg_api_send_shmem (q, (u8 *) & rmp);
1041 }
1042 
1043 static void
1045 {
1046  lisp_adjacency_t *adj;
1048  u32 i, n = vec_len (adjs);
1049 
1050  for (i = 0; i < n; i++)
1051  {
1052  adj = vec_elt_at_index (adjs, i);
1053  memset (&a, 0, sizeof (a));
1054 
1055  switch (gid_address_type (&adj->reid))
1056  {
1057  case GID_ADDR_IP_PREFIX:
1060  if (gid_address_ip_version (&adj->reid) == IP4)
1061  {
1062  a.eid_type = 0; /* ipv4 type */
1063  clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 4);
1064  clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 4);
1065  }
1066  else
1067  {
1068  a.eid_type = 1; /* ipv6 type */
1069  clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 16);
1070  clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 16);
1071  }
1072  break;
1073  case GID_ADDR_MAC:
1074  a.eid_type = 2; /* l2 mac type */
1075  mac_copy (a.reid, gid_address_mac (&adj->reid));
1076  mac_copy (a.leid, gid_address_mac (&adj->leid));
1077  break;
1078  default:
1079  ASSERT (0);
1080  }
1081  dst[i] = a;
1082  }
1083 }
1084 
1085 static void
1088 {
1090  int rv = 0;
1091 
1092  /* *INDENT-OFF* */
1093  REPLY_MACRO2 (VL_API_SHOW_LISP_RLOC_PROBE_STATE_REPLY,
1094  {
1096  });
1097  /* *INDENT-ON* */
1098 }
1099 
1100 static void
1103 {
1105  int rv = 0;
1106 
1107  /* *INDENT-OFF* */
1108  REPLY_MACRO2 (VL_API_SHOW_LISP_MAP_REGISTER_STATE_REPLY,
1109  {
1111  });
1112  /* *INDENT-ON* */
1113 }
1114 
1115 static void
1117 {
1119  lisp_adjacency_t *adjs = 0;
1120  int rv = 0;
1121  u32 size = ~0;
1122  u32 vni = clib_net_to_host_u32 (mp->vni);
1123 
1124  adjs = vnet_lisp_adjacencies_get_by_vni (vni);
1125  size = vec_len (adjs) * sizeof (vl_api_lisp_adjacency_t);
1126 
1127  /* *INDENT-OFF* */
1128  REPLY_MACRO4 (VL_API_LISP_ADJACENCIES_GET_REPLY, size,
1129  {
1130  rmp->count = clib_host_to_net_u32 (vec_len (adjs));
1131  lisp_adjacency_copy (rmp->adjacencies, adjs);
1132  });
1133  /* *INDENT-ON* */
1134 
1135  vec_free (adjs);
1136 }
1137 
1138 static void
1140  mp)
1141 {
1142  hash_pair_t *p;
1143  u32 *vnis = 0;
1146 
1148  if (q == 0)
1149  {
1150  return;
1151  }
1152 
1153  /* *INDENT-OFF* */
1155  ({
1156  hash_set (vnis, p->key, 0);
1157  }));
1158 
1160  ({
1161  hash_set (vnis, p->key, 0);
1162  }));
1163 
1164  hash_foreach_pair (p, vnis,
1165  ({
1166  send_eid_table_vni (p->key, q, mp->context);
1167  }));
1168  /* *INDENT-ON* */
1169 
1170  hash_free (vnis);
1171 }
1172 
1173 static void
1175 {
1178  int rv = 0;
1179 
1181  if (q == 0)
1182  {
1183  return;
1184  }
1185 
1186  /* *INDENT-OFF* */
1187  REPLY_MACRO2(VL_API_SHOW_LISP_STATUS_REPLY,
1188  ({
1191  }));
1192  /* *INDENT-ON* */
1193 }
1194 
1195 static void
1198 {
1202  locator_set_t *loc_set = 0;
1203  u8 *tmp_str = 0;
1204  int rv = 0;
1205 
1207  if (q == 0)
1208  {
1209  return;
1210  }
1211 
1212  if (~0 == lcm->mreq_itr_rlocs)
1213  {
1214  tmp_str = format (0, " ");
1215  }
1216  else
1217  {
1218  loc_set =
1220  tmp_str = format (0, "%s", loc_set->name);
1221  }
1222 
1223  /* *INDENT-OFF* */
1224  REPLY_MACRO2(VL_API_LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY,
1225  ({
1226  strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1227  ARRAY_LEN(rmp->locator_set_name) - 1);
1228  }));
1229  /* *INDENT-ON* */
1230 
1231  vec_free (tmp_str);
1232 }
1233 
1234 static void
1236 {
1240  mapping_t *m;
1241  locator_set_t *ls = 0;
1242  u8 *tmp_str = 0;
1243  int rv = 0;
1244 
1246  if (q == 0)
1247  {
1248  return;
1249  }
1250 
1251  if (!lcm->lisp_pitr)
1252  {
1253  tmp_str = format (0, "N/A");
1254  }
1255  else
1256  {
1258  if (~0 != m->locator_set_index)
1259  {
1260  ls =
1262  tmp_str = format (0, "%s", ls->name);
1263  }
1264  else
1265  {
1266  tmp_str = format (0, "N/A");
1267  }
1268  }
1269  vec_add1 (tmp_str, 0);
1270 
1271  /* *INDENT-OFF* */
1272  REPLY_MACRO2(VL_API_SHOW_LISP_PITR_REPLY,
1273  ({
1274  rmp->status = lcm->lisp_pitr;
1275  strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1276  ARRAY_LEN(rmp->locator_set_name) - 1);
1277  }));
1278  /* *INDENT-ON* */
1279 }
1280 
1281 /*
1282  * lisp_api_hookup
1283  * Add vpe's API message handlers to the table.
1284  * vlib has alread mapped shared memory and
1285  * added the client registration handlers.
1286  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1287  */
1288 #define vl_msg_name_crc_list
1289 #include <vnet/vnet_all_api_h.h>
1290 #undef vl_msg_name_crc_list
1291 
1292 static void
1294 {
1295 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1296  foreach_vl_msg_name_crc_lisp;
1297 #undef _
1298 }
1299 
1300 static clib_error_t *
1302 {
1303  api_main_t *am = &api_main;
1304 
1305 #define _(N,n) \
1306  vl_msg_api_set_handlers(VL_API_##N, #n, \
1307  vl_api_##n##_t_handler, \
1308  vl_noop_handler, \
1309  vl_api_##n##_t_endian, \
1310  vl_api_##n##_t_print, \
1311  sizeof(vl_api_##n##_t), 1);
1313 #undef _
1314 
1315  /*
1316  * Set up the (msg_name, crc, message-id) table
1317  */
1319 
1320  return 0;
1321 }
1322 
1324 
1325 /*
1326  * fd.io coding-style-patch-verification: ON
1327  *
1328  * Local Variables:
1329  * eval: (c-set-style "gnu")
1330  * End:
1331  */
#define ip_prefix_v4(_a)
Definition: lisp_types.h:74
Reply for show_lisp_map_register_state.
Definition: lisp.api:354
vl_api_local_locator_t locators[locator_num]
Definition: lisp.api:38
#define gid_address_ip_version(_a)
Definition: lisp_types.h:245
u32 pitr_map_index
Definition: control.h:194
gid_address_t leid
Definition: control.h:63
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
LISP locator_set status.
Definition: lisp.api:571
enable/disable LISP RLOC probing
Definition: lisp.api:301
#define gid_address_type(_a)
Definition: lisp_types.h:241
static u8 fid_type_to_api_type(fid_address_t *fid)
Definition: lisp_api.c:720
a
Definition: bitmap.h:516
u8 vnet_lisp_gpe_enable_disable_status(void)
Check if LISP-GPE is enabled.
Definition: lisp_gpe.c:181
void vl_msg_api_send_shmem(unix_shared_memory_queue_t *q, u8 *elem)
static void vl_api_lisp_get_map_request_itr_rlocs_t_handler(vl_api_lisp_get_map_request_itr_rlocs_t *mp)
Definition: lisp_api.c:1197
lisp_msmr_t * map_resolvers
Definition: control.h:166
VLIB_API_INIT_FUNCTION(lisp_api_hookup)
configure or disable LISP PITR node
Definition: lisp.api:205
Reply for locator_set add/del.
Definition: lisp.api:46
#define REPLY_MACRO4(t, n, body)
LISP map resolver status.
Definition: lisp.api:778
vl_api_lisp_adjacency_t adjacencies[count]
Definition: lisp.api:714
uword * table_id_by_vni
Definition: control.h:183
#define REPLY_MACRO2(t, body)
#define NULL
Definition: clib.h:55
static void lisp_adjacency_copy(vl_api_lisp_adjacency_t *dst, lisp_adjacency_t *adjs)
Definition: lisp_api.c:1044
locator_t * locator_pool
Definition: control.h:132
u8 vnet_lisp_get_map_request_mode(void)
Definition: control.c:55
#define ip_prefix_len(_a)
Definition: lisp_types.h:73
static void vl_api_lisp_add_del_map_server_t_handler(vl_api_lisp_add_del_map_server_t *mp)
Definition: lisp_api.c:293
Reply for lisp_add_del_map_request_itr_rlocs.
Definition: lisp.api:515
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
LISP locator_set status.
Definition: lisp.api:587
unix_shared_memory_queue_t * vl_api_client_index_to_input_queue(u32 index)
Request for lisp_eid_table_map_details.
Definition: lisp.api:745
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
configure or disable use of PETR
Definition: lisp.api:230
static void vl_api_lisp_pitr_set_locator_set_t_handler(vl_api_lisp_pitr_set_locator_set_t *mp)
Definition: lisp_api.c:385
Request for LISP PETR status.
Definition: lisp.api:253
static void vl_api_lisp_eid_table_add_del_map_t_handler(vl_api_lisp_eid_table_add_del_map_t *mp)
Definition: lisp_api.c:283
static void vl_api_lisp_add_del_locator_set_t_handler(vl_api_lisp_add_del_locator_set_t *mp)
Definition: lisp_api.c:117
ip_address_t address
Definition: control.h:78
static void vl_api_lisp_locator_dump_t_handler(vl_api_lisp_locator_dump_t *mp)
Definition: lisp_api.c:589
void ip_address_set(ip_address_t *dst, const void *src, u8 version)
Definition: lisp_types.c:843
Reply for locator add/del.
Definition: lisp.api:77
#define ip_prefix_version(_a)
Definition: lisp_types.h:72
LISP adjacency.
Definition: lisp.api:696
#define fid_addr_mac(_a)
Definition: lisp_types.h:131
u8 vnet_lisp_map_register_state_get(void)
Definition: control.c:420
int vnet_lisp_set_map_request_mode(u8 mode)
Definition: control.c:1265
Reply for show_lisp_map_request_mode.
Definition: lisp.api:401
int vnet_lisp_add_del_adjacency(vnet_lisp_add_del_adjacency_args_t *a)
Adds adjacency or removes forwarding entry associated to remote mapping.
Definition: control.c:1219
Request for map resolver summary status.
Definition: lisp.api:789
static void vl_api_lisp_map_register_enable_disable_t_handler(vl_api_lisp_map_register_enable_disable_t *mp)
Definition: lisp_api.c:328
uword value[0]
Definition: hash.h:164
static void send_lisp_map_server_details(ip_address_t *ip, unix_shared_memory_queue_t *q, u32 context)
Definition: lisp_api.c:881
api_main_t api_main
Definition: api_shared.c:35
lisp_msmr_t * map_servers
Definition: control.h:169
add or delete LISP adjacency adjacency
Definition: lisp.api:473
#define foreach_vpe_api_msg
Definition: lisp_api.c:61
static void send_eid_table_vni(u32 vni, unix_shared_memory_queue_t *q, u32 context)
Definition: lisp_api.c:1031
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:376
static void vl_api_lisp_rloc_probe_enable_disable_t_handler(vl_api_lisp_rloc_probe_enable_disable_t *mp)
Definition: lisp_api.c:339
static void vl_api_lisp_add_del_remote_mapping_t_handler(vl_api_lisp_add_del_remote_mapping_t *mp)
Definition: lisp_api.c:493
u8 * key
Definition: lisp_types.h:341
#define gid_address_sd_src(_a)
Definition: lisp_types.h:256
static void vl_api_show_lisp_map_register_state_t_handler(vl_api_show_lisp_map_register_state_t *mp)
Definition: lisp_api.c:1102
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
static void vl_api_lisp_adjacencies_get_t_handler(vl_api_lisp_adjacencies_get_t *mp)
Definition: lisp_api.c:1116
Get LISP map request itr rlocs status.
Definition: lisp.api:843
Reply for show_lisp_rloc_probe_state.
Definition: lisp.api:289
add or delete map request itr rlocs
Definition: lisp.api:502
int vnet_lisp_eid_table_map(u32 vni, u32 dp_id, u8 is_l2, u8 is_add)
Definition: control.c:832
uword * bd_id_by_vni
Definition: control.h:187
#define ip_addr_v4(_a)
Definition: lisp_types.h:54
static lisp_cp_main_t * vnet_lisp_cp_get_main()
Definition: control.h:231
u32 petr_map_index
Proxy ETR map index.
Definition: control.h:197
#define ip_addr_version(_a)
Definition: lisp_types.h:56
static void vl_api_lisp_use_petr_t_handler(vl_api_lisp_use_petr_t *mp)
Definition: lisp_api.c:400
Reply for lisp_add_del_map_server.
Definition: lisp.api:145
clib_error_t * vnet_lisp_enable_disable(u8 is_enable)
Definition: control.c:1745
static void vl_api_show_lisp_pitr_t_handler(vl_api_show_lisp_pitr_t *mp)
Definition: lisp_api.c:1235
Get state of LISP map-register.
Definition: lisp.api:344
Reply for gpe enable/disable.
Definition: lisp.api:193
u32 gid_dictionary_lookup(gid_dictionary_t *db, gid_address_t *key)
Get state of LISP RLOC probing.
Definition: lisp.api:278
void ip_address_copy_addr(void *dst, const ip_address_t *src)
Definition: lisp_types.c:837
Reply for lisp_pitr_set_locator_set.
Definition: lisp.api:217
int vnet_lisp_pitr_set_locator_set(u8 *locator_set_name, u8 is_add)
Definition: control.c:1286
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:397
u8 vnet_lisp_rloc_probe_state_get(void)
Definition: control.c:427
static void send_lisp_locator_set_details(lisp_cp_main_t *lcm, locator_set_t *lsit, unix_shared_memory_queue_t *q, u32 context, u32 ls_index)
Definition: lisp_api.c:633
#define gid_address_mac(_a)
Definition: lisp_types.h:247
set LISP map-request mode.
Definition: lisp.api:369
static void send_lisp_map_resolver_details(ip_address_t *ip, unix_shared_memory_queue_t *q, u32 context)
Definition: lisp_api.c:932
#define ip_prefix_v6(_a)
Definition: lisp_types.h:75
int vnet_lisp_add_del_local_mapping(vnet_lisp_add_del_mapping_args_t *a, u32 *map_index_result)
Add/update/delete mapping to/in/from map-cache.
Definition: control.c:798
Request for LISP adjacencies.
Definition: lisp.api:722
#define hash_free(h)
Definition: hash.h:286
void gid_address_free(gid_address_t *a)
Definition: lisp_types.c:785
static void send_lisp_locator_details(lisp_cp_main_t *lcm, locator_t *loc, unix_shared_memory_queue_t *q, u32 context)
Definition: lisp_api.c:561
u8 authoritative
Definition: lisp_types.h:333
add or delete lisp eid-table
Definition: lisp.api:101
LISP adjacency reply.
Definition: lisp.api:709
#define REPLY_MACRO(t)
static void vl_api_lisp_map_server_dump_t_handler(vl_api_lisp_map_server_dump_t *mp)
Definition: lisp_api.c:913
static void vl_api_lisp_add_del_adjacency_t_handler(vl_api_lisp_add_del_adjacency_t *mp)
Definition: lisp_api.c:537
int vnet_lisp_add_del_mapping(gid_address_t *eid, locator_t *rlocs, u8 action, u8 authoritative, u32 ttl, u8 is_add, u8 is_static, u32 *res_map_index)
Adds/removes/updates mapping.
Definition: control.c:1035
void ip_prefix_normalize(ip_prefix_t *a)
Definition: lisp_types.c:923
#define ip_addr_v6(_a)
Definition: lisp_types.h:55
#define gid_address_ippref(_a)
Definition: lisp_types.h:242
LISP PETR status, enable or disable.
Definition: lisp.api:265
lisp_adjacency_t * vnet_lisp_adjacencies_get_by_vni(u32 vni)
Returns vector of adjacencies.
Definition: control.c:598
Reply for lisp_add_del_adjacency.
Definition: lisp.api:490
Reply for lisp_map_request_mode.
Definition: lisp.api:380
#define BAD_SW_IF_INDEX_LABEL
u32 sw_if_index
Definition: lisp_types.h:294
Request for lisp-gpe protocol status.
Definition: lisp.api:820
void * vl_msg_api_alloc(int nbytes)
int vnet_lisp_add_del_mreq_itr_rlocs(vnet_lisp_add_del_mreq_itr_rloc_args_t *a)
Definition: control.c:1842
enable or disable LISP feature
Definition: lisp.api:182
Reply for lisp_add_del_remote_mapping.
Definition: lisp.api:455
vlib_main_t * vm
Definition: buffer.c:276
Shows relationship between vni and vrf/bd.
Definition: lisp.api:733
void gid_address_ip_set(gid_address_t *dst, void *src, u8 version)
Definition: lisp_types.c:1465
static void vl_api_show_lisp_status_t_handler(vl_api_show_lisp_status_t *mp)
Definition: lisp_api.c:1174
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:340
#define gid_address_ippref_len(_a)
Definition: lisp_types.h:243
#define clib_warning(format, args...)
Definition: error.h:59
u32 locator_set_index
Definition: lisp_types.h:326
#define clib_memcpy(a, b, c)
Definition: string.h:69
static void vl_api_lisp_locator_set_dump_t_handler(vl_api_lisp_locator_set_dump_t *mp)
Definition: lisp_api.c:664
int vnet_lisp_map_register_enable_disable(u8 is_enable)
Definition: control.c:1736
add or delete map-resolver
Definition: lisp.api:158
Reply for lisp_eid_table_add_del_map.
Definition: lisp.api:542
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:238
#define ARRAY_LEN(x)
Definition: clib.h:59
lisp_key_type_t key_id
Definition: lisp_types.h:342
Request for map lisp locator status.
Definition: lisp.api:555
Reply for local_eid add/del.
Definition: lisp.api:119
#define fid_addr_ippref(_a)
Definition: lisp_types.h:128
u8 vnet_lisp_enable_disable_status(void)
Definition: control.c:1787
static void send_lisp_eid_table_details(mapping_t *mapit, unix_shared_memory_queue_t *q, u32 context, u8 filter)
Definition: lisp_api.c:745
struct _gid_address_t gid_address_t
Dump lisp eid-table.
Definition: lisp.api:636
static clib_error_t * lisp_api_hookup(vlib_main_t *vm)
Definition: lisp_api.c:1301
int vnet_lisp_add_del_map_server(ip_address_t *addr, u8 is_add)
Definition: control.c:652
#define ASSERT(truth)
#define fid_addr_type(_a)
Definition: lisp_types.h:133
unsigned int u32
Definition: types.h:88
Request for eid table summary status.
Definition: lisp.api:674
enable/disable LISP map-register
Definition: lisp.api:323
int vnet_lisp_clear_all_remote_adjacencies(void)
Definition: control.c:1168
Request for locator_set summary status.
Definition: lisp.api:603
#define gid_address_sd_dst(_a)
Definition: lisp_types.h:257
static void vl_api_show_lisp_use_petr_t_handler(vl_api_show_lisp_use_petr_t *mp)
Definition: lisp_api.c:413
map/unmap vni/bd_index to vrf
Definition: lisp.api:528
gid_dictionary_t mapping_index_by_gid
Definition: control.h:123
u64 size
Definition: vhost-user.h:77
locator_set_t * locator_set_pool
Definition: control.h:135
Status of lisp pitr, enable or disable.
Definition: lisp.api:873
static void vl_api_lisp_map_resolver_dump_t_handler(vl_api_lisp_map_resolver_dump_t *mp)
Definition: lisp_api.c:964
int vnet_lisp_rloc_probe_enable_disable(u8 is_enable)
Definition: control.c:1727
add or delete locator_set
Definition: lisp.api:31
vl_api_remote_locator_t rlocs[rloc_num]
Definition: lisp.api:448
static void lisp_fid_put_api(u8 *dst, fid_address_t *src, u8 *prefix_length)
Definition: lisp_api.c:693
static void vl_api_lisp_add_del_map_request_itr_rlocs_t_handler(vl_api_lisp_add_del_map_request_itr_rlocs_t *mp)
Definition: lisp_api.c:472
Reply for lisp_pitr_set_locator_set.
Definition: lisp.api:243
u64 uword
Definition: types.h:112
static void vl_api_lisp_add_del_local_eid_t_handler(vl_api_lisp_add_del_local_eid_t *mp)
Definition: lisp_api.c:233
int vnet_lisp_add_del_locator_set(vnet_lisp_add_del_locator_set_args_t *a, u32 *ls_result)
Definition: control.c:1587
#define gid_address_ip(_a)
Definition: lisp_types.h:244
Status of lisp, enable or disable.
Definition: lisp.api:831
#define gid_address_vni(_a)
Definition: lisp_types.h:249
Request for map server summary status.
Definition: lisp.api:810
static void vl_api_lisp_eid_table_dump_t_handler(vl_api_lisp_eid_table_dump_t *mp)
Definition: lisp_api.c:839
static void vl_api_show_lisp_map_request_mode_t_handler(vl_api_show_lisp_map_request_mode_t *mp)
Definition: lisp_api.c:360
static locator_t * unformat_lisp_locs(vl_api_remote_locator_t *rmt_locs, u32 rloc_num)
Definition: lisp_api.c:95
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:349
add or delete locator for locator_set
Definition: lisp.api:62
int vnet_lisp_add_del_locator(vnet_lisp_add_del_locator_set_args_t *a, locator_set_t *ls, u32 *ls_result)
Definition: control.c:1497
mapping_t * mapping_pool
Definition: control.h:126
uword * locator_set_index_by_name
Definition: control.h:141
add or delete remote static mapping
Definition: lisp.api:433
static void setup_message_id_table(api_main_t *am)
Definition: lisp_api.c:1293
static void vl_api_lisp_map_request_mode_t_handler(vl_api_lisp_map_request_mode_t *mp)
Definition: lisp_api.c:374
void gid_address_copy(gid_address_t *dst, gid_address_t *src)
Definition: lisp_types.c:1399
Definition: lisp_types.h:37
gid_address_t eid
Definition: lisp_types.h:321
gid_address_t reid
Definition: control.h:64
gid_address_t address
Definition: lisp_types.h:295
#define hash_get_mem(h, key)
Definition: hash.h:268
void mac_copy(void *dst, void *src)
Definition: lisp_types.c:986
LISP map server details.
Definition: lisp.api:799
static void vl_api_lisp_enable_disable_t_handler(vl_api_lisp_enable_disable_t *mp)
Definition: lisp_api.c:349
int vnet_lisp_add_del_map_resolver(vnet_lisp_add_del_map_resolver_args_t *a)
Definition: control.c:1794
static void vl_api_lisp_eid_table_vni_dump_t_handler(vl_api_lisp_eid_table_vni_dump_t *mp)
Definition: lisp_api.c:1139
#define vec_foreach(var, vec)
Vector iterator.
Dumps all VNIs used in mappings.
Definition: lisp.api:756
Reply for map_resolver add/del.
Definition: lisp.api:171
Request for map request itr rlocs summary status.
Definition: lisp.api:851
static void vl_api_lisp_add_del_locator_t_handler(vl_api_lisp_add_del_locator_t *mp)
Definition: lisp_api.c:167
Reply for lisp_rloc_probe_enable_disable.
Definition: lisp.api:312
Request for LISP map-request mode.
Definition: lisp.api:390
vhost_vring_addr_t addr
Definition: vhost-user.h:84
Reply for lisp_map_register_enable_disable.
Definition: lisp.api:334
Definition: lisp_types.h:38
static int unformat_lisp_eid_api(gid_address_t *dst, u32 vni, u8 type, void *src, u8 len)
Definition: lisp_api.c:201
static void send_eid_table_map_pair(hash_pair_t *p, unix_shared_memory_queue_t *q, u32 context)
Definition: lisp_api.c:983
static void vl_api_show_lisp_rloc_probe_state_t_handler(vl_api_show_lisp_rloc_probe_state_t *mp)
Definition: lisp_api.c:1087
int vnet_lisp_use_petr(ip_address_t *ip, u8 is_add)
Configure Proxy-ETR.
Definition: control.c:1338
reply to lisp_eid_table_vni_dump
Definition: lisp.api:767
u32 mreq_itr_rlocs
Definition: control.h:180
u32 * locator_indices
Definition: lisp_types.h:315
uword key
Definition: hash.h:161
LISP-GPE definitions.
static void vl_api_lisp_eid_table_map_dump_t_handler(vl_api_lisp_eid_table_map_dump_t *mp)
Definition: lisp_api.c:999
Request for lisp pitr status.
Definition: lisp.api:862
Add/delete map server.
Definition: lisp.api:132
#define VALIDATE_SW_IF_INDEX(mp)
static void vl_api_lisp_add_del_map_resolver_t_handler(vl_api_lisp_add_del_map_resolver_t *mp)
Definition: lisp_api.c:309
struct _unix_shared_memory_queue unix_shared_memory_queue_t