FD.io VPP  v18.01.2-1-g9b554f3
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  mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
132  locator_name = format (0, "%s", mp->locator_set_name);
133  vec_terminate_c_string (locator_name);
134 
135  a->name = locator_name;
136  a->is_add = mp->is_add;
137  a->local = 1;
138  locator_num = clib_net_to_host_u32 (mp->locator_num);
139 
140  memset (&locator, 0, sizeof (locator));
141  for (i = 0; i < locator_num; i++)
142  {
143  ls_loc = &mp->locators[i];
144  VALIDATE_SW_IF_INDEX (ls_loc);
145 
146  locator.sw_if_index = htonl (ls_loc->sw_if_index);
147  locator.priority = ls_loc->priority;
148  locator.weight = ls_loc->weight;
149  locator.local = 1;
150  vec_add1 (a->locators, locator);
151  }
152 
153  rv = vnet_lisp_add_del_locator_set (a, &ls_index);
154 
156 
157  vec_free (locator_name);
158  vec_free (a->locators);
159 
160  /* *INDENT-OFF* */
161  REPLY_MACRO2 (VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY,
162  ({
163  rmp->ls_index = clib_host_to_net_u32 (ls_index);
164  }));
165  /* *INDENT-ON* */
166 }
167 
168 static void
170 {
171  vl_api_lisp_add_del_locator_reply_t *rmp;
172  int rv = 0;
173  locator_t locator, *locators = NULL;
175  u32 ls_index = ~0;
176  u8 *locator_name = NULL;
177 
178  memset (&locator, 0, sizeof (locator));
179  memset (a, 0, sizeof (a[0]));
180 
181  locator.sw_if_index = ntohl (mp->sw_if_index);
182  locator.priority = mp->priority;
183  locator.weight = mp->weight;
184  locator.local = 1;
185  vec_add1 (locators, locator);
186 
187  mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
188  locator_name = format (0, "%s", mp->locator_set_name);
189  vec_terminate_c_string (locator_name);
190 
191  a->name = locator_name;
192  a->locators = locators;
193  a->is_add = mp->is_add;
194  a->local = 1;
195 
196  rv = vnet_lisp_add_del_locator (a, NULL, &ls_index);
197 
198  vec_free (locators);
199  vec_free (locator_name);
200 
201  REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCATOR_REPLY);
202 }
203 
204 static int
205 unformat_lisp_eid_api (gid_address_t * dst, u32 vni, u8 type, void *src,
206  u8 len)
207 {
208  switch (type)
209  {
210  case 0: /* ipv4 */
212  gid_address_ip_set (dst, src, IP4);
213  gid_address_ippref_len (dst) = len;
215  break;
216  case 1: /* ipv6 */
218  gid_address_ip_set (dst, src, IP6);
219  gid_address_ippref_len (dst) = len;
221  break;
222  case 2: /* l2 mac */
224  clib_memcpy (&gid_address_mac (dst), src, 6);
225  break;
226  default:
227  /* unknown type */
228  return VNET_API_ERROR_INVALID_VALUE;
229  }
230 
231  gid_address_vni (dst) = vni;
232 
233  return 0;
234 }
235 
236 static void
238 {
239  vl_api_lisp_add_del_local_eid_reply_t *rmp;
241  int rv = 0;
242  gid_address_t _eid, *eid = &_eid;
243  uword *p = NULL;
244  u32 locator_set_index = ~0, map_index = ~0;
246  u8 *name = NULL, *key = NULL;
247  memset (a, 0, sizeof (a[0]));
248  memset (eid, 0, sizeof (eid[0]));
249 
250  rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
251  mp->eid_type, mp->eid, mp->prefix_len);
252  if (rv)
253  goto out;
254 
255  mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
256  name = format (0, "%s", mp->locator_set_name);
257  vec_terminate_c_string (name);
258  p = hash_get_mem (lcm->locator_set_index_by_name, name);
259  if (!p)
260  {
261  rv = VNET_API_ERROR_INVALID_VALUE;
262  goto out;
263  }
264  locator_set_index = p[0];
265 
266  if (*mp->key)
267  key = format (0, "%s", mp->key);
268 
269  /* XXX treat batch configuration */
270  a->is_add = mp->is_add;
271  gid_address_copy (&a->eid, eid);
272  a->locator_set_index = locator_set_index;
273  a->local = 1;
274  a->key = key;
275  a->key_id = clib_net_to_host_u16 (mp->key_id);
276 
277  rv = vnet_lisp_add_del_local_mapping (a, &map_index);
278 
279 out:
280  vec_free (name);
281  vec_free (key);
282  gid_address_free (&a->eid);
283 
284  REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCAL_EID_REPLY);
285 }
286 
287 static void
290 {
291  vl_api_lisp_eid_table_add_del_map_reply_t *rmp;
292  int rv = 0;
293  rv = vnet_lisp_eid_table_map (clib_net_to_host_u32 (mp->vni),
294  clib_net_to_host_u32 (mp->dp_table),
295  mp->is_l2, mp->is_add);
296 REPLY_MACRO (VL_API_LISP_EID_TABLE_ADD_DEL_MAP_REPLY)}
297 
298 static void
300  * mp)
301 {
302  vl_api_lisp_add_del_map_server_reply_t *rmp;
303  int rv = 0;
304  ip_address_t addr;
305 
306  memset (&addr, 0, sizeof (addr));
307 
308  ip_address_set (&addr, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
309  rv = vnet_lisp_add_del_map_server (&addr, mp->is_add);
310 
311  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_SERVER_REPLY);
312 }
313 
314 static void
316  * mp)
317 {
318  vl_api_lisp_add_del_map_resolver_reply_t *rmp;
319  int rv = 0;
321 
322  memset (a, 0, sizeof (a[0]));
323 
324  a->is_add = mp->is_add;
325  ip_address_set (&a->address, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
326 
328 
329  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_RESOLVER_REPLY);
330 }
331 
332 static void
335 {
336  vl_api_lisp_map_register_enable_disable_reply_t *rmp;
337  int rv = 0;
338 
340  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
341 }
342 
343 static void
346 {
347  vl_api_lisp_rloc_probe_enable_disable_reply_t *rmp;
348  int rv = 0;
349 
351  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
352 }
353 
354 static void
356 {
357  vl_api_lisp_enable_disable_reply_t *rmp;
358  int rv = 0;
359 
361  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
362 }
363 
364 static void
367 {
368  int rv = 0;
370 
371  /* *INDENT-OFF* */
372  REPLY_MACRO2(VL_API_SHOW_LISP_MAP_REQUEST_MODE_REPLY,
373  ({
375  }));
376  /* *INDENT-ON* */
377 }
378 
379 static void
381 {
382  vl_api_lisp_map_request_mode_reply_t *rmp;
383  int rv = 0;
384 
386 
387  REPLY_MACRO (VL_API_LISP_MAP_REQUEST_MODE_REPLY);
388 }
389 
390 static void
392  * mp)
393 {
394  vl_api_lisp_pitr_set_locator_set_reply_t *rmp;
395  int rv = 0;
396  u8 *ls_name = 0;
397 
398  mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
399  ls_name = format (0, "%s", mp->ls_name);
400  vec_terminate_c_string (ls_name);
401  rv = vnet_lisp_pitr_set_locator_set (ls_name, mp->is_add);
402  vec_free (ls_name);
403 
404  REPLY_MACRO (VL_API_LISP_PITR_SET_LOCATOR_SET_REPLY);
405 }
406 
407 static void
409 {
410  vl_api_lisp_use_petr_reply_t *rmp;
411  int rv = 0;
412  ip_address_t addr;
413 
414  ip_address_set (&addr, &mp->address, mp->is_ip4 ? IP4 : IP6);
415  rv = vnet_lisp_use_petr (&addr, mp->is_add);
416 
417  REPLY_MACRO (VL_API_LISP_USE_PETR_REPLY);
418 }
419 
420 static void
422 {
426  mapping_t *m;
427  locator_set_t *ls = 0;
428  int rv = 0;
429  locator_t *loc = 0;
430  u8 status = 0;
432 
434  if (q == 0)
435  {
436  return;
437  }
438 
439  memset (&addr, 0, sizeof (addr));
440  status = lcm->flags & LISP_FLAG_USE_PETR;
441  if (status)
442  {
444  if (~0 != m->locator_set_index)
445  {
446  ls =
448  loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
449  gid_address_copy (&addr, &loc->address);
450  }
451  }
452 
453  /* *INDENT-OFF* */
454  REPLY_MACRO2 (VL_API_SHOW_LISP_USE_PETR_REPLY,
455  {
456  rmp->status = status;
457  ip_address_t *ip = &gid_address_ip (&addr);
458  switch (ip_addr_version (ip))
459  {
460  case IP4:
461  clib_memcpy (rmp->address, &ip_addr_v4 (ip),
462  sizeof (ip_addr_v4 (ip)));
463  break;
464 
465  case IP6:
466  clib_memcpy (rmp->address, &ip_addr_v6 (ip),
467  sizeof (ip_addr_v6 (ip)));
468  break;
469 
470  default:
471  ASSERT (0);
472  }
473  rmp->is_ip4 = (gid_address_ip_version (&addr) == IP4);
474  });
475  /* *INDENT-ON* */
476 }
477 
478 static void
481 {
482  vl_api_lisp_add_del_map_request_itr_rlocs_reply_t *rmp;
483  int rv = 0;
484  u8 *locator_set_name = NULL;
486 
487  mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
488  locator_set_name = format (0, "%s", mp->locator_set_name);
489  vec_terminate_c_string (locator_set_name);
490 
491  a->is_add = mp->is_add;
492  a->locator_set_name = locator_set_name;
493 
495 
496  vec_free (locator_set_name);
497 
498  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY);
499 }
500 
501 static void
504 {
505  locator_t *rlocs = 0;
506  vl_api_lisp_add_del_remote_mapping_reply_t *rmp;
507  int rv = 0;
508  gid_address_t _eid, *eid = &_eid;
509  u32 rloc_num = clib_net_to_host_u32 (mp->rloc_num);
510 
511  memset (eid, 0, sizeof (eid[0]));
512 
513  rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
514  mp->eid_type, mp->eid, mp->eid_len);
515  if (rv)
516  goto send_reply;
517 
518  rlocs = unformat_lisp_locs (mp->rlocs, rloc_num);
519 
520  if (!mp->is_add)
521  {
523  memset (a, 0, sizeof (*a));
524  gid_address_copy (&a->reid, eid);
525  a->is_add = 0;
527  if (rv)
528  {
529  goto out;
530  }
531  }
532 
533  /* NOTE: for now this works as a static remote mapping, i.e.,
534  * not authoritative and ttl infinite. */
535  if (mp->is_add)
536  {
537  vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
538  memset (m_args, 0, sizeof (m_args[0]));
539  gid_address_copy (&m_args->eid, eid);
540  m_args->action = mp->action;
541  m_args->is_static = 1;
542  m_args->ttl = ~0;
543  m_args->authoritative = 0;
544  rv = vnet_lisp_add_mapping (m_args, rlocs, NULL, NULL);
545  }
546  else
547  {
548  rv = vnet_lisp_del_mapping (eid, NULL);
549  }
550 
551  if (mp->del_all)
553 
554 out:
555  vec_free (rlocs);
556 send_reply:
557  REPLY_MACRO (VL_API_LISP_ADD_DEL_REMOTE_MAPPING_REPLY);
558 }
559 
560 static void
562 {
563  vl_api_lisp_add_del_adjacency_reply_t *rmp;
565 
566  int rv = 0;
567  memset (a, 0, sizeof (a[0]));
568 
569  rv = unformat_lisp_eid_api (&a->leid, clib_net_to_host_u32 (mp->vni),
570  mp->eid_type, mp->leid, mp->leid_len);
571  rv |= unformat_lisp_eid_api (&a->reid, clib_net_to_host_u32 (mp->vni),
572  mp->eid_type, mp->reid, mp->reid_len);
573 
574  if (rv)
575  goto send_reply;
576 
577  a->is_add = mp->is_add;
579 
580 send_reply:
581  REPLY_MACRO (VL_API_LISP_ADD_DEL_ADJACENCY_REPLY);
582 }
583 
584 static void
586  locator_t * loc,
587  unix_shared_memory_queue_t * q, u32 context)
588 {
590 
591  rmp = vl_msg_api_alloc (sizeof (*rmp));
592  memset (rmp, 0, sizeof (*rmp));
593  rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_DETAILS);
594  rmp->context = context;
595 
596  rmp->local = loc->local;
597  if (loc->local)
598  {
599  rmp->sw_if_index = ntohl (loc->sw_if_index);
600  }
601  else
602  {
603  rmp->is_ipv6 = gid_address_ip_version (&loc->address);
605  }
606  rmp->priority = loc->priority;
607  rmp->weight = loc->weight;
608 
609  vl_msg_api_send_shmem (q, (u8 *) & rmp);
610 }
611 
612 static void
614 {
615  u8 *ls_name = 0;
618  locator_set_t *lsit = 0;
619  locator_t *loc = 0;
620  u32 ls_index = ~0, *locit = 0;
621  uword *p = 0;
622 
624  if (q == 0)
625  {
626  return;
627  }
628 
629  if (mp->is_index_set)
630  ls_index = htonl (mp->ls_index);
631  else
632  {
633  /* make sure we get a proper C-string */
634  mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
635  ls_name = format (0, "%s", mp->ls_name);
636  vec_terminate_c_string (ls_name);
637  p = hash_get_mem (lcm->locator_set_index_by_name, ls_name);
638  if (!p)
639  goto out;
640  ls_index = p[0];
641  }
642 
643  if (pool_is_free_index (lcm->locator_set_pool, ls_index))
644  return;
645 
646  lsit = pool_elt_at_index (lcm->locator_set_pool, ls_index);
647 
648  vec_foreach (locit, lsit->locator_indices)
649  {
650  loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
651  send_lisp_locator_details (lcm, loc, q, mp->context);
652  };
653 out:
654  vec_free (ls_name);
655 }
656 
657 static void
659  locator_set_t * lsit,
661  u32 context, u32 ls_index)
662 {
664  u8 *str = 0;
665 
666  rmp = vl_msg_api_alloc (sizeof (*rmp));
667  memset (rmp, 0, sizeof (*rmp));
668  rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_SET_DETAILS);
669  rmp->context = context;
670 
671  rmp->ls_index = htonl (ls_index);
672  if (lsit->local)
673  {
674  ASSERT (lsit->name != NULL);
675  strncpy ((char *) rmp->ls_name, (char *) lsit->name,
676  vec_len (lsit->name));
677  }
678  else
679  {
680  str = format (0, "<remote-%d>", ls_index);
681  strncpy ((char *) rmp->ls_name, (char *) str, vec_len (str));
682  vec_free (str);
683  }
684 
685  vl_msg_api_send_shmem (q, (u8 *) & rmp);
686 }
687 
688 static void
690 {
693  locator_set_t *lsit = NULL;
694  u8 filter;
695 
697  if (q == 0)
698  {
699  return;
700  }
701 
702  filter = mp->filter;
703  /* *INDENT-OFF* */
704  pool_foreach (lsit, lcm->locator_set_pool,
705  ({
706  if (filter && !((1 == filter && lsit->local) ||
707  (2 == filter && !lsit->local)))
708  {
709  continue;
710  }
711  send_lisp_locator_set_details (lcm, lsit, q, mp->context,
712  lsit - lcm->locator_set_pool);
713  }));
714  /* *INDENT-ON* */
715 }
716 
717 static void
718 lisp_fid_put_api (u8 * dst, fid_address_t * src, u8 * prefix_length)
719 {
720  ASSERT (prefix_length);
721  ip_prefix_t *ippref = &fid_addr_ippref (src);
722 
723  switch (fid_addr_type (src))
724  {
725  case FID_ADDR_IP_PREF:
726  if (ip_prefix_version (ippref) == IP4)
727  clib_memcpy (dst, &ip_prefix_v4 (ippref), 4);
728  else
729  clib_memcpy (dst, &ip_prefix_v6 (ippref), 16);
730  prefix_length[0] = ip_prefix_len (ippref);
731  break;
732 
733  case FID_ADDR_MAC:
734  prefix_length[0] = 0;
735  clib_memcpy (dst, fid_addr_mac (src), 6);
736  break;
737 
738  default:
739  clib_warning ("Unknown FID type %d!", fid_addr_type (src));
740  break;
741  }
742 }
743 
744 static u8
746 {
747  ip_prefix_t *ippref;
748 
749  switch (fid_addr_type (fid))
750  {
751  case FID_ADDR_IP_PREF:
752  ippref = &fid_addr_ippref (fid);
753  if (ip_prefix_version (ippref) == IP4)
754  return 0;
755  else if (ip_prefix_version (ippref) == IP6)
756  return 1;
757  else
758  return ~0;
759 
760  case FID_ADDR_MAC:
761  return 2;
762  case FID_ADDR_NSH:
763  return 3;
764  }
765 
766  return ~0;
767 }
768 
769 static void
772  u32 context, u8 filter)
773 {
774  fid_address_t *fid;
776  locator_set_t *ls = 0;
778  gid_address_t *gid = NULL;
779  u8 *mac = 0;
780  ip_prefix_t *ip_prefix = NULL;
781 
782  switch (filter)
783  {
784  case 0: /* all mappings */
785  break;
786 
787  case 1: /* local only */
788  if (!mapit->local)
789  return;
790  break;
791  case 2: /* remote only */
792  if (mapit->local)
793  return;
794  break;
795  default:
796  clib_warning ("Filter error, unknown filter: %d", filter);
797  return;
798  }
799 
800  /* don't send PITR generated mapping */
801  if (mapit->pitr_set)
802  return;
803 
804  gid = &mapit->eid;
805  ip_prefix = &gid_address_ippref (gid);
806  mac = gid_address_mac (gid);
807 
808  rmp = vl_msg_api_alloc (sizeof (*rmp));
809  memset (rmp, 0, sizeof (*rmp));
810  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_DETAILS);
811 
813  if (vec_len (ls->locator_indices) == 0)
814  rmp->locator_set_index = ~0;
815  else
816  rmp->locator_set_index = clib_host_to_net_u32 (mapit->locator_set_index);
817 
818  rmp->is_local = mapit->local;
819  rmp->ttl = clib_host_to_net_u32 (mapit->ttl);
820  rmp->action = mapit->action;
821  rmp->authoritative = mapit->authoritative;
822 
823  switch (gid_address_type (gid))
824  {
825  case GID_ADDR_SRC_DST:
826  rmp->is_src_dst = 1;
827  fid = &gid_address_sd_src (gid);
828  rmp->eid_type = fid_type_to_api_type (fid);
830  &rmp->seid_prefix_len);
832  &rmp->eid_prefix_len);
833  break;
834  case GID_ADDR_IP_PREFIX:
835  rmp->eid_prefix_len = ip_prefix_len (ip_prefix);
836  if (ip_prefix_version (ip_prefix) == IP4)
837  {
838  rmp->eid_type = 0; /* ipv4 type */
839  clib_memcpy (rmp->eid, &ip_prefix_v4 (ip_prefix),
840  sizeof (ip_prefix_v4 (ip_prefix)));
841  }
842  else
843  {
844  rmp->eid_type = 1; /* ipv6 type */
845  clib_memcpy (rmp->eid, &ip_prefix_v6 (ip_prefix),
846  sizeof (ip_prefix_v6 (ip_prefix)));
847  }
848  break;
849  case GID_ADDR_MAC:
850  rmp->eid_type = 2; /* l2 mac type */
851  clib_memcpy (rmp->eid, mac, 6);
852  break;
853  default:
854  ASSERT (0);
855  }
856  rmp->context = context;
857  rmp->vni = clib_host_to_net_u32 (gid_address_vni (gid));
858  rmp->key_id = clib_host_to_net_u16 (mapit->key_id);
859  memcpy (rmp->key, mapit->key, vec_len (mapit->key));
860  vl_msg_api_send_shmem (q, (u8 *) & rmp);
861 }
862 
863 static void
865 {
866  u32 mi;
869  mapping_t *mapit = NULL;
870  gid_address_t _eid, *eid = &_eid;
871 
873  if (q == 0)
874  {
875  return;
876  }
877 
878  if (mp->eid_set)
879  {
880  memset (eid, 0, sizeof (*eid));
881 
882  unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
883  mp->eid_type, mp->eid, mp->prefix_length);
884 
886  if ((u32) ~ 0 == mi)
887  return;
888 
889  mapit = pool_elt_at_index (lcm->mapping_pool, mi);
890  send_lisp_eid_table_details (mapit, q, mp->context,
891  0 /* ignore filter */ );
892  }
893  else
894  {
895  /* *INDENT-OFF* */
896  pool_foreach (mapit, lcm->mapping_pool,
897  ({
898  send_lisp_eid_table_details(mapit, q, mp->context,
899  mp->filter);
900  }));
901  /* *INDENT-ON* */
902  }
903 }
904 
905 static void
906 send_lisp_map_server_details (ip_address_t * ip,
907  unix_shared_memory_queue_t * q, u32 context)
908 {
910 
911  rmp = vl_msg_api_alloc (sizeof (*rmp));
912  memset (rmp, 0, sizeof (*rmp));
913  rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_SERVER_DETAILS);
914 
915  switch (ip_addr_version (ip))
916  {
917  case IP4:
918  rmp->is_ipv6 = 0;
919  clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
920  sizeof (ip_addr_v4 (ip)));
921  break;
922 
923  case IP6:
924  rmp->is_ipv6 = 1;
925  clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
926  sizeof (ip_addr_v6 (ip)));
927  break;
928 
929  default:
930  ASSERT (0);
931  }
932  rmp->context = context;
933 
934  vl_msg_api_send_shmem (q, (u8 *) & rmp);
935 }
936 
937 static void
939 {
942  lisp_msmr_t *mr;
943 
945  if (q == 0)
946  {
947  return;
948  }
949 
950  vec_foreach (mr, lcm->map_servers)
951  {
953  }
954 }
955 
956 static void
958  unix_shared_memory_queue_t * q, u32 context)
959 {
961 
962  rmp = vl_msg_api_alloc (sizeof (*rmp));
963  memset (rmp, 0, sizeof (*rmp));
964  rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_RESOLVER_DETAILS);
965 
966  switch (ip_addr_version (ip))
967  {
968  case IP4:
969  rmp->is_ipv6 = 0;
970  clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
971  sizeof (ip_addr_v4 (ip)));
972  break;
973 
974  case IP6:
975  rmp->is_ipv6 = 1;
976  clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
977  sizeof (ip_addr_v6 (ip)));
978  break;
979 
980  default:
981  ASSERT (0);
982  }
983  rmp->context = context;
984 
985  vl_msg_api_send_shmem (q, (u8 *) & rmp);
986 }
987 
988 static void
990 {
993  lisp_msmr_t *mr;
994 
996  if (q == 0)
997  {
998  return;
999  }
1000 
1001  vec_foreach (mr, lcm->map_resolvers)
1002  {
1004  }
1005 }
1006 
1007 static void
1009  unix_shared_memory_queue_t * q, u32 context)
1010 {
1012 
1013  rmp = vl_msg_api_alloc (sizeof (*rmp));
1014  memset (rmp, 0, sizeof (*rmp));
1015  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_MAP_DETAILS);
1016 
1017  rmp->vni = clib_host_to_net_u32 (p->key);
1018  rmp->dp_table = clib_host_to_net_u32 (p->value[0]);
1019  rmp->context = context;
1020  vl_msg_api_send_shmem (q, (u8 *) & rmp);
1021 }
1022 
1023 static void
1025  mp)
1026 {
1029  hash_pair_t *p;
1030  uword *vni_table = 0;
1031 
1033  if (q == 0)
1034  {
1035  return;
1036  }
1037 
1038  if (mp->is_l2)
1039  {
1040  vni_table = lcm->bd_id_by_vni;
1041  }
1042  else
1043  {
1044  vni_table = lcm->table_id_by_vni;
1045  }
1046 
1047  /* *INDENT-OFF* */
1048  hash_foreach_pair (p, vni_table,
1049  ({
1050  send_eid_table_map_pair (p, q, mp->context);
1051  }));
1052  /* *INDENT-ON* */
1053 }
1054 
1055 static void
1057 {
1059 
1060  rmp = vl_msg_api_alloc (sizeof (*rmp));
1061  memset (rmp, 0, sizeof (*rmp));
1062  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_VNI_DETAILS);
1063  rmp->context = context;
1064  rmp->vni = clib_host_to_net_u32 (vni);
1065  vl_msg_api_send_shmem (q, (u8 *) & rmp);
1066 }
1067 
1068 static void
1070 {
1071  lisp_adjacency_t *adj;
1073  u32 i, n = vec_len (adjs);
1074 
1075  for (i = 0; i < n; i++)
1076  {
1077  adj = vec_elt_at_index (adjs, i);
1078  memset (&a, 0, sizeof (a));
1079 
1080  switch (gid_address_type (&adj->reid))
1081  {
1082  case GID_ADDR_IP_PREFIX:
1085  if (gid_address_ip_version (&adj->reid) == IP4)
1086  {
1087  a.eid_type = 0; /* ipv4 type */
1088  clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 4);
1089  clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 4);
1090  }
1091  else
1092  {
1093  a.eid_type = 1; /* ipv6 type */
1094  clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 16);
1095  clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 16);
1096  }
1097  break;
1098  case GID_ADDR_MAC:
1099  a.eid_type = 2; /* l2 mac type */
1100  mac_copy (a.reid, gid_address_mac (&adj->reid));
1101  mac_copy (a.leid, gid_address_mac (&adj->leid));
1102  break;
1103  default:
1104  ASSERT (0);
1105  }
1106  dst[i] = a;
1107  }
1108 }
1109 
1110 static void
1113 {
1115  int rv = 0;
1116 
1117  /* *INDENT-OFF* */
1118  REPLY_MACRO2 (VL_API_SHOW_LISP_RLOC_PROBE_STATE_REPLY,
1119  {
1121  });
1122  /* *INDENT-ON* */
1123 }
1124 
1125 static void
1128 {
1130  int rv = 0;
1131 
1132  /* *INDENT-OFF* */
1133  REPLY_MACRO2 (VL_API_SHOW_LISP_MAP_REGISTER_STATE_REPLY,
1134  {
1136  });
1137  /* *INDENT-ON* */
1138 }
1139 
1140 static void
1142 {
1144  lisp_adjacency_t *adjs = 0;
1145  int rv = 0;
1146  u32 size = ~0;
1147  u32 vni = clib_net_to_host_u32 (mp->vni);
1148 
1149  adjs = vnet_lisp_adjacencies_get_by_vni (vni);
1150  size = vec_len (adjs) * sizeof (vl_api_lisp_adjacency_t);
1151 
1152  /* *INDENT-OFF* */
1153  REPLY_MACRO4 (VL_API_LISP_ADJACENCIES_GET_REPLY, size,
1154  {
1155  rmp->count = clib_host_to_net_u32 (vec_len (adjs));
1156  lisp_adjacency_copy (rmp->adjacencies, adjs);
1157  });
1158  /* *INDENT-ON* */
1159 
1160  vec_free (adjs);
1161 }
1162 
1163 static void
1165  mp)
1166 {
1167  hash_pair_t *p;
1168  u32 *vnis = 0;
1171 
1173  if (q == 0)
1174  {
1175  return;
1176  }
1177 
1178  /* *INDENT-OFF* */
1180  ({
1181  hash_set (vnis, p->key, 0);
1182  }));
1183 
1185  ({
1186  hash_set (vnis, p->key, 0);
1187  }));
1188 
1189  hash_foreach_pair (p, vnis,
1190  ({
1191  send_eid_table_vni (p->key, q, mp->context);
1192  }));
1193  /* *INDENT-ON* */
1194 
1195  hash_free (vnis);
1196 }
1197 
1198 static void
1200 {
1203  int rv = 0;
1204 
1206  if (q == 0)
1207  {
1208  return;
1209  }
1210 
1211  /* *INDENT-OFF* */
1212  REPLY_MACRO2(VL_API_SHOW_LISP_STATUS_REPLY,
1213  ({
1216  }));
1217  /* *INDENT-ON* */
1218 }
1219 
1220 static void
1223 {
1227  locator_set_t *loc_set = 0;
1228  u8 *tmp_str = 0;
1229  int rv = 0;
1230 
1232  if (q == 0)
1233  {
1234  return;
1235  }
1236 
1237  if (~0 == lcm->mreq_itr_rlocs)
1238  {
1239  tmp_str = format (0, " ");
1240  }
1241  else
1242  {
1243  loc_set =
1245  tmp_str = format (0, "%s", loc_set->name);
1246  }
1247 
1248  /* *INDENT-OFF* */
1249  REPLY_MACRO2(VL_API_LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY,
1250  ({
1251  strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1252  ARRAY_LEN(rmp->locator_set_name) - 1);
1253  }));
1254  /* *INDENT-ON* */
1255 
1256  vec_free (tmp_str);
1257 }
1258 
1259 static void
1261 {
1265  mapping_t *m;
1266  locator_set_t *ls = 0;
1267  u8 *tmp_str = 0;
1268  int rv = 0;
1269 
1271  if (q == 0)
1272  {
1273  return;
1274  }
1275 
1276  u8 is_enabled = (lcm->flags & LISP_FLAG_PITR_MODE)
1277  && lcm->pitr_map_index != ~0;
1278 
1279  if (!is_enabled)
1280  {
1281  tmp_str = format (0, "N/A");
1282  }
1283  else
1284  {
1286  if (~0 != m->locator_set_index)
1287  {
1288  ls =
1290  tmp_str = format (0, "%s", ls->name);
1291  }
1292  else
1293  {
1294  tmp_str = format (0, "N/A");
1295  }
1296  }
1297  vec_add1 (tmp_str, 0);
1298 
1299  /* *INDENT-OFF* */
1300  REPLY_MACRO2(VL_API_SHOW_LISP_PITR_REPLY,
1301  ({
1302  rmp->status = lcm->flags & LISP_FLAG_PITR_MODE;
1303  strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1304  ARRAY_LEN(rmp->locator_set_name) - 1);
1305  }));
1306  /* *INDENT-ON* */
1307 }
1308 
1309 /*
1310  * lisp_api_hookup
1311  * Add vpe's API message handlers to the table.
1312  * vlib has alread mapped shared memory and
1313  * added the client registration handlers.
1314  * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1315  */
1316 #define vl_msg_name_crc_list
1317 #include <vnet/vnet_all_api_h.h>
1318 #undef vl_msg_name_crc_list
1319 
1320 static void
1322 {
1323 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1324  foreach_vl_msg_name_crc_lisp;
1325 #undef _
1326 }
1327 
1328 static clib_error_t *
1330 {
1331  api_main_t *am = &api_main;
1332 
1333 #define _(N,n) \
1334  vl_msg_api_set_handlers(VL_API_##N, #n, \
1335  vl_api_##n##_t_handler, \
1336  vl_noop_handler, \
1337  vl_api_##n##_t_endian, \
1338  vl_api_##n##_t_print, \
1339  sizeof(vl_api_##n##_t), 1);
1341 #undef _
1342 
1343  /*
1344  * Set up the (msg_name, crc, message-id) table
1345  */
1347 
1348  return 0;
1349 }
1350 
1352 
1353 /*
1354  * fd.io coding-style-patch-verification: ON
1355  *
1356  * Local Variables:
1357  * eval: (c-set-style "gnu")
1358  * End:
1359  */
#define ip_prefix_v4(_a)
Definition: lisp_types.h:74
Reply for show_lisp_map_register_state.
Definition: lisp.api:266
vl_api_local_locator_t locators[locator_num]
Definition: lisp.api:40
#define gid_address_ip_version(_a)
Definition: lisp_types.h:265
u32 pitr_map_index
Definition: control.h:250
gid_address_t leid
Definition: control.h:73
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
LISP locator_set status.
Definition: lisp.api:437
enable/disable LISP RLOC probing
Definition: lisp.api:233
#define gid_address_type(_a)
Definition: lisp_types.h:261
static u8 fid_type_to_api_type(fid_address_t *fid)
Definition: lisp_api.c:745
a
Definition: bitmap.h:516
u8 vnet_lisp_gpe_enable_disable_status(void)
Check if LISP-GPE is enabled.
Definition: lisp_gpe.c:184
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:1222
lisp_msmr_t * map_resolvers
Definition: control.h:220
VLIB_API_INIT_FUNCTION(lisp_api_hookup)
configure or disable LISP PITR node
Definition: lisp.api:157
Reply for locator_set add/del.
Definition: lisp.api:48
#define REPLY_MACRO4(t, n, body)
LISP map resolver status.
Definition: lisp.api:644
vl_api_lisp_adjacency_t adjacencies[count]
Definition: lisp.api:580
uword * table_id_by_vni
Definition: control.h:239
#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:1069
locator_t * locator_pool
Definition: control.h:177
u8 vnet_lisp_get_map_request_mode(void)
Definition: control.c:57
#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:299
#define vec_terminate_c_string(V)
(If necessary) NULL terminate a vector containing a c-string.
Definition: vec.h:990
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:518
LISP locator_set status.
Definition: lisp.api:453
Request for lisp_eid_table_map_details.
Definition: lisp.api:611
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
configure or disable use of PETR
Definition: lisp.api:172
static void vl_api_lisp_pitr_set_locator_set_t_handler(vl_api_lisp_pitr_set_locator_set_t *mp)
Definition: lisp_api.c:391
Request for LISP PETR status.
Definition: lisp.api:185
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:289
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:88
int vnet_lisp_add_mapping(vnet_lisp_add_del_mapping_args_t *a, locator_t *rlocs, u32 *res_map_index, u8 *is_updated)
Adds/updates mapping.
Definition: control.c:1279
static void vl_api_lisp_locator_dump_t_handler(vl_api_lisp_locator_dump_t *mp)
Definition: lisp_api.c:613
void ip_address_set(ip_address_t *dst, const void *src, u8 version)
Definition: lisp_types.c:908
#define ip_prefix_version(_a)
Definition: lisp_types.h:72
LISP adjacency.
Definition: lisp.api:562
#define fid_addr_mac(_a)
Definition: lisp_types.h:134
u8 vnet_lisp_map_register_state_get(void)
Definition: control.c:424
int vnet_lisp_set_map_request_mode(u8 mode)
Definition: control.c:1559
Reply for show_lisp_map_request_mode.
Definition: lisp.api:303
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:1488
Request for map resolver summary status.
Definition: lisp.api:655
static void vl_api_lisp_map_register_enable_disable_t_handler(vl_api_lisp_map_register_enable_disable_t *mp)
Definition: lisp_api.c:334
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:906
lisp_msmr_t * map_servers
Definition: control.h:223
add or delete LISP adjacency adjacency
Definition: lisp.api:365
#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:1056
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:438
static void vl_api_lisp_rloc_probe_enable_disable_t_handler(vl_api_lisp_rloc_probe_enable_disable_t *mp)
Definition: lisp_api.c:345
static void vl_api_lisp_add_del_remote_mapping_t_handler(vl_api_lisp_add_del_remote_mapping_t *mp)
Definition: lisp_api.c:503
u8 * key
Definition: lisp_types.h:373
#define gid_address_sd_src(_a)
Definition: lisp_types.h:278
static void vl_api_show_lisp_map_register_state_t_handler(vl_api_show_lisp_map_register_state_t *mp)
Definition: lisp_api.c:1127
#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:1141
Get LISP map request itr rlocs status.
Definition: lisp.api:709
Reply for show_lisp_rloc_probe_state.
Definition: lisp.api:221
add or delete map request itr rlocs
Definition: lisp.api:384
int vnet_lisp_eid_table_map(u32 vni, u32 dp_id, u8 is_l2, u8 is_add)
Definition: control.c:1079
uword * bd_id_by_vni
Definition: control.h:243
#define ip_addr_v4(_a)
Definition: lisp_types.h:54
static lisp_cp_main_t * vnet_lisp_cp_get_main()
Definition: control.h:301
void * vl_msg_api_alloc(int nbytes)
u32 petr_map_index
Proxy ETR map index used for &#39;use-petr&#39;.
Definition: control.h:254
#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:408
clib_error_t * vnet_lisp_enable_disable(u8 is_enable)
Definition: control.c:2260
static void vl_api_show_lisp_pitr_t_handler(vl_api_show_lisp_pitr_t *mp)
Definition: lisp_api.c:1260
Get state of LISP map-register.
Definition: lisp.api:256
Get state of LISP RLOC probing.
Definition: lisp.api:210
void ip_address_copy_addr(void *dst, const ip_address_t *src)
Definition: lisp_types.c:902
int vnet_lisp_pitr_set_locator_set(u8 *locator_set_name, u8 is_add)
Definition: control.c:1631
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:459
u8 vnet_lisp_rloc_probe_state_get(void)
Definition: control.c:431
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:658
#define gid_address_mac(_a)
Definition: lisp_types.h:267
set LISP map-request mode.
Definition: lisp.api:281
static void send_lisp_map_resolver_details(ip_address_t *ip, unix_shared_memory_queue_t *q, u32 context)
Definition: lisp_api.c:957
#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:884
Request for LISP adjacencies.
Definition: lisp.api:588
#define hash_free(h)
Definition: hash.h:309
void gid_address_free(gid_address_t *a)
Definition: lisp_types.c:850
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:585
u8 authoritative
Definition: lisp_types.h:363
add or delete lisp eid-table
Definition: lisp.api:93
LISP adjacency reply.
Definition: lisp.api:575
#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:938
static void vl_api_lisp_add_del_adjacency_t_handler(vl_api_lisp_add_del_adjacency_t *mp)
Definition: lisp_api.c:561
void ip_prefix_normalize(ip_prefix_t *a)
Definition: lisp_types.c:988
#define ip_addr_v6(_a)
Definition: lisp_types.h:55
#define gid_address_ippref(_a)
Definition: lisp_types.h:262
LISP PETR status, enable or disable.
Definition: lisp.api:197
API main structure, used by both vpp and binary API clients.
Definition: api_common.h:198
lisp_adjacency_t * vnet_lisp_adjacencies_get_by_vni(u32 vni)
Returns vector of adjacencies.
Definition: control.c:627
#define BAD_SW_IF_INDEX_LABEL
u32 sw_if_index
Definition: lisp_types.h:324
Request for lisp-gpe protocol status.
Definition: lisp.api:686
api_main_t api_main
Definition: api_shared.c:35
int vnet_lisp_add_del_mreq_itr_rlocs(vnet_lisp_add_del_mreq_itr_rloc_args_t *a)
Definition: control.c:2392
enable or disable LISP feature
Definition: lisp.api:144
vlib_main_t * vm
Definition: buffer.c:283
Shows relationship between vni and vrf/bd.
Definition: lisp.api:599
void gid_address_ip_set(gid_address_t *dst, void *src, u8 version)
Definition: lisp_types.c:1560
static void vl_api_show_lisp_status_t_handler(vl_api_show_lisp_status_t *mp)
Definition: lisp_api.c:1199
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:336
#define gid_address_ippref_len(_a)
Definition: lisp_types.h:263
#define clib_warning(format, args...)
Definition: error.h:59
u32 locator_set_index
Definition: lisp_types.h:356
#define clib_memcpy(a, b, c)
Definition: string.h:75
unix_shared_memory_queue_t * vl_api_client_index_to_input_queue(u32 index)
static void vl_api_lisp_locator_set_dump_t_handler(vl_api_lisp_locator_set_dump_t *mp)
Definition: lisp_api.c:689
int vnet_lisp_map_register_enable_disable(u8 is_enable)
Definition: control.c:2194
add or delete map-resolver
Definition: lisp.api:130
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:268
#define ARRAY_LEN(x)
Definition: clib.h:59
lisp_key_type_t key_id
Definition: lisp_types.h:374
Request for map lisp locator status.
Definition: lisp.api:421
#define fid_addr_ippref(_a)
Definition: lisp_types.h:131
u8 vnet_lisp_enable_disable_status(void)
Definition: control.c:2322
static void send_lisp_eid_table_details(mapping_t *mapit, unix_shared_memory_queue_t *q, u32 context, u8 filter)
Definition: lisp_api.c:770
struct _gid_address_t gid_address_t
Dump lisp eid-table.
Definition: lisp.api:502
void vl_msg_api_send_shmem(unix_shared_memory_queue_t *q, u8 *elem)
static clib_error_t * lisp_api_hookup(vlib_main_t *vm)
Definition: lisp_api.c:1329
int vnet_lisp_add_del_map_server(ip_address_t *addr, u8 is_add)
Definition: control.c:681
#define ASSERT(truth)
#define fid_addr_type(_a)
Definition: lisp_types.h:136
unsigned int u32
Definition: types.h:88
Request for eid table summary status.
Definition: lisp.api:540
enable/disable LISP map-register
Definition: lisp.api:245
int vnet_lisp_clear_all_remote_adjacencies(void)
Definition: control.c:1437
Request for locator_set summary status.
Definition: lisp.api:469
#define gid_address_sd_dst(_a)
Definition: lisp_types.h:279
static void vl_api_show_lisp_use_petr_t_handler(vl_api_show_lisp_use_petr_t *mp)
Definition: lisp_api.c:421
Reply for lisp_add_del_map_request_itr_rlocs.
Definition: lisp.api:404
gid_dictionary_t mapping_index_by_gid
Definition: control.h:168
u64 size
Definition: vhost-user.h:76
locator_set_t * locator_set_pool
Definition: control.h:180
Status of lisp pitr, enable or disable.
Definition: lisp.api:739
static void vl_api_lisp_map_resolver_dump_t_handler(vl_api_lisp_map_resolver_dump_t *mp)
Definition: lisp_api.c:989
int vnet_lisp_rloc_probe_enable_disable(u8 is_enable)
Definition: control.c:2185
add or delete locator_set
Definition: lisp.api:33
vl_api_remote_locator_t rlocs[rloc_num]
Definition: lisp.api:350
static void lisp_fid_put_api(u8 *dst, fid_address_t *src, u8 *prefix_length)
Definition: lisp_api.c:718
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:480
u64 gid_dictionary_lookup(gid_dictionary_t *db, gid_address_t *key)
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:237
int vnet_lisp_add_del_locator_set(vnet_lisp_add_del_locator_set_args_t *a, u32 *ls_result)
Definition: control.c:2045
#define gid_address_ip(_a)
Definition: lisp_types.h:264
Status of lisp, enable or disable.
Definition: lisp.api:697
#define gid_address_vni(_a)
Definition: lisp_types.h:271
Request for map server summary status.
Definition: lisp.api:676
static void vl_api_lisp_eid_table_dump_t_handler(vl_api_lisp_eid_table_dump_t *mp)
Definition: lisp_api.c:864
static void vl_api_show_lisp_map_request_mode_t_handler(vl_api_show_lisp_map_request_mode_t *mp)
Definition: lisp_api.c:366
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:372
add or delete locator for locator_set
Definition: lisp.api:64
int vnet_lisp_del_mapping(gid_address_t *eid, u32 *res_map_index)
Removes a mapping.
Definition: control.c:1388
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:1941
mapping_t * mapping_pool
Definition: control.h:171
uword * locator_set_index_by_name
Definition: control.h:186
add or delete remote static mapping
Definition: lisp.api:335
static void setup_message_id_table(api_main_t *am)
Definition: lisp_api.c:1321
static void vl_api_lisp_map_request_mode_t_handler(vl_api_lisp_map_request_mode_t *mp)
Definition: lisp_api.c:380
void gid_address_copy(gid_address_t *dst, gid_address_t *src)
Definition: lisp_types.c:1495
Definition: lisp_types.h:37
gid_address_t eid
Definition: lisp_types.h:351
gid_address_t reid
Definition: control.h:74
gid_address_t address
Definition: lisp_types.h:325
#define hash_get_mem(h, key)
Definition: hash.h:268
void mac_copy(void *dst, void *src)
Definition: lisp_types.c:1051
LISP map server details.
Definition: lisp.api:665
static void vl_api_lisp_enable_disable_t_handler(vl_api_lisp_enable_disable_t *mp)
Definition: lisp_api.c:355
int vnet_lisp_add_del_map_resolver(vnet_lisp_add_del_map_resolver_args_t *a)
Definition: control.c:2329
static void vl_api_lisp_eid_table_vni_dump_t_handler(vl_api_lisp_eid_table_vni_dump_t *mp)
Definition: lisp_api.c:1164
#define vec_foreach(var, vec)
Vector iterator.
Dumps all VNIs used in mappings.
Definition: lisp.api:622
Request for map request itr rlocs summary status.
Definition: lisp.api:717
static void vl_api_lisp_add_del_locator_t_handler(vl_api_lisp_add_del_locator_t *mp)
Definition: lisp_api.c:169
Request for LISP map-request mode.
Definition: lisp.api:292
vhost_vring_addr_t addr
Definition: vhost-user.h:83
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:205
static void send_eid_table_map_pair(hash_pair_t *p, unix_shared_memory_queue_t *q, u32 context)
Definition: lisp_api.c:1008
static void vl_api_show_lisp_rloc_probe_state_t_handler(vl_api_show_lisp_rloc_probe_state_t *mp)
Definition: lisp_api.c:1112
int vnet_lisp_use_petr(ip_address_t *ip, u8 is_add)
Configure Proxy-ETR.
Definition: control.c:1698
reply to lisp_eid_table_vni_dump
Definition: lisp.api:633
u32 mreq_itr_rlocs
Definition: control.h:236
u32 * locator_indices
Definition: lisp_types.h:345
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:1024
Request for lisp pitr status.
Definition: lisp.api:728
Add/delete map server.
Definition: lisp.api:114
#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:315
struct _unix_shared_memory_queue unix_shared_memory_queue_t