lisp_api.c revision 39d69112
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
31#define vl_api_lisp_add_del_locator_set_t_endian vl_noop_handler
32#define vl_api_lisp_add_del_locator_set_t_print vl_noop_handler
33#define vl_api_lisp_add_del_remote_mapping_t_endian vl_noop_handler
34#define vl_api_lisp_add_del_remote_mapping_t_print vl_noop_handler
35
36#define vl_api_one_add_del_locator_set_t_endian vl_noop_handler
37#define vl_api_one_add_del_locator_set_t_print vl_noop_handler
38#define vl_api_one_add_del_remote_mapping_t_endian vl_noop_handler
39#define vl_api_one_add_del_remote_mapping_t_print vl_noop_handler
40
41#define vl_typedefs		/* define message structures */
42#include <vnet/vnet_all_api_h.h>
43#undef vl_typedefs
44
45#define vl_endianfun		/* define message structures */
46#include <vnet/vnet_all_api_h.h>
47#undef vl_endianfun
48
49/* instantiate all the print functions we know about */
50#define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
51#define vl_printfun
52#include <vnet/vnet_all_api_h.h>
53#undef vl_printfun
54
55#include <vlibapi/api_helper_macros.h>
56
57#define foreach_vpe_api_msg                             \
58_(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set)                   \
59_(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator)                           \
60_(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid)                       \
61_(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver)                 \
62_(LISP_ADD_DEL_MAP_SERVER, lisp_add_del_map_server)                     \
63_(LISP_ENABLE_DISABLE, lisp_enable_disable)                             \
64_(LISP_RLOC_PROBE_ENABLE_DISABLE, lisp_rloc_probe_enable_disable)       \
65_(LISP_MAP_REGISTER_ENABLE_DISABLE, lisp_map_register_enable_disable)   \
66_(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping)             \
67_(LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency)                       \
68_(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set)                 \
69_(LISP_MAP_REQUEST_MODE, lisp_map_request_mode)                         \
70_(LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map)               \
71_(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump)                         \
72_(LISP_LOCATOR_DUMP, lisp_locator_dump)                                 \
73_(LISP_EID_TABLE_DUMP, lisp_eid_table_dump)                             \
74_(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump)                       \
75_(LISP_MAP_SERVER_DUMP, lisp_map_server_dump)                           \
76_(LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump)                     \
77_(LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump)                     \
78_(LISP_ADJACENCIES_GET, lisp_adjacencies_get)                           \
79_(SHOW_LISP_RLOC_PROBE_STATE, show_lisp_rloc_probe_state)               \
80_(SHOW_LISP_MAP_REGISTER_STATE, show_lisp_map_register_state)           \
81_(SHOW_LISP_STATUS, show_lisp_status)                                   \
82_(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS,                                   \
83  lisp_add_del_map_request_itr_rlocs)                                   \
84_(LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs)       \
85_(SHOW_LISP_PITR, show_lisp_pitr)                                       \
86_(SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode)               \
87_(LISP_USE_PETR, lisp_use_petr)                                         \
88_(SHOW_LISP_USE_PETR, show_lisp_use_petr)                               \
89
90static locator_t *
91unformat_lisp_locs (vl_api_remote_locator_t * rmt_locs, u32 rloc_num)
92{
93  u32 i;
94  locator_t *locs = 0, loc;
95  vl_api_remote_locator_t *r;
96
97  for (i = 0; i < rloc_num; i++)
98    {
99      /* remote locators */
100      r = &rmt_locs[i];
101      clib_memset (&loc, 0, sizeof (loc));
102      gid_address_ip_set (&loc.address, &r->addr,
103			  r->is_ip4 ? AF_IP4 : AF_IP6);
104
105      loc.priority = r->priority;
106      loc.weight = r->weight;
107
108      vec_add1 (locs, loc);
109    }
110  return locs;
111}
112
113static void
114vl_api_lisp_add_del_locator_set_t_handler (vl_api_lisp_add_del_locator_set_t *
115					   mp)
116{
117  vl_api_lisp_add_del_locator_set_reply_t *rmp;
118  int rv = 0;
119  vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
120  locator_t locator;
121  vl_api_local_locator_t *ls_loc;
122  u32 ls_index = ~0, locator_num;
123  u8 *locator_name = NULL;
124  int i;
125
126  clib_memset (a, 0, sizeof (a[0]));
127
128  mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
129  locator_name = format (0, "%s", mp->locator_set_name);
130  vec_terminate_c_string (locator_name);
131
132  a->name = locator_name;
133  a->is_add = mp->is_add;
134  a->local = 1;
135  locator_num = clib_net_to_host_u32 (mp->locator_num);
136
137  clib_memset (&locator, 0, sizeof (locator));
138  for (i = 0; i < locator_num; i++)
139    {
140      ls_loc = &mp->locators[i];
141      VALIDATE_SW_IF_INDEX (ls_loc);
142
143      locator.sw_if_index = htonl (ls_loc->sw_if_index);
144      locator.priority = ls_loc->priority;
145      locator.weight = ls_loc->weight;
146      locator.local = 1;
147      vec_add1 (a->locators, locator);
148    }
149
150  rv = vnet_lisp_add_del_locator_set (a, &ls_index);
151
152  BAD_SW_IF_INDEX_LABEL;
153
154  vec_free (locator_name);
155  vec_free (a->locators);
156
157  /* *INDENT-OFF* */
158  REPLY_MACRO2 (VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY,
159  ({
160    rmp->ls_index = clib_host_to_net_u32 (ls_index);
161  }));
162  /* *INDENT-ON* */
163}
164
165static void
166vl_api_lisp_add_del_locator_t_handler (vl_api_lisp_add_del_locator_t * mp)
167{
168  vl_api_lisp_add_del_locator_reply_t *rmp;
169  int rv = 0;
170  locator_t locator, *locators = NULL;
171  vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
172  u32 ls_index = ~0;
173  u8 *locator_name = NULL;
174
175  clib_memset (&locator, 0, sizeof (locator));
176  clib_memset (a, 0, sizeof (a[0]));
177
178  locator.sw_if_index = ntohl (mp->sw_if_index);
179  locator.priority = mp->priority;
180  locator.weight = mp->weight;
181  locator.local = 1;
182  vec_add1 (locators, locator);
183
184  mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
185  locator_name = format (0, "%s", mp->locator_set_name);
186  vec_terminate_c_string (locator_name);
187
188  a->name = locator_name;
189  a->locators = locators;
190  a->is_add = mp->is_add;
191  a->local = 1;
192
193  rv = vnet_lisp_add_del_locator (a, NULL, &ls_index);
194
195  vec_free (locators);
196  vec_free (locator_name);
197
198  REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCATOR_REPLY);
199}
200
201static int
202unformat_lisp_eid_api (gid_address_t * dst, u32 vni, u8 type, void *src,
203		       u8 len)
204{
205  switch (type)
206    {
207    case 0:			/* ipv4 */
208      gid_address_type (dst) = GID_ADDR_IP_PREFIX;
209      gid_address_ip_set (dst, src, AF_IP4);
210      gid_address_ippref_len (dst) = len;
211      ip_prefix_normalize (&gid_address_ippref (dst));
212      break;
213    case 1:			/* ipv6 */
214      gid_address_type (dst) = GID_ADDR_IP_PREFIX;
215      gid_address_ip_set (dst, src, AF_IP6);
216      gid_address_ippref_len (dst) = len;
217      ip_prefix_normalize (&gid_address_ippref (dst));
218      break;
219    case 2:			/* l2 mac */
220      gid_address_type (dst) = GID_ADDR_MAC;
221      clib_memcpy (&gid_address_mac (dst), src, 6);
222      break;
223    default:
224      /* unknown type */
225      return VNET_API_ERROR_INVALID_VALUE;
226    }
227
228  gid_address_vni (dst) = vni;
229
230  return 0;
231}
232
233static void
234vl_api_lisp_add_del_local_eid_t_handler (vl_api_lisp_add_del_local_eid_t * mp)
235{
236  vl_api_lisp_add_del_local_eid_reply_t *rmp;
237  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
238  int rv = 0;
239  gid_address_t _eid, *eid = &_eid;
240  uword *p = NULL;
241  u32 locator_set_index = ~0, map_index = ~0;
242  vnet_lisp_add_del_mapping_args_t _a, *a = &_a;
243  u8 *name = NULL, *key = NULL;
244  clib_memset (a, 0, sizeof (a[0]));
245  clib_memset (eid, 0, sizeof (eid[0]));
246
247  rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
248			      mp->eid_type, mp->eid, mp->prefix_len);
249  if (rv)
250    goto out;
251
252  mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
253  name = format (0, "%s", mp->locator_set_name);
254  vec_terminate_c_string (name);
255  p = hash_get_mem (lcm->locator_set_index_by_name, name);
256  if (!p)
257    {
258      rv = VNET_API_ERROR_INVALID_VALUE;
259      goto out;
260    }
261  locator_set_index = p[0];
262
263  if (*mp->key)
264    key = format (0, "%s", mp->key);
265
266  /* XXX treat batch configuration */
267  a->is_add = mp->is_add;
268  gid_address_copy (&a->eid, eid);
269  a->locator_set_index = locator_set_index;
270  a->local = 1;
271  a->key = key;
272  a->key_id = clib_net_to_host_u16 (mp->key_id);
273
274  rv = vnet_lisp_add_del_local_mapping (a, &map_index);
275
276out:
277  vec_free (name);
278  vec_free (key);
279  gid_address_free (&a->eid);
280
281  REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCAL_EID_REPLY);
282}
283
284static void
285  vl_api_lisp_eid_table_add_del_map_t_handler
286  (vl_api_lisp_eid_table_add_del_map_t * mp)
287{
288  vl_api_lisp_eid_table_add_del_map_reply_t *rmp;
289  int rv = 0;
290  rv = vnet_lisp_eid_table_map (clib_net_to_host_u32 (mp->vni),
291				clib_net_to_host_u32 (mp->dp_table),
292				mp->is_l2, mp->is_add);
293REPLY_MACRO (VL_API_LISP_EID_TABLE_ADD_DEL_MAP_REPLY)}
294
295static void
296vl_api_lisp_add_del_map_server_t_handler (vl_api_lisp_add_del_map_server_t
297					  * mp)
298{
299  vl_api_lisp_add_del_map_server_reply_t *rmp;
300  int rv = 0;
301  ip_address_t addr;
302
303  clib_memset (&addr, 0, sizeof (addr));
304
305  ip_address_set (&addr, mp->ip_address, mp->is_ipv6 ? AF_IP6 : AF_IP4);
306  rv = vnet_lisp_add_del_map_server (&addr, mp->is_add);
307
308  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_SERVER_REPLY);
309}
310
311static void
312vl_api_lisp_add_del_map_resolver_t_handler (vl_api_lisp_add_del_map_resolver_t
313					    * mp)
314{
315  vl_api_lisp_add_del_map_resolver_reply_t *rmp;
316  int rv = 0;
317  vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a;
318
319  clib_memset (a, 0, sizeof (a[0]));
320
321  a->is_add = mp->is_add;
322  ip_address_set (&a->address, mp->ip_address, mp->is_ipv6 ? AF_IP6 : AF_IP4);
323
324  rv = vnet_lisp_add_del_map_resolver (a);
325
326  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_RESOLVER_REPLY);
327}
328
329static void
330  vl_api_lisp_map_register_enable_disable_t_handler
331  (vl_api_lisp_map_register_enable_disable_t * mp)
332{
333  vl_api_lisp_map_register_enable_disable_reply_t *rmp;
334  int rv = 0;
335
336  vnet_lisp_map_register_enable_disable (mp->is_enabled);
337  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
338}
339
340static void
341  vl_api_lisp_rloc_probe_enable_disable_t_handler
342  (vl_api_lisp_rloc_probe_enable_disable_t * mp)
343{
344  vl_api_lisp_rloc_probe_enable_disable_reply_t *rmp;
345  int rv = 0;
346
347  vnet_lisp_rloc_probe_enable_disable (mp->is_enabled);
348  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
349}
350
351static void
352vl_api_lisp_enable_disable_t_handler (vl_api_lisp_enable_disable_t * mp)
353{
354  vl_api_lisp_enable_disable_reply_t *rmp;
355  int rv = 0;
356
357  vnet_lisp_enable_disable (mp->is_en);
358  REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
359}
360
361static void
362  vl_api_show_lisp_map_request_mode_t_handler
363  (vl_api_show_lisp_map_request_mode_t * mp)
364{
365  int rv = 0;
366  vl_api_show_lisp_map_request_mode_reply_t *rmp;
367
368  /* *INDENT-OFF* */
369  REPLY_MACRO2(VL_API_SHOW_LISP_MAP_REQUEST_MODE_REPLY,
370  ({
371    rmp->mode = vnet_lisp_get_map_request_mode ();
372  }));
373  /* *INDENT-ON* */
374}
375
376static void
377vl_api_lisp_map_request_mode_t_handler (vl_api_lisp_map_request_mode_t * mp)
378{
379  vl_api_lisp_map_request_mode_reply_t *rmp;
380  int rv = 0;
381
382  rv = vnet_lisp_set_map_request_mode (mp->mode);
383
384  REPLY_MACRO (VL_API_LISP_MAP_REQUEST_MODE_REPLY);
385}
386
387static void
388vl_api_lisp_pitr_set_locator_set_t_handler (vl_api_lisp_pitr_set_locator_set_t
389					    * mp)
390{
391  vl_api_lisp_pitr_set_locator_set_reply_t *rmp;
392  int rv = 0;
393  u8 *ls_name = 0;
394
395  mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
396  ls_name = format (0, "%s", mp->ls_name);
397  vec_terminate_c_string (ls_name);
398  rv = vnet_lisp_pitr_set_locator_set (ls_name, mp->is_add);
399  vec_free (ls_name);
400
401  REPLY_MACRO (VL_API_LISP_PITR_SET_LOCATOR_SET_REPLY);
402}
403
404static void
405vl_api_lisp_use_petr_t_handler (vl_api_lisp_use_petr_t * mp)
406{
407  vl_api_lisp_use_petr_reply_t *rmp;
408  int rv = 0;
409  ip_address_t addr;
410
411  ip_address_set (&addr, &mp->address, mp->is_ip4 ? AF_IP4 : AF_IP6);
412  rv = vnet_lisp_use_petr (&addr, mp->is_add);
413
414  REPLY_MACRO (VL_API_LISP_USE_PETR_REPLY);
415}
416
417static void
418vl_api_show_lisp_use_petr_t_handler (vl_api_show_lisp_use_petr_t * mp)
419{
420  vl_api_show_lisp_use_petr_reply_t *rmp = NULL;
421  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
422  mapping_t *m;
423  locator_set_t *ls = 0;
424  int rv = 0;
425  locator_t *loc = 0;
426  u8 status = 0;
427  gid_address_t addr;
428
429  clib_memset (&addr, 0, sizeof (addr));
430  status = lcm->flags & LISP_FLAG_USE_PETR;
431  if (status)
432    {
433      m = pool_elt_at_index (lcm->mapping_pool, lcm->petr_map_index);
434      if (~0 != m->locator_set_index)
435	{
436	  ls =
437	    pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
438	  loc = pool_elt_at_index (lcm->locator_pool, ls->locator_indices[0]);
439	  gid_address_copy (&addr, &loc->address);
440	}
441    }
442
443  /* *INDENT-OFF* */
444  REPLY_MACRO2 (VL_API_SHOW_LISP_USE_PETR_REPLY,
445  {
446    rmp->status = status;
447    ip_address_t *ip = &gid_address_ip (&addr);
448    switch (ip_addr_version (ip))
449      {
450      case AF_IP4:
451        clib_memcpy (rmp->address, &ip_addr_v4 (ip),
452                     sizeof (ip_addr_v4 (ip)));
453        break;
454
455      case AF_IP6:
456        clib_memcpy (rmp->address, &ip_addr_v6 (ip),
457                     sizeof (ip_addr_v6 (ip)));
458        break;
459
460      default:
461        ASSERT (0);
462      }
463    rmp->is_ip4 = (gid_address_ip_version (&addr) == AF_IP4);
464  });
465  /* *INDENT-ON* */
466}
467
468static void
469  vl_api_lisp_add_del_map_request_itr_rlocs_t_handler
470  (vl_api_lisp_add_del_map_request_itr_rlocs_t * mp)
471{
472  vl_api_lisp_add_del_map_request_itr_rlocs_reply_t *rmp;
473  int rv = 0;
474  u8 *locator_set_name = NULL;
475  vnet_lisp_add_del_mreq_itr_rloc_args_t _a, *a = &_a;
476
477  mp->locator_set_name[sizeof (mp->locator_set_name) - 1] = 0;
478  locator_set_name = format (0, "%s", mp->locator_set_name);
479  vec_terminate_c_string (locator_set_name);
480
481  a->is_add = mp->is_add;
482  a->locator_set_name = locator_set_name;
483
484  rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
485
486  vec_free (locator_set_name);
487
488  REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY);
489}
490
491static void
492  vl_api_lisp_add_del_remote_mapping_t_handler
493  (vl_api_lisp_add_del_remote_mapping_t * mp)
494{
495  locator_t *rlocs = 0;
496  vl_api_lisp_add_del_remote_mapping_reply_t *rmp;
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  clib_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    {
512      vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
513      clib_memset (a, 0, sizeof (*a));
514      gid_address_copy (&a->reid, eid);
515      a->is_add = 0;
516      rv = vnet_lisp_add_del_adjacency (a);
517      if (rv)
518	{
519	  goto out;
520	}
521    }
522
523  /* NOTE: for now this works as a static remote mapping, i.e.,
524   * not authoritative and ttl infinite. */
525  if (mp->is_add)
526    {
527      vnet_lisp_add_del_mapping_args_t _m_args, *m_args = &_m_args;
528      clib_memset (m_args, 0, sizeof (m_args[0]));
529      gid_address_copy (&m_args->eid, eid);
530      m_args->action = mp->action;
531      m_args->is_static = 1;
532      m_args->ttl = ~0;
533      m_args->authoritative = 0;
534      rv = vnet_lisp_add_mapping (m_args, rlocs, NULL, NULL);
535    }
536  else
537    {
538      rv = vnet_lisp_del_mapping (eid, NULL);
539    }
540
541  if (mp->del_all)
542    vnet_lisp_clear_all_remote_adjacencies ();
543
544out:
545  vec_free (rlocs);
546send_reply:
547  REPLY_MACRO (VL_API_LISP_ADD_DEL_REMOTE_MAPPING_REPLY);
548}
549
550static void
551vl_api_lisp_add_del_adjacency_t_handler (vl_api_lisp_add_del_adjacency_t * mp)
552{
553  vl_api_lisp_add_del_adjacency_reply_t *rmp;
554  vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
555
556  int rv = 0;
557  clib_memset (a, 0, sizeof (a[0]));
558
559  rv = unformat_lisp_eid_api (&a->leid, clib_net_to_host_u32 (mp->vni),
560			      mp->eid_type, mp->leid, mp->leid_len);
561  rv |= unformat_lisp_eid_api (&a->reid, clib_net_to_host_u32 (mp->vni),
562			       mp->eid_type, mp->reid, mp->reid_len);
563
564  if (rv)
565    goto send_reply;
566
567  a->is_add = mp->is_add;
568  rv = vnet_lisp_add_del_adjacency (a);
569
570send_reply:
571  REPLY_MACRO (VL_API_LISP_ADD_DEL_ADJACENCY_REPLY);
572}
573
574static void
575send_lisp_locator_details (lisp_cp_main_t * lcm,
576			   locator_t * loc, vl_api_registration_t * reg,
577			   u32 context)
578{
579  vl_api_lisp_locator_details_t *rmp;
580
581  rmp = vl_msg_api_alloc (sizeof (*rmp));
582  clib_memset (rmp, 0, sizeof (*rmp));
583  rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_DETAILS);
584  rmp->context = context;
585
586  rmp->local = loc->local;
587  if (loc->local)
588    {
589      rmp->sw_if_index = ntohl (loc->sw_if_index);
590    }
591  else
592    {
593      rmp->is_ipv6 = gid_address_ip_version (&loc->address);
594      ip_address_copy_addr (rmp->ip_address, &gid_address_ip (&loc->address));
595    }
596  rmp->priority = loc->priority;
597  rmp->weight = loc->weight;
598
599  vl_api_send_msg (reg, (u8 *) rmp);
600}
601
602static void
603vl_api_lisp_locator_dump_t_handler (vl_api_lisp_locator_dump_t * mp)
604{
605  u8 *ls_name = 0;
606  vl_api_registration_t *reg = 0;
607  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
608  locator_set_t *lsit = 0;
609  locator_t *loc = 0;
610  u32 ls_index = ~0, *locit = 0;
611  uword *p = 0;
612
613  reg = vl_api_client_index_to_registration (mp->client_index);
614  if (!reg)
615    return;
616
617  if (mp->is_index_set)
618    ls_index = htonl (mp->ls_index);
619  else
620    {
621      /* make sure we get a proper C-string */
622      mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
623      ls_name = format (0, "%s", mp->ls_name);
624      vec_terminate_c_string (ls_name);
625      p = hash_get_mem (lcm->locator_set_index_by_name, ls_name);
626      if (!p)
627	goto out;
628      ls_index = p[0];
629    }
630
631  if (pool_is_free_index (lcm->locator_set_pool, ls_index))
632    return;
633
634  lsit = pool_elt_at_index (lcm->locator_set_pool, ls_index);
635
636  vec_foreach (locit, lsit->locator_indices)
637  {
638    loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
639    send_lisp_locator_details (lcm, loc, reg, mp->context);
640  };
641out:
642  vec_free (ls_name);
643}
644
645static void
646send_lisp_locator_set_details (lisp_cp_main_t * lcm,
647			       locator_set_t * lsit,
648			       vl_api_registration_t * reg, u32 context,
649			       u32 ls_index)
650{
651  vl_api_lisp_locator_set_details_t *rmp;
652  u8 *str = 0;
653
654  rmp = vl_msg_api_alloc (sizeof (*rmp));
655  clib_memset (rmp, 0, sizeof (*rmp));
656  rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_SET_DETAILS);
657  rmp->context = context;
658
659  rmp->ls_index = htonl (ls_index);
660  if (lsit->local)
661    {
662      ASSERT (lsit->name != NULL);
663      strncpy ((char *) rmp->ls_name, (char *) lsit->name,
664	       vec_len (lsit->name));
665    }
666  else
667    {
668      str = format (0, "<remote-%d>", ls_index);
669      strncpy ((char *) rmp->ls_name, (char *) str, vec_len (str));
670      vec_free (str);
671    }
672
673  vl_api_send_msg (reg, (u8 *) rmp);
674}
675
676static void
677vl_api_lisp_locator_set_dump_t_handler (vl_api_lisp_locator_set_dump_t * mp)
678{
679  vl_api_registration_t *reg;
680  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
681  locator_set_t *lsit = NULL;
682  u8 filter;
683
684  reg = vl_api_client_index_to_registration (mp->client_index);
685  if (!reg)
686    return;
687
688  filter = mp->filter;
689  /* *INDENT-OFF* */
690  pool_foreach (lsit, lcm->locator_set_pool,
691  ({
692    if (filter && !((1 == filter && lsit->local) ||
693                    (2 == filter && !lsit->local)))
694      {
695        continue;
696      }
697    send_lisp_locator_set_details (lcm, lsit, reg, mp->context,
698                                   lsit - lcm->locator_set_pool);
699  }));
700  /* *INDENT-ON* */
701}
702
703static void
704lisp_fid_put_api (u8 * dst, fid_address_t * src, u8 * prefix_length)
705{
706  ASSERT (prefix_length);
707  ip_prefix_t *ippref = &fid_addr_ippref (src);
708
709  switch (fid_addr_type (src))
710    {
711    case FID_ADDR_IP_PREF:
712      if (ip_prefix_version (ippref) == AF_IP4)
713	clib_memcpy (dst, &ip_prefix_v4 (ippref), 4);
714      else
715	clib_memcpy (dst, &ip_prefix_v6 (ippref), 16);
716      prefix_length[0] = ip_prefix_len (ippref);
717      break;
718
719    case FID_ADDR_MAC:
720      prefix_length[0] = 0;
721      clib_memcpy (dst, fid_addr_mac (src), 6);
722      break;
723
724    default:
725      clib_warning ("Unknown FID type %d!", fid_addr_type (src));
726      break;
727    }
728}
729
730static u8
731fid_type_to_api_type (fid_address_t * fid)
732{
733  ip_prefix_t *ippref;
734
735  switch (fid_addr_type (fid))
736    {
737    case FID_ADDR_IP_PREF:
738      ippref = &fid_addr_ippref (fid);
739      if (ip_prefix_version (ippref) == AF_IP4)
740	return 0;
741      else if (ip_prefix_version (ippref) == AF_IP6)
742	return 1;
743      else
744	return ~0;
745
746    case FID_ADDR_MAC:
747      return 2;
748    case FID_ADDR_NSH:
749      return 3;
750    }
751
752  return ~0;
753}
754
755static void
756send_lisp_eid_table_details (mapping_t * mapit,
757			     vl_api_registration_t * reg, u32 context,
758			     u8 filter)
759{
760  fid_address_t *fid;
761  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
762  locator_set_t *ls = 0;
763  vl_api_lisp_eid_table_details_t *rmp = NULL;
764  gid_address_t *gid = NULL;
765  u8 *mac = 0;
766  ip_prefix_t *ip_prefix = NULL;
767
768  switch (filter)
769    {
770    case 0:			/* all mappings */
771      break;
772
773    case 1:			/* local only */
774      if (!mapit->local)
775	return;
776      break;
777    case 2:			/* remote only */
778      if (mapit->local)
779	return;
780      break;
781    default:
782      clib_warning ("Filter error, unknown filter: %d", filter);
783      return;
784    }
785
786  /* don't send PITR generated mapping */
787  if (mapit->pitr_set)
788    return;
789
790  gid = &mapit->eid;
791  ip_prefix = &gid_address_ippref (gid);
792  mac = gid_address_mac (gid);
793
794  rmp = vl_msg_api_alloc (sizeof (*rmp));
795  clib_memset (rmp, 0, sizeof (*rmp));
796  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_DETAILS);
797
798  ls = pool_elt_at_index (lcm->locator_set_pool, mapit->locator_set_index);
799  if (vec_len (ls->locator_indices) == 0)
800    rmp->locator_set_index = ~0;
801  else
802    rmp->locator_set_index = clib_host_to_net_u32 (mapit->locator_set_index);
803
804  rmp->is_local = mapit->local;
805  rmp->ttl = clib_host_to_net_u32 (mapit->ttl);
806  rmp->action = mapit->action;
807  rmp->authoritative = mapit->authoritative;
808
809  switch (gid_address_type (gid))
810    {
811    case GID_ADDR_SRC_DST:
812      rmp->is_src_dst = 1;
813      fid = &gid_address_sd_src (gid);
814      rmp->eid_type = fid_type_to_api_type (fid);
815      lisp_fid_put_api (rmp->seid, &gid_address_sd_src (gid),
816			&rmp->seid_prefix_len);
817      lisp_fid_put_api (rmp->eid, &gid_address_sd_dst (gid),
818			&rmp->eid_prefix_len);
819      break;
820    case GID_ADDR_IP_PREFIX:
821      rmp->eid_prefix_len = ip_prefix_len (ip_prefix);
822      if (ip_prefix_version (ip_prefix) == AF_IP4)
823	{
824	  rmp->eid_type = 0;	/* ipv4 type */
825	  clib_memcpy (rmp->eid, &ip_prefix_v4 (ip_prefix),
826		       sizeof (ip_prefix_v4 (ip_prefix)));
827	}
828      else
829	{
830	  rmp->eid_type = 1;	/* ipv6 type */
831	  clib_memcpy (rmp->eid, &ip_prefix_v6 (ip_prefix),
832		       sizeof (ip_prefix_v6 (ip_prefix)));
833	}
834      break;
835    case GID_ADDR_MAC:
836      rmp->eid_type = 2;	/* l2 mac type */
837      clib_memcpy (rmp->eid, mac, 6);
838      break;
839    default:
840      ASSERT (0);
841    }
842  rmp->context = context;
843  rmp->vni = clib_host_to_net_u32 (gid_address_vni (gid));
844  rmp->key_id = clib_host_to_net_u16 (mapit->key_id);
845  memcpy (rmp->key, mapit->key, vec_len (mapit->key));
846  vl_api_send_msg (reg, (u8 *) rmp);
847}
848
849static void
850vl_api_lisp_eid_table_dump_t_handler (vl_api_lisp_eid_table_dump_t * mp)
851{
852  u32 mi;
853  vl_api_registration_t *reg;
854  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
855  mapping_t *mapit = NULL;
856  gid_address_t _eid, *eid = &_eid;
857
858  reg = vl_api_client_index_to_registration (mp->client_index);
859  if (!reg)
860    return;
861
862  if (mp->eid_set)
863    {
864      clib_memset (eid, 0, sizeof (*eid));
865
866      unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
867			     mp->eid_type, mp->eid, mp->prefix_length);
868
869      mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid);
870      if ((u32) ~ 0 == mi)
871	return;
872
873      mapit = pool_elt_at_index (lcm->mapping_pool, mi);
874      send_lisp_eid_table_details (mapit, reg, mp->context,
875				   0 /* ignore filter */ );
876    }
877  else
878    {
879      /* *INDENT-OFF* */
880      pool_foreach (mapit, lcm->mapping_pool,
881      ({
882        send_lisp_eid_table_details(mapit, reg, mp->context,
883                                    mp->filter);
884      }));
885      /* *INDENT-ON* */
886    }
887}
888
889static void
890send_lisp_map_server_details (ip_address_t * ip, vl_api_registration_t * reg,
891			      u32 context)
892{
893  vl_api_lisp_map_server_details_t *rmp = NULL;
894
895  rmp = vl_msg_api_alloc (sizeof (*rmp));
896  clib_memset (rmp, 0, sizeof (*rmp));
897  rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_SERVER_DETAILS);
898
899  switch (ip_addr_version (ip))
900    {
901    case AF_IP4:
902      rmp->is_ipv6 = 0;
903      clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
904		   sizeof (ip_addr_v4 (ip)));
905      break;
906
907    case AF_IP6:
908      rmp->is_ipv6 = 1;
909      clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
910		   sizeof (ip_addr_v6 (ip)));
911      break;
912
913    default:
914      ASSERT (0);
915    }
916  rmp->context = context;
917
918  vl_api_send_msg (reg, (u8 *) rmp);
919}
920
921static void
922vl_api_lisp_map_server_dump_t_handler (vl_api_lisp_map_server_dump_t * mp)
923{
924  vl_api_registration_t *reg;
925  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
926  lisp_msmr_t *mr;
927
928  reg = vl_api_client_index_to_registration (mp->client_index);
929  if (!reg)
930    return;
931
932  vec_foreach (mr, lcm->map_servers)
933  {
934    send_lisp_map_server_details (&mr->address, reg, mp->context);
935  }
936}
937
938static void
939send_lisp_map_resolver_details (ip_address_t * ip,
940				vl_api_registration_t * reg, u32 context)
941{
942  vl_api_lisp_map_resolver_details_t *rmp = NULL;
943
944  rmp = vl_msg_api_alloc (sizeof (*rmp));
945  clib_memset (rmp, 0, sizeof (*rmp));
946  rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_RESOLVER_DETAILS);
947
948  switch (ip_addr_version (ip))
949    {
950    case AF_IP4:
951      rmp->is_ipv6 = 0;
952      clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
953		   sizeof (ip_addr_v4 (ip)));
954      break;
955
956    case AF_IP6:
957      rmp->is_ipv6 = 1;
958      clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
959		   sizeof (ip_addr_v6 (ip)));
960      break;
961
962    default:
963      ASSERT (0);
964    }
965  rmp->context = context;
966
967  vl_api_send_msg (reg, (u8 *) rmp);
968}
969
970static void
971vl_api_lisp_map_resolver_dump_t_handler (vl_api_lisp_map_resolver_dump_t * mp)
972{
973  vl_api_registration_t *reg;
974  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
975  lisp_msmr_t *mr;
976
977  reg = vl_api_client_index_to_registration (mp->client_index);
978  if (!reg)
979    return;
980
981  vec_foreach (mr, lcm->map_resolvers)
982  {
983    send_lisp_map_resolver_details (&mr->address, reg, mp->context);
984  }
985}
986
987static void
988send_eid_table_map_pair (hash_pair_t * p, vl_api_registration_t * reg,
989			 u32 context)
990{
991  vl_api_lisp_eid_table_map_details_t *rmp = NULL;
992
993  rmp = vl_msg_api_alloc (sizeof (*rmp));
994  clib_memset (rmp, 0, sizeof (*rmp));
995  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_MAP_DETAILS);
996
997  rmp->vni = clib_host_to_net_u32 (p->key);
998  rmp->dp_table = clib_host_to_net_u32 (p->value[0]);
999  rmp->context = context;
1000  vl_api_send_msg (reg, (u8 *) rmp);
1001}
1002
1003static void
1004vl_api_lisp_eid_table_map_dump_t_handler (vl_api_lisp_eid_table_map_dump_t *
1005					  mp)
1006{
1007  vl_api_registration_t *reg;
1008  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1009  hash_pair_t *p;
1010  uword *vni_table = 0;
1011
1012  reg = vl_api_client_index_to_registration (mp->client_index);
1013  if (!reg)
1014    return;
1015
1016  if (mp->is_l2)
1017    {
1018      vni_table = lcm->bd_id_by_vni;
1019    }
1020  else
1021    {
1022      vni_table = lcm->table_id_by_vni;
1023    }
1024
1025  /* *INDENT-OFF* */
1026  hash_foreach_pair (p, vni_table,
1027  ({
1028    send_eid_table_map_pair (p, reg, mp->context);
1029  }));
1030  /* *INDENT-ON* */
1031}
1032
1033static void
1034send_eid_table_vni (u32 vni, vl_api_registration_t * reg, u32 context)
1035{
1036  vl_api_lisp_eid_table_vni_details_t *rmp = 0;
1037
1038  rmp = vl_msg_api_alloc (sizeof (*rmp));
1039  clib_memset (rmp, 0, sizeof (*rmp));
1040  rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_VNI_DETAILS);
1041  rmp->context = context;
1042  rmp->vni = clib_host_to_net_u32 (vni);
1043  vl_api_send_msg (reg, (u8 *) rmp);
1044}
1045
1046static void
1047lisp_adjacency_copy (vl_api_lisp_adjacency_t * dst, lisp_adjacency_t * adjs)
1048{
1049  lisp_adjacency_t *adj;
1050  vl_api_lisp_adjacency_t a;
1051  u32 i, n = vec_len (adjs);
1052
1053  for (i = 0; i < n; i++)
1054    {
1055      adj = vec_elt_at_index (adjs, i);
1056      clib_memset (&a, 0, sizeof (a));
1057
1058      switch (gid_address_type (&adj->reid))
1059	{
1060	case GID_ADDR_IP_PREFIX:
1061	  a.reid_prefix_len = gid_address_ippref_len (&adj->reid);
1062	  a.leid_prefix_len = gid_address_ippref_len (&adj->leid);
1063	  if (gid_address_ip_version (&adj->reid) == AF_IP4)
1064	    {
1065	      a.eid_type = 0;	/* ipv4 type */
1066	      clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 4);
1067	      clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 4);
1068	    }
1069	  else
1070	    {
1071	      a.eid_type = 1;	/* ipv6 type */
1072	      clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 16);
1073	      clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 16);
1074	    }
1075	  break;
1076	case GID_ADDR_MAC:
1077	  a.eid_type = 2;	/* l2 mac type */
1078	  mac_copy (a.reid, gid_address_mac (&adj->reid));
1079	  mac_copy (a.leid, gid_address_mac (&adj->leid));
1080	  break;
1081	default:
1082	  ASSERT (0);
1083	}
1084      dst[i] = a;
1085    }
1086}
1087
1088static void
1089  vl_api_show_lisp_rloc_probe_state_t_handler
1090  (vl_api_show_lisp_rloc_probe_state_t * mp)
1091{
1092  vl_api_show_lisp_rloc_probe_state_reply_t *rmp = 0;
1093  int rv = 0;
1094
1095  /* *INDENT-OFF* */
1096  REPLY_MACRO2 (VL_API_SHOW_LISP_RLOC_PROBE_STATE_REPLY,
1097  {
1098    rmp->is_enabled = vnet_lisp_rloc_probe_state_get ();
1099  });
1100  /* *INDENT-ON* */
1101}
1102
1103static void
1104  vl_api_show_lisp_map_register_state_t_handler
1105  (vl_api_show_lisp_map_register_state_t * mp)
1106{
1107  vl_api_show_lisp_map_register_state_reply_t *rmp = 0;
1108  int rv = 0;
1109
1110  /* *INDENT-OFF* */
1111  REPLY_MACRO2 (VL_API_SHOW_LISP_MAP_REGISTER_STATE_REPLY,
1112  {
1113    rmp->is_enabled = vnet_lisp_map_register_state_get ();
1114  });
1115  /* *INDENT-ON* */
1116}
1117
1118static void
1119vl_api_lisp_adjacencies_get_t_handler (vl_api_lisp_adjacencies_get_t * mp)
1120{
1121  vl_api_lisp_adjacencies_get_reply_t *rmp = 0;
1122  lisp_adjacency_t *adjs = 0;
1123  int rv = 0;
1124  u32 size = ~0;
1125  u32 vni = clib_net_to_host_u32 (mp->vni);
1126
1127  adjs = vnet_lisp_adjacencies_get_by_vni (vni);
1128  size = vec_len (adjs) * sizeof (vl_api_lisp_adjacency_t);
1129
1130  /* *INDENT-OFF* */
1131  REPLY_MACRO4 (VL_API_LISP_ADJACENCIES_GET_REPLY, size,
1132  {
1133    rmp->count = clib_host_to_net_u32 (vec_len (adjs));
1134    lisp_adjacency_copy (rmp->adjacencies, adjs);
1135  });
1136  /* *INDENT-ON* */
1137
1138  vec_free (adjs);
1139}
1140
1141static void
1142vl_api_lisp_eid_table_vni_dump_t_handler (vl_api_lisp_eid_table_vni_dump_t *
1143					  mp)
1144{
1145  hash_pair_t *p;
1146  u32 *vnis = 0;
1147  vl_api_registration_t *reg = 0;
1148  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1149
1150  reg = vl_api_client_index_to_registration (mp->client_index);
1151  if (!reg)
1152    return;
1153
1154  /* *INDENT-OFF* */
1155  hash_foreach_pair (p, lcm->table_id_by_vni,
1156  ({
1157    hash_set (vnis, p->key, 0);
1158  }));
1159
1160  hash_foreach_pair (p, lcm->bd_id_by_vni,
1161  ({
1162    hash_set (vnis, p->key, 0);
1163  }));
1164
1165  hash_foreach_pair (p, vnis,
1166  ({
1167    send_eid_table_vni (p->key, reg, mp->context);
1168  }));
1169  /* *INDENT-ON* */
1170
1171  hash_free (vnis);
1172}
1173
1174static void
1175vl_api_show_lisp_status_t_handler (vl_api_show_lisp_status_t * mp)
1176{
1177  vl_api_show_lisp_status_reply_t *rmp = NULL;
1178  int rv = 0;
1179
1180  /* *INDENT-OFF* */
1181  REPLY_MACRO2(VL_API_SHOW_LISP_STATUS_REPLY,
1182  ({
1183    rmp->gpe_status = vnet_lisp_gpe_enable_disable_status ();
1184    rmp->feature_status = vnet_lisp_enable_disable_status ();
1185  }));
1186  /* *INDENT-ON* */
1187}
1188
1189static void
1190  vl_api_lisp_get_map_request_itr_rlocs_t_handler
1191  (vl_api_lisp_get_map_request_itr_rlocs_t * mp)
1192{
1193  vl_api_lisp_get_map_request_itr_rlocs_reply_t *rmp = NULL;
1194  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1195  locator_set_t *loc_set = 0;
1196  u8 *tmp_str = 0;
1197  int rv = 0;
1198
1199  if (~0 == lcm->mreq_itr_rlocs)
1200    {
1201      tmp_str = format (0, " ");
1202    }
1203  else
1204    {
1205      loc_set =
1206	pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
1207      tmp_str = format (0, "%s", loc_set->name);
1208    }
1209
1210  /* *INDENT-OFF* */
1211  REPLY_MACRO2(VL_API_LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY,
1212  ({
1213    strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1214            ARRAY_LEN(rmp->locator_set_name) - 1);
1215  }));
1216  /* *INDENT-ON* */
1217
1218  vec_free (tmp_str);
1219}
1220
1221static void
1222vl_api_show_lisp_pitr_t_handler (vl_api_show_lisp_pitr_t * mp)
1223{
1224  vl_api_show_lisp_pitr_reply_t *rmp = NULL;
1225  lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
1226  mapping_t *m;
1227  locator_set_t *ls = 0;
1228  u8 *tmp_str = 0;
1229  int rv = 0;
1230
1231  u8 is_enabled = (lcm->flags & LISP_FLAG_PITR_MODE)
1232    && lcm->pitr_map_index != ~0;
1233
1234  if (!is_enabled)
1235    {
1236      tmp_str = format (0, "N/A");
1237    }
1238  else
1239    {
1240      m = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
1241      if (~0 != m->locator_set_index)
1242	{
1243	  ls =
1244	    pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
1245	  tmp_str = format (0, "%s", ls->name);
1246	}
1247      else
1248	{
1249	  tmp_str = format (0, "N/A");
1250	}
1251    }
1252  vec_add1 (tmp_str, 0);
1253
1254  /* *INDENT-OFF* */
1255  REPLY_MACRO2(VL_API_SHOW_LISP_PITR_REPLY,
1256  ({
1257    rmp->status = lcm->flags & LISP_FLAG_PITR_MODE;
1258    strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
1259            ARRAY_LEN(rmp->locator_set_name) - 1);
1260  }));
1261  /* *INDENT-ON* */
1262}
1263
1264/*
1265 * lisp_api_hookup
1266 * Add vpe's API message handlers to the table.
1267 * vlib has already mapped shared memory and
1268 * added the client registration handlers.
1269 * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process()
1270 */
1271#define vl_msg_name_crc_list
1272#include <vnet/vnet_all_api_h.h>
1273#undef vl_msg_name_crc_list
1274
1275static void
1276setup_message_id_table (api_main_t * am)
1277{
1278#define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1279  foreach_vl_msg_name_crc_lisp;
1280#undef _
1281}
1282
1283static clib_error_t *
1284lisp_api_hookup (vlib_main_t * vm)
1285{
1286  api_main_t *am = vlibapi_get_main ();
1287
1288#define _(N,n)                                                  \
1289    vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1290                           vl_api_##n##_t_handler,              \
1291                           vl_noop_handler,                     \
1292                           vl_api_##n##_t_endian,               \
1293                           vl_api_##n##_t_print,                \
1294                           sizeof(vl_api_##n##_t), 1);
1295  foreach_vpe_api_msg;
1296#undef _
1297
1298  /*
1299   * Set up the (msg_name, crc, message-id) table
1300   */
1301  setup_message_id_table (am);
1302
1303  return 0;
1304}
1305
1306VLIB_API_INIT_FUNCTION (lisp_api_hookup);
1307
1308/*
1309 * fd.io coding-style-patch-verification: ON
1310 *
1311 * Local Variables:
1312 * eval: (c-set-style "gnu")
1313 * End:
1314 */
1315