2 *------------------------------------------------------------------
3 * api.c - message handler registration
5 * Copyright (c) 2010-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:
10 * http://www.apache.org/licenses/LICENSE-2.0
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 *------------------------------------------------------------------
23 #include <sys/types.h>
26 #include <netinet/in.h>
36 #include <vppinfra/clib.h>
37 #include <vppinfra/vec.h>
38 #include <vppinfra/hash.h>
39 #include <vppinfra/bitmap.h>
40 #include <vppinfra/fifo.h>
41 #include <vppinfra/time.h>
42 #include <vppinfra/mheap.h>
43 #include <vppinfra/heap.h>
44 #include <vppinfra/pool.h>
45 #include <vppinfra/format.h>
46 #include <vppinfra/error.h>
48 #include <vnet/api_errno.h>
49 #include <vnet/vnet.h>
50 #include <vnet/l2/l2_input.h>
51 #include <vnet/l2/l2_bd.h>
52 #include <vnet/ip/ip.h>
53 #include <vnet/ip/ip6.h>
54 #include <vnet/ip/ip6_neighbor.h>
55 #include <vnet/mpls/mpls.h>
56 #include <vnet/mpls/mpls_tunnel.h>
57 #include <vnet/dhcp/proxy.h>
58 #include <vnet/dhcp/client.h>
60 #include <vnet/sr/sr.h>
62 #include <vnet/dhcpv6/proxy.h>
63 #include <vlib/vlib.h>
64 #include <vlib/unix/unix.h>
65 #include <vlibapi/api.h>
66 #include <vlibmemory/api.h>
67 #include <vnet/classify/vnet_classify.h>
68 #include <vnet/classify/input_acl.h>
69 #include <vnet/classify/policer_classify.h>
70 #include <vnet/classify/flow_classify.h>
71 #include <vnet/l2/l2_classify.h>
72 #include <vnet/vxlan/vxlan.h>
73 #include <vnet/l2/l2_vtr.h>
74 #include <vnet/vxlan-gpe/vxlan_gpe.h>
75 #include <vnet/lisp-gpe/lisp_gpe.h>
76 #include <vnet/lisp-gpe/lisp_gpe_fwd_entry.h>
77 #include <vnet/lisp-gpe/lisp_gpe_tenant.h>
78 #include <vnet/lisp-cp/control.h>
79 #include <vnet/map/map.h>
80 #include <vnet/cop/cop.h>
81 #include <vnet/ip/ip6_hop_by_hop.h>
82 #include <vnet/ip/ip_source_and_port_range_check.h>
83 #include <vnet/policer/policer.h>
84 #include <vnet/flow/flow_report.h>
85 #include <vnet/ipsec-gre/ipsec_gre.h>
86 #include <vnet/flow/flow_report_classify.h>
87 #include <vnet/ip/punt.h>
88 #include <vnet/feature/feature.h>
91 #undef __included_bihash_template_h__
92 #include <vnet/l2/l2_fib.h>
95 #include <vnet/devices/dpdk/dpdk.h>
99 #include <vnet/ipsec/ipsec.h>
100 #include <vnet/ipsec/ikev2.h>
103 #include <stats/stats.h>
106 #include <vnet/ethernet/ethernet.h>
107 #include <vnet/ethernet/arp_packet.h>
108 #include <vnet/interface.h>
110 #include <vnet/l2/l2_fib.h>
111 #include <vnet/l2/l2_bd.h>
112 #include <vpp-api/vpe_msg_enum.h>
113 #include <vnet/span/span.h>
115 #include <vnet/fib/ip6_fib.h>
116 #include <vnet/fib/ip4_fib.h>
117 #include <vnet/fib/fib_api.h>
118 #include <vnet/dpo/drop_dpo.h>
119 #include <vnet/dpo/receive_dpo.h>
120 #include <vnet/dpo/lookup_dpo.h>
121 #include <vnet/dpo/classify_dpo.h>
122 #include <vnet/dpo/ip_null_dpo.h>
124 #define vl_typedefs /* define message structures */
125 #include <vpp-api/vpe_all_api_h.h>
128 #define vl_endianfun /* define message structures */
129 #include <vpp-api/vpe_all_api_h.h>
132 /* instantiate all the print functions we know about */
133 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
135 #include <vpp-api/vpe_all_api_h.h>
138 #include <vlibapi/api_helper_macros.h>
140 #define foreach_vpe_api_msg \
141 _(WANT_OAM_EVENTS, want_oam_events) \
142 _(OAM_ADD_DEL, oam_add_del) \
143 _(MPLS_ROUTE_ADD_DEL, mpls_route_add_del) \
144 _(MPLS_IP_BIND_UNBIND, mpls_ip_bind_unbind) \
145 _(IS_ADDRESS_REACHABLE, is_address_reachable) \
146 _(SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable) \
147 _(SW_INTERFACE_SET_VPATH, sw_interface_set_vpath) \
148 _(SW_INTERFACE_SET_VXLAN_BYPASS, sw_interface_set_vxlan_bypass) \
149 _(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect) \
150 _(SW_INTERFACE_SET_L2_BRIDGE, sw_interface_set_l2_bridge) \
151 _(SW_INTERFACE_SET_DPDK_HQOS_PIPE, sw_interface_set_dpdk_hqos_pipe) \
152 _(SW_INTERFACE_SET_DPDK_HQOS_SUBPORT, sw_interface_set_dpdk_hqos_subport) \
153 _(SW_INTERFACE_SET_DPDK_HQOS_TCTBL, sw_interface_set_dpdk_hqos_tctbl) \
154 _(BRIDGE_DOMAIN_ADD_DEL, bridge_domain_add_del) \
155 _(BRIDGE_DOMAIN_DUMP, bridge_domain_dump) \
156 _(BRIDGE_DOMAIN_DETAILS, bridge_domain_details) \
157 _(BRIDGE_DOMAIN_SW_IF_DETAILS, bridge_domain_sw_if_details) \
158 _(L2FIB_ADD_DEL, l2fib_add_del) \
159 _(L2_FLAGS, l2_flags) \
160 _(BRIDGE_FLAGS, bridge_flags) \
161 _(CREATE_VLAN_SUBIF, create_vlan_subif) \
162 _(CREATE_SUBIF, create_subif) \
163 _(MPLS_TUNNEL_ADD_DEL, mpls_tunnel_add_del) \
164 _(PROXY_ARP_ADD_DEL, proxy_arp_add_del) \
165 _(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable) \
166 _(VNET_GET_SUMMARY_STATS, vnet_get_summary_stats) \
167 _(RESET_FIB, reset_fib) \
168 _(DHCP_PROXY_CONFIG,dhcp_proxy_config) \
169 _(DHCP_PROXY_CONFIG_2,dhcp_proxy_config_2) \
170 _(DHCP_PROXY_SET_VSS,dhcp_proxy_set_vss) \
171 _(DHCP_CLIENT_CONFIG, dhcp_client_config) \
172 _(CREATE_LOOPBACK, create_loopback) \
173 _(CONTROL_PING, control_ping) \
174 _(CLI_REQUEST, cli_request) \
175 _(CLI_INBAND, cli_inband) \
176 _(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit) \
177 _(L2_PATCH_ADD_DEL, l2_patch_add_del) \
178 _(CLASSIFY_ADD_DEL_TABLE, classify_add_del_table) \
179 _(CLASSIFY_ADD_DEL_SESSION, classify_add_del_session) \
180 _(CLASSIFY_SET_INTERFACE_IP_TABLE, classify_set_interface_ip_table) \
181 _(CLASSIFY_SET_INTERFACE_L2_TABLES, classify_set_interface_l2_tables) \
182 _(GET_NODE_INDEX, get_node_index) \
183 _(ADD_NODE_NEXT, add_node_next) \
184 _(VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel) \
185 _(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump) \
186 _(L2_FIB_CLEAR_TABLE, l2_fib_clear_table) \
187 _(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter) \
188 _(L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite) \
189 _(SHOW_VERSION, show_version) \
190 _(L2_FIB_TABLE_DUMP, l2_fib_table_dump) \
191 _(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
192 _(VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel) \
193 _(VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump) \
194 _(INTERFACE_NAME_RENUMBER, interface_name_renumber) \
195 _(WANT_IP4_ARP_EVENTS, want_ip4_arp_events) \
196 _(WANT_IP6_ND_EVENTS, want_ip6_nd_events) \
197 _(INPUT_ACL_SET_INTERFACE, input_acl_set_interface) \
198 _(IPSEC_SPD_ADD_DEL, ipsec_spd_add_del) \
199 _(IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd) \
200 _(IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry) \
201 _(IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry) \
202 _(IPSEC_SA_SET_KEY, ipsec_sa_set_key) \
203 _(IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del) \
204 _(IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth) \
205 _(IKEV2_PROFILE_SET_ID, ikev2_profile_set_id) \
206 _(IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts) \
207 _(IKEV2_SET_LOCAL_KEY, ikev2_set_local_key) \
208 _(DELETE_LOOPBACK, delete_loopback) \
209 _(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del) \
210 _(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable) \
211 _(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable) \
212 _(GET_NODE_GRAPH, get_node_graph) \
213 _(IOAM_ENABLE, ioam_enable) \
214 _(IOAM_DISABLE, ioam_disable) \
215 _(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set) \
216 _(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator) \
217 _(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid) \
218 _(LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry) \
219 _(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver) \
220 _(LISP_ADD_DEL_MAP_SERVER, lisp_add_del_map_server) \
221 _(LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable) \
222 _(LISP_ENABLE_DISABLE, lisp_enable_disable) \
223 _(LISP_RLOC_PROBE_ENABLE_DISABLE, lisp_rloc_probe_enable_disable) \
224 _(LISP_MAP_REGISTER_ENABLE_DISABLE, lisp_map_register_enable_disable) \
225 _(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface) \
226 _(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping) \
227 _(LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency) \
228 _(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set) \
229 _(LISP_MAP_REQUEST_MODE, lisp_map_request_mode) \
230 _(LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map) \
231 _(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump) \
232 _(LISP_LOCATOR_DUMP, lisp_locator_dump) \
233 _(LISP_EID_TABLE_DUMP, lisp_eid_table_dump) \
234 _(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump) \
235 _(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump) \
236 _(LISP_MAP_SERVER_DUMP, lisp_map_server_dump) \
237 _(LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump) \
238 _(LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump) \
239 _(LISP_ADJACENCIES_GET, lisp_adjacencies_get) \
240 _(SHOW_LISP_RLOC_PROBE_STATE, show_lisp_rloc_probe_state) \
241 _(SHOW_LISP_MAP_REGISTER_STATE, show_lisp_map_register_state) \
242 _(SHOW_LISP_STATUS, show_lisp_status) \
243 _(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, \
244 lisp_add_del_map_request_itr_rlocs) \
245 _(LISP_GET_MAP_REQUEST_ITR_RLOCS, lisp_get_map_request_itr_rlocs) \
246 _(SHOW_LISP_PITR, show_lisp_pitr) \
247 _(SHOW_LISP_MAP_REQUEST_MODE, show_lisp_map_request_mode) \
248 _(SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del) \
249 _(POLICER_ADD_DEL, policer_add_del) \
250 _(POLICER_DUMP, policer_dump) \
251 _(POLICER_CLASSIFY_SET_INTERFACE, policer_classify_set_interface) \
252 _(POLICER_CLASSIFY_DUMP, policer_classify_dump) \
253 _(MPLS_TUNNEL_DUMP, mpls_tunnel_dump) \
254 _(MPLS_TUNNEL_DETAILS, mpls_tunnel_details) \
255 _(MPLS_FIB_DUMP, mpls_fib_dump) \
256 _(MPLS_FIB_DETAILS, mpls_fib_details) \
257 _(CLASSIFY_TABLE_IDS,classify_table_ids) \
258 _(CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface) \
259 _(CLASSIFY_TABLE_INFO,classify_table_info) \
260 _(CLASSIFY_SESSION_DUMP,classify_session_dump) \
261 _(CLASSIFY_SESSION_DETAILS,classify_session_details) \
262 _(SET_IPFIX_EXPORTER, set_ipfix_exporter) \
263 _(IPFIX_EXPORTER_DUMP, ipfix_exporter_dump) \
264 _(SET_IPFIX_CLASSIFY_STREAM, set_ipfix_classify_stream) \
265 _(IPFIX_CLASSIFY_STREAM_DUMP, ipfix_classify_stream_dump) \
266 _(IPFIX_CLASSIFY_TABLE_ADD_DEL, ipfix_classify_table_add_del) \
267 _(IPFIX_CLASSIFY_TABLE_DUMP, ipfix_classify_table_dump) \
268 _(GET_NEXT_INDEX, get_next_index) \
269 _(PG_CREATE_INTERFACE, pg_create_interface) \
270 _(PG_CAPTURE, pg_capture) \
271 _(PG_ENABLE_DISABLE, pg_enable_disable) \
272 _(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, \
273 ip_source_and_port_range_check_add_del) \
274 _(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, \
275 ip_source_and_port_range_check_interface_add_del) \
276 _(IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel) \
277 _(IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump) \
278 _(DELETE_SUBIF, delete_subif) \
279 _(L2_INTERFACE_PBB_TAG_REWRITE, l2_interface_pbb_tag_rewrite) \
281 _(FLOW_CLASSIFY_SET_INTERFACE, flow_classify_set_interface) \
282 _(FLOW_CLASSIFY_DUMP, flow_classify_dump) \
283 _(IPSEC_SPD_DUMP, ipsec_spd_dump) \
284 _(FEATURE_ENABLE_DISABLE, feature_enable_disable)
287 #define QUOTE(x) QUOTE_(x)
291 RESOLVE_IP4_ADD_DEL_ROUTE = 1,
292 RESOLVE_IP6_ADD_DEL_ROUTE,
295 static vlib_node_registration_t vpe_resolver_process_node;
296 vpe_api_main_t vpe_api_main;
298 static int arp_change_delete_callback (u32 pool_index, u8 * notused);
299 static int nd_change_delete_callback (u32 pool_index, u8 * notused);
301 /* Clean up all registrations belonging to the indicated client */
303 vl_api_memclnt_delete_callback (u32 client_index)
305 vpe_api_main_t *vam = &vpe_api_main;
306 vpe_client_registration_t *rp;
308 int stats_memclnt_delete_callback (u32 client_index);
310 stats_memclnt_delete_callback (client_index);
313 p = hash_get (vam->a##_registration_hash, client_index); \
315 rp = pool_elt_at_index (vam->a##_registrations, p[0]); \
316 pool_put (vam->a##_registrations, rp); \
317 hash_unset (vam->a##_registration_hash, client_index); \
319 foreach_registration_hash;
324 pub_sub_handler (oam_events, OAM_EVENTS);
326 #define RESOLUTION_EVENT 1
327 #define RESOLUTION_PENDING_EVENT 2
328 #define IP4_ARP_EVENT 3
329 #define IP6_ND_EVENT 4
331 int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp);
333 int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp);
336 handle_ip4_arp_event (u32 pool_index)
338 vpe_api_main_t *vam = &vpe_api_main;
339 vnet_main_t *vnm = vam->vnet_main;
340 vlib_main_t *vm = vam->vlib_main;
341 vl_api_ip4_arp_event_t *event;
342 vl_api_ip4_arp_event_t *mp;
343 unix_shared_memory_queue_t *q;
345 /* Client can cancel, die, etc. */
346 if (pool_is_free_index (vam->arp_events, pool_index))
349 event = pool_elt_at_index (vam->arp_events, pool_index);
351 q = vl_api_client_index_to_input_queue (event->client_index);
354 (void) vnet_add_del_ip4_arp_change_event
355 (vnm, arp_change_delete_callback,
356 event->pid, &event->address,
357 vpe_resolver_process_node.index, IP4_ARP_EVENT,
358 ~0 /* pool index, notused */ , 0 /* is_add */ );
362 if (q->cursize < q->maxsize)
364 mp = vl_msg_api_alloc (sizeof (*mp));
365 clib_memcpy (mp, event, sizeof (*mp));
366 vl_msg_api_send_shmem (q, (u8 *) & mp);
370 static f64 last_time;
372 * Throttle syslog msgs.
373 * It's pretty tempting to just revoke the registration...
375 if (vlib_time_now (vm) > last_time + 10.0)
377 clib_warning ("arp event for %U to pid %d: queue stuffed!",
378 format_ip4_address, &event->address, event->pid);
379 last_time = vlib_time_now (vm);
385 handle_ip6_nd_event (u32 pool_index)
387 vpe_api_main_t *vam = &vpe_api_main;
388 vnet_main_t *vnm = vam->vnet_main;
389 vlib_main_t *vm = vam->vlib_main;
390 vl_api_ip6_nd_event_t *event;
391 vl_api_ip6_nd_event_t *mp;
392 unix_shared_memory_queue_t *q;
394 /* Client can cancel, die, etc. */
395 if (pool_is_free_index (vam->nd_events, pool_index))
398 event = pool_elt_at_index (vam->nd_events, pool_index);
400 q = vl_api_client_index_to_input_queue (event->client_index);
403 (void) vnet_add_del_ip6_nd_change_event
404 (vnm, nd_change_delete_callback,
405 event->pid, &event->address,
406 vpe_resolver_process_node.index, IP6_ND_EVENT,
407 ~0 /* pool index, notused */ , 0 /* is_add */ );
411 if (q->cursize < q->maxsize)
413 mp = vl_msg_api_alloc (sizeof (*mp));
414 clib_memcpy (mp, event, sizeof (*mp));
415 vl_msg_api_send_shmem (q, (u8 *) & mp);
419 static f64 last_time;
421 * Throttle syslog msgs.
422 * It's pretty tempting to just revoke the registration...
424 if (vlib_time_now (vm) > last_time + 10.0)
426 clib_warning ("ip6 nd event for %U to pid %d: queue stuffed!",
427 format_ip6_address, &event->address, event->pid);
428 last_time = vlib_time_now (vm);
434 resolver_process (vlib_main_t * vm,
435 vlib_node_runtime_t * rt, vlib_frame_t * f)
438 uword *event_data = 0;
444 vlib_process_wait_for_event_or_clock (vm, timeout);
446 event_type = vlib_process_get_events (vm, &event_data);
450 case RESOLUTION_PENDING_EVENT:
454 case RESOLUTION_EVENT:
455 clib_warning ("resolver: BOGUS TYPE");
459 for (i = 0; i < vec_len (event_data); i++)
460 handle_ip4_arp_event (event_data[i]);
464 for (i = 0; i < vec_len (event_data); i++)
465 handle_ip6_nd_event (event_data[i]);
468 case ~0: /* timeout */
472 vec_reset_length (event_data);
474 return 0; /* or not */
478 VLIB_REGISTER_NODE (vpe_resolver_process_node,static) = {
479 .function = resolver_process,
480 .type = VLIB_NODE_TYPE_PROCESS,
481 .name = "vpe-route-resolver-process",
486 mpls_route_add_del_t_handler (vnet_main_t * vnm,
487 vl_api_mpls_route_add_del_t * mp)
489 u32 fib_index, next_hop_fib_index;
490 mpls_label_t *label_stack = NULL;
491 int rv, ii, n_labels;;
495 .fp_proto = FIB_PROTOCOL_MPLS,
496 .fp_eos = mp->mr_eos,
497 .fp_label = ntohl (mp->mr_label),
501 if (mp->mr_next_hop_proto_is_ip4)
503 pfx.fp_payload_proto = DPO_PROTO_IP4;
507 pfx.fp_payload_proto = DPO_PROTO_IP6;
512 pfx.fp_payload_proto = DPO_PROTO_MPLS;
515 rv = add_del_route_check (FIB_PROTOCOL_MPLS,
517 mp->mr_next_hop_sw_if_index,
518 dpo_proto_to_fib (pfx.fp_payload_proto),
519 mp->mr_next_hop_table_id,
520 mp->mr_create_table_if_needed,
521 &fib_index, &next_hop_fib_index);
527 memset (&nh, 0, sizeof (nh));
529 if (mp->mr_next_hop_proto_is_ip4)
530 memcpy (&nh.ip4, mp->mr_next_hop, sizeof (nh.ip4));
532 memcpy (&nh.ip6, mp->mr_next_hop, sizeof (nh.ip6));
534 n_labels = mp->mr_next_hop_n_out_labels;
537 else if (1 == n_labels)
538 vec_add1 (label_stack, ntohl (mp->mr_next_hop_out_label_stack[0]));
541 vec_validate (label_stack, n_labels - 1);
542 for (ii = 0; ii < n_labels; ii++)
543 label_stack[ii] = ntohl (mp->mr_next_hop_out_label_stack[ii]);
546 return (add_del_route_t_handler (mp->mr_is_multipath, mp->mr_is_add, 0, // mp->is_drop,
547 0, // mp->is_unreach,
548 0, // mp->is_prohibit,
551 mp->mr_classify_table_index,
552 mp->mr_is_resolve_host,
553 mp->mr_is_resolve_attached,
555 mp->mr_next_hop_proto_is_ip4,
556 &nh, ntohl (mp->mr_next_hop_sw_if_index),
558 mp->mr_next_hop_weight,
559 ntohl (mp->mr_next_hop_via_label),
564 vl_api_mpls_route_add_del_t_handler (vl_api_mpls_route_add_del_t * mp)
566 vl_api_mpls_route_add_del_reply_t *rmp;
570 vnm = vnet_get_main ();
573 rv = mpls_route_add_del_t_handler (vnm, mp);
575 rv = (rv == 0) ? vnm->api_errno : rv;
577 REPLY_MACRO (VL_API_MPLS_ROUTE_ADD_DEL_REPLY);
581 mpls_ip_bind_unbind_handler (vnet_main_t * vnm,
582 vl_api_mpls_ip_bind_unbind_t * mp)
584 u32 mpls_fib_index, ip_fib_index;
587 fib_table_find (FIB_PROTOCOL_MPLS, ntohl (mp->mb_mpls_table_id));
589 if (~0 == mpls_fib_index)
591 if (mp->mb_create_table_if_needed)
594 fib_table_find_or_create_and_lock (FIB_PROTOCOL_MPLS,
595 ntohl (mp->mb_mpls_table_id));
598 return VNET_API_ERROR_NO_SUCH_FIB;
601 ip_fib_index = fib_table_find ((mp->mb_is_ip4 ?
604 ntohl (mp->mb_ip_table_id));
605 if (~0 == ip_fib_index)
606 return VNET_API_ERROR_NO_SUCH_FIB;
609 .fp_len = mp->mb_address_length,
614 pfx.fp_proto = FIB_PROTOCOL_IP4;
615 clib_memcpy (&pfx.fp_addr.ip4, mp->mb_address,
616 sizeof (pfx.fp_addr.ip4));
620 pfx.fp_proto = FIB_PROTOCOL_IP6;
621 clib_memcpy (&pfx.fp_addr.ip6, mp->mb_address,
622 sizeof (pfx.fp_addr.ip6));
626 fib_table_entry_local_label_add (ip_fib_index, &pfx,
627 ntohl (mp->mb_label));
629 fib_table_entry_local_label_remove (ip_fib_index, &pfx,
630 ntohl (mp->mb_label));
636 vl_api_mpls_ip_bind_unbind_t_handler (vl_api_mpls_ip_bind_unbind_t * mp)
638 vl_api_mpls_route_add_del_reply_t *rmp;
642 vnm = vnet_get_main ();
645 rv = mpls_ip_bind_unbind_handler (vnm, mp);
647 rv = (rv == 0) ? vnm->api_errno : rv;
649 REPLY_MACRO (VL_API_MPLS_ROUTE_ADD_DEL_REPLY);
653 vl_api_sw_interface_set_vpath_t_handler (vl_api_sw_interface_set_vpath_t * mp)
655 vl_api_sw_interface_set_vpath_reply_t *rmp;
657 u32 sw_if_index = ntohl (mp->sw_if_index);
659 VALIDATE_SW_IF_INDEX (mp);
661 l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_VPATH, mp->enable);
662 vnet_feature_enable_disable ("ip4-unicast", "vpath-input-ip4",
663 sw_if_index, mp->enable, 0, 0);
664 vnet_feature_enable_disable ("ip4-multicast", "vpath-input-ip4",
665 sw_if_index, mp->enable, 0, 0);
666 vnet_feature_enable_disable ("ip6-unicast", "vpath-input-ip6",
667 sw_if_index, mp->enable, 0, 0);
668 vnet_feature_enable_disable ("ip6-multicast", "vpath-input-ip6",
669 sw_if_index, mp->enable, 0, 0);
671 BAD_SW_IF_INDEX_LABEL;
673 REPLY_MACRO (VL_API_SW_INTERFACE_SET_VPATH_REPLY);
677 vl_api_sw_interface_set_vxlan_bypass_t_handler
678 (vl_api_sw_interface_set_vxlan_bypass_t * mp)
680 vl_api_sw_interface_set_vxlan_bypass_reply_t *rmp;
682 u32 sw_if_index = ntohl (mp->sw_if_index);
684 VALIDATE_SW_IF_INDEX (mp);
688 /* not yet implemented */
691 vnet_feature_enable_disable ("ip4-unicast", "ip4-vxlan-bypass",
692 sw_if_index, mp->enable, 0, 0);
694 BAD_SW_IF_INDEX_LABEL;
696 REPLY_MACRO (VL_API_SW_INTERFACE_SET_VXLAN_BYPASS_REPLY);
700 vl_api_sw_interface_set_l2_xconnect_t_handler
701 (vl_api_sw_interface_set_l2_xconnect_t * mp)
703 vl_api_sw_interface_set_l2_xconnect_reply_t *rmp;
705 u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index);
706 u32 tx_sw_if_index = ntohl (mp->tx_sw_if_index);
707 vlib_main_t *vm = vlib_get_main ();
708 vnet_main_t *vnm = vnet_get_main ();
710 VALIDATE_RX_SW_IF_INDEX (mp);
714 VALIDATE_TX_SW_IF_INDEX (mp);
715 rv = set_int_l2_mode (vm, vnm, MODE_L2_XC,
716 rx_sw_if_index, 0, 0, 0, tx_sw_if_index);
720 rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0, 0, 0, 0);
723 BAD_RX_SW_IF_INDEX_LABEL;
724 BAD_TX_SW_IF_INDEX_LABEL;
726 REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_XCONNECT_REPLY);
730 vl_api_sw_interface_set_l2_bridge_t_handler
731 (vl_api_sw_interface_set_l2_bridge_t * mp)
733 bd_main_t *bdm = &bd_main;
734 vl_api_sw_interface_set_l2_bridge_reply_t *rmp;
736 u32 rx_sw_if_index = ntohl (mp->rx_sw_if_index);
737 u32 bd_id = ntohl (mp->bd_id);
741 vlib_main_t *vm = vlib_get_main ();
742 vnet_main_t *vnm = vnet_get_main ();
744 VALIDATE_RX_SW_IF_INDEX (mp);
746 bd_index = bd_find_or_add_bd_index (bdm, bd_id);
750 //VALIDATE_TX_SW_IF_INDEX(mp);
751 rv = set_int_l2_mode (vm, vnm, MODE_L2_BRIDGE,
752 rx_sw_if_index, bd_index, bvi, shg, 0);
756 rv = set_int_l2_mode (vm, vnm, MODE_L3, rx_sw_if_index, 0, 0, 0, 0);
759 BAD_RX_SW_IF_INDEX_LABEL;
761 REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_BRIDGE_REPLY);
765 vl_api_sw_interface_set_dpdk_hqos_pipe_t_handler
766 (vl_api_sw_interface_set_dpdk_hqos_pipe_t * mp)
768 vl_api_sw_interface_set_dpdk_hqos_pipe_reply_t *rmp;
772 dpdk_main_t *dm = &dpdk_main;
775 u32 sw_if_index = ntohl (mp->sw_if_index);
776 u32 subport = ntohl (mp->subport);
777 u32 pipe = ntohl (mp->pipe);
778 u32 profile = ntohl (mp->profile);
779 vnet_hw_interface_t *hw;
781 VALIDATE_SW_IF_INDEX (mp);
783 /* hw_if & dpdk device */
784 hw = vnet_get_sup_hw_interface (dm->vnet_main, sw_if_index);
786 xd = vec_elt_at_index (dm->devices, hw->dev_instance);
788 rv = rte_sched_pipe_config (xd->hqos_ht->hqos, subport, pipe, profile);
790 BAD_SW_IF_INDEX_LABEL;
792 clib_warning ("setting HQoS pipe parameters without DPDK not implemented");
793 rv = VNET_API_ERROR_UNIMPLEMENTED;
796 REPLY_MACRO (VL_API_SW_INTERFACE_SET_DPDK_HQOS_PIPE_REPLY);
800 vl_api_sw_interface_set_dpdk_hqos_subport_t_handler
801 (vl_api_sw_interface_set_dpdk_hqos_subport_t * mp)
803 vl_api_sw_interface_set_dpdk_hqos_subport_reply_t *rmp;
807 dpdk_main_t *dm = &dpdk_main;
809 struct rte_sched_subport_params p;
811 u32 sw_if_index = ntohl (mp->sw_if_index);
812 u32 subport = ntohl (mp->subport);
813 p.tb_rate = ntohl (mp->tb_rate);
814 p.tb_size = ntohl (mp->tb_size);
815 p.tc_rate[0] = ntohl (mp->tc_rate[0]);
816 p.tc_rate[1] = ntohl (mp->tc_rate[1]);
817 p.tc_rate[2] = ntohl (mp->tc_rate[2]);
818 p.tc_rate[3] = ntohl (mp->tc_rate[3]);
819 p.tc_period = ntohl (mp->tc_period);
821 vnet_hw_interface_t *hw;
823 VALIDATE_SW_IF_INDEX (mp);
825 /* hw_if & dpdk device */
826 hw = vnet_get_sup_hw_interface (dm->vnet_main, sw_if_index);
828 xd = vec_elt_at_index (dm->devices, hw->dev_instance);
830 rv = rte_sched_subport_config (xd->hqos_ht->hqos, subport, &p);
832 BAD_SW_IF_INDEX_LABEL;
835 ("setting HQoS subport parameters without DPDK not implemented");
836 rv = VNET_API_ERROR_UNIMPLEMENTED;
839 REPLY_MACRO (VL_API_SW_INTERFACE_SET_DPDK_HQOS_SUBPORT_REPLY);
843 vl_api_sw_interface_set_dpdk_hqos_tctbl_t_handler
844 (vl_api_sw_interface_set_dpdk_hqos_tctbl_t * mp)
846 vl_api_sw_interface_set_dpdk_hqos_tctbl_reply_t *rmp;
850 dpdk_main_t *dm = &dpdk_main;
851 vlib_thread_main_t *tm = vlib_get_thread_main ();
854 u32 sw_if_index = ntohl (mp->sw_if_index);
855 u32 entry = ntohl (mp->entry);
856 u32 tc = ntohl (mp->tc);
857 u32 queue = ntohl (mp->queue);
860 vnet_hw_interface_t *hw;
862 VALIDATE_SW_IF_INDEX (mp);
864 /* hw_if & dpdk device */
865 hw = vnet_get_sup_hw_interface (dm->vnet_main, sw_if_index);
867 xd = vec_elt_at_index (dm->devices, hw->dev_instance);
869 if (tc >= RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE)
871 clib_warning ("invalid traffic class !!");
872 rv = VNET_API_ERROR_INVALID_VALUE;
875 if (queue >= RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS)
877 clib_warning ("invalid queue !!");
878 rv = VNET_API_ERROR_INVALID_VALUE;
882 /* Detect the set of worker threads */
883 uword *p = hash_get_mem (tm->thread_registrations_by_name, "workers");
887 clib_warning ("worker thread registration AWOL !!");
888 rv = VNET_API_ERROR_INVALID_VALUE_2;
892 vlib_thread_registration_t *tr = (vlib_thread_registration_t *) p[0];
893 int worker_thread_first = tr->first_index;
894 int worker_thread_count = tr->count;
896 val = tc * RTE_SCHED_QUEUES_PER_TRAFFIC_CLASS + queue;
897 for (i = 0; i < worker_thread_count; i++)
898 xd->hqos_wt[worker_thread_first + i].hqos_tc_table[entry] = val;
900 BAD_SW_IF_INDEX_LABEL;
903 clib_warning ("setting HQoS DSCP table entry without DPDK not implemented");
904 rv = VNET_API_ERROR_UNIMPLEMENTED;
907 REPLY_MACRO (VL_API_SW_INTERFACE_SET_DPDK_HQOS_TCTBL_REPLY);
911 vl_api_bridge_domain_add_del_t_handler (vl_api_bridge_domain_add_del_t * mp)
913 vlib_main_t *vm = vlib_get_main ();
914 bd_main_t *bdm = &bd_main;
915 vl_api_bridge_domain_add_del_reply_t *rmp;
917 u32 enable_flags = 0, disable_flags = 0;
918 u32 bd_id = ntohl (mp->bd_id);
923 bd_index = bd_find_or_add_bd_index (bdm, bd_id);
926 enable_flags |= L2_FLOOD;
928 disable_flags |= L2_FLOOD;
931 enable_flags |= L2_UU_FLOOD;
933 disable_flags |= L2_UU_FLOOD;
936 enable_flags |= L2_FWD;
938 disable_flags |= L2_FWD;
941 enable_flags |= L2_ARP_TERM;
943 disable_flags |= L2_ARP_TERM;
946 enable_flags |= L2_LEARN;
948 disable_flags |= L2_LEARN;
951 bd_set_flags (vm, bd_index, enable_flags, 1 /* enable */ );
954 bd_set_flags (vm, bd_index, disable_flags, 0 /* disable */ );
956 bd_set_mac_age (vm, bd_index, mp->mac_age);
959 rv = bd_delete_bd_index (bdm, bd_id);
961 REPLY_MACRO (VL_API_BRIDGE_DOMAIN_ADD_DEL_REPLY);
965 vl_api_bridge_domain_details_t_handler (vl_api_bridge_domain_details_t * mp)
967 clib_warning ("BUG");
971 vl_api_bridge_domain_sw_if_details_t_handler
972 (vl_api_bridge_domain_sw_if_details_t * mp)
974 clib_warning ("BUG");
978 send_bridge_domain_details (unix_shared_memory_queue_t * q,
979 l2_bridge_domain_t * bd_config,
980 u32 n_sw_ifs, u32 context)
982 vl_api_bridge_domain_details_t *mp;
984 mp = vl_msg_api_alloc (sizeof (*mp));
985 memset (mp, 0, sizeof (*mp));
986 mp->_vl_msg_id = ntohs (VL_API_BRIDGE_DOMAIN_DETAILS);
987 mp->bd_id = ntohl (bd_config->bd_id);
988 mp->flood = bd_feature_flood (bd_config);
989 mp->uu_flood = bd_feature_uu_flood (bd_config);
990 mp->forward = bd_feature_forward (bd_config);
991 mp->learn = bd_feature_learn (bd_config);
992 mp->arp_term = bd_feature_arp_term (bd_config);
993 mp->bvi_sw_if_index = ntohl (bd_config->bvi_sw_if_index);
994 mp->mac_age = bd_config->mac_age;
995 mp->n_sw_ifs = ntohl (n_sw_ifs);
996 mp->context = context;
998 vl_msg_api_send_shmem (q, (u8 *) & mp);
1002 send_bd_sw_if_details (l2input_main_t * l2im,
1003 unix_shared_memory_queue_t * q,
1004 l2_flood_member_t * member, u32 bd_id, u32 context)
1006 vl_api_bridge_domain_sw_if_details_t *mp;
1007 l2_input_config_t *input_cfg;
1009 mp = vl_msg_api_alloc (sizeof (*mp));
1010 memset (mp, 0, sizeof (*mp));
1011 mp->_vl_msg_id = ntohs (VL_API_BRIDGE_DOMAIN_SW_IF_DETAILS);
1012 mp->bd_id = ntohl (bd_id);
1013 mp->sw_if_index = ntohl (member->sw_if_index);
1014 input_cfg = vec_elt_at_index (l2im->configs, member->sw_if_index);
1015 mp->shg = input_cfg->shg;
1016 mp->context = context;
1018 vl_msg_api_send_shmem (q, (u8 *) & mp);
1022 vl_api_bridge_domain_dump_t_handler (vl_api_bridge_domain_dump_t * mp)
1024 bd_main_t *bdm = &bd_main;
1025 l2input_main_t *l2im = &l2input_main;
1026 unix_shared_memory_queue_t *q;
1027 l2_bridge_domain_t *bd_config;
1028 u32 bd_id, bd_index;
1031 q = vl_api_client_index_to_input_queue (mp->client_index);
1036 bd_id = ntohl (mp->bd_id);
1038 bd_index = (bd_id == ~0) ? 0 : bd_find_or_add_bd_index (bdm, bd_id);
1039 end = (bd_id == ~0) ? vec_len (l2im->bd_configs) : bd_index + 1;
1040 for (; bd_index < end; bd_index++)
1042 bd_config = l2input_bd_config_from_index (l2im, bd_index);
1043 /* skip dummy bd_id 0 */
1044 if (bd_config && (bd_config->bd_id > 0))
1047 l2_flood_member_t *m;
1049 n_sw_ifs = vec_len (bd_config->members);
1050 send_bridge_domain_details (q, bd_config, n_sw_ifs, mp->context);
1052 vec_foreach (m, bd_config->members)
1054 send_bd_sw_if_details (l2im, q, m, bd_config->bd_id, mp->context);
1061 vl_api_l2fib_add_del_t_handler (vl_api_l2fib_add_del_t * mp)
1063 bd_main_t *bdm = &bd_main;
1064 l2input_main_t *l2im = &l2input_main;
1065 vl_api_l2fib_add_del_reply_t *rmp;
1068 u32 sw_if_index = ntohl (mp->sw_if_index);
1069 u32 bd_id = ntohl (mp->bd_id);
1078 p = hash_get (bdm->bd_index_by_bd_id, bd_id);
1081 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1082 goto bad_sw_if_index;
1088 filter_mac = mp->filter_mac ? 1 : 0;
1089 if (filter_mac == 0)
1091 VALIDATE_SW_IF_INDEX (mp);
1092 if (vec_len (l2im->configs) <= sw_if_index)
1094 rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
1095 goto bad_sw_if_index;
1099 l2_input_config_t *config;
1100 config = vec_elt_at_index (l2im->configs, sw_if_index);
1101 if (config->bridge == 0)
1103 rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
1104 goto bad_sw_if_index;
1108 static_mac = mp->static_mac ? 1 : 0;
1109 bvi_mac = mp->bvi_mac ? 1 : 0;
1110 l2fib_add_entry (mac, bd_index, sw_if_index, static_mac, filter_mac,
1115 l2fib_del_entry (mac, bd_index);
1118 BAD_SW_IF_INDEX_LABEL;
1120 REPLY_MACRO (VL_API_L2FIB_ADD_DEL_REPLY);
1124 vl_api_l2_flags_t_handler (vl_api_l2_flags_t * mp)
1126 vl_api_l2_flags_reply_t *rmp;
1128 u32 sw_if_index = ntohl (mp->sw_if_index);
1129 u32 flags = ntohl (mp->feature_bitmap);
1132 VALIDATE_SW_IF_INDEX (mp);
1135 if (flags & L2INPUT_FEAT_ ## a) \
1136 rbm = l2input_intf_bitmap_enable (sw_if_index, L2INPUT_FEAT_ ## a, mp->is_set);
1137 foreach_l2input_feat;
1140 BAD_SW_IF_INDEX_LABEL;
1143 REPLY_MACRO2(VL_API_L2_FLAGS_REPLY,
1145 rmp->resulting_feature_bitmap = ntohl(rbm);
1151 vl_api_bridge_flags_t_handler (vl_api_bridge_flags_t * mp)
1153 vlib_main_t *vm = vlib_get_main ();
1154 bd_main_t *bdm = &bd_main;
1155 vl_api_bridge_flags_reply_t *rmp;
1157 u32 bd_id = ntohl (mp->bd_id);
1159 u32 flags = ntohl (mp->feature_bitmap);
1162 p = hash_get (bdm->bd_index_by_bd_id, bd_id);
1165 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1171 bd_set_flags (vm, bd_index, flags, mp->is_set);
1175 REPLY_MACRO2(VL_API_BRIDGE_FLAGS_REPLY,
1177 rmp->resulting_feature_bitmap = ntohl(flags);
1183 vl_api_bd_ip_mac_add_del_t_handler (vl_api_bd_ip_mac_add_del_t * mp)
1185 bd_main_t *bdm = &bd_main;
1186 vl_api_bd_ip_mac_add_del_reply_t *rmp;
1188 u32 bd_id = ntohl (mp->bd_id);
1192 p = hash_get (bdm->bd_index_by_bd_id, bd_id);
1195 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
1200 if (bd_add_del_ip_mac (bd_index, mp->ip_address,
1201 mp->mac_address, mp->is_ipv6, mp->is_add))
1202 rv = VNET_API_ERROR_UNSPECIFIED;
1205 REPLY_MACRO (VL_API_BD_IP_MAC_ADD_DEL_REPLY);
1209 vl_api_create_vlan_subif_t_handler (vl_api_create_vlan_subif_t * mp)
1211 vl_api_create_vlan_subif_reply_t *rmp;
1212 vnet_main_t *vnm = vnet_get_main ();
1213 u32 hw_if_index, sw_if_index = (u32) ~ 0;
1214 vnet_hw_interface_t *hi;
1217 vnet_sw_interface_t template;
1219 vnet_interface_main_t *im = &vnm->interface_main;
1220 u64 sup_and_sub_key;
1222 unix_shared_memory_queue_t *q;
1223 clib_error_t *error;
1225 VALIDATE_SW_IF_INDEX (mp);
1227 hw_if_index = ntohl (mp->sw_if_index);
1228 hi = vnet_get_hw_interface (vnm, hw_if_index);
1230 id = ntohl (mp->vlan_id);
1231 if (id == 0 || id > 4095)
1233 rv = VNET_API_ERROR_INVALID_VLAN;
1237 sup_and_sub_key = ((u64) (hi->sw_if_index) << 32) | (u64) id;
1239 p = hash_get_mem (im->sw_if_index_by_sup_and_sub, &sup_and_sub_key);
1242 rv = VNET_API_ERROR_VLAN_ALREADY_EXISTS;
1246 kp = clib_mem_alloc (sizeof (*kp));
1247 *kp = sup_and_sub_key;
1249 memset (&template, 0, sizeof (template));
1250 template.type = VNET_SW_INTERFACE_TYPE_SUB;
1251 template.sup_sw_if_index = hi->sw_if_index;
1252 template.sub.id = id;
1253 template.sub.eth.raw_flags = 0;
1254 template.sub.eth.flags.one_tag = 1;
1255 template.sub.eth.outer_vlan_id = id;
1256 template.sub.eth.flags.exact_match = 1;
1258 error = vnet_create_sw_interface (vnm, &template, &sw_if_index);
1261 clib_error_report (error);
1262 rv = VNET_API_ERROR_INVALID_REGISTRATION;
1265 hash_set (hi->sub_interface_sw_if_index_by_id, id, sw_if_index);
1266 hash_set_mem (im->sw_if_index_by_sup_and_sub, kp, sw_if_index);
1268 BAD_SW_IF_INDEX_LABEL;
1271 q = vl_api_client_index_to_input_queue (mp->client_index);
1275 rmp = vl_msg_api_alloc (sizeof (*rmp));
1276 rmp->_vl_msg_id = ntohs (VL_API_CREATE_VLAN_SUBIF_REPLY);
1277 rmp->context = mp->context;
1278 rmp->retval = ntohl (rv);
1279 rmp->sw_if_index = ntohl (sw_if_index);
1280 vl_msg_api_send_shmem (q, (u8 *) & rmp);
1284 vl_api_create_subif_t_handler (vl_api_create_subif_t * mp)
1286 vl_api_create_subif_reply_t *rmp;
1287 vnet_main_t *vnm = vnet_get_main ();
1288 u32 sw_if_index = ~0;
1291 vnet_sw_interface_t *si;
1292 vnet_hw_interface_t *hi;
1293 vnet_sw_interface_t template;
1295 vnet_interface_main_t *im = &vnm->interface_main;
1296 u64 sup_and_sub_key;
1298 clib_error_t *error;
1300 VALIDATE_SW_IF_INDEX (mp);
1302 si = vnet_get_sup_sw_interface (vnm, ntohl (mp->sw_if_index));
1303 hi = vnet_get_sup_hw_interface (vnm, ntohl (mp->sw_if_index));
1305 if (hi->bond_info == VNET_HW_INTERFACE_BOND_INFO_SLAVE)
1307 rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED;
1311 sw_if_index = si->sw_if_index;
1312 sub_id = ntohl (mp->sub_id);
1314 sup_and_sub_key = ((u64) (sw_if_index) << 32) | (u64) sub_id;
1316 p = hash_get_mem (im->sw_if_index_by_sup_and_sub, &sup_and_sub_key);
1320 clib_warning ("sup sw_if_index %d, sub id %d already exists\n",
1321 sw_if_index, sub_id);
1322 rv = VNET_API_ERROR_SUBIF_ALREADY_EXISTS;
1326 kp = clib_mem_alloc (sizeof (*kp));
1327 *kp = sup_and_sub_key;
1329 memset (&template, 0, sizeof (template));
1330 template.type = VNET_SW_INTERFACE_TYPE_SUB;
1331 template.sup_sw_if_index = sw_if_index;
1332 template.sub.id = sub_id;
1333 template.sub.eth.flags.no_tags = mp->no_tags;
1334 template.sub.eth.flags.one_tag = mp->one_tag;
1335 template.sub.eth.flags.two_tags = mp->two_tags;
1336 template.sub.eth.flags.dot1ad = mp->dot1ad;
1337 template.sub.eth.flags.exact_match = mp->exact_match;
1338 template.sub.eth.flags.default_sub = mp->default_sub;
1339 template.sub.eth.flags.outer_vlan_id_any = mp->outer_vlan_id_any;
1340 template.sub.eth.flags.inner_vlan_id_any = mp->inner_vlan_id_any;
1341 template.sub.eth.outer_vlan_id = ntohs (mp->outer_vlan_id);
1342 template.sub.eth.inner_vlan_id = ntohs (mp->inner_vlan_id);
1344 error = vnet_create_sw_interface (vnm, &template, &sw_if_index);
1347 clib_error_report (error);
1348 rv = VNET_API_ERROR_SUBIF_CREATE_FAILED;
1352 hash_set (hi->sub_interface_sw_if_index_by_id, sub_id, sw_if_index);
1353 hash_set_mem (im->sw_if_index_by_sup_and_sub, kp, sw_if_index);
1355 BAD_SW_IF_INDEX_LABEL;
1360 REPLY_MACRO2(VL_API_CREATE_SUBIF_REPLY,
1362 rmp->sw_if_index = ntohl(sw_if_index);
1368 vl_api_mpls_tunnel_add_del_t_handler (vl_api_mpls_tunnel_add_del_t * mp)
1370 vl_api_mpls_tunnel_add_del_reply_t *rmp;
1372 stats_main_t *sm = &stats_main;
1373 u32 tunnel_sw_if_index;
1376 dslock (sm, 1 /* release hint */ , 5 /* tag */ );
1380 fib_route_path_t rpath, *rpaths = NULL;
1381 mpls_label_t *label_stack = NULL;
1383 memset (&rpath, 0, sizeof (rpath));
1385 if (mp->mt_next_hop_proto_is_ip4)
1387 rpath.frp_proto = FIB_PROTOCOL_IP4;
1388 clib_memcpy (&rpath.frp_addr.ip4,
1389 mp->mt_next_hop, sizeof (rpath.frp_addr.ip4));
1393 rpath.frp_proto = FIB_PROTOCOL_IP6;
1394 clib_memcpy (&rpath.frp_addr.ip6,
1395 mp->mt_next_hop, sizeof (rpath.frp_addr.ip6));
1397 rpath.frp_sw_if_index = ntohl (mp->mt_next_hop_sw_if_index);
1399 for (ii = 0; ii < mp->mt_next_hop_n_out_labels; ii++)
1400 vec_add1 (label_stack, ntohl (mp->mt_next_hop_out_label_stack[ii]));
1402 vec_add1 (rpaths, rpath);
1404 vnet_mpls_tunnel_add (rpaths, label_stack,
1405 mp->mt_l2_only, &tunnel_sw_if_index);
1407 vec_free (label_stack);
1411 tunnel_sw_if_index = ntohl (mp->mt_sw_if_index);
1412 vnet_mpls_tunnel_del (tunnel_sw_if_index);
1418 REPLY_MACRO2(VL_API_MPLS_TUNNEL_ADD_DEL_REPLY,
1420 rmp->sw_if_index = ntohl(tunnel_sw_if_index);
1426 vl_api_proxy_arp_add_del_t_handler (vl_api_proxy_arp_add_del_t * mp)
1428 vl_api_proxy_arp_add_del_reply_t *rmp;
1431 ip4_main_t *im = &ip4_main;
1432 stats_main_t *sm = &stats_main;
1433 int vnet_proxy_arp_add_del (ip4_address_t * lo_addr,
1434 ip4_address_t * hi_addr,
1435 u32 fib_index, int is_del);
1438 dslock (sm, 1 /* release hint */ , 6 /* tag */ );
1440 p = hash_get (im->fib_index_by_table_id, ntohl (mp->vrf_id));
1444 rv = VNET_API_ERROR_NO_SUCH_FIB;
1450 rv = vnet_proxy_arp_add_del ((ip4_address_t *) mp->low_address,
1451 (ip4_address_t *) mp->hi_address,
1452 fib_index, mp->is_add == 0);
1456 REPLY_MACRO (VL_API_PROXY_ARP_ADD_DEL_REPLY);
1460 vl_api_proxy_arp_intfc_enable_disable_t_handler
1461 (vl_api_proxy_arp_intfc_enable_disable_t * mp)
1464 vnet_main_t *vnm = vnet_get_main ();
1465 vl_api_proxy_arp_intfc_enable_disable_reply_t *rmp;
1466 vnet_sw_interface_t *si;
1469 VALIDATE_SW_IF_INDEX (mp);
1471 sw_if_index = ntohl (mp->sw_if_index);
1473 if (pool_is_free_index (vnm->interface_main.sw_interfaces, sw_if_index))
1475 rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
1479 si = vnet_get_sw_interface (vnm, sw_if_index);
1483 if (mp->enable_disable)
1484 si->flags |= VNET_SW_INTERFACE_FLAG_PROXY_ARP;
1486 si->flags &= ~VNET_SW_INTERFACE_FLAG_PROXY_ARP;
1488 BAD_SW_IF_INDEX_LABEL;
1491 REPLY_MACRO (VL_API_PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY);
1495 vl_api_is_address_reachable_t_handler (vl_api_is_address_reachable_t * mp)
1498 vpe_main_t *rm = &vpe_main;
1499 ip4_main_t *im4 = &ip4_main;
1500 ip6_main_t *im6 = &ip6_main;
1501 ip_lookup_main_t *lm;
1507 u32 adj_index, sw_if_index;
1508 vl_api_is_address_reachable_t *rmp;
1509 ip_adjacency_t *adj;
1510 unix_shared_memory_queue_t *q;
1512 q = vl_api_client_index_to_input_queue (mp->client_index);
1515 increment_missing_api_client_counter (rm->vlib_main);
1519 rmp = vl_msg_api_alloc (sizeof (*rmp));
1520 clib_memcpy (rmp, mp, sizeof (*rmp));
1522 sw_if_index = mp->next_hop_sw_if_index;
1523 clib_memcpy (&addr, mp->address, sizeof (addr));
1526 lm = &im6->lookup_main;
1527 adj_index = ip6_fib_lookup (im6, sw_if_index, &addr.ip6);
1531 lm = &im4->lookup_main;
1533 adj_index = ip4_fib_lookup (im4, sw_if_index, &addr.ip4);
1535 if (adj_index == ~0)
1540 adj = ip_get_adjacency (lm, adj_index);
1542 if (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE
1543 && adj->rewrite_header.sw_if_index == sw_if_index)
1549 if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP
1550 && adj->rewrite_header.sw_if_index == sw_if_index)
1553 ip6_probe_neighbor (rm->vlib_main, &addr.ip6, sw_if_index);
1555 ip4_probe_neighbor (rm->vlib_main, &addr.ip4, sw_if_index);
1557 else if (adj->lookup_next_index == IP_LOOKUP_NEXT_DROP)
1566 vl_msg_api_send_shmem (q, (u8 *) & rmp);
1571 vl_api_sw_interface_set_mpls_enable_t_handler
1572 (vl_api_sw_interface_set_mpls_enable_t * mp)
1574 vl_api_sw_interface_set_mpls_enable_reply_t *rmp;
1577 VALIDATE_SW_IF_INDEX (mp);
1579 mpls_sw_interface_enable_disable (&mpls_main,
1580 ntohl (mp->sw_if_index), mp->enable);
1582 BAD_SW_IF_INDEX_LABEL;
1583 REPLY_MACRO (VL_API_SW_INTERFACE_SET_MPLS_ENABLE_REPLY);
1587 send_oam_event (oam_target_t * t)
1589 vpe_api_main_t *vam = &vpe_api_main;
1590 unix_shared_memory_queue_t *q;
1591 vpe_client_registration_t *reg;
1592 vl_api_oam_event_t *mp;
1595 pool_foreach(reg, vam->oam_events_registrations,
1597 q = vl_api_client_index_to_input_queue (reg->client_index);
1600 mp = vl_msg_api_alloc (sizeof (*mp));
1601 mp->_vl_msg_id = ntohs (VL_API_OAM_EVENT);
1602 clib_memcpy (mp->dst_address, &t->dst_address,
1603 sizeof (mp->dst_address));
1604 mp->state = t->state;
1605 vl_msg_api_send_shmem (q, (u8 *)&mp);
1612 vl_api_oam_add_del_t_handler (vl_api_oam_add_del_t * mp)
1614 vl_api_oam_add_del_reply_t *rmp;
1617 rv = vpe_oam_add_del_target ((ip4_address_t *) mp->src_address,
1618 (ip4_address_t *) mp->dst_address,
1619 ntohl (mp->vrf_id), (int) (mp->is_add));
1621 REPLY_MACRO (VL_API_OAM_ADD_DEL_REPLY);
1625 vl_api_vnet_get_summary_stats_t_handler (vl_api_vnet_get_summary_stats_t * mp)
1627 stats_main_t *sm = &stats_main;
1628 vnet_interface_main_t *im = sm->interface_main;
1629 vl_api_vnet_summary_stats_reply_t *rmp;
1630 vlib_combined_counter_main_t *cm;
1633 u64 total_pkts[VLIB_N_RX_TX];
1634 u64 total_bytes[VLIB_N_RX_TX];
1636 unix_shared_memory_queue_t *q =
1637 vl_api_client_index_to_input_queue (mp->client_index);
1642 rmp = vl_msg_api_alloc (sizeof (*rmp));
1643 rmp->_vl_msg_id = ntohs (VL_API_VNET_SUMMARY_STATS_REPLY);
1644 rmp->context = mp->context;
1647 memset (total_pkts, 0, sizeof (total_pkts));
1648 memset (total_bytes, 0, sizeof (total_bytes));
1650 vnet_interface_counter_lock (im);
1652 vec_foreach (cm, im->combined_sw_if_counters)
1654 which = cm - im->combined_sw_if_counters;
1656 for (i = 0; i < vec_len (cm->maxi); i++)
1658 vlib_get_combined_counter (cm, i, &v);
1659 total_pkts[which] += v.packets;
1660 total_bytes[which] += v.bytes;
1663 vnet_interface_counter_unlock (im);
1665 rmp->total_pkts[VLIB_RX] = clib_host_to_net_u64 (total_pkts[VLIB_RX]);
1666 rmp->total_bytes[VLIB_RX] = clib_host_to_net_u64 (total_bytes[VLIB_RX]);
1667 rmp->total_pkts[VLIB_TX] = clib_host_to_net_u64 (total_pkts[VLIB_TX]);
1668 rmp->total_bytes[VLIB_TX] = clib_host_to_net_u64 (total_bytes[VLIB_TX]);
1670 clib_host_to_net_u64 (vlib_last_vector_length_per_node (sm->vlib_main));
1672 vl_msg_api_send_shmem (q, (u8 *) & rmp);
1676 typedef CLIB_PACKED (struct {
1677 ip4_address_t address;
1678 u32 address_length: 6;
1684 ip4_reset_fib_t_handler (vl_api_reset_fib_t * mp)
1686 vnet_main_t *vnm = vnet_get_main ();
1687 vnet_interface_main_t *im = &vnm->interface_main;
1688 ip4_main_t *im4 = &ip4_main;
1689 static u32 *sw_if_indices_to_shut;
1690 stats_main_t *sm = &stats_main;
1691 fib_table_t *fib_table;
1695 int rv = VNET_API_ERROR_NO_SUCH_FIB;
1696 u32 target_fib_id = ntohl (mp->vrf_id);
1698 dslock (sm, 1 /* release hint */ , 8 /* tag */ );
1701 pool_foreach (fib_table, im4->fibs,
1703 fib = &fib_table->v4;
1704 vnet_sw_interface_t * si;
1706 if (fib->table_id != target_fib_id)
1709 /* remove any mpls encap/decap labels */
1710 mpls_fib_reset_labels (fib->table_id);
1712 /* remove any proxy arps in this fib */
1713 vnet_proxy_arp_fib_reset (fib->table_id);
1715 /* Set the flow hash for this fib to the default */
1716 vnet_set_ip4_flow_hash (fib->table_id, IP_FLOW_HASH_DEFAULT);
1718 vec_reset_length (sw_if_indices_to_shut);
1720 /* Shut down interfaces in this FIB / clean out intfc routes */
1721 pool_foreach (si, im->sw_interfaces,
1723 u32 sw_if_index = si->sw_if_index;
1725 if (sw_if_index < vec_len (im4->fib_index_by_sw_if_index)
1726 && (im4->fib_index_by_sw_if_index[si->sw_if_index] ==
1728 vec_add1 (sw_if_indices_to_shut, si->sw_if_index);
1731 for (i = 0; i < vec_len (sw_if_indices_to_shut); i++) {
1732 sw_if_index = sw_if_indices_to_shut[i];
1733 // vec_foreach (sw_if_index, sw_if_indices_to_shut) {
1735 u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index);
1736 flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP);
1737 vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
1740 fib_table_flush(fib->index, FIB_PROTOCOL_IP4, FIB_SOURCE_API);
1741 fib_table_flush(fib->index, FIB_PROTOCOL_IP4, FIB_SOURCE_INTERFACE);
1745 })); /* pool_foreach (fib) */
1753 ip6_reset_fib_t_handler (vl_api_reset_fib_t * mp)
1755 vnet_main_t *vnm = vnet_get_main ();
1756 vnet_interface_main_t *im = &vnm->interface_main;
1757 ip6_main_t *im6 = &ip6_main;
1758 stats_main_t *sm = &stats_main;
1759 static u32 *sw_if_indices_to_shut;
1760 fib_table_t *fib_table;
1764 int rv = VNET_API_ERROR_NO_SUCH_FIB;
1765 u32 target_fib_id = ntohl (mp->vrf_id);
1767 dslock (sm, 1 /* release hint */ , 9 /* tag */ );
1770 pool_foreach (fib_table, im6->fibs,
1772 vnet_sw_interface_t * si;
1773 fib = &(fib_table->v6);
1775 if (fib->table_id != target_fib_id)
1778 vec_reset_length (sw_if_indices_to_shut);
1780 /* Shut down interfaces in this FIB / clean out intfc routes */
1781 pool_foreach (si, im->sw_interfaces,
1783 if (im6->fib_index_by_sw_if_index[si->sw_if_index] ==
1785 vec_add1 (sw_if_indices_to_shut, si->sw_if_index);
1788 for (i = 0; i < vec_len (sw_if_indices_to_shut); i++) {
1789 sw_if_index = sw_if_indices_to_shut[i];
1790 // vec_foreach (sw_if_index, sw_if_indices_to_shut) {
1792 u32 flags = vnet_sw_interface_get_flags (vnm, sw_if_index);
1793 flags &= ~(VNET_SW_INTERFACE_FLAG_ADMIN_UP);
1794 vnet_sw_interface_set_flags (vnm, sw_if_index, flags);
1797 fib_table_flush(fib->index, FIB_PROTOCOL_IP6, FIB_SOURCE_API);
1798 fib_table_flush(fib->index, FIB_PROTOCOL_IP6, FIB_SOURCE_INTERFACE);
1802 })); /* pool_foreach (fib) */
1810 vl_api_reset_fib_t_handler (vl_api_reset_fib_t * mp)
1813 vl_api_reset_fib_reply_t *rmp;
1816 rv = ip6_reset_fib_t_handler (mp);
1818 rv = ip4_reset_fib_t_handler (mp);
1820 REPLY_MACRO (VL_API_RESET_FIB_REPLY);
1825 dhcpv4_proxy_config (vl_api_dhcp_proxy_config_t * mp)
1827 vl_api_dhcp_proxy_config_reply_t *rmp;
1830 rv = dhcp_proxy_set_server ((ip4_address_t *) (&mp->dhcp_server),
1831 (ip4_address_t *) (&mp->dhcp_src_address),
1832 (u32) ntohl (mp->vrf_id),
1833 (int) mp->insert_circuit_id,
1834 (int) (mp->is_add == 0));
1836 REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
1841 dhcpv6_proxy_config (vl_api_dhcp_proxy_config_t * mp)
1843 vl_api_dhcp_proxy_config_reply_t *rmp;
1846 rv = dhcpv6_proxy_set_server ((ip6_address_t *) (&mp->dhcp_server),
1847 (ip6_address_t *) (&mp->dhcp_src_address),
1848 (u32) ntohl (mp->vrf_id),
1849 (int) mp->insert_circuit_id,
1850 (int) (mp->is_add == 0));
1852 REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_REPLY);
1856 dhcpv4_proxy_config_2 (vl_api_dhcp_proxy_config_2_t * mp)
1858 vl_api_dhcp_proxy_config_reply_t *rmp;
1861 rv = dhcp_proxy_set_server_2 ((ip4_address_t *) (&mp->dhcp_server),
1862 (ip4_address_t *) (&mp->dhcp_src_address),
1863 (u32) ntohl (mp->rx_vrf_id),
1864 (u32) ntohl (mp->server_vrf_id),
1865 (int) mp->insert_circuit_id,
1866 (int) (mp->is_add == 0));
1868 REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_2_REPLY);
1873 dhcpv6_proxy_config_2 (vl_api_dhcp_proxy_config_2_t * mp)
1875 vl_api_dhcp_proxy_config_reply_t *rmp;
1878 rv = dhcpv6_proxy_set_server_2 ((ip6_address_t *) (&mp->dhcp_server),
1879 (ip6_address_t *) (&mp->dhcp_src_address),
1880 (u32) ntohl (mp->rx_vrf_id),
1881 (u32) ntohl (mp->server_vrf_id),
1882 (int) mp->insert_circuit_id,
1883 (int) (mp->is_add == 0));
1885 REPLY_MACRO (VL_API_DHCP_PROXY_CONFIG_2_REPLY);
1890 vl_api_dhcp_proxy_set_vss_t_handler (vl_api_dhcp_proxy_set_vss_t * mp)
1892 vl_api_dhcp_proxy_set_vss_reply_t *rmp;
1895 rv = dhcp_proxy_set_option82_vss (ntohl (mp->tbl_id),
1898 (int) mp->is_add == 0);
1900 rv = dhcpv6_proxy_set_vss (ntohl (mp->tbl_id),
1902 ntohl (mp->fib_id), (int) mp->is_add == 0);
1904 REPLY_MACRO (VL_API_DHCP_PROXY_SET_VSS_REPLY);
1908 static void vl_api_dhcp_proxy_config_t_handler
1909 (vl_api_dhcp_proxy_config_t * mp)
1911 if (mp->is_ipv6 == 0)
1912 dhcpv4_proxy_config (mp);
1914 dhcpv6_proxy_config (mp);
1917 static void vl_api_dhcp_proxy_config_2_t_handler
1918 (vl_api_dhcp_proxy_config_2_t * mp)
1920 if (mp->is_ipv6 == 0)
1921 dhcpv4_proxy_config_2 (mp);
1923 dhcpv6_proxy_config_2 (mp);
1927 dhcp_compl_event_callback (u32 client_index, u32 pid, u8 * hostname,
1928 u8 is_ipv6, u8 * host_address, u8 * router_address,
1931 unix_shared_memory_queue_t *q;
1932 vl_api_dhcp_compl_event_t *mp;
1934 q = vl_api_client_index_to_input_queue (client_index);
1938 mp = vl_msg_api_alloc (sizeof (*mp));
1939 mp->client_index = client_index;
1941 mp->is_ipv6 = is_ipv6;
1942 clib_memcpy (&mp->hostname, hostname, vec_len (hostname));
1943 mp->hostname[vec_len (hostname) + 1] = '\n';
1944 clib_memcpy (&mp->host_address[0], host_address, 16);
1945 clib_memcpy (&mp->router_address[0], router_address, 16);
1947 if (NULL != host_mac)
1948 clib_memcpy (&mp->host_mac[0], host_mac, 6);
1950 mp->_vl_msg_id = ntohs (VL_API_DHCP_COMPL_EVENT);
1952 vl_msg_api_send_shmem (q, (u8 *) & mp);
1955 static void vl_api_dhcp_client_config_t_handler
1956 (vl_api_dhcp_client_config_t * mp)
1958 vlib_main_t *vm = vlib_get_main ();
1959 vl_api_dhcp_client_config_reply_t *rmp;
1962 VALIDATE_SW_IF_INDEX (mp);
1964 rv = dhcp_client_config (vm, ntohl (mp->sw_if_index),
1965 mp->hostname, mp->is_add, mp->client_index,
1966 mp->want_dhcp_event ? dhcp_compl_event_callback :
1969 BAD_SW_IF_INDEX_LABEL;
1971 REPLY_MACRO (VL_API_DHCP_CLIENT_CONFIG_REPLY);
1975 vl_api_create_loopback_t_handler (vl_api_create_loopback_t * mp)
1977 vl_api_create_loopback_reply_t *rmp;
1981 rv = vnet_create_loopback_interface (&sw_if_index, mp->mac_address);
1984 REPLY_MACRO2(VL_API_CREATE_LOOPBACK_REPLY,
1986 rmp->sw_if_index = ntohl (sw_if_index);
1992 vl_api_delete_loopback_t_handler (vl_api_delete_loopback_t * mp)
1994 vl_api_delete_loopback_reply_t *rmp;
1998 sw_if_index = ntohl (mp->sw_if_index);
1999 rv = vnet_delete_loopback_interface (sw_if_index);
2001 REPLY_MACRO (VL_API_DELETE_LOOPBACK_REPLY);
2005 vl_api_control_ping_t_handler (vl_api_control_ping_t * mp)
2007 vl_api_control_ping_reply_t *rmp;
2011 REPLY_MACRO2(VL_API_CONTROL_PING_REPLY,
2013 rmp->vpe_pid = ntohl (getpid());
2019 shmem_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
2021 u8 **shmem_vecp = (u8 **) arg;
2024 api_main_t *am = &api_main;
2027 shmem_vec = *shmem_vecp;
2029 offset = vec_len (shmem_vec);
2031 pthread_mutex_lock (&am->vlib_rp->mutex);
2032 oldheap = svm_push_data_heap (am->vlib_rp);
2034 vec_validate (shmem_vec, offset + buffer_bytes - 1);
2036 clib_memcpy (shmem_vec + offset, buffer, buffer_bytes);
2038 svm_pop_heap (oldheap);
2039 pthread_mutex_unlock (&am->vlib_rp->mutex);
2041 *shmem_vecp = shmem_vec;
2046 vl_api_cli_request_t_handler (vl_api_cli_request_t * mp)
2048 vl_api_cli_reply_t *rp;
2049 unix_shared_memory_queue_t *q;
2050 vlib_main_t *vm = vlib_get_main ();
2051 api_main_t *am = &api_main;
2052 unformat_input_t input;
2056 q = vl_api_client_index_to_input_queue (mp->client_index);
2060 rp = vl_msg_api_alloc (sizeof (*rp));
2061 rp->_vl_msg_id = ntohs (VL_API_CLI_REPLY);
2062 rp->context = mp->context;
2064 unformat_init_vector (&input, (u8 *) (uword) mp->cmd_in_shmem);
2066 vlib_cli_input (vm, &input, shmem_cli_output, (uword) & shmem_vec);
2068 pthread_mutex_lock (&am->vlib_rp->mutex);
2069 oldheap = svm_push_data_heap (am->vlib_rp);
2071 vec_add1 (shmem_vec, 0);
2073 svm_pop_heap (oldheap);
2074 pthread_mutex_unlock (&am->vlib_rp->mutex);
2076 rp->reply_in_shmem = (uword) shmem_vec;
2078 vl_msg_api_send_shmem (q, (u8 *) & rp);
2082 inband_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
2084 u8 **mem_vecp = (u8 **) arg;
2085 u8 *mem_vec = *mem_vecp;
2086 u32 offset = vec_len (mem_vec);
2088 vec_validate (mem_vec, offset + buffer_bytes - 1);
2089 clib_memcpy (mem_vec + offset, buffer, buffer_bytes);
2090 *mem_vecp = mem_vec;
2094 vl_api_cli_inband_t_handler (vl_api_cli_inband_t * mp)
2096 vl_api_cli_inband_reply_t *rmp;
2098 unix_shared_memory_queue_t *q;
2099 vlib_main_t *vm = vlib_get_main ();
2100 unformat_input_t input;
2103 q = vl_api_client_index_to_input_queue (mp->client_index);
2107 unformat_init_string (&input, (char *) mp->cmd, ntohl (mp->length));
2108 vlib_cli_input (vm, &input, inband_cli_output, (uword) & out_vec);
2110 u32 len = vec_len (out_vec);
2112 REPLY_MACRO3(VL_API_CLI_INBAND_REPLY, len,
2114 rmp->length = htonl (len);
2115 clib_memcpy (rmp->reply, out_vec, len);
2122 vl_api_set_arp_neighbor_limit_t_handler (vl_api_set_arp_neighbor_limit_t * mp)
2125 vl_api_set_arp_neighbor_limit_reply_t *rmp;
2126 vnet_main_t *vnm = vnet_get_main ();
2127 clib_error_t *error;
2132 error = ip6_set_neighbor_limit (ntohl (mp->arp_neighbor_limit));
2134 error = ip4_set_arp_limit (ntohl (mp->arp_neighbor_limit));
2138 clib_error_report (error);
2139 rv = VNET_API_ERROR_UNSPECIFIED;
2143 rv = vnm->api_errno;
2146 REPLY_MACRO (VL_API_SET_ARP_NEIGHBOR_LIMIT_REPLY);
2149 static void vl_api_sr_tunnel_add_del_t_handler
2150 (vl_api_sr_tunnel_add_del_t * mp)
2153 clib_warning ("unimplemented");
2155 ip6_sr_add_del_tunnel_args_t _a, *a = &_a;
2157 vl_api_sr_tunnel_add_del_reply_t *rmp;
2158 ip6_address_t *segments = 0, *seg;
2159 ip6_address_t *tags = 0, *tag;
2160 ip6_address_t *this_address;
2163 if (mp->n_segments == 0)
2169 memset (a, 0, sizeof (*a));
2170 a->src_address = (ip6_address_t *) & mp->src_address;
2171 a->dst_address = (ip6_address_t *) & mp->dst_address;
2172 a->dst_mask_width = mp->dst_mask_width;
2173 a->flags_net_byte_order = mp->flags_net_byte_order;
2174 a->is_del = (mp->is_add == 0);
2175 a->rx_table_id = ntohl (mp->outer_vrf_id);
2176 a->tx_table_id = ntohl (mp->inner_vrf_id);
2178 a->name = format (0, "%s", mp->name);
2179 if (!(vec_len (a->name)))
2182 a->policy_name = format (0, "%s", mp->policy_name);
2183 if (!(vec_len (a->policy_name)))
2186 /* Yank segments and tags out of the API message */
2187 this_address = (ip6_address_t *) mp->segs_and_tags;
2188 for (i = 0; i < mp->n_segments; i++)
2190 vec_add2 (segments, seg, 1);
2191 clib_memcpy (seg->as_u8, this_address->as_u8, sizeof (*this_address));
2194 for (i = 0; i < mp->n_tags; i++)
2196 vec_add2 (tags, tag, 1);
2197 clib_memcpy (tag->as_u8, this_address->as_u8, sizeof (*this_address));
2201 a->segments = segments;
2204 rv = ip6_sr_add_del_tunnel (a);
2208 REPLY_MACRO (VL_API_SR_TUNNEL_ADD_DEL_REPLY);
2212 static void vl_api_sr_policy_add_del_t_handler
2213 (vl_api_sr_policy_add_del_t * mp)
2216 clib_warning ("unimplemented");
2218 ip6_sr_add_del_policy_args_t _a, *a = &_a;
2220 vl_api_sr_policy_add_del_reply_t *rmp;
2223 memset (a, 0, sizeof (*a));
2224 a->is_del = (mp->is_add == 0);
2226 a->name = format (0, "%s", mp->name);
2227 if (!(vec_len (a->name)))
2229 rv = VNET_API_ERROR_NO_SUCH_NODE2;
2233 if (!(mp->tunnel_names[0]))
2235 rv = VNET_API_ERROR_NO_SUCH_NODE2;
2239 // start deserializing tunnel_names
2240 int num_tunnels = mp->tunnel_names[0]; //number of tunnels
2241 u8 *deser_tun_names = mp->tunnel_names;
2242 deser_tun_names += 1; //moving along
2245 int tun_name_len = 0;
2247 for (i = 0; i < num_tunnels; i++)
2249 tun_name_len = *deser_tun_names;
2250 deser_tun_names += 1;
2251 vec_resize (tun_name, tun_name_len);
2252 memcpy (tun_name, deser_tun_names, tun_name_len);
2253 vec_add1 (a->tunnel_names, tun_name);
2254 deser_tun_names += tun_name_len;
2258 rv = ip6_sr_add_del_policy (a);
2262 REPLY_MACRO (VL_API_SR_POLICY_ADD_DEL_REPLY);
2266 static void vl_api_sr_multicast_map_add_del_t_handler
2267 (vl_api_sr_multicast_map_add_del_t * mp)
2270 clib_warning ("unimplemented");
2272 ip6_sr_add_del_multicastmap_args_t _a, *a = &_a;
2274 vl_api_sr_multicast_map_add_del_reply_t *rmp;
2276 memset (a, 0, sizeof (*a));
2277 a->is_del = (mp->is_add == 0);
2279 a->multicast_address = (ip6_address_t *) & mp->multicast_address;
2280 a->policy_name = format (0, "%s", mp->policy_name);
2282 if (a->multicast_address == 0)
2288 if (!(a->policy_name))
2294 #if DPDK > 0 /* Cannot call replicate without DPDK */
2295 rv = ip6_sr_add_del_multicastmap (a);
2297 clib_warning ("multicast replication without DPDK not implemented");
2298 rv = VNET_API_ERROR_UNIMPLEMENTED;
2303 REPLY_MACRO (VL_API_SR_MULTICAST_MAP_ADD_DEL_REPLY);
2307 #define foreach_classify_add_del_table_field \
2312 _(match_n_vectors) \
2313 _(next_table_index) \
2314 _(miss_next_index) \
2315 _(current_data_flag) \
2316 _(current_data_offset)
2318 static void vl_api_classify_add_del_table_t_handler
2319 (vl_api_classify_add_del_table_t * mp)
2321 vl_api_classify_add_del_table_reply_t *rmp;
2322 vnet_classify_main_t *cm = &vnet_classify_main;
2323 vnet_classify_table_t *t;
2327 foreach_classify_add_del_table_field;
2330 #define _(a) a = ntohl(mp->a);
2331 foreach_classify_add_del_table_field;
2334 /* The underlying API fails silently, on purpose, so check here */
2335 if (mp->is_add == 0) /* delete */
2337 if (pool_is_free_index (cm->tables, table_index))
2339 rv = VNET_API_ERROR_NO_SUCH_TABLE;
2343 else /* add or update */
2345 if (table_index != ~0 && pool_is_free_index (cm->tables, table_index))
2349 rv = vnet_classify_add_del_table
2350 (cm, mp->mask, nbuckets, memory_size,
2351 skip_n_vectors, match_n_vectors,
2352 next_table_index, miss_next_index, &table_index,
2353 current_data_flag, current_data_offset, mp->is_add, mp->del_chain);
2357 REPLY_MACRO2(VL_API_CLASSIFY_ADD_DEL_TABLE_REPLY,
2359 if (rv == 0 && mp->is_add)
2361 t = pool_elt_at_index (cm->tables, table_index);
2362 rmp->skip_n_vectors = ntohl(t->skip_n_vectors);
2363 rmp->match_n_vectors = ntohl(t->match_n_vectors);
2364 rmp->new_table_index = ntohl(table_index);
2368 rmp->skip_n_vectors = ~0;
2369 rmp->match_n_vectors = ~0;
2370 rmp->new_table_index = ~0;
2376 static void vl_api_classify_add_del_session_t_handler
2377 (vl_api_classify_add_del_session_t * mp)
2379 vnet_classify_main_t *cm = &vnet_classify_main;
2380 vl_api_classify_add_del_session_reply_t *rmp;
2382 u32 table_index, hit_next_index, opaque_index, metadata;
2386 table_index = ntohl (mp->table_index);
2387 hit_next_index = ntohl (mp->hit_next_index);
2388 opaque_index = ntohl (mp->opaque_index);
2389 advance = ntohl (mp->advance);
2390 action = mp->action;
2391 metadata = ntohl (mp->metadata);
2393 rv = vnet_classify_add_del_session
2394 (cm, table_index, mp->match, hit_next_index, opaque_index,
2395 advance, action, metadata, mp->is_add);
2397 REPLY_MACRO (VL_API_CLASSIFY_ADD_DEL_SESSION_REPLY);
2400 static void vl_api_classify_set_interface_ip_table_t_handler
2401 (vl_api_classify_set_interface_ip_table_t * mp)
2403 vlib_main_t *vm = vlib_get_main ();
2404 vl_api_classify_set_interface_ip_table_reply_t *rmp;
2406 u32 table_index, sw_if_index;
2408 table_index = ntohl (mp->table_index);
2409 sw_if_index = ntohl (mp->sw_if_index);
2411 VALIDATE_SW_IF_INDEX (mp);
2414 rv = vnet_set_ip6_classify_intfc (vm, sw_if_index, table_index);
2416 rv = vnet_set_ip4_classify_intfc (vm, sw_if_index, table_index);
2418 BAD_SW_IF_INDEX_LABEL;
2420 REPLY_MACRO (VL_API_CLASSIFY_SET_INTERFACE_IP_TABLE_REPLY);
2423 static void vl_api_classify_set_interface_l2_tables_t_handler
2424 (vl_api_classify_set_interface_l2_tables_t * mp)
2426 vl_api_classify_set_interface_l2_tables_reply_t *rmp;
2428 u32 sw_if_index, ip4_table_index, ip6_table_index, other_table_index;
2431 ip4_table_index = ntohl (mp->ip4_table_index);
2432 ip6_table_index = ntohl (mp->ip6_table_index);
2433 other_table_index = ntohl (mp->other_table_index);
2434 sw_if_index = ntohl (mp->sw_if_index);
2436 VALIDATE_SW_IF_INDEX (mp);
2439 rv = vnet_l2_input_classify_set_tables (sw_if_index, ip4_table_index,
2443 rv = vnet_l2_output_classify_set_tables (sw_if_index, ip4_table_index,
2449 if (ip4_table_index != ~0 || ip6_table_index != ~0
2450 || other_table_index != ~0)
2456 vnet_l2_input_classify_enable_disable (sw_if_index, enable);
2458 vnet_l2_output_classify_enable_disable (sw_if_index, enable);
2461 BAD_SW_IF_INDEX_LABEL;
2463 REPLY_MACRO (VL_API_CLASSIFY_SET_INTERFACE_L2_TABLES_REPLY);
2467 vl_api_l2_fib_clear_table_t_handler (vl_api_l2_fib_clear_table_t * mp)
2470 vl_api_l2_fib_clear_table_reply_t *rmp;
2472 /* DAW-FIXME: This API should only clear non-static l2fib entries, but
2473 * that is not currently implemented. When that TODO is fixed
2474 * this call should be changed to pass 1 instead of 0.
2476 l2fib_clear_table (0);
2478 REPLY_MACRO (VL_API_L2_FIB_CLEAR_TABLE_REPLY);
2481 extern void l2_efp_filter_configure (vnet_main_t * vnet_main,
2482 u32 sw_if_index, u32 enable);
2485 vl_api_l2_interface_efp_filter_t_handler (vl_api_l2_interface_efp_filter_t *
2489 vl_api_l2_interface_efp_filter_reply_t *rmp;
2490 vnet_main_t *vnm = vnet_get_main ();
2492 // enable/disable the feature
2493 l2_efp_filter_configure (vnm, mp->sw_if_index, mp->enable_disable);
2494 rv = vnm->api_errno;
2496 REPLY_MACRO (VL_API_L2_INTERFACE_EFP_FILTER_REPLY);
2500 vl_api_l2_interface_vlan_tag_rewrite_t_handler
2501 (vl_api_l2_interface_vlan_tag_rewrite_t * mp)
2504 vl_api_l2_interface_vlan_tag_rewrite_reply_t *rmp;
2505 vnet_main_t *vnm = vnet_get_main ();
2506 vlib_main_t *vm = vlib_get_main ();
2509 VALIDATE_SW_IF_INDEX (mp);
2511 vtr_op = ntohl (mp->vtr_op);
2513 /* The L2 code is unsuspicious */
2516 case L2_VTR_DISABLED:
2521 case L2_VTR_TRANSLATE_1_1:
2522 case L2_VTR_TRANSLATE_1_2:
2523 case L2_VTR_TRANSLATE_2_1:
2524 case L2_VTR_TRANSLATE_2_2:
2528 rv = VNET_API_ERROR_INVALID_VALUE;
2529 goto bad_sw_if_index;
2532 rv = l2vtr_configure (vm, vnm, ntohl (mp->sw_if_index), vtr_op,
2533 ntohl (mp->push_dot1q), ntohl (mp->tag1),
2536 BAD_SW_IF_INDEX_LABEL;
2538 REPLY_MACRO (VL_API_L2_INTERFACE_VLAN_TAG_REWRITE_REPLY);
2542 vl_api_l2_fib_table_entry_t_handler (vl_api_l2_fib_table_entry_t * mp)
2544 clib_warning ("BUG");
2548 send_l2fib_table_entry (vpe_api_main_t * am,
2549 unix_shared_memory_queue_t * q,
2550 l2fib_entry_key_t * l2fe_key,
2551 l2fib_entry_result_t * l2fe_res, u32 context)
2553 vl_api_l2_fib_table_entry_t *mp;
2555 mp = vl_msg_api_alloc (sizeof (*mp));
2556 memset (mp, 0, sizeof (*mp));
2557 mp->_vl_msg_id = ntohs (VL_API_L2_FIB_TABLE_ENTRY);
2560 ntohl (l2input_main.bd_configs[l2fe_key->fields.bd_index].bd_id);
2562 mp->mac = l2fib_make_key (l2fe_key->fields.mac, 0);
2563 mp->sw_if_index = ntohl (l2fe_res->fields.sw_if_index);
2564 mp->static_mac = l2fe_res->fields.static_mac;
2565 mp->filter_mac = l2fe_res->fields.filter;
2566 mp->bvi_mac = l2fe_res->fields.bvi;
2567 mp->context = context;
2569 vl_msg_api_send_shmem (q, (u8 *) & mp);
2573 vl_api_l2_fib_table_dump_t_handler (vl_api_l2_fib_table_dump_t * mp)
2575 vpe_api_main_t *am = &vpe_api_main;
2576 bd_main_t *bdm = &bd_main;
2577 l2fib_entry_key_t *l2fe_key = NULL;
2578 l2fib_entry_result_t *l2fe_res = NULL;
2579 u32 ni, bd_id = ntohl (mp->bd_id);
2581 unix_shared_memory_queue_t *q;
2584 q = vl_api_client_index_to_input_queue (mp->client_index);
2588 /* see l2fib_table_dump: ~0 means "any" */
2593 p = hash_get (bdm->bd_index_by_bd_id, bd_id);
2600 l2fib_table_dump (bd_index, &l2fe_key, &l2fe_res);
2602 vec_foreach_index (ni, l2fe_key)
2604 send_l2fib_table_entry (am, q, vec_elt_at_index (l2fe_key, ni),
2605 vec_elt_at_index (l2fe_res, ni), mp->context);
2607 vec_free (l2fe_key);
2608 vec_free (l2fe_res);
2612 vl_api_show_version_t_handler (vl_api_show_version_t * mp)
2614 vl_api_show_version_reply_t *rmp;
2616 char *vpe_api_get_build_directory (void);
2617 char *vpe_api_get_version (void);
2618 char *vpe_api_get_build_date (void);
2620 unix_shared_memory_queue_t *q =
2621 vl_api_client_index_to_input_queue (mp->client_index);
2627 REPLY_MACRO2(VL_API_SHOW_VERSION_REPLY,
2629 strncpy ((char *) rmp->program, "vpe", ARRAY_LEN(rmp->program)-1);
2630 strncpy ((char *) rmp->build_directory, vpe_api_get_build_directory(),
2631 ARRAY_LEN(rmp->build_directory)-1);
2632 strncpy ((char *) rmp->version, vpe_api_get_version(),
2633 ARRAY_LEN(rmp->version)-1);
2634 strncpy ((char *) rmp->build_date, vpe_api_get_build_date(),
2635 ARRAY_LEN(rmp->build_date)-1);
2641 vl_api_get_node_index_t_handler (vl_api_get_node_index_t * mp)
2643 vlib_main_t *vm = vlib_get_main ();
2644 vl_api_get_node_index_reply_t *rmp;
2647 u32 node_index = ~0;
2649 n = vlib_get_node_by_name (vm, mp->node_name);
2652 rv = VNET_API_ERROR_NO_SUCH_NODE;
2654 node_index = n->index;
2657 REPLY_MACRO2(VL_API_GET_NODE_INDEX_REPLY,
2659 rmp->node_index = ntohl(node_index);
2665 vl_api_get_next_index_t_handler (vl_api_get_next_index_t * mp)
2667 vlib_main_t *vm = vlib_get_main ();
2668 vl_api_get_next_index_reply_t *rmp;
2669 vlib_node_t *node, *next_node;
2671 u32 next_node_index = ~0, next_index = ~0;
2674 node = vlib_get_node_by_name (vm, mp->node_name);
2678 rv = VNET_API_ERROR_NO_SUCH_NODE;
2682 next_node = vlib_get_node_by_name (vm, mp->next_name);
2686 rv = VNET_API_ERROR_NO_SUCH_NODE2;
2690 next_node_index = next_node->index;
2692 p = hash_get (node->next_slot_by_node, next_node_index);
2696 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
2704 REPLY_MACRO2(VL_API_GET_NEXT_INDEX_REPLY,
2706 rmp->next_index = ntohl(next_index);
2712 vl_api_add_node_next_t_handler (vl_api_add_node_next_t * mp)
2714 vlib_main_t *vm = vlib_get_main ();
2715 vl_api_add_node_next_reply_t *rmp;
2716 vlib_node_t *n, *next;
2718 u32 next_index = ~0;
2720 n = vlib_get_node_by_name (vm, mp->node_name);
2724 rv = VNET_API_ERROR_NO_SUCH_NODE;
2728 next = vlib_get_node_by_name (vm, mp->next_name);
2731 rv = VNET_API_ERROR_NO_SUCH_NODE2;
2733 next_index = vlib_node_add_next (vm, n->index, next->index);
2737 REPLY_MACRO2(VL_API_GET_NODE_INDEX_REPLY,
2739 rmp->next_index = ntohl(next_index);
2744 static void vl_api_vxlan_add_del_tunnel_t_handler
2745 (vl_api_vxlan_add_del_tunnel_t * mp)
2747 vl_api_vxlan_add_del_tunnel_reply_t *rmp;
2749 vnet_vxlan_add_del_tunnel_args_t _a, *a = &_a;
2750 u32 encap_fib_index;
2752 ip4_main_t *im = &ip4_main;
2753 vnet_main_t *vnm = vnet_get_main ();
2754 u32 sw_if_index = ~0;
2756 p = hash_get (im->fib_index_by_table_id, ntohl (mp->encap_vrf_id));
2759 rv = VNET_API_ERROR_NO_SUCH_FIB;
2762 encap_fib_index = p[0];
2763 memset (a, 0, sizeof (*a));
2765 a->is_add = mp->is_add;
2766 a->is_ip6 = mp->is_ipv6;
2768 /* ip addresses sent in network byte order */
2769 ip46_from_addr_buf (mp->is_ipv6, mp->dst_address, &a->dst);
2770 ip46_from_addr_buf (mp->is_ipv6, mp->src_address, &a->src);
2772 /* Check src & dst are different */
2773 if (ip46_address_cmp (&a->dst, &a->src) == 0)
2775 rv = VNET_API_ERROR_SAME_SRC_DST;
2778 a->mcast_sw_if_index = ntohl (mp->mcast_sw_if_index);
2779 if (ip46_address_is_multicast (&a->dst) &&
2780 pool_is_free_index (vnm->interface_main.sw_interfaces,
2781 a->mcast_sw_if_index))
2783 rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
2786 a->encap_fib_index = encap_fib_index;
2787 a->decap_next_index = ntohl (mp->decap_next_index);
2788 a->vni = ntohl (mp->vni);
2789 rv = vnet_vxlan_add_del_tunnel (a, &sw_if_index);
2793 REPLY_MACRO2(VL_API_VXLAN_ADD_DEL_TUNNEL_REPLY,
2795 rmp->sw_if_index = ntohl (sw_if_index);
2800 static void send_vxlan_tunnel_details
2801 (vxlan_tunnel_t * t, unix_shared_memory_queue_t * q, u32 context)
2803 vl_api_vxlan_tunnel_details_t *rmp;
2804 ip4_main_t *im4 = &ip4_main;
2805 ip6_main_t *im6 = &ip6_main;
2806 u8 is_ipv6 = !ip46_address_is_ip4 (&t->dst);
2808 rmp = vl_msg_api_alloc (sizeof (*rmp));
2809 memset (rmp, 0, sizeof (*rmp));
2810 rmp->_vl_msg_id = ntohs (VL_API_VXLAN_TUNNEL_DETAILS);
2813 memcpy (rmp->src_address, t->src.ip6.as_u8, 16);
2814 memcpy (rmp->dst_address, t->dst.ip6.as_u8, 16);
2815 rmp->encap_vrf_id = htonl (im6->fibs[t->encap_fib_index].ft_table_id);
2819 memcpy (rmp->src_address, t->src.ip4.as_u8, 4);
2820 memcpy (rmp->dst_address, t->dst.ip4.as_u8, 4);
2821 rmp->encap_vrf_id = htonl (im4->fibs[t->encap_fib_index].ft_table_id);
2823 rmp->mcast_sw_if_index = htonl (t->mcast_sw_if_index);
2824 rmp->vni = htonl (t->vni);
2825 rmp->decap_next_index = htonl (t->decap_next_index);
2826 rmp->sw_if_index = htonl (t->sw_if_index);
2827 rmp->is_ipv6 = is_ipv6;
2828 rmp->context = context;
2830 vl_msg_api_send_shmem (q, (u8 *) & rmp);
2833 static void vl_api_vxlan_tunnel_dump_t_handler
2834 (vl_api_vxlan_tunnel_dump_t * mp)
2836 unix_shared_memory_queue_t *q;
2837 vxlan_main_t *vxm = &vxlan_main;
2841 q = vl_api_client_index_to_input_queue (mp->client_index);
2847 sw_if_index = ntohl (mp->sw_if_index);
2849 if (~0 == sw_if_index)
2852 pool_foreach (t, vxm->tunnels,
2854 send_vxlan_tunnel_details(t, q, mp->context);
2860 if ((sw_if_index >= vec_len (vxm->tunnel_index_by_sw_if_index)) ||
2861 (~0 == vxm->tunnel_index_by_sw_if_index[sw_if_index]))
2865 t = &vxm->tunnels[vxm->tunnel_index_by_sw_if_index[sw_if_index]];
2866 send_vxlan_tunnel_details (t, q, mp->context);
2871 vl_api_l2_patch_add_del_t_handler (vl_api_l2_patch_add_del_t * mp)
2873 extern int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index,
2875 vl_api_l2_patch_add_del_reply_t *rmp;
2876 int vnet_l2_patch_add_del (u32 rx_sw_if_index, u32 tx_sw_if_index,
2880 VALIDATE_RX_SW_IF_INDEX (mp);
2881 VALIDATE_TX_SW_IF_INDEX (mp);
2883 rv = vnet_l2_patch_add_del (ntohl (mp->rx_sw_if_index),
2884 ntohl (mp->tx_sw_if_index),
2885 (int) (mp->is_add != 0));
2887 BAD_RX_SW_IF_INDEX_LABEL;
2888 BAD_TX_SW_IF_INDEX_LABEL;
2890 REPLY_MACRO (VL_API_L2_PATCH_ADD_DEL_REPLY);
2894 vl_api_vxlan_gpe_add_del_tunnel_t_handler
2895 (vl_api_vxlan_gpe_add_del_tunnel_t * mp)
2897 vl_api_vxlan_gpe_add_del_tunnel_reply_t *rmp;
2899 vnet_vxlan_gpe_add_del_tunnel_args_t _a, *a = &_a;
2900 u32 encap_fib_index, decap_fib_index;
2903 ip4_main_t *im = &ip4_main;
2904 u32 sw_if_index = ~0;
2907 p = hash_get (im->fib_index_by_table_id, ntohl (mp->encap_vrf_id));
2910 rv = VNET_API_ERROR_NO_SUCH_FIB;
2913 encap_fib_index = p[0];
2915 protocol = mp->protocol;
2917 /* Interpret decap_vrf_id as an opaque if sending to other-than-ip4-input */
2918 if (protocol == VXLAN_GPE_INPUT_NEXT_IP4_INPUT)
2920 p = hash_get (im->fib_index_by_table_id, ntohl (mp->decap_vrf_id));
2923 rv = VNET_API_ERROR_NO_SUCH_INNER_FIB;
2926 decap_fib_index = p[0];
2930 decap_fib_index = ntohl (mp->decap_vrf_id);
2933 /* Check src & dst are different */
2934 if ((mp->is_ipv6 && memcmp (mp->local, mp->remote, 16) == 0) ||
2935 (!mp->is_ipv6 && memcmp (mp->local, mp->remote, 4) == 0))
2937 rv = VNET_API_ERROR_SAME_SRC_DST;
2940 memset (a, 0, sizeof (*a));
2942 a->is_add = mp->is_add;
2943 a->is_ip6 = mp->is_ipv6;
2944 /* ip addresses sent in network byte order */
2947 clib_memcpy (&(a->local.ip6), mp->local, 16);
2948 clib_memcpy (&(a->remote.ip6), mp->remote, 16);
2952 clib_memcpy (&(a->local.ip4), mp->local, 4);
2953 clib_memcpy (&(a->remote.ip4), mp->remote, 4);
2955 a->encap_fib_index = encap_fib_index;
2956 a->decap_fib_index = decap_fib_index;
2957 a->protocol = protocol;
2958 a->vni = ntohl (mp->vni);
2959 rv = vnet_vxlan_gpe_add_del_tunnel (a, &sw_if_index);
2963 REPLY_MACRO2(VL_API_VXLAN_GPE_ADD_DEL_TUNNEL_REPLY,
2965 rmp->sw_if_index = ntohl (sw_if_index);
2970 static void send_vxlan_gpe_tunnel_details
2971 (vxlan_gpe_tunnel_t * t, unix_shared_memory_queue_t * q, u32 context)
2973 vl_api_vxlan_gpe_tunnel_details_t *rmp;
2974 ip4_main_t *im4 = &ip4_main;
2975 ip6_main_t *im6 = &ip6_main;
2976 u8 is_ipv6 = !(t->flags & VXLAN_GPE_TUNNEL_IS_IPV4);
2978 rmp = vl_msg_api_alloc (sizeof (*rmp));
2979 memset (rmp, 0, sizeof (*rmp));
2980 rmp->_vl_msg_id = ntohs (VL_API_VXLAN_GPE_TUNNEL_DETAILS);
2983 memcpy (rmp->local, &(t->local.ip6), 16);
2984 memcpy (rmp->remote, &(t->remote.ip6), 16);
2985 rmp->encap_vrf_id = htonl (im6->fibs[t->encap_fib_index].ft_table_id);
2986 rmp->decap_vrf_id = htonl (im6->fibs[t->decap_fib_index].ft_table_id);
2990 memcpy (rmp->local, &(t->local.ip4), 4);
2991 memcpy (rmp->remote, &(t->remote.ip4), 4);
2992 rmp->encap_vrf_id = htonl (im4->fibs[t->encap_fib_index].ft_table_id);
2993 rmp->decap_vrf_id = htonl (im4->fibs[t->decap_fib_index].ft_table_id);
2995 rmp->vni = htonl (t->vni);
2996 rmp->protocol = t->protocol;
2997 rmp->sw_if_index = htonl (t->sw_if_index);
2998 rmp->is_ipv6 = is_ipv6;
2999 rmp->context = context;
3001 vl_msg_api_send_shmem (q, (u8 *) & rmp);
3004 static void vl_api_vxlan_gpe_tunnel_dump_t_handler
3005 (vl_api_vxlan_gpe_tunnel_dump_t * mp)
3007 unix_shared_memory_queue_t *q;
3008 vxlan_gpe_main_t *vgm = &vxlan_gpe_main;
3009 vxlan_gpe_tunnel_t *t;
3012 q = vl_api_client_index_to_input_queue (mp->client_index);
3018 sw_if_index = ntohl (mp->sw_if_index);
3020 if (~0 == sw_if_index)
3023 pool_foreach (t, vgm->tunnels,
3025 send_vxlan_gpe_tunnel_details(t, q, mp->context);
3031 if ((sw_if_index >= vec_len (vgm->tunnel_index_by_sw_if_index)) ||
3032 (~0 == vgm->tunnel_index_by_sw_if_index[sw_if_index]))
3036 t = &vgm->tunnels[vgm->tunnel_index_by_sw_if_index[sw_if_index]];
3037 send_vxlan_gpe_tunnel_details (t, q, mp->context);
3041 /** Used for transferring locators via VPP API */
3043 typedef CLIB_PACKED (struct {
3044 u32 sw_if_index; /**< locator sw_if_index */
3045 u8 priority; /**< locator priority */
3046 u8 weight; /**< locator weight */
3051 vl_api_lisp_add_del_locator_set_t_handler (vl_api_lisp_add_del_locator_set_t *
3054 vl_api_lisp_add_del_locator_set_reply_t *rmp;
3056 vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
3058 ls_locator_t *ls_loc;
3059 u32 ls_index = ~0, locator_num;
3060 u8 *locator_name = NULL;
3063 memset (a, 0, sizeof (a[0]));
3065 locator_name = format (0, "%s", mp->locator_set_name);
3067 a->name = locator_name;
3068 a->is_add = mp->is_add;
3070 locator_num = clib_net_to_host_u32 (mp->locator_num);
3072 memset (&locator, 0, sizeof (locator));
3073 for (i = 0; i < locator_num; i++)
3075 ls_loc = &((ls_locator_t *) mp->locators)[i];
3076 VALIDATE_SW_IF_INDEX (ls_loc);
3078 locator.sw_if_index = htonl (ls_loc->sw_if_index);
3079 locator.priority = ls_loc->priority;
3080 locator.weight = ls_loc->weight;
3082 vec_add1 (a->locators, locator);
3085 rv = vnet_lisp_add_del_locator_set (a, &ls_index);
3087 BAD_SW_IF_INDEX_LABEL;
3089 vec_free (locator_name);
3090 vec_free (a->locators);
3093 REPLY_MACRO2 (VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY,
3095 rmp->ls_index = clib_host_to_net_u32 (ls_index);
3101 vl_api_lisp_add_del_locator_t_handler (vl_api_lisp_add_del_locator_t * mp)
3103 vl_api_lisp_add_del_locator_reply_t *rmp;
3105 locator_t locator, *locators = NULL;
3106 vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
3108 u8 *locator_name = NULL;
3110 memset (&locator, 0, sizeof (locator));
3111 memset (a, 0, sizeof (a[0]));
3113 locator.sw_if_index = ntohl (mp->sw_if_index);
3114 locator.priority = mp->priority;
3115 locator.weight = mp->weight;
3117 vec_add1 (locators, locator);
3119 locator_name = format (0, "%s", mp->locator_set_name);
3121 a->name = locator_name;
3122 a->locators = locators;
3123 a->is_add = mp->is_add;
3126 rv = vnet_lisp_add_del_locator (a, NULL, &ls_index);
3128 vec_free (locators);
3129 vec_free (locator_name);
3131 REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCATOR_REPLY);
3135 unformat_lisp_eid_api (gid_address_t * dst, u32 vni, u8 type, void *src,
3141 gid_address_type (dst) = GID_ADDR_IP_PREFIX;
3142 gid_address_ip_set (dst, src, IP4);
3143 gid_address_ippref_len (dst) = len;
3144 ip_prefix_normalize (&gid_address_ippref (dst));
3147 gid_address_type (dst) = GID_ADDR_IP_PREFIX;
3148 gid_address_ip_set (dst, src, IP6);
3149 gid_address_ippref_len (dst) = len;
3150 ip_prefix_normalize (&gid_address_ippref (dst));
3152 case 2: /* l2 mac */
3153 gid_address_type (dst) = GID_ADDR_MAC;
3154 clib_memcpy (&gid_address_mac (dst), src, 6);
3158 return VNET_API_ERROR_INVALID_VALUE;
3161 gid_address_vni (dst) = vni;
3167 vl_api_lisp_add_del_local_eid_t_handler (vl_api_lisp_add_del_local_eid_t * mp)
3169 vl_api_lisp_add_del_local_eid_reply_t *rmp;
3170 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3172 gid_address_t _eid, *eid = &_eid;
3174 u32 locator_set_index = ~0, map_index = ~0;
3175 vnet_lisp_add_del_mapping_args_t _a, *a = &_a;
3176 u8 *name = NULL, *key = NULL;
3177 memset (a, 0, sizeof (a[0]));
3178 memset (eid, 0, sizeof (eid[0]));
3180 rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
3181 mp->eid_type, mp->eid, mp->prefix_len);
3185 name = format (0, "%s", mp->locator_set_name);
3186 p = hash_get_mem (lcm->locator_set_index_by_name, name);
3189 rv = VNET_API_ERROR_INVALID_VALUE;
3192 locator_set_index = p[0];
3195 key = format (0, "%s", mp->key);
3197 /* XXX treat batch configuration */
3198 a->is_add = mp->is_add;
3199 gid_address_copy (&a->eid, eid);
3200 a->locator_set_index = locator_set_index;
3203 a->key_id = clib_net_to_host_u16 (mp->key_id);
3205 rv = vnet_lisp_add_del_local_mapping (a, &map_index);
3210 gid_address_free (&a->eid);
3212 REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCAL_EID_REPLY);
3216 vl_api_lisp_eid_table_add_del_map_t_handler
3217 (vl_api_lisp_eid_table_add_del_map_t * mp)
3219 vl_api_lisp_eid_table_add_del_map_reply_t *rmp;
3221 rv = vnet_lisp_eid_table_map (clib_net_to_host_u32 (mp->vni),
3222 clib_net_to_host_u32 (mp->dp_table),
3223 mp->is_l2, mp->is_add);
3224 REPLY_MACRO (VL_API_LISP_EID_TABLE_ADD_DEL_MAP_REPLY)}
3226 /** Used for transferring locators via VPP API */
3228 typedef CLIB_PACKED (struct {
3229 u8 is_ip4; /**< is locator an IPv4 address */
3230 u8 priority; /**< locator priority */
3231 u8 weight; /**< locator weight */
3232 u8 addr[16]; /**< IPv4/IPv6 address */
3236 static locator_pair_t *
3237 unformat_lisp_loc_pairs (void *lcl_locs, void *rmt_locs, u32 rloc_num)
3240 locator_pair_t *pairs = 0, pair;
3243 for (i = 0; i < rloc_num; i++)
3246 r = &((rloc_t *) lcl_locs)[i];
3247 memset (&pair.lcl_loc, 0, sizeof (pair.lcl_loc));
3248 ip_address_set (&pair.lcl_loc, &r->addr, r->is_ip4 ? IP4 : IP6);
3250 /* remote locators */
3251 r = &((rloc_t *) rmt_locs)[i];
3252 memset (&pair.rmt_loc, 0, sizeof (pair.rmt_loc));
3253 ip_address_set (&pair.rmt_loc, &r->addr, r->is_ip4 ? IP4 : IP6);
3255 pair.priority = r->priority;
3256 pair.weight = r->weight;
3258 vec_add1 (pairs, pair);
3264 unformat_lisp_locs (void *rmt_locs, u32 rloc_num)
3267 locator_t *locs = 0, loc;
3270 for (i = 0; i < rloc_num; i++)
3272 /* remote locators */
3273 r = &((rloc_t *) rmt_locs)[i];
3274 memset (&loc, 0, sizeof (loc));
3275 gid_address_ip_set (&loc.address, &r->addr, r->is_ip4 ? IP4 : IP6);
3277 loc.priority = r->priority;
3278 loc.weight = r->weight;
3280 vec_add1 (locs, loc);
3286 vl_api_lisp_gpe_add_del_fwd_entry_t_handler
3287 (vl_api_lisp_gpe_add_del_fwd_entry_t * mp)
3289 vl_api_lisp_gpe_add_del_fwd_entry_reply_t *rmp;
3290 vnet_lisp_gpe_add_del_fwd_entry_args_t _a, *a = &_a;
3291 locator_pair_t *pairs = 0;
3294 memset (a, 0, sizeof (a[0]));
3296 rv = unformat_lisp_eid_api (&a->rmt_eid, mp->vni, mp->eid_type,
3297 mp->rmt_eid, mp->rmt_len);
3298 rv |= unformat_lisp_eid_api (&a->lcl_eid, mp->vni, mp->eid_type,
3299 mp->lcl_eid, mp->lcl_len);
3301 pairs = unformat_lisp_loc_pairs (mp->lcl_locs, mp->rmt_locs, mp->loc_num);
3303 if (rv || 0 == pairs)
3306 a->is_add = mp->is_add;
3307 a->locator_pairs = pairs;
3308 a->dp_table = mp->dp_table;
3310 a->action = mp->action;
3312 rv = vnet_lisp_gpe_add_del_fwd_entry (a, 0);
3315 REPLY_MACRO (VL_API_LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY);
3319 vl_api_lisp_add_del_map_server_t_handler (vl_api_lisp_add_del_map_server_t
3322 vl_api_lisp_add_del_map_server_reply_t *rmp;
3326 memset (&addr, 0, sizeof (addr));
3328 ip_address_set (&addr, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
3329 rv = vnet_lisp_add_del_map_server (&addr, mp->is_add);
3331 REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_SERVER_REPLY);
3335 vl_api_lisp_add_del_map_resolver_t_handler (vl_api_lisp_add_del_map_resolver_t
3338 vl_api_lisp_add_del_map_resolver_reply_t *rmp;
3340 vnet_lisp_add_del_map_resolver_args_t _a, *a = &_a;
3342 memset (a, 0, sizeof (a[0]));
3344 a->is_add = mp->is_add;
3345 ip_address_set (&a->address, mp->ip_address, mp->is_ipv6 ? IP6 : IP4);
3347 rv = vnet_lisp_add_del_map_resolver (a);
3349 REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_RESOLVER_REPLY);
3353 vl_api_lisp_gpe_enable_disable_t_handler (vl_api_lisp_gpe_enable_disable_t *
3356 vl_api_lisp_gpe_enable_disable_reply_t *rmp;
3358 vnet_lisp_gpe_enable_disable_args_t _a, *a = &_a;
3360 a->is_en = mp->is_en;
3361 vnet_lisp_gpe_enable_disable (a);
3363 REPLY_MACRO (VL_API_LISP_GPE_ENABLE_DISABLE_REPLY);
3367 vl_api_lisp_map_register_enable_disable_t_handler
3368 (vl_api_lisp_map_register_enable_disable_t * mp)
3370 vl_api_lisp_map_register_enable_disable_reply_t *rmp;
3373 vnet_lisp_map_register_enable_disable (mp->is_enabled);
3374 REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
3378 vl_api_lisp_rloc_probe_enable_disable_t_handler
3379 (vl_api_lisp_rloc_probe_enable_disable_t * mp)
3381 vl_api_lisp_rloc_probe_enable_disable_reply_t *rmp;
3384 vnet_lisp_rloc_probe_enable_disable (mp->is_enabled);
3385 REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
3389 vl_api_lisp_enable_disable_t_handler (vl_api_lisp_enable_disable_t * mp)
3391 vl_api_lisp_enable_disable_reply_t *rmp;
3394 vnet_lisp_enable_disable (mp->is_en);
3395 REPLY_MACRO (VL_API_LISP_ENABLE_DISABLE_REPLY);
3399 vl_api_lisp_gpe_add_del_iface_t_handler (vl_api_lisp_gpe_add_del_iface_t * mp)
3401 vl_api_lisp_gpe_add_del_iface_reply_t *rmp;
3409 lisp_gpe_tenant_l2_iface_add_or_lock (mp->vni, mp->dp_table))
3413 lisp_gpe_tenant_l2_iface_unlock (mp->vni);
3420 lisp_gpe_tenant_l3_iface_add_or_lock (mp->vni, mp->dp_table))
3424 lisp_gpe_tenant_l3_iface_unlock (mp->vni);
3427 REPLY_MACRO (VL_API_LISP_GPE_ADD_DEL_IFACE_REPLY);
3431 vl_api_show_lisp_map_request_mode_t_handler
3432 (vl_api_show_lisp_map_request_mode_t * mp)
3435 vl_api_show_lisp_map_request_mode_reply_t *rmp;
3438 REPLY_MACRO2(VL_API_SHOW_LISP_MAP_REQUEST_MODE_REPLY,
3440 rmp->mode = vnet_lisp_get_map_request_mode ();
3446 vl_api_lisp_map_request_mode_t_handler (vl_api_lisp_map_request_mode_t * mp)
3448 vl_api_lisp_map_request_mode_reply_t *rmp;
3451 rv = vnet_lisp_set_map_request_mode (mp->mode);
3453 REPLY_MACRO (VL_API_LISP_MAP_REQUEST_MODE_REPLY);
3457 vl_api_lisp_pitr_set_locator_set_t_handler (vl_api_lisp_pitr_set_locator_set_t
3460 vl_api_lisp_pitr_set_locator_set_reply_t *rmp;
3464 ls_name = format (0, "%s", mp->ls_name);
3465 rv = vnet_lisp_pitr_set_locator_set (ls_name, mp->is_add);
3468 REPLY_MACRO (VL_API_LISP_PITR_SET_LOCATOR_SET_REPLY);
3472 vl_api_lisp_add_del_map_request_itr_rlocs_t_handler
3473 (vl_api_lisp_add_del_map_request_itr_rlocs_t * mp)
3475 vl_api_lisp_add_del_map_request_itr_rlocs_reply_t *rmp;
3477 u8 *locator_set_name = NULL;
3478 vnet_lisp_add_del_mreq_itr_rloc_args_t _a, *a = &_a;
3480 locator_set_name = format (0, "%s", mp->locator_set_name);
3482 a->is_add = mp->is_add;
3483 a->locator_set_name = locator_set_name;
3485 rv = vnet_lisp_add_del_mreq_itr_rlocs (a);
3487 vec_free (locator_set_name);
3489 REPLY_MACRO (VL_API_LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY);
3493 vl_api_lisp_add_del_remote_mapping_t_handler
3494 (vl_api_lisp_add_del_remote_mapping_t * mp)
3496 locator_t *rlocs = 0;
3497 vl_api_lisp_add_del_remote_mapping_reply_t *rmp;
3499 gid_address_t _eid, *eid = &_eid;
3500 u32 rloc_num = clib_net_to_host_u32 (mp->rloc_num);
3502 memset (eid, 0, sizeof (eid[0]));
3504 rv = unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
3505 mp->eid_type, mp->eid, mp->eid_len);
3509 rlocs = unformat_lisp_locs (mp->rlocs, rloc_num);
3513 vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
3514 gid_address_copy (&a->reid, eid);
3516 rv = vnet_lisp_add_del_adjacency (a);
3523 /* NOTE: for now this works as a static remote mapping, i.e.,
3524 * not authoritative and ttl infinite. */
3525 rv = vnet_lisp_add_del_mapping (eid, rlocs, mp->action, 0, ~0,
3526 mp->is_add, 1 /* is_static */ , 0);
3529 vnet_lisp_clear_all_remote_adjacencies ();
3534 REPLY_MACRO (VL_API_LISP_ADD_DEL_REMOTE_MAPPING_REPLY);
3538 vl_api_lisp_add_del_adjacency_t_handler (vl_api_lisp_add_del_adjacency_t * mp)
3540 vl_api_lisp_add_del_adjacency_reply_t *rmp;
3541 vnet_lisp_add_del_adjacency_args_t _a, *a = &_a;
3544 memset (a, 0, sizeof (a[0]));
3546 rv = unformat_lisp_eid_api (&a->leid, clib_net_to_host_u32 (mp->vni),
3547 mp->eid_type, mp->leid, mp->leid_len);
3548 rv |= unformat_lisp_eid_api (&a->reid, clib_net_to_host_u32 (mp->vni),
3549 mp->eid_type, mp->reid, mp->reid_len);
3554 a->is_add = mp->is_add;
3555 rv = vnet_lisp_add_del_adjacency (a);
3558 REPLY_MACRO (VL_API_LISP_ADD_DEL_ADJACENCY_REPLY);
3562 send_lisp_locator_details (lisp_cp_main_t * lcm,
3564 unix_shared_memory_queue_t * q, u32 context)
3566 vl_api_lisp_locator_details_t *rmp;
3568 rmp = vl_msg_api_alloc (sizeof (*rmp));
3569 memset (rmp, 0, sizeof (*rmp));
3570 rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_DETAILS);
3571 rmp->context = context;
3573 rmp->local = loc->local;
3576 rmp->sw_if_index = ntohl (loc->sw_if_index);
3580 rmp->is_ipv6 = gid_address_ip_version (&loc->address);
3581 ip_address_copy_addr (rmp->ip_address, &gid_address_ip (&loc->address));
3583 rmp->priority = loc->priority;
3584 rmp->weight = loc->weight;
3586 vl_msg_api_send_shmem (q, (u8 *) & rmp);
3590 vl_api_lisp_locator_dump_t_handler (vl_api_lisp_locator_dump_t * mp)
3593 unix_shared_memory_queue_t *q = 0;
3594 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3595 locator_set_t *lsit = 0;
3597 u32 ls_index = ~0, *locit = 0;
3600 q = vl_api_client_index_to_input_queue (mp->client_index);
3606 if (mp->is_index_set)
3607 ls_index = htonl (mp->ls_index);
3610 /* make sure we get a proper C-string */
3611 mp->ls_name[sizeof (mp->ls_name) - 1] = 0;
3612 ls_name = format (0, "%s", mp->ls_name);
3613 p = hash_get_mem (lcm->locator_set_index_by_name, ls_name);
3619 if (pool_is_free_index (lcm->locator_set_pool, ls_index))
3622 lsit = pool_elt_at_index (lcm->locator_set_pool, ls_index);
3624 vec_foreach (locit, lsit->locator_indices)
3626 loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
3627 send_lisp_locator_details (lcm, loc, q, mp->context);
3634 send_lisp_locator_set_details (lisp_cp_main_t * lcm,
3635 locator_set_t * lsit,
3636 unix_shared_memory_queue_t * q,
3637 u32 context, u32 ls_index)
3639 vl_api_lisp_locator_set_details_t *rmp;
3642 rmp = vl_msg_api_alloc (sizeof (*rmp));
3643 memset (rmp, 0, sizeof (*rmp));
3644 rmp->_vl_msg_id = ntohs (VL_API_LISP_LOCATOR_SET_DETAILS);
3645 rmp->context = context;
3647 rmp->ls_index = htonl (ls_index);
3650 ASSERT (lsit->name != NULL);
3651 strncpy ((char *) rmp->ls_name, (char *) lsit->name,
3652 vec_len (lsit->name));
3656 str = format (0, "<remote-%d>", ls_index);
3657 strncpy ((char *) rmp->ls_name, (char *) str, vec_len (str));
3661 vl_msg_api_send_shmem (q, (u8 *) & rmp);
3665 vl_api_lisp_locator_set_dump_t_handler (vl_api_lisp_locator_set_dump_t * mp)
3667 unix_shared_memory_queue_t *q = NULL;
3668 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3669 locator_set_t *lsit = NULL;
3672 q = vl_api_client_index_to_input_queue (mp->client_index);
3678 filter = mp->filter;
3680 pool_foreach (lsit, lcm->locator_set_pool,
3682 if (filter && !((1 == filter && lsit->local) ||
3683 (2 == filter && !lsit->local)))
3687 send_lisp_locator_set_details (lcm, lsit, q, mp->context,
3688 lsit - lcm->locator_set_pool);
3694 lisp_fid_put_api (u8 * dst, fid_address_t * src, u8 * prefix_length)
3696 ASSERT (prefix_length);
3697 ip_prefix_t *ippref = &fid_addr_ippref (src);
3699 switch (fid_addr_type (src))
3701 case FID_ADDR_IP_PREF:
3702 if (ip_prefix_version (ippref) == IP4)
3703 clib_memcpy (dst, &ip_prefix_v4 (ippref), 4);
3705 clib_memcpy (dst, &ip_prefix_v6 (ippref), 16);
3706 prefix_length[0] = ip_prefix_len (ippref);
3710 prefix_length[0] = 0;
3711 clib_memcpy (dst, fid_addr_mac (src), 6);
3715 clib_warning ("Unknown FID type %d!", fid_addr_type (src));
3721 fid_type_to_api_type (fid_address_t * fid)
3723 ip_prefix_t *ippref;
3725 switch (fid_addr_type (fid))
3727 case FID_ADDR_IP_PREF:
3728 ippref = &fid_addr_ippref (fid);
3729 if (ip_prefix_version (ippref) == IP4)
3731 else if (ip_prefix_version (ippref) == IP6)
3744 send_lisp_eid_table_details (mapping_t * mapit,
3745 unix_shared_memory_queue_t * q,
3746 u32 context, u8 filter)
3749 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3750 locator_set_t *ls = 0;
3751 vl_api_lisp_eid_table_details_t *rmp = NULL;
3752 gid_address_t *gid = NULL;
3754 ip_prefix_t *ip_prefix = NULL;
3758 case 0: /* all mappings */
3761 case 1: /* local only */
3765 case 2: /* remote only */
3770 clib_warning ("Filter error, unknown filter: %d", filter);
3775 ip_prefix = &gid_address_ippref (gid);
3776 mac = gid_address_mac (gid);
3778 rmp = vl_msg_api_alloc (sizeof (*rmp));
3779 memset (rmp, 0, sizeof (*rmp));
3780 rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_DETAILS);
3782 ls = pool_elt_at_index (lcm->locator_set_pool, mapit->locator_set_index);
3783 if (vec_len (ls->locator_indices) == 0)
3784 rmp->locator_set_index = ~0;
3786 rmp->locator_set_index = clib_host_to_net_u32 (mapit->locator_set_index);
3788 rmp->is_local = mapit->local;
3789 rmp->ttl = clib_host_to_net_u32 (mapit->ttl);
3790 rmp->action = mapit->action;
3791 rmp->authoritative = mapit->authoritative;
3793 switch (gid_address_type (gid))
3795 case GID_ADDR_SRC_DST:
3796 rmp->is_src_dst = 1;
3797 fid = &gid_address_sd_src (gid);
3798 rmp->eid_type = fid_type_to_api_type (fid);
3799 lisp_fid_put_api (rmp->seid, &gid_address_sd_src (gid),
3800 &rmp->seid_prefix_len);
3801 lisp_fid_put_api (rmp->eid, &gid_address_sd_dst (gid),
3802 &rmp->eid_prefix_len);
3804 case GID_ADDR_IP_PREFIX:
3805 rmp->eid_prefix_len = ip_prefix_len (ip_prefix);
3806 if (ip_prefix_version (ip_prefix) == IP4)
3808 rmp->eid_type = 0; /* ipv4 type */
3809 clib_memcpy (rmp->eid, &ip_prefix_v4 (ip_prefix),
3810 sizeof (ip_prefix_v4 (ip_prefix)));
3814 rmp->eid_type = 1; /* ipv6 type */
3815 clib_memcpy (rmp->eid, &ip_prefix_v6 (ip_prefix),
3816 sizeof (ip_prefix_v6 (ip_prefix)));
3820 rmp->eid_type = 2; /* l2 mac type */
3821 clib_memcpy (rmp->eid, mac, 6);
3826 rmp->context = context;
3827 rmp->vni = clib_host_to_net_u32 (gid_address_vni (gid));
3828 rmp->key_id = clib_host_to_net_u16 (mapit->key_id);
3829 memcpy (rmp->key, mapit->key, vec_len (mapit->key));
3830 vl_msg_api_send_shmem (q, (u8 *) & rmp);
3834 vl_api_lisp_eid_table_dump_t_handler (vl_api_lisp_eid_table_dump_t * mp)
3837 unix_shared_memory_queue_t *q = NULL;
3838 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3839 mapping_t *mapit = NULL;
3840 gid_address_t _eid, *eid = &_eid;
3842 q = vl_api_client_index_to_input_queue (mp->client_index);
3850 memset (eid, 0, sizeof (*eid));
3852 unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
3853 mp->eid_type, mp->eid, mp->prefix_length);
3855 mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid);
3856 if ((u32) ~ 0 == mi)
3859 mapit = pool_elt_at_index (lcm->mapping_pool, mi);
3860 send_lisp_eid_table_details (mapit, q, mp->context,
3861 0 /* ignore filter */ );
3866 pool_foreach (mapit, lcm->mapping_pool,
3868 send_lisp_eid_table_details(mapit, q, mp->context,
3876 send_lisp_gpe_fwd_entry_details (lisp_gpe_fwd_entry_t * lfe,
3877 unix_shared_memory_queue_t * q, u32 context)
3879 vl_api_lisp_gpe_tunnel_details_t *rmp;
3880 lisp_gpe_main_t *lgm = &lisp_gpe_main;
3882 rmp = vl_msg_api_alloc (sizeof (*rmp));
3883 memset (rmp, 0, sizeof (*rmp));
3884 rmp->_vl_msg_id = ntohs (VL_API_LISP_GPE_TUNNEL_DETAILS);
3886 rmp->tunnels = lfe - lgm->lisp_fwd_entry_pool;
3888 rmp->is_ipv6 = ip_prefix_version (&(lfe->key->rmt.ippref)) == IP6 ? 1 : 0;
3889 ip_address_copy_addr (rmp->source_ip,
3890 &ip_prefix_addr (&(lfe->key->rmt.ippref)));
3891 ip_address_copy_addr (rmp->destination_ip,
3892 &ip_prefix_addr (&(lfe->key->rmt.ippref)));
3894 rmp->encap_fib_id = htonl (0);
3895 rmp->decap_fib_id = htonl (lfe->eid_fib_index);
3896 rmp->iid = htonl (lfe->key->vni);
3897 rmp->context = context;
3899 vl_msg_api_send_shmem (q, (u8 *) & rmp);
3903 vl_api_lisp_gpe_tunnel_dump_t_handler (vl_api_lisp_gpe_tunnel_dump_t * mp)
3905 unix_shared_memory_queue_t *q = NULL;
3906 lisp_gpe_main_t *lgm = &lisp_gpe_main;
3907 lisp_gpe_fwd_entry_t *lfe = NULL;
3909 if (pool_elts (lgm->lisp_fwd_entry_pool) == 0)
3914 q = vl_api_client_index_to_input_queue (mp->client_index);
3921 pool_foreach(lfe, lgm->lisp_fwd_entry_pool,
3923 send_lisp_gpe_fwd_entry_details(lfe, q, mp->context);
3929 send_lisp_map_server_details (ip_address_t * ip,
3930 unix_shared_memory_queue_t * q, u32 context)
3932 vl_api_lisp_map_server_details_t *rmp = NULL;
3934 rmp = vl_msg_api_alloc (sizeof (*rmp));
3935 memset (rmp, 0, sizeof (*rmp));
3936 rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_SERVER_DETAILS);
3938 switch (ip_addr_version (ip))
3942 clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
3943 sizeof (ip_addr_v4 (ip)));
3948 clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
3949 sizeof (ip_addr_v6 (ip)));
3955 rmp->context = context;
3957 vl_msg_api_send_shmem (q, (u8 *) & rmp);
3961 vl_api_lisp_map_server_dump_t_handler (vl_api_lisp_map_server_dump_t * mp)
3963 unix_shared_memory_queue_t *q = NULL;
3964 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
3967 q = vl_api_client_index_to_input_queue (mp->client_index);
3973 vec_foreach (mr, lcm->map_servers)
3975 send_lisp_map_server_details (&mr->address, q, mp->context);
3980 send_lisp_map_resolver_details (ip_address_t * ip,
3981 unix_shared_memory_queue_t * q, u32 context)
3983 vl_api_lisp_map_resolver_details_t *rmp = NULL;
3985 rmp = vl_msg_api_alloc (sizeof (*rmp));
3986 memset (rmp, 0, sizeof (*rmp));
3987 rmp->_vl_msg_id = ntohs (VL_API_LISP_MAP_RESOLVER_DETAILS);
3989 switch (ip_addr_version (ip))
3993 clib_memcpy (rmp->ip_address, &ip_addr_v4 (ip),
3994 sizeof (ip_addr_v4 (ip)));
3999 clib_memcpy (rmp->ip_address, &ip_addr_v6 (ip),
4000 sizeof (ip_addr_v6 (ip)));
4006 rmp->context = context;
4008 vl_msg_api_send_shmem (q, (u8 *) & rmp);
4012 vl_api_lisp_map_resolver_dump_t_handler (vl_api_lisp_map_resolver_dump_t * mp)
4014 unix_shared_memory_queue_t *q = NULL;
4015 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4018 q = vl_api_client_index_to_input_queue (mp->client_index);
4024 vec_foreach (mr, lcm->map_resolvers)
4026 send_lisp_map_resolver_details (&mr->address, q, mp->context);
4031 send_eid_table_map_pair (hash_pair_t * p,
4032 unix_shared_memory_queue_t * q, u32 context)
4034 vl_api_lisp_eid_table_map_details_t *rmp = NULL;
4036 rmp = vl_msg_api_alloc (sizeof (*rmp));
4037 memset (rmp, 0, sizeof (*rmp));
4038 rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_MAP_DETAILS);
4040 rmp->vni = clib_host_to_net_u32 (p->key);
4041 rmp->dp_table = clib_host_to_net_u32 (p->value[0]);
4042 rmp->context = context;
4043 vl_msg_api_send_shmem (q, (u8 *) & rmp);
4047 vl_api_lisp_eid_table_map_dump_t_handler (vl_api_lisp_eid_table_map_dump_t *
4050 unix_shared_memory_queue_t *q = NULL;
4051 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4053 uword *vni_table = 0;
4055 q = vl_api_client_index_to_input_queue (mp->client_index);
4063 vni_table = lcm->bd_id_by_vni;
4067 vni_table = lcm->table_id_by_vni;
4071 hash_foreach_pair (p, vni_table,
4073 send_eid_table_map_pair (p, q, mp->context);
4079 send_eid_table_vni (u32 vni, unix_shared_memory_queue_t * q, u32 context)
4081 vl_api_lisp_eid_table_vni_details_t *rmp = 0;
4083 rmp = vl_msg_api_alloc (sizeof (*rmp));
4084 memset (rmp, 0, sizeof (*rmp));
4085 rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_VNI_DETAILS);
4086 rmp->context = context;
4087 rmp->vni = clib_host_to_net_u32 (vni);
4088 vl_msg_api_send_shmem (q, (u8 *) & rmp);
4092 lisp_adjacency_copy (vl_api_lisp_adjacency_t * dst, lisp_adjacency_t * adjs)
4094 lisp_adjacency_t *adj;
4095 vl_api_lisp_adjacency_t a;
4096 u32 i, n = vec_len (adjs);
4098 for (i = 0; i < n; i++)
4100 adj = vec_elt_at_index (adjs, i);
4101 memset (&a, 0, sizeof (a));
4103 switch (gid_address_type (&adj->reid))
4105 case GID_ADDR_IP_PREFIX:
4106 a.reid_prefix_len = gid_address_ippref_len (&adj->reid);
4107 a.leid_prefix_len = gid_address_ippref_len (&adj->leid);
4108 if (gid_address_ip_version (&adj->reid) == IP4)
4110 a.eid_type = 0; /* ipv4 type */
4111 clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 4);
4112 clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 4);
4116 a.eid_type = 1; /* ipv6 type */
4117 clib_memcpy (a.reid, &gid_address_ip (&adj->reid), 16);
4118 clib_memcpy (a.leid, &gid_address_ip (&adj->leid), 16);
4122 a.eid_type = 2; /* l2 mac type */
4123 mac_copy (a.reid, gid_address_mac (&adj->reid));
4124 mac_copy (a.leid, gid_address_mac (&adj->leid));
4134 vl_api_show_lisp_rloc_probe_state_t_handler
4135 (vl_api_show_lisp_rloc_probe_state_t * mp)
4137 vl_api_show_lisp_rloc_probe_state_reply_t *rmp = 0;
4141 REPLY_MACRO2 (VL_API_SHOW_LISP_RLOC_PROBE_STATE_REPLY,
4143 rmp->is_enabled = vnet_lisp_rloc_probe_state_get ();
4149 vl_api_show_lisp_map_register_state_t_handler
4150 (vl_api_show_lisp_map_register_state_t * mp)
4152 vl_api_show_lisp_map_register_state_reply_t *rmp = 0;
4156 REPLY_MACRO2 (VL_API_SHOW_LISP_MAP_REGISTER_STATE_REPLY,
4158 rmp->is_enabled = vnet_lisp_map_register_state_get ();
4164 vl_api_lisp_adjacencies_get_t_handler (vl_api_lisp_adjacencies_get_t * mp)
4166 vl_api_lisp_adjacencies_get_reply_t *rmp = 0;
4167 lisp_adjacency_t *adjs = 0;
4169 vl_api_lisp_adjacency_t a;
4171 u32 vni = clib_net_to_host_u32 (mp->vni);
4173 adjs = vnet_lisp_adjacencies_get_by_vni (vni);
4174 size = vec_len (adjs) * sizeof (a);
4177 REPLY_MACRO4 (VL_API_LISP_ADJACENCIES_GET_REPLY, size,
4179 rmp->count = clib_host_to_net_u32 (vec_len (adjs));
4180 lisp_adjacency_copy (rmp->adjacencies, adjs);
4188 vl_api_lisp_eid_table_vni_dump_t_handler (vl_api_lisp_eid_table_vni_dump_t *
4193 unix_shared_memory_queue_t *q = 0;
4194 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4196 q = vl_api_client_index_to_input_queue (mp->client_index);
4203 hash_foreach_pair (p, lcm->table_id_by_vni,
4205 hash_set (vnis, p->key, 0);
4208 hash_foreach_pair (p, lcm->bd_id_by_vni,
4210 hash_set (vnis, p->key, 0);
4213 hash_foreach_pair (p, vnis,
4215 send_eid_table_vni (p->key, q, mp->context);
4223 vl_api_show_lisp_status_t_handler (vl_api_show_lisp_status_t * mp)
4225 unix_shared_memory_queue_t *q = NULL;
4226 vl_api_show_lisp_status_reply_t *rmp = NULL;
4229 q = vl_api_client_index_to_input_queue (mp->client_index);
4236 REPLY_MACRO2(VL_API_SHOW_LISP_STATUS_REPLY,
4238 rmp->gpe_status = vnet_lisp_gpe_enable_disable_status ();
4239 rmp->feature_status = vnet_lisp_enable_disable_status ();
4245 vl_api_lisp_get_map_request_itr_rlocs_t_handler
4246 (vl_api_lisp_get_map_request_itr_rlocs_t * mp)
4248 unix_shared_memory_queue_t *q = NULL;
4249 vl_api_lisp_get_map_request_itr_rlocs_reply_t *rmp = NULL;
4250 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4251 locator_set_t *loc_set = 0;
4255 q = vl_api_client_index_to_input_queue (mp->client_index);
4261 if (~0 == lcm->mreq_itr_rlocs)
4263 tmp_str = format (0, " ");
4268 pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
4269 tmp_str = format (0, "%s", loc_set->name);
4273 REPLY_MACRO2(VL_API_LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY,
4275 strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
4276 ARRAY_LEN(rmp->locator_set_name) - 1);
4284 vl_api_show_lisp_pitr_t_handler (vl_api_show_lisp_pitr_t * mp)
4286 unix_shared_memory_queue_t *q = NULL;
4287 vl_api_show_lisp_pitr_reply_t *rmp = NULL;
4288 lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
4290 locator_set_t *ls = 0;
4294 q = vl_api_client_index_to_input_queue (mp->client_index);
4300 if (!lcm->lisp_pitr)
4302 tmp_str = format (0, "N/A");
4306 m = pool_elt_at_index (lcm->mapping_pool, lcm->pitr_map_index);
4307 if (~0 != m->locator_set_index)
4310 pool_elt_at_index (lcm->locator_set_pool, m->locator_set_index);
4311 tmp_str = format (0, "%s", ls->name);
4315 tmp_str = format (0, "N/A");
4318 vec_add1 (tmp_str, 0);
4321 REPLY_MACRO2(VL_API_SHOW_LISP_PITR_REPLY,
4323 rmp->status = lcm->lisp_pitr;
4324 strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
4325 ARRAY_LEN(rmp->locator_set_name) - 1);
4331 vl_api_interface_name_renumber_t_handler (vl_api_interface_name_renumber_t *
4334 vl_api_interface_name_renumber_reply_t *rmp;
4337 VALIDATE_SW_IF_INDEX (mp);
4339 rv = vnet_interface_name_renumber
4340 (ntohl (mp->sw_if_index), ntohl (mp->new_show_dev_instance));
4342 BAD_SW_IF_INDEX_LABEL;
4344 REPLY_MACRO (VL_API_INTERFACE_NAME_RENUMBER_REPLY);
4348 arp_change_data_callback (u32 pool_index, u8 * new_mac,
4349 u32 sw_if_index, u32 address)
4351 vpe_api_main_t *am = &vpe_api_main;
4352 vlib_main_t *vm = am->vlib_main;
4353 vl_api_ip4_arp_event_t *event;
4354 static f64 arp_event_last_time;
4355 f64 now = vlib_time_now (vm);
4357 if (pool_is_free_index (am->arp_events, pool_index))
4360 event = pool_elt_at_index (am->arp_events, pool_index);
4362 if (memcmp (&event->new_mac, new_mac, sizeof (event->new_mac)))
4364 clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac));
4368 if (sw_if_index == event->sw_if_index &&
4370 /* for BD case, also check IP address with 10 sec timeout */
4371 (address == event->address &&
4372 (now - arp_event_last_time) < 10.0)))
4377 arp_event_last_time = now;
4378 event->sw_if_index = sw_if_index;
4380 event->address = address;
4385 nd_change_data_callback (u32 pool_index, u8 * new_mac,
4386 u32 sw_if_index, ip6_address_t * address)
4388 vpe_api_main_t *am = &vpe_api_main;
4389 vlib_main_t *vm = am->vlib_main;
4390 vl_api_ip6_nd_event_t *event;
4391 static f64 nd_event_last_time;
4392 f64 now = vlib_time_now (vm);
4394 if (pool_is_free_index (am->nd_events, pool_index))
4397 event = pool_elt_at_index (am->nd_events, pool_index);
4400 if (memcmp (&event->new_mac, new_mac, sizeof (event->new_mac)))
4402 clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac));
4406 if (sw_if_index == event->sw_if_index &&
4408 /* for BD case, also check IP address with 10 sec timeout */
4409 (ip6_address_is_equal (address,
4410 (ip6_address_t *) event->address) &&
4411 (now - nd_event_last_time) < 10.0)))
4416 nd_event_last_time = now;
4417 event->sw_if_index = sw_if_index;
4419 clib_memcpy (event->address, address, sizeof (event->address));
4424 arp_change_delete_callback (u32 pool_index, u8 * notused)
4426 vpe_api_main_t *am = &vpe_api_main;
4428 if (pool_is_free_index (am->arp_events, pool_index))
4431 pool_put_index (am->arp_events, pool_index);
4436 nd_change_delete_callback (u32 pool_index, u8 * notused)
4438 vpe_api_main_t *am = &vpe_api_main;
4440 if (pool_is_free_index (am->nd_events, pool_index))
4443 pool_put_index (am->nd_events, pool_index);
4448 vl_api_want_ip4_arp_events_t_handler (vl_api_want_ip4_arp_events_t * mp)
4450 vpe_api_main_t *am = &vpe_api_main;
4451 vnet_main_t *vnm = vnet_get_main ();
4452 vl_api_want_ip4_arp_events_reply_t *rmp;
4453 vl_api_ip4_arp_event_t *event;
4456 if (mp->enable_disable)
4458 pool_get (am->arp_events, event);
4459 memset (event, 0, sizeof (*event));
4461 event->_vl_msg_id = ntohs (VL_API_IP4_ARP_EVENT);
4462 event->client_index = mp->client_index;
4463 event->context = mp->context;
4464 event->address = mp->address;
4465 event->pid = mp->pid;
4466 if (mp->address == 0)
4469 rv = vnet_add_del_ip4_arp_change_event
4470 (vnm, arp_change_data_callback,
4471 mp->pid, &mp->address /* addr, in net byte order */ ,
4472 vpe_resolver_process_node.index,
4473 IP4_ARP_EVENT, event - am->arp_events, 1 /* is_add */ );
4477 rv = vnet_add_del_ip4_arp_change_event
4478 (vnm, arp_change_delete_callback,
4479 mp->pid, &mp->address /* addr, in net byte order */ ,
4480 vpe_resolver_process_node.index,
4481 IP4_ARP_EVENT, ~0 /* pool index */ , 0 /* is_add */ );
4483 REPLY_MACRO (VL_API_WANT_IP4_ARP_EVENTS_REPLY);
4487 vl_api_want_ip6_nd_events_t_handler (vl_api_want_ip6_nd_events_t * mp)
4489 vpe_api_main_t *am = &vpe_api_main;
4490 vnet_main_t *vnm = vnet_get_main ();
4491 vl_api_want_ip6_nd_events_reply_t *rmp;
4492 vl_api_ip6_nd_event_t *event;
4495 if (mp->enable_disable)
4497 pool_get (am->nd_events, event);
4498 memset (event, 0, sizeof (*event));
4500 event->_vl_msg_id = ntohs (VL_API_IP6_ND_EVENT);
4501 event->client_index = mp->client_index;
4502 event->context = mp->context;
4503 clib_memcpy (event->address, mp->address, 16);
4504 event->pid = mp->pid;
4505 if (ip6_address_is_zero ((ip6_address_t *) mp->address))
4508 rv = vnet_add_del_ip6_nd_change_event
4509 (vnm, nd_change_data_callback,
4510 mp->pid, mp->address /* addr, in net byte order */ ,
4511 vpe_resolver_process_node.index,
4512 IP6_ND_EVENT, event - am->nd_events, 1 /* is_add */ );
4516 rv = vnet_add_del_ip6_nd_change_event
4517 (vnm, nd_change_delete_callback,
4518 mp->pid, mp->address /* addr, in net byte order */ ,
4519 vpe_resolver_process_node.index,
4520 IP6_ND_EVENT, ~0 /* pool index */ , 0 /* is_add */ );
4522 REPLY_MACRO (VL_API_WANT_IP6_ND_EVENTS_REPLY);
4525 static void vl_api_input_acl_set_interface_t_handler
4526 (vl_api_input_acl_set_interface_t * mp)
4528 vlib_main_t *vm = vlib_get_main ();
4529 vl_api_input_acl_set_interface_reply_t *rmp;
4531 u32 sw_if_index, ip4_table_index, ip6_table_index, l2_table_index;
4533 ip4_table_index = ntohl (mp->ip4_table_index);
4534 ip6_table_index = ntohl (mp->ip6_table_index);
4535 l2_table_index = ntohl (mp->l2_table_index);
4536 sw_if_index = ntohl (mp->sw_if_index);
4538 VALIDATE_SW_IF_INDEX (mp);
4540 rv = vnet_set_input_acl_intfc (vm, sw_if_index, ip4_table_index,
4541 ip6_table_index, l2_table_index, mp->is_add);
4543 BAD_SW_IF_INDEX_LABEL;
4545 REPLY_MACRO (VL_API_INPUT_ACL_SET_INTERFACE_REPLY);
4548 static void vl_api_ipsec_spd_add_del_t_handler
4549 (vl_api_ipsec_spd_add_del_t * mp)
4552 clib_warning ("unimplemented");
4555 vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main ();
4556 vl_api_ipsec_spd_add_del_reply_t *rmp;
4560 rv = ipsec_add_del_spd (vm, ntohl (mp->spd_id), mp->is_add);
4562 rv = VNET_API_ERROR_UNIMPLEMENTED;
4565 REPLY_MACRO (VL_API_IPSEC_SPD_ADD_DEL_REPLY);
4569 static void vl_api_ipsec_interface_add_del_spd_t_handler
4570 (vl_api_ipsec_interface_add_del_spd_t * mp)
4572 vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main ();
4573 vl_api_ipsec_interface_add_del_spd_reply_t *rmp;
4575 u32 sw_if_index __attribute__ ((unused));
4576 u32 spd_id __attribute__ ((unused));
4578 sw_if_index = ntohl (mp->sw_if_index);
4579 spd_id = ntohl (mp->spd_id);
4581 VALIDATE_SW_IF_INDEX (mp);
4584 rv = ipsec_set_interface_spd (vm, sw_if_index, spd_id, mp->is_add);
4586 rv = VNET_API_ERROR_UNIMPLEMENTED;
4589 BAD_SW_IF_INDEX_LABEL;
4591 REPLY_MACRO (VL_API_IPSEC_INTERFACE_ADD_DEL_SPD_REPLY);
4594 static void vl_api_ipsec_spd_add_del_entry_t_handler
4595 (vl_api_ipsec_spd_add_del_entry_t * mp)
4597 vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main ();
4598 vl_api_ipsec_spd_add_del_entry_reply_t *rmp;
4604 memset (&p, 0, sizeof (p));
4606 p.id = ntohl (mp->spd_id);
4607 p.priority = ntohl (mp->priority);
4608 p.is_outbound = mp->is_outbound;
4609 p.is_ipv6 = mp->is_ipv6;
4611 if (mp->is_ipv6 || mp->is_ip_any)
4613 clib_memcpy (&p.raddr.start, mp->remote_address_start, 16);
4614 clib_memcpy (&p.raddr.stop, mp->remote_address_stop, 16);
4615 clib_memcpy (&p.laddr.start, mp->local_address_start, 16);
4616 clib_memcpy (&p.laddr.stop, mp->local_address_stop, 16);
4620 clib_memcpy (&p.raddr.start.ip4.data, mp->remote_address_start, 4);
4621 clib_memcpy (&p.raddr.stop.ip4.data, mp->remote_address_stop, 4);
4622 clib_memcpy (&p.laddr.start.ip4.data, mp->local_address_start, 4);
4623 clib_memcpy (&p.laddr.stop.ip4.data, mp->local_address_stop, 4);
4625 p.protocol = mp->protocol;
4626 p.rport.start = ntohs (mp->remote_port_start);
4627 p.rport.stop = ntohs (mp->remote_port_stop);
4628 p.lport.start = ntohs (mp->local_port_start);
4629 p.lport.stop = ntohs (mp->local_port_stop);
4630 /* policy action resolve unsupported */
4631 if (mp->policy == IPSEC_POLICY_ACTION_RESOLVE)
4633 clib_warning ("unsupported action: 'resolve'");
4634 rv = VNET_API_ERROR_UNIMPLEMENTED;
4637 p.policy = mp->policy;
4638 p.sa_id = ntohl (mp->sa_id);
4640 rv = ipsec_add_del_policy (vm, &p, mp->is_add);
4647 rv = ipsec_add_del_policy (vm, &p, mp->is_add);
4650 rv = VNET_API_ERROR_UNIMPLEMENTED;
4655 REPLY_MACRO (VL_API_IPSEC_SPD_ADD_DEL_ENTRY_REPLY);
4658 static void vl_api_ipsec_sad_add_del_entry_t_handler
4659 (vl_api_ipsec_sad_add_del_entry_t * mp)
4661 vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main ();
4662 vl_api_ipsec_sad_add_del_entry_reply_t *rmp;
4667 memset (&sa, 0, sizeof (sa));
4669 sa.id = ntohl (mp->sad_id);
4670 sa.spi = ntohl (mp->spi);
4671 /* security protocol AH unsupported */
4672 if (mp->protocol == IPSEC_PROTOCOL_AH)
4674 clib_warning ("unsupported security protocol 'AH'");
4675 rv = VNET_API_ERROR_UNIMPLEMENTED;
4678 sa.protocol = mp->protocol;
4679 /* check for unsupported crypto-alg */
4680 if (mp->crypto_algorithm < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
4681 mp->crypto_algorithm >= IPSEC_CRYPTO_N_ALG)
4683 clib_warning ("unsupported crypto-alg: '%U'", format_ipsec_crypto_alg,
4684 mp->crypto_algorithm);
4685 rv = VNET_API_ERROR_UNIMPLEMENTED;
4688 sa.crypto_alg = mp->crypto_algorithm;
4689 sa.crypto_key_len = mp->crypto_key_length;
4690 clib_memcpy (&sa.crypto_key, mp->crypto_key, sizeof (sa.crypto_key));
4691 /* check for unsupported integ-alg */
4693 if (mp->integrity_algorithm < IPSEC_INTEG_ALG_NONE ||
4695 if (mp->integrity_algorithm < IPSEC_INTEG_ALG_SHA1_96 ||
4697 mp->integrity_algorithm >= IPSEC_INTEG_N_ALG)
4699 clib_warning ("unsupported integ-alg: '%U'", format_ipsec_integ_alg,
4700 mp->integrity_algorithm);
4701 rv = VNET_API_ERROR_UNIMPLEMENTED;
4706 /*Special cases, aes-gcm-128 encryption */
4707 if (mp->crypto_algorithm == IPSEC_CRYPTO_ALG_AES_GCM_128)
4709 if (mp->integrity_algorithm != IPSEC_INTEG_ALG_NONE
4710 && mp->integrity_algorithm != IPSEC_INTEG_ALG_AES_GCM_128)
4713 ("unsupported: aes-gcm-128 crypto-alg needs none as integ-alg");
4714 rv = VNET_API_ERROR_UNIMPLEMENTED;
4717 else /*set integ-alg internally to aes-gcm-128 */
4718 mp->integrity_algorithm = IPSEC_INTEG_ALG_AES_GCM_128;
4720 else if (mp->integrity_algorithm == IPSEC_INTEG_ALG_AES_GCM_128)
4722 clib_warning ("unsupported integ-alg: aes-gcm-128");
4723 rv = VNET_API_ERROR_UNIMPLEMENTED;
4726 else if (mp->integrity_algorithm == IPSEC_INTEG_ALG_NONE)
4728 clib_warning ("unsupported integ-alg: none");
4729 rv = VNET_API_ERROR_UNIMPLEMENTED;
4734 sa.integ_alg = mp->integrity_algorithm;
4735 sa.integ_key_len = mp->integrity_key_length;
4736 clib_memcpy (&sa.integ_key, mp->integrity_key, sizeof (sa.integ_key));
4737 sa.use_esn = mp->use_extended_sequence_number;
4738 sa.is_tunnel = mp->is_tunnel;
4739 sa.is_tunnel_ip6 = mp->is_tunnel_ipv6;
4740 if (sa.is_tunnel_ip6)
4742 clib_memcpy (&sa.tunnel_src_addr, mp->tunnel_src_address, 16);
4743 clib_memcpy (&sa.tunnel_dst_addr, mp->tunnel_dst_address, 16);
4747 clib_memcpy (&sa.tunnel_src_addr.ip4.data, mp->tunnel_src_address, 4);
4748 clib_memcpy (&sa.tunnel_dst_addr.ip4.data, mp->tunnel_dst_address, 4);
4751 rv = ipsec_add_del_sa (vm, &sa, mp->is_add);
4753 rv = VNET_API_ERROR_UNIMPLEMENTED;
4758 REPLY_MACRO (VL_API_IPSEC_SAD_ADD_DEL_ENTRY_REPLY);
4762 vl_api_ikev2_profile_add_del_t_handler (vl_api_ikev2_profile_add_del_t * mp)
4764 vl_api_ikev2_profile_add_del_reply_t *rmp;
4768 vlib_main_t *vm = vlib_get_main ();
4769 clib_error_t *error;
4770 u8 *tmp = format (0, "%s", mp->name);
4771 error = ikev2_add_del_profile (vm, tmp, mp->is_add);
4774 rv = VNET_API_ERROR_UNSPECIFIED;
4776 rv = VNET_API_ERROR_UNIMPLEMENTED;
4779 REPLY_MACRO (VL_API_IKEV2_PROFILE_ADD_DEL_REPLY);
4783 vl_api_ikev2_profile_set_auth_t_handler
4784 (vl_api_ikev2_profile_set_auth_t * mp)
4786 vl_api_ikev2_profile_set_auth_reply_t *rmp;
4790 vlib_main_t *vm = vlib_get_main ();
4791 clib_error_t *error;
4792 u8 *tmp = format (0, "%s", mp->name);
4793 u8 *data = vec_new (u8, mp->data_len);
4794 clib_memcpy (data, mp->data, mp->data_len);
4795 error = ikev2_set_profile_auth (vm, tmp, mp->auth_method, data, mp->is_hex);
4799 rv = VNET_API_ERROR_UNSPECIFIED;
4801 rv = VNET_API_ERROR_UNIMPLEMENTED;
4804 REPLY_MACRO (VL_API_IKEV2_PROFILE_SET_AUTH_REPLY);
4808 vl_api_ikev2_profile_set_id_t_handler (vl_api_ikev2_profile_set_id_t * mp)
4810 vl_api_ikev2_profile_add_del_reply_t *rmp;
4814 vlib_main_t *vm = vlib_get_main ();
4815 clib_error_t *error;
4816 u8 *tmp = format (0, "%s", mp->name);
4817 u8 *data = vec_new (u8, mp->data_len);
4818 clib_memcpy (data, mp->data, mp->data_len);
4819 error = ikev2_set_profile_id (vm, tmp, mp->id_type, data, mp->is_local);
4823 rv = VNET_API_ERROR_UNSPECIFIED;
4825 rv = VNET_API_ERROR_UNIMPLEMENTED;
4828 REPLY_MACRO (VL_API_IKEV2_PROFILE_SET_ID_REPLY);
4832 vl_api_ikev2_profile_set_ts_t_handler (vl_api_ikev2_profile_set_ts_t * mp)
4834 vl_api_ikev2_profile_set_ts_reply_t *rmp;
4838 vlib_main_t *vm = vlib_get_main ();
4839 clib_error_t *error;
4840 u8 *tmp = format (0, "%s", mp->name);
4841 error = ikev2_set_profile_ts (vm, tmp, mp->proto, mp->start_port,
4842 mp->end_port, (ip4_address_t) mp->start_addr,
4843 (ip4_address_t) mp->end_addr, mp->is_local);
4846 rv = VNET_API_ERROR_UNSPECIFIED;
4848 rv = VNET_API_ERROR_UNIMPLEMENTED;
4851 REPLY_MACRO (VL_API_IKEV2_PROFILE_SET_TS_REPLY);
4855 vl_api_ikev2_set_local_key_t_handler (vl_api_ikev2_set_local_key_t * mp)
4857 vl_api_ikev2_profile_set_ts_reply_t *rmp;
4861 vlib_main_t *vm = vlib_get_main ();
4862 clib_error_t *error;
4864 error = ikev2_set_local_key (vm, mp->key_file);
4866 rv = VNET_API_ERROR_UNSPECIFIED;
4868 rv = VNET_API_ERROR_UNIMPLEMENTED;
4871 REPLY_MACRO (VL_API_IKEV2_SET_LOCAL_KEY_REPLY);
4875 vl_api_ipsec_sa_set_key_t_handler (vl_api_ipsec_sa_set_key_t * mp)
4877 vlib_main_t *vm __attribute__ ((unused)) = vlib_get_main ();
4878 vl_api_ipsec_sa_set_key_reply_t *rmp;
4882 sa.id = ntohl (mp->sa_id);
4883 sa.crypto_key_len = mp->crypto_key_length;
4884 clib_memcpy (&sa.crypto_key, mp->crypto_key, sizeof (sa.crypto_key));
4885 sa.integ_key_len = mp->integrity_key_length;
4886 clib_memcpy (&sa.integ_key, mp->integrity_key, sizeof (sa.integ_key));
4888 rv = ipsec_set_sa_key (vm, &sa);
4890 rv = VNET_API_ERROR_UNIMPLEMENTED;
4893 REPLY_MACRO (VL_API_IPSEC_SA_SET_KEY_REPLY);
4896 static void vl_api_cop_interface_enable_disable_t_handler
4897 (vl_api_cop_interface_enable_disable_t * mp)
4899 vl_api_cop_interface_enable_disable_reply_t *rmp;
4901 u32 sw_if_index = ntohl (mp->sw_if_index);
4904 VALIDATE_SW_IF_INDEX (mp);
4906 enable_disable = (int) mp->enable_disable;
4908 rv = cop_interface_enable_disable (sw_if_index, enable_disable);
4910 BAD_SW_IF_INDEX_LABEL;
4912 REPLY_MACRO (VL_API_COP_INTERFACE_ENABLE_DISABLE_REPLY);
4915 static void vl_api_cop_whitelist_enable_disable_t_handler
4916 (vl_api_cop_whitelist_enable_disable_t * mp)
4918 vl_api_cop_whitelist_enable_disable_reply_t *rmp;
4919 cop_whitelist_enable_disable_args_t _a, *a = &_a;
4920 u32 sw_if_index = ntohl (mp->sw_if_index);
4923 VALIDATE_SW_IF_INDEX (mp);
4925 a->sw_if_index = sw_if_index;
4928 a->default_cop = mp->default_cop;
4929 a->fib_id = ntohl (mp->fib_id);
4931 rv = cop_whitelist_enable_disable (a);
4933 BAD_SW_IF_INDEX_LABEL;
4935 REPLY_MACRO (VL_API_COP_WHITELIST_ENABLE_DISABLE_REPLY);
4939 vl_api_get_node_graph_t_handler (vl_api_get_node_graph_t * mp)
4943 api_main_t *am = &api_main;
4944 vlib_main_t *vm = vlib_get_main ();
4946 vl_api_get_node_graph_reply_t *rmp;
4948 pthread_mutex_lock (&am->vlib_rp->mutex);
4949 oldheap = svm_push_data_heap (am->vlib_rp);
4952 * Keep the number of memcpy ops to a minimum (e.g. 1).
4954 vec_validate (vector, 16384);
4955 vec_reset_length (vector);
4958 vector = vlib_node_serialize (&vm->node_main, vector,
4959 (u32) ~ 0 /* all threads */ ,
4960 1 /* include nexts */ ,
4961 1 /* include stats */ );
4963 svm_pop_heap (oldheap);
4964 pthread_mutex_unlock (&am->vlib_rp->mutex);
4967 REPLY_MACRO2(VL_API_GET_NODE_GRAPH_REPLY,
4969 rmp->reply_in_shmem = (uword) vector;
4975 vl_api_ioam_enable_t_handler (vl_api_ioam_enable_t * mp)
4978 vl_api_ioam_enable_reply_t *rmp;
4979 clib_error_t *error;
4981 /* Ignoring the profile id as currently a single profile
4983 error = ip6_ioam_enable (mp->trace_enable, mp->pot_enable,
4984 mp->seqno, mp->analyse);
4987 clib_error_report (error);
4988 rv = clib_error_get_code (error);
4991 REPLY_MACRO (VL_API_IOAM_ENABLE_REPLY);
4995 vl_api_ioam_disable_t_handler (vl_api_ioam_disable_t * mp)
4998 vl_api_ioam_disable_reply_t *rmp;
4999 clib_error_t *error;
5001 error = clear_ioam_rewrite_fn ();
5004 clib_error_report (error);
5005 rv = clib_error_get_code (error);
5008 REPLY_MACRO (VL_API_IOAM_DISABLE_REPLY);
5012 vl_api_policer_add_del_t_handler (vl_api_policer_add_del_t * mp)
5014 vlib_main_t *vm = vlib_get_main ();
5015 vl_api_policer_add_del_reply_t *rmp;
5018 sse2_qos_pol_cfg_params_st cfg;
5019 clib_error_t *error;
5022 name = format (0, "%s", mp->name);
5024 memset (&cfg, 0, sizeof (cfg));
5026 cfg.rnd_type = mp->round_type;
5027 cfg.rate_type = mp->rate_type;
5028 cfg.rb.kbps.cir_kbps = mp->cir;
5029 cfg.rb.kbps.eir_kbps = mp->eir;
5030 cfg.rb.kbps.cb_bytes = mp->cb;
5031 cfg.rb.kbps.eb_bytes = mp->eb;
5032 cfg.conform_action.action_type = mp->conform_action_type;
5033 cfg.conform_action.dscp = mp->conform_dscp;
5034 cfg.exceed_action.action_type = mp->exceed_action_type;
5035 cfg.exceed_action.dscp = mp->exceed_dscp;
5036 cfg.violate_action.action_type = mp->violate_action_type;
5037 cfg.violate_action.dscp = mp->violate_dscp;
5038 cfg.color_aware = mp->color_aware;
5040 error = policer_add_del (vm, name, &cfg, &policer_index, mp->is_add);
5043 rv = VNET_API_ERROR_UNSPECIFIED;
5046 REPLY_MACRO2(VL_API_POLICER_ADD_DEL_REPLY,
5048 if (rv == 0 && mp->is_add)
5049 rmp->policer_index = ntohl(policer_index);
5051 rmp->policer_index = ~0;
5057 send_policer_details (u8 * name,
5058 sse2_qos_pol_cfg_params_st * config,
5059 policer_read_response_type_st * templ,
5060 unix_shared_memory_queue_t * q, u32 context)
5062 vl_api_policer_details_t *mp;
5064 mp = vl_msg_api_alloc (sizeof (*mp));
5065 memset (mp, 0, sizeof (*mp));
5066 mp->_vl_msg_id = ntohs (VL_API_POLICER_DETAILS);
5067 mp->context = context;
5068 mp->cir = htonl (config->rb.kbps.cir_kbps);
5069 mp->eir = htonl (config->rb.kbps.eir_kbps);
5070 mp->cb = htonl (config->rb.kbps.cb_bytes);
5071 mp->eb = htonl (config->rb.kbps.eb_bytes);
5072 mp->rate_type = config->rate_type;
5073 mp->round_type = config->rnd_type;
5074 mp->type = config->rfc;
5075 mp->conform_action_type = config->conform_action.action_type;
5076 mp->conform_dscp = config->conform_action.dscp;
5077 mp->exceed_action_type = config->exceed_action.action_type;
5078 mp->exceed_dscp = config->exceed_action.dscp;
5079 mp->violate_action_type = config->violate_action.action_type;
5080 mp->violate_dscp = config->violate_action.dscp;
5081 mp->single_rate = templ->single_rate ? 1 : 0;
5082 mp->color_aware = templ->color_aware ? 1 : 0;
5083 mp->scale = htonl (templ->scale);
5084 mp->cir_tokens_per_period = htonl (templ->cir_tokens_per_period);
5085 mp->pir_tokens_per_period = htonl (templ->pir_tokens_per_period);
5086 mp->current_limit = htonl (templ->current_limit);
5087 mp->current_bucket = htonl (templ->current_bucket);
5088 mp->extended_limit = htonl (templ->extended_limit);
5089 mp->extended_bucket = htonl (templ->extended_bucket);
5090 mp->last_update_time = clib_host_to_net_u64 (templ->last_update_time);
5092 strncpy ((char *) mp->name, (char *) name, ARRAY_LEN (mp->name) - 1);
5094 vl_msg_api_send_shmem (q, (u8 *) & mp);
5098 vl_api_policer_dump_t_handler (vl_api_policer_dump_t * mp)
5100 unix_shared_memory_queue_t *q;
5101 vnet_policer_main_t *pm = &vnet_policer_main;
5107 sse2_qos_pol_cfg_params_st *config;
5108 policer_read_response_type_st *templ;
5110 q = vl_api_client_index_to_input_queue (mp->client_index);
5114 if (mp->match_name_valid)
5116 match_name = format (0, "%s%c", mp->match_name, 0);
5119 if (mp->match_name_valid)
5121 p = hash_get_mem (pm->policer_config_by_name, match_name);
5125 config = pool_elt_at_index (pm->configs, pool_index);
5126 templ = pool_elt_at_index (pm->policer_templates, pool_index);
5127 send_policer_details (match_name, config, templ, q, mp->context);
5133 hash_foreach_pair (hp, pm->policer_config_by_name,
5135 name = (u8 *) hp->key;
5136 pool_index = hp->value[0];
5137 config = pool_elt_at_index (pm->configs, pool_index);
5138 templ = pool_elt_at_index (pm->policer_templates, pool_index);
5139 send_policer_details(name, config, templ, q, mp->context);
5146 vl_api_policer_classify_set_interface_t_handler
5147 (vl_api_policer_classify_set_interface_t * mp)
5149 vlib_main_t *vm = vlib_get_main ();
5150 vl_api_policer_classify_set_interface_reply_t *rmp;
5152 u32 sw_if_index, ip4_table_index, ip6_table_index, l2_table_index;
5154 ip4_table_index = ntohl (mp->ip4_table_index);
5155 ip6_table_index = ntohl (mp->ip6_table_index);
5156 l2_table_index = ntohl (mp->l2_table_index);
5157 sw_if_index = ntohl (mp->sw_if_index);
5159 VALIDATE_SW_IF_INDEX (mp);
5161 rv = vnet_set_policer_classify_intfc (vm, sw_if_index, ip4_table_index,
5162 ip6_table_index, l2_table_index,
5165 BAD_SW_IF_INDEX_LABEL;
5167 REPLY_MACRO (VL_API_POLICER_CLASSIFY_SET_INTERFACE_REPLY);
5171 send_policer_classify_details (u32 sw_if_index,
5173 unix_shared_memory_queue_t * q, u32 context)
5175 vl_api_policer_classify_details_t *mp;
5177 mp = vl_msg_api_alloc (sizeof (*mp));
5178 memset (mp, 0, sizeof (*mp));
5179 mp->_vl_msg_id = ntohs (VL_API_POLICER_CLASSIFY_DETAILS);
5180 mp->context = context;
5181 mp->sw_if_index = htonl (sw_if_index);
5182 mp->table_index = htonl (table_index);
5184 vl_msg_api_send_shmem (q, (u8 *) & mp);
5188 vl_api_policer_classify_dump_t_handler (vl_api_policer_classify_dump_t * mp)
5190 unix_shared_memory_queue_t *q;
5191 policer_classify_main_t *pcm = &policer_classify_main;
5195 q = vl_api_client_index_to_input_queue (mp->client_index);
5199 vec_tbl = pcm->classify_table_index_by_sw_if_index[mp->type];
5201 if (vec_len (vec_tbl))
5203 for (i = 0; i < vec_len (vec_tbl); i++)
5205 if (vec_elt (vec_tbl, i) == ~0)
5208 send_policer_classify_details (i, vec_elt (vec_tbl, i), q,
5215 vl_api_mpls_tunnel_details_t_handler (vl_api_mpls_fib_details_t * mp)
5217 clib_warning ("BUG");
5220 typedef struct mpls_tunnel_send_walk_ctx_t_
5222 unix_shared_memory_queue_t *q;
5225 } mpls_tunnel_send_walk_ctx_t;
5228 send_mpls_tunnel_entry (u32 mti, void *arg)
5230 mpls_tunnel_send_walk_ctx_t *ctx;
5231 vl_api_mpls_tunnel_details_t *mp;
5232 const mpls_tunnel_t *mt;
5237 if (~0 != ctx->index && mti != ctx->index)
5240 mt = mpls_tunnel_get (mti);
5241 nlabels = vec_len (mt->mt_label_stack);
5243 mp = vl_msg_api_alloc (sizeof (*mp) + nlabels * sizeof (u32));
5244 memset (mp, 0, sizeof (*mp));
5245 mp->_vl_msg_id = ntohs (VL_API_MPLS_TUNNEL_DETAILS);
5246 mp->context = ctx->context;
5248 mp->tunnel_index = ntohl (mti);
5249 memcpy (mp->mt_next_hop_out_labels,
5250 mt->mt_label_stack, nlabels * sizeof (u32));
5254 vl_msg_api_send_shmem (ctx->q, (u8 *) & mp);
5258 vl_api_mpls_tunnel_dump_t_handler (vl_api_mpls_tunnel_dump_t * mp)
5260 unix_shared_memory_queue_t *q;
5262 q = vl_api_client_index_to_input_queue (mp->client_index);
5266 mpls_tunnel_send_walk_ctx_t ctx = {
5268 .index = ntohl (mp->tunnel_index),
5269 .context = mp->context,
5271 mpls_tunnel_walk (send_mpls_tunnel_entry, &ctx);
5275 vl_api_mpls_fib_details_t_handler (vl_api_mpls_fib_details_t * mp)
5277 clib_warning ("BUG");
5281 vl_api_mpls_fib_details_t_endian (vl_api_mpls_fib_details_t * mp)
5283 clib_warning ("BUG");
5287 vl_api_mpls_fib_details_t_print (vl_api_mpls_fib_details_t * mp)
5289 clib_warning ("BUG");
5293 send_mpls_fib_details (vpe_api_main_t * am,
5294 unix_shared_memory_queue_t * q,
5295 u32 table_id, u32 label, u32 eos,
5296 fib_route_path_encode_t * api_rpaths, u32 context)
5298 vl_api_mpls_fib_details_t *mp;
5299 fib_route_path_encode_t *api_rpath;
5300 vl_api_fib_path2_t *fp;
5303 path_count = vec_len (api_rpaths);
5304 mp = vl_msg_api_alloc (sizeof (*mp) + path_count * sizeof (*fp));
5307 memset (mp, 0, sizeof (*mp));
5308 mp->_vl_msg_id = ntohs (VL_API_MPLS_FIB_DETAILS);
5309 mp->context = context;
5311 mp->table_id = htonl (table_id);
5313 mp->label = htonl (label);
5315 mp->count = htonl (path_count);
5317 vec_foreach (api_rpath, api_rpaths)
5319 memset (fp, 0, sizeof (*fp));
5320 fp->weight = htonl (api_rpath->rpath.frp_weight);
5321 fp->sw_if_index = htonl (api_rpath->rpath.frp_sw_if_index);
5322 copy_fib_next_hop (api_rpath, fp);
5326 vl_msg_api_send_shmem (q, (u8 *) & mp);
5330 vl_api_mpls_fib_dump_t_handler (vl_api_mpls_fib_dump_t * mp)
5332 vpe_api_main_t *am = &vpe_api_main;
5333 unix_shared_memory_queue_t *q;
5334 mpls_main_t *mm = &mpls_main;
5335 fib_table_t *fib_table;
5336 fib_node_index_t lfei, *lfeip, *lfeis = NULL;
5340 fib_route_path_encode_t *api_rpaths;
5342 q = vl_api_client_index_to_input_queue (mp->client_index);
5347 pool_foreach (fib_table, mm->fibs,
5349 hash_foreach(key, lfei, fib_table->mpls.mf_entries,
5351 vec_add1(lfeis, lfei);
5354 vec_sort_with_function(lfeis, fib_entry_cmp_for_sort);
5356 vec_foreach(lfeip, lfeis)
5358 fib_entry_get_prefix(*lfeip, &pfx);
5359 fib_index = fib_entry_get_fib_index(*lfeip);
5360 fib_table = fib_table_get(fib_index, pfx.fp_proto);
5362 fib_entry_encode(*lfeip, &api_rpaths);
5363 send_mpls_fib_details (am, q,
5364 fib_table->ft_table_id,
5369 vec_free(api_rpaths);
5376 vl_api_classify_table_ids_t_handler (vl_api_classify_table_ids_t * mp)
5378 unix_shared_memory_queue_t *q;
5380 q = vl_api_client_index_to_input_queue (mp->client_index);
5384 vnet_classify_main_t *cm = &vnet_classify_main;
5385 vnet_classify_table_t *t;
5390 pool_foreach (t, cm->tables,
5392 vec_add1 (table_ids, ntohl(t - cm->tables));
5395 count = vec_len (table_ids);
5397 vl_api_classify_table_ids_reply_t *rmp;
5398 rmp = vl_msg_api_alloc_as_if_client (sizeof (*rmp) + count * sizeof (u32));
5399 rmp->_vl_msg_id = ntohs (VL_API_CLASSIFY_TABLE_IDS_REPLY);
5400 rmp->context = mp->context;
5401 rmp->count = ntohl (count);
5402 clib_memcpy (rmp->ids, table_ids, count * sizeof (u32));
5405 vl_msg_api_send_shmem (q, (u8 *) & rmp);
5407 vec_free (table_ids);
5411 vl_api_classify_table_by_interface_t_handler
5412 (vl_api_classify_table_by_interface_t * mp)
5414 vl_api_classify_table_by_interface_reply_t *rmp;
5417 u32 sw_if_index = ntohl (mp->sw_if_index);
5420 vec_validate (acl, INPUT_ACL_N_TABLES - 1);
5423 VALIDATE_SW_IF_INDEX (mp);
5425 input_acl_main_t *am = &input_acl_main;
5430 for (type = 0; type < INPUT_ACL_N_TABLES; type++)
5432 u32 *vec_tbl = am->classify_table_index_by_sw_if_index[type];
5433 if (vec_len (vec_tbl))
5435 for (if_idx = 0; if_idx < vec_len (vec_tbl); if_idx++)
5437 if (vec_elt (vec_tbl, if_idx) == ~0 || sw_if_index != if_idx)
5441 acl[type] = vec_elt (vec_tbl, if_idx);
5446 BAD_SW_IF_INDEX_LABEL;
5449 REPLY_MACRO2(VL_API_CLASSIFY_TABLE_BY_INTERFACE_REPLY,
5451 rmp->sw_if_index = ntohl(sw_if_index);
5452 rmp->l2_table_id = ntohl(acl[INPUT_ACL_TABLE_L2]);
5453 rmp->ip4_table_id = ntohl(acl[INPUT_ACL_TABLE_IP4]);
5454 rmp->ip6_table_id = ntohl(acl[INPUT_ACL_TABLE_IP6]);
5461 vl_api_classify_table_info_t_handler (vl_api_classify_table_info_t * mp)
5463 unix_shared_memory_queue_t *q;
5465 q = vl_api_client_index_to_input_queue (mp->client_index);
5469 vl_api_classify_table_info_reply_t *rmp = 0;
5471 vnet_classify_main_t *cm = &vnet_classify_main;
5472 u32 table_id = ntohl (mp->table_id);
5473 vnet_classify_table_t *t;
5476 pool_foreach (t, cm->tables,
5478 if (table_id == t - cm->tables)
5480 rmp = vl_msg_api_alloc_as_if_client
5481 (sizeof (*rmp) + t->match_n_vectors * sizeof (u32x4));
5482 rmp->_vl_msg_id = ntohs (VL_API_CLASSIFY_TABLE_INFO_REPLY);
5483 rmp->context = mp->context;
5484 rmp->table_id = ntohl(table_id);
5485 rmp->nbuckets = ntohl(t->nbuckets);
5486 rmp->match_n_vectors = ntohl(t->match_n_vectors);
5487 rmp->skip_n_vectors = ntohl(t->skip_n_vectors);
5488 rmp->active_sessions = ntohl(t->active_elements);
5489 rmp->next_table_index = ntohl(t->next_table_index);
5490 rmp->miss_next_index = ntohl(t->miss_next_index);
5491 rmp->mask_length = ntohl(t->match_n_vectors * sizeof (u32x4));
5492 clib_memcpy(rmp->mask, t->mask, t->match_n_vectors * sizeof(u32x4));
5501 rmp = vl_msg_api_alloc (sizeof (*rmp));
5502 rmp->_vl_msg_id = ntohs ((VL_API_CLASSIFY_TABLE_INFO_REPLY));
5503 rmp->context = mp->context;
5504 rmp->retval = ntohl (VNET_API_ERROR_CLASSIFY_TABLE_NOT_FOUND);
5507 vl_msg_api_send_shmem (q, (u8 *) & rmp);
5511 vl_api_classify_session_details_t_handler (vl_api_classify_session_details_t *
5514 clib_warning ("BUG");
5518 send_classify_session_details (unix_shared_memory_queue_t * q,
5521 vnet_classify_entry_t * e, u32 context)
5523 vl_api_classify_session_details_t *rmp;
5525 rmp = vl_msg_api_alloc (sizeof (*rmp));
5526 memset (rmp, 0, sizeof (*rmp));
5527 rmp->_vl_msg_id = ntohs (VL_API_CLASSIFY_SESSION_DETAILS);
5528 rmp->context = context;
5529 rmp->table_id = ntohl (table_id);
5530 rmp->hit_next_index = ntohl (e->next_index);
5531 rmp->advance = ntohl (e->advance);
5532 rmp->opaque_index = ntohl (e->opaque_index);
5533 rmp->match_length = ntohl (match_length);
5534 clib_memcpy (rmp->match, e->key, match_length);
5536 vl_msg_api_send_shmem (q, (u8 *) & rmp);
5540 vl_api_classify_session_dump_t_handler (vl_api_classify_session_dump_t * mp)
5542 vnet_classify_main_t *cm = &vnet_classify_main;
5543 unix_shared_memory_queue_t *q;
5545 u32 table_id = ntohl (mp->table_id);
5546 vnet_classify_table_t *t;
5548 q = vl_api_client_index_to_input_queue (mp->client_index);
5553 pool_foreach (t, cm->tables,
5555 if (table_id == t - cm->tables)
5557 vnet_classify_bucket_t * b;
5558 vnet_classify_entry_t * v, * save_v;
5561 for (i = 0; i < t->nbuckets; i++)
5563 b = &t->buckets [i];
5567 save_v = vnet_classify_get_entry (t, b->offset);
5568 for (j = 0; j < (1<<b->log2_pages); j++)
5570 for (k = 0; k < t->entries_per_page; k++)
5572 v = vnet_classify_entry_at_index
5573 (t, save_v, j*t->entries_per_page + k);
5574 if (vnet_classify_entry_is_free (v))
5577 send_classify_session_details
5578 (q, table_id, t->match_n_vectors * sizeof (u32x4),
5590 vl_api_set_ipfix_exporter_t_handler (vl_api_set_ipfix_exporter_t * mp)
5592 vlib_main_t *vm = vlib_get_main ();
5593 flow_report_main_t *frm = &flow_report_main;
5594 vl_api_set_ipfix_exporter_reply_t *rmp;
5595 ip4_address_t collector, src;
5596 u16 collector_port = UDP_DST_PORT_ipfix;
5598 u32 template_interval;
5604 memcpy (collector.data, mp->collector_address, sizeof (collector.data));
5605 collector_port = ntohs (mp->collector_port);
5606 if (collector_port == (u16) ~ 0)
5607 collector_port = UDP_DST_PORT_ipfix;
5608 memcpy (src.data, mp->src_address, sizeof (src.data));
5609 fib_id = ntohl (mp->vrf_id);
5611 ip4_main_t *im = &ip4_main;
5618 uword *p = hash_get (im->fib_index_by_table_id, fib_id);
5621 rv = VNET_API_ERROR_NO_SUCH_FIB;
5627 path_mtu = ntohl (mp->path_mtu);
5629 path_mtu = 512; // RFC 7011 section 10.3.3.
5630 template_interval = ntohl (mp->template_interval);
5631 if (template_interval == ~0)
5632 template_interval = 20;
5633 udp_checksum = mp->udp_checksum;
5635 if (collector.as_u32 == 0)
5637 rv = VNET_API_ERROR_INVALID_VALUE;
5641 if (src.as_u32 == 0)
5643 rv = VNET_API_ERROR_INVALID_VALUE;
5647 if (path_mtu > 1450 /* vpp does not support fragmentation */ )
5649 rv = VNET_API_ERROR_INVALID_VALUE;
5655 rv = VNET_API_ERROR_INVALID_VALUE;
5659 /* Reset report streams if we are reconfiguring IP addresses */
5660 if (frm->ipfix_collector.as_u32 != collector.as_u32 ||
5661 frm->src_address.as_u32 != src.as_u32 ||
5662 frm->collector_port != collector_port)
5663 vnet_flow_reports_reset (frm);
5665 frm->ipfix_collector.as_u32 = collector.as_u32;
5666 frm->collector_port = collector_port;
5667 frm->src_address.as_u32 = src.as_u32;
5668 frm->fib_index = fib_index;
5669 frm->path_mtu = path_mtu;
5670 frm->template_interval = template_interval;
5671 frm->udp_checksum = udp_checksum;
5673 /* Turn on the flow reporting process */
5674 vlib_process_signal_event (vm, flow_report_process_node.index, 1, 0);
5677 REPLY_MACRO (VL_API_SET_IPFIX_EXPORTER_REPLY);
5681 vl_api_ipfix_exporter_dump_t_handler (vl_api_ipfix_exporter_dump_t * mp)
5683 flow_report_main_t *frm = &flow_report_main;
5684 unix_shared_memory_queue_t *q;
5685 vl_api_ipfix_exporter_details_t *rmp;
5686 ip4_main_t *im = &ip4_main;
5689 q = vl_api_client_index_to_input_queue (mp->client_index);
5693 rmp = vl_msg_api_alloc (sizeof (*rmp));
5694 memset (rmp, 0, sizeof (*rmp));
5695 rmp->_vl_msg_id = ntohs (VL_API_IPFIX_EXPORTER_DETAILS);
5696 rmp->context = mp->context;
5697 memcpy (rmp->collector_address, frm->ipfix_collector.data,
5698 sizeof (frm->ipfix_collector.data));
5699 rmp->collector_port = htons (frm->collector_port);
5700 memcpy (rmp->src_address, frm->src_address.data,
5701 sizeof (frm->src_address.data));
5702 if (frm->fib_index == ~0)
5705 vrf_id = im->fibs[frm->fib_index].ft_table_id;
5706 rmp->vrf_id = htonl (vrf_id);
5707 rmp->path_mtu = htonl (frm->path_mtu);
5708 rmp->template_interval = htonl (frm->template_interval);
5709 rmp->udp_checksum = (frm->udp_checksum != 0);
5711 vl_msg_api_send_shmem (q, (u8 *) & rmp);
5715 vl_api_set_ipfix_classify_stream_t_handler
5716 (vl_api_set_ipfix_classify_stream_t * mp)
5718 vl_api_set_ipfix_classify_stream_reply_t *rmp;
5719 flow_report_classify_main_t *fcm = &flow_report_classify_main;
5720 flow_report_main_t *frm = &flow_report_main;
5722 u32 src_port = UDP_DST_PORT_ipfix;
5725 domain_id = ntohl (mp->domain_id);
5726 src_port = ntohs (mp->src_port);
5728 if (fcm->src_port != 0 &&
5729 (fcm->domain_id != domain_id || fcm->src_port != (u16) src_port))
5731 int rv = vnet_stream_change (frm, fcm->domain_id, fcm->src_port,
5732 domain_id, (u16) src_port);
5736 fcm->domain_id = domain_id;
5737 fcm->src_port = (u16) src_port;
5739 REPLY_MACRO (VL_API_SET_IPFIX_CLASSIFY_STREAM_REPLY);
5743 vl_api_ipfix_classify_stream_dump_t_handler
5744 (vl_api_ipfix_classify_stream_dump_t * mp)
5746 flow_report_classify_main_t *fcm = &flow_report_classify_main;
5747 unix_shared_memory_queue_t *q;
5748 vl_api_ipfix_classify_stream_details_t *rmp;
5750 q = vl_api_client_index_to_input_queue (mp->client_index);
5754 rmp = vl_msg_api_alloc (sizeof (*rmp));
5755 memset (rmp, 0, sizeof (*rmp));
5756 rmp->_vl_msg_id = ntohs (VL_API_IPFIX_CLASSIFY_STREAM_DETAILS);
5757 rmp->context = mp->context;
5758 rmp->domain_id = htonl (fcm->domain_id);
5759 rmp->src_port = htons (fcm->src_port);
5761 vl_msg_api_send_shmem (q, (u8 *) & rmp);
5765 vl_api_ipfix_classify_table_add_del_t_handler
5766 (vl_api_ipfix_classify_table_add_del_t * mp)
5768 vl_api_ipfix_classify_table_add_del_reply_t *rmp;
5769 flow_report_classify_main_t *fcm = &flow_report_classify_main;
5770 flow_report_main_t *frm = &flow_report_main;
5771 vnet_flow_report_add_del_args_t args;
5772 ipfix_classify_table_t *table;
5774 u32 classify_table_index;
5776 u8 transport_protocol;
5779 classify_table_index = ntohl (mp->table_id);
5780 ip_version = mp->ip_version;
5781 transport_protocol = mp->transport_protocol;
5782 is_add = mp->is_add;
5784 if (fcm->src_port == 0)
5786 /* call set_ipfix_classify_stream first */
5787 rv = VNET_API_ERROR_UNSPECIFIED;
5791 memset (&args, 0, sizeof (args));
5795 for (i = 0; i < vec_len (fcm->tables); i++)
5796 if (ipfix_classify_table_index_valid (i))
5797 if (fcm->tables[i].classify_table_index == classify_table_index)
5799 table = &fcm->tables[i];
5807 rv = VNET_API_ERROR_VALUE_EXIST;
5810 table = ipfix_classify_add_table ();
5811 table->classify_table_index = classify_table_index;
5817 rv = VNET_API_ERROR_NO_SUCH_ENTRY;
5822 table->ip_version = ip_version;
5823 table->transport_protocol = transport_protocol;
5825 args.opaque.as_uword = table - fcm->tables;
5826 args.rewrite_callback = ipfix_classify_template_rewrite;
5827 args.flow_data_callback = ipfix_classify_send_flows;
5828 args.is_add = is_add;
5829 args.domain_id = fcm->domain_id;
5830 args.src_port = fcm->src_port;
5832 rv = vnet_flow_report_add_del (frm, &args);
5834 /* If deleting, or add failed */
5835 if (is_add == 0 || (rv && is_add))
5836 ipfix_classify_delete_table (table - fcm->tables);
5839 REPLY_MACRO (VL_API_SET_IPFIX_CLASSIFY_STREAM_REPLY);
5843 send_ipfix_classify_table_details (u32 table_index,
5844 unix_shared_memory_queue_t * q,
5847 flow_report_classify_main_t *fcm = &flow_report_classify_main;
5848 vl_api_ipfix_classify_table_details_t *mp;
5850 ipfix_classify_table_t *table = &fcm->tables[table_index];
5852 mp = vl_msg_api_alloc (sizeof (*mp));
5853 memset (mp, 0, sizeof (*mp));
5854 mp->_vl_msg_id = ntohs (VL_API_IPFIX_CLASSIFY_TABLE_DETAILS);
5855 mp->context = context;
5856 mp->table_id = htonl (table->classify_table_index);
5857 mp->ip_version = table->ip_version;
5858 mp->transport_protocol = table->transport_protocol;
5860 vl_msg_api_send_shmem (q, (u8 *) & mp);
5864 vl_api_ipfix_classify_table_dump_t_handler
5865 (vl_api_ipfix_classify_table_dump_t * mp)
5867 flow_report_classify_main_t *fcm = &flow_report_classify_main;
5868 unix_shared_memory_queue_t *q;
5871 q = vl_api_client_index_to_input_queue (mp->client_index);
5875 for (i = 0; i < vec_len (fcm->tables); i++)
5876 if (ipfix_classify_table_index_valid (i))
5877 send_ipfix_classify_table_details (i, q, mp->context);
5881 vl_api_pg_create_interface_t_handler (vl_api_pg_create_interface_t * mp)
5883 vl_api_pg_create_interface_reply_t *rmp;
5886 pg_main_t *pg = &pg_main;
5887 u32 pg_if_id = pg_interface_add_or_get (pg, ntohl (mp->interface_id));
5888 pg_interface_t *pi = pool_elt_at_index (pg->interfaces, pg_if_id);
5891 REPLY_MACRO2(VL_API_PG_CREATE_INTERFACE_REPLY,
5893 rmp->sw_if_index = ntohl(pi->sw_if_index);
5899 vl_api_pg_capture_t_handler (vl_api_pg_capture_t * mp)
5901 vl_api_pg_capture_reply_t *rmp;
5904 vnet_main_t *vnm = vnet_get_main ();
5905 vnet_interface_main_t *im = &vnm->interface_main;
5906 vnet_hw_interface_t *hi = 0;
5908 u8 *intf_name = format (0, "pg%d", ntohl (mp->interface_id), 0);
5909 u32 hw_if_index = ~0;
5910 uword *p = hash_get_mem (im->hw_interface_by_name, intf_name);
5913 vec_free (intf_name);
5915 if (hw_if_index != ~0)
5917 pg_capture_args_t _a, *a = &_a;
5919 u32 len = ntohl (mp->pcap_name_length);
5920 u8 *pcap_file_name = vec_new (u8, len);
5921 clib_memcpy (pcap_file_name, mp->pcap_file_name, len);
5923 hi = vnet_get_sup_hw_interface (vnm, hw_if_index);
5924 a->hw_if_index = hw_if_index;
5925 a->dev_instance = hi->dev_instance;
5926 a->is_enabled = mp->is_enabled;
5927 a->pcap_file_name = pcap_file_name;
5928 a->count = ntohl (mp->count);
5930 clib_error_t *e = pg_capture (a);
5933 clib_error_report (e);
5934 rv = VNET_API_ERROR_CANNOT_CREATE_PCAP_FILE;
5937 vec_free (pcap_file_name);
5939 REPLY_MACRO (VL_API_PG_CAPTURE_REPLY);
5943 vl_api_pg_enable_disable_t_handler (vl_api_pg_enable_disable_t * mp)
5945 vl_api_pg_enable_disable_reply_t *rmp;
5948 pg_main_t *pg = &pg_main;
5949 u32 stream_index = ~0;
5951 int is_enable = mp->is_enabled != 0;
5952 u32 len = ntohl (mp->stream_name_length) - 1;
5956 u8 *stream_name = vec_new (u8, len);
5957 clib_memcpy (stream_name, mp->stream_name, len);
5958 uword *p = hash_get_mem (pg->stream_index_by_name, stream_name);
5961 vec_free (stream_name);
5964 pg_enable_disable (stream_index, is_enable);
5966 REPLY_MACRO (VL_API_PG_ENABLE_DISABLE_REPLY);
5970 vl_api_ip_source_and_port_range_check_add_del_t_handler
5971 (vl_api_ip_source_and_port_range_check_add_del_t * mp)
5973 vl_api_ip_source_and_port_range_check_add_del_reply_t *rmp;
5976 u8 is_ipv6 = mp->is_ipv6;
5977 u8 is_add = mp->is_add;
5978 u8 mask_length = mp->mask_length;
5979 ip4_address_t ip4_addr;
5980 ip6_address_t ip6_addr;
5982 u16 *high_ports = 0;
5984 u16 tmp_low, tmp_high;
5988 // Validate port range
5989 num_ranges = mp->number_of_ranges;
5990 if (num_ranges > 32)
5991 { // This is size of array in VPE.API
5992 rv = VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY;
5996 vec_reset_length (low_ports);
5997 vec_reset_length (high_ports);
5999 for (i = 0; i < num_ranges; i++)
6001 tmp_low = mp->low_ports[i];
6002 tmp_high = mp->high_ports[i];
6003 // If tmp_low <= tmp_high then only need to check tmp_low = 0
6004 // If tmp_low <= tmp_high then only need to check tmp_high > 65535
6005 if (tmp_low > tmp_high || tmp_low == 0 || tmp_high > 65535)
6007 rv = VNET_API_ERROR_INVALID_VALUE;
6010 vec_add1 (low_ports, tmp_low);
6011 vec_add1 (high_ports, tmp_high + 1);
6014 // Validate mask_length
6015 if ((is_ipv6 && mask_length > 128) || (!is_ipv6 && mask_length > 32))
6017 rv = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH;
6021 vrf_id = ntohl (mp->vrf_id);
6025 rv = VNET_API_ERROR_INVALID_VALUE;
6032 clib_memcpy (ip6_addr.as_u8, mp->address, sizeof (ip6_addr.as_u8));
6033 rv = ip6_source_and_port_range_check_add_del (&ip6_addr,
6037 high_ports, is_add);
6041 clib_memcpy (ip4_addr.data, mp->address, sizeof (ip4_addr));
6042 rv = ip4_source_and_port_range_check_add_del (&ip4_addr,
6046 high_ports, is_add);
6050 vec_free (low_ports);
6051 vec_free (high_ports);
6052 REPLY_MACRO (VL_API_IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL_REPLY);
6056 vl_api_ip_source_and_port_range_check_interface_add_del_t_handler
6057 (vl_api_ip_source_and_port_range_check_interface_add_del_t * mp)
6059 vlib_main_t *vm = vlib_get_main ();
6060 vl_api_ip_source_and_port_range_check_interface_add_del_reply_t *rmp;
6061 ip4_main_t *im = &ip4_main;
6064 u32 fib_index[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS];
6065 u32 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS];
6069 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_OUT] =
6070 ntohl (mp->tcp_out_vrf_id);
6071 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_OUT] =
6072 ntohl (mp->udp_out_vrf_id);
6073 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_TCP_IN] =
6074 ntohl (mp->tcp_in_vrf_id);
6075 vrf_id[IP_SOURCE_AND_PORT_RANGE_CHECK_PROTOCOL_UDP_IN] =
6076 ntohl (mp->udp_in_vrf_id);
6079 for (i = 0; i < IP_SOURCE_AND_PORT_RANGE_CHECK_N_PROTOCOLS; i++)
6081 if (vrf_id[i] != 0 && vrf_id[i] != ~0)
6083 p = hash_get (im->fib_index_by_table_id, vrf_id[i]);
6087 rv = VNET_API_ERROR_INVALID_VALUE;
6091 fib_index[i] = p[0];
6096 sw_if_index = ntohl (mp->sw_if_index);
6098 VALIDATE_SW_IF_INDEX (mp);
6101 set_ip_source_and_port_range_check (vm, fib_index, sw_if_index,
6104 BAD_SW_IF_INDEX_LABEL;
6107 REPLY_MACRO (VL_API_IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY);
6111 vl_api_ipsec_gre_add_del_tunnel_t_handler (vl_api_ipsec_gre_add_del_tunnel_t *
6114 vl_api_ipsec_gre_add_del_tunnel_reply_t *rmp;
6116 vnet_ipsec_gre_add_del_tunnel_args_t _a, *a = &_a;
6117 u32 sw_if_index = ~0;
6119 /* Check src & dst are different */
6120 if (memcmp (mp->src_address, mp->dst_address, 4) == 0)
6122 rv = VNET_API_ERROR_SAME_SRC_DST;
6126 memset (a, 0, sizeof (*a));
6128 /* ip addresses sent in network byte order */
6129 clib_memcpy (&(a->src), mp->src_address, 4);
6130 clib_memcpy (&(a->dst), mp->dst_address, 4);
6131 a->is_add = mp->is_add;
6132 a->lsa = ntohl (mp->local_sa_id);
6133 a->rsa = ntohl (mp->remote_sa_id);
6135 rv = vnet_ipsec_gre_add_del_tunnel (a, &sw_if_index);
6139 REPLY_MACRO2(VL_API_GRE_ADD_DEL_TUNNEL_REPLY,
6141 rmp->sw_if_index = ntohl (sw_if_index);
6146 static void send_ipsec_gre_tunnel_details
6147 (ipsec_gre_tunnel_t * t, unix_shared_memory_queue_t * q, u32 context)
6149 vl_api_ipsec_gre_tunnel_details_t *rmp;
6151 rmp = vl_msg_api_alloc (sizeof (*rmp));
6152 memset (rmp, 0, sizeof (*rmp));
6153 rmp->_vl_msg_id = ntohs (VL_API_IPSEC_GRE_TUNNEL_DETAILS);
6154 clib_memcpy (rmp->src_address, &(t->tunnel_src), 4);
6155 clib_memcpy (rmp->dst_address, &(t->tunnel_dst), 4);
6156 rmp->sw_if_index = htonl (t->sw_if_index);
6157 rmp->local_sa_id = htonl (t->local_sa_id);
6158 rmp->remote_sa_id = htonl (t->remote_sa_id);
6159 rmp->context = context;
6161 vl_msg_api_send_shmem (q, (u8 *) & rmp);
6164 static void vl_api_ipsec_gre_tunnel_dump_t_handler
6165 (vl_api_ipsec_gre_tunnel_dump_t * mp)
6167 unix_shared_memory_queue_t *q;
6168 ipsec_gre_main_t *igm = &ipsec_gre_main;
6169 ipsec_gre_tunnel_t *t;
6172 q = vl_api_client_index_to_input_queue (mp->client_index);
6178 sw_if_index = ntohl (mp->sw_if_index);
6180 if (~0 == sw_if_index)
6183 pool_foreach (t, igm->tunnels,
6185 send_ipsec_gre_tunnel_details(t, q, mp->context);
6191 if ((sw_if_index >= vec_len (igm->tunnel_index_by_sw_if_index)) ||
6192 (~0 == igm->tunnel_index_by_sw_if_index[sw_if_index]))
6196 t = &igm->tunnels[igm->tunnel_index_by_sw_if_index[sw_if_index]];
6197 send_ipsec_gre_tunnel_details (t, q, mp->context);
6202 vl_api_delete_subif_t_handler (vl_api_delete_subif_t * mp)
6204 vl_api_delete_subif_reply_t *rmp;
6207 rv = vnet_delete_sub_interface (ntohl (mp->sw_if_index));
6209 REPLY_MACRO (VL_API_DELETE_SUBIF_REPLY);
6213 vl_api_l2_interface_pbb_tag_rewrite_t_handler
6214 (vl_api_l2_interface_pbb_tag_rewrite_t * mp)
6216 vl_api_l2_interface_pbb_tag_rewrite_reply_t *rmp;
6217 vnet_main_t *vnm = vnet_get_main ();
6218 vlib_main_t *vm = vlib_get_main ();
6222 VALIDATE_SW_IF_INDEX (mp);
6224 vtr_op = ntohl (mp->vtr_op);
6228 case L2_VTR_DISABLED:
6231 case L2_VTR_TRANSLATE_2_1:
6235 rv = VNET_API_ERROR_INVALID_VALUE;
6236 goto bad_sw_if_index;
6239 rv = l2pbb_configure (vm, vnm, ntohl (mp->sw_if_index), vtr_op,
6240 mp->b_dmac, mp->b_smac, ntohs (mp->b_vlanid),
6241 ntohl (mp->i_sid), ntohs (mp->outer_tag));
6243 BAD_SW_IF_INDEX_LABEL;
6245 REPLY_MACRO (VL_API_L2_INTERFACE_PBB_TAG_REWRITE_REPLY);
6250 vl_api_punt_t_handler (vl_api_punt_t * mp)
6252 vl_api_punt_reply_t *rmp;
6253 vlib_main_t *vm = vlib_get_main ();
6255 clib_error_t *error;
6257 error = vnet_punt_add_del (vm, mp->ipv, mp->l4_protocol,
6258 ntohs (mp->l4_port), mp->is_add);
6262 clib_error_report (error);
6265 REPLY_MACRO (VL_API_PUNT_REPLY);
6269 vl_api_flow_classify_set_interface_t_handler
6270 (vl_api_flow_classify_set_interface_t * mp)
6272 vlib_main_t *vm = vlib_get_main ();
6273 vl_api_flow_classify_set_interface_reply_t *rmp;
6275 u32 sw_if_index, ip4_table_index, ip6_table_index;
6277 ip4_table_index = ntohl (mp->ip4_table_index);
6278 ip6_table_index = ntohl (mp->ip6_table_index);
6279 sw_if_index = ntohl (mp->sw_if_index);
6281 VALIDATE_SW_IF_INDEX (mp);
6283 rv = vnet_set_flow_classify_intfc (vm, sw_if_index, ip4_table_index,
6284 ip6_table_index, mp->is_add);
6286 BAD_SW_IF_INDEX_LABEL;
6288 REPLY_MACRO (VL_API_FLOW_CLASSIFY_SET_INTERFACE_REPLY);
6292 send_flow_classify_details (u32 sw_if_index,
6294 unix_shared_memory_queue_t * q, u32 context)
6296 vl_api_flow_classify_details_t *mp;
6298 mp = vl_msg_api_alloc (sizeof (*mp));
6299 memset (mp, 0, sizeof (*mp));
6300 mp->_vl_msg_id = ntohs (VL_API_FLOW_CLASSIFY_DETAILS);
6301 mp->context = context;
6302 mp->sw_if_index = htonl (sw_if_index);
6303 mp->table_index = htonl (table_index);
6305 vl_msg_api_send_shmem (q, (u8 *) & mp);
6309 vl_api_flow_classify_dump_t_handler (vl_api_flow_classify_dump_t * mp)
6311 unix_shared_memory_queue_t *q;
6312 flow_classify_main_t *pcm = &flow_classify_main;
6316 q = vl_api_client_index_to_input_queue (mp->client_index);
6320 vec_tbl = pcm->classify_table_index_by_sw_if_index[mp->type];
6322 if (vec_len (vec_tbl))
6324 for (i = 0; i < vec_len (vec_tbl); i++)
6326 if (vec_elt (vec_tbl, i) == ~0)
6329 send_flow_classify_details (i, vec_elt (vec_tbl, i), q,
6336 send_ipsec_spd_details (ipsec_policy_t * p, unix_shared_memory_queue_t * q,
6339 vl_api_ipsec_spd_details_t *mp;
6341 mp = vl_msg_api_alloc (sizeof (*mp));
6342 memset (mp, 0, sizeof (*mp));
6343 mp->_vl_msg_id = ntohs (VL_API_IPSEC_SPD_DETAILS);
6344 mp->context = context;
6346 mp->spd_id = htonl (p->id);
6347 mp->priority = htonl (p->priority);
6348 mp->is_outbound = p->is_outbound;
6349 mp->is_ipv6 = p->is_ipv6;
6352 memcpy (mp->local_start_addr, &p->laddr.start.ip6, 16);
6353 memcpy (mp->local_stop_addr, &p->laddr.stop.ip6, 16);
6354 memcpy (mp->remote_start_addr, &p->raddr.start.ip6, 16);
6355 memcpy (mp->remote_stop_addr, &p->raddr.stop.ip6, 16);
6359 memcpy (mp->local_start_addr, &p->laddr.start.ip4, 4);
6360 memcpy (mp->local_stop_addr, &p->laddr.stop.ip4, 4);
6361 memcpy (mp->remote_start_addr, &p->raddr.start.ip4, 4);
6362 memcpy (mp->remote_stop_addr, &p->raddr.stop.ip4, 4);
6364 mp->local_start_port = htons (p->lport.start);
6365 mp->local_stop_port = htons (p->lport.stop);
6366 mp->remote_start_port = htons (p->rport.start);
6367 mp->remote_stop_port = htons (p->rport.stop);
6368 mp->protocol = p->protocol;
6369 mp->policy = p->policy;
6370 mp->sa_id = htonl (p->sa_id);
6371 mp->bytes = clib_host_to_net_u64 (p->counter.bytes);
6372 mp->packets = clib_host_to_net_u64 (p->counter.packets);
6374 vl_msg_api_send_shmem (q, (u8 *) & mp);
6378 vl_api_ipsec_spd_dump_t_handler (vl_api_ipsec_spd_dump_t * mp)
6380 unix_shared_memory_queue_t *q;
6381 ipsec_main_t *im = &ipsec_main;
6382 ipsec_policy_t *policy;
6387 q = vl_api_client_index_to_input_queue (mp->client_index);
6391 p = hash_get (im->spd_index_by_spd_id, ntohl (mp->spd_id));
6396 spd = pool_elt_at_index (im->spds, spd_index);
6399 pool_foreach (policy, spd->policies,
6401 if (mp->sa_id == ~(0) || ntohl (mp->sa_id) == policy->sa_id)
6402 send_ipsec_spd_details (policy, q,
6407 clib_warning ("unimplemented");
6412 vl_api_feature_enable_disable_t_handler (vl_api_feature_enable_disable_t * mp)
6414 vl_api_feature_enable_disable_reply_t *rmp;
6416 u8 *arc_name, *feature_name;
6418 VALIDATE_SW_IF_INDEX (mp);
6420 arc_name = format (0, "%s%c", mp->arc_name, 0);
6421 feature_name = format (0, "%s%c", mp->feature_name, 0);
6423 vnet_feature_registration_t *reg;
6425 vnet_get_feature_reg ((const char *) arc_name,
6426 (const char *) feature_name);
6428 rv = VNET_API_ERROR_INVALID_VALUE;
6432 clib_error_t *error = 0;
6434 sw_if_index = ntohl (mp->sw_if_index);
6435 if (reg->enable_disable_cb)
6436 error = reg->enable_disable_cb (sw_if_index, mp->enable);
6438 vnet_feature_enable_disable ((const char *) arc_name,
6439 (const char *) feature_name,
6440 sw_if_index, mp->enable, 0, 0);
6443 clib_error_report (error);
6444 rv = VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
6448 vec_free (feature_name);
6449 vec_free (arc_name);
6451 BAD_SW_IF_INDEX_LABEL;
6453 REPLY_MACRO (VL_API_FEATURE_ENABLE_DISABLE_REPLY);
6456 #define BOUNCE_HANDLER(nn) \
6457 static void vl_api_##nn##_t_handler ( \
6458 vl_api_##nn##_t *mp) \
6460 vpe_client_registration_t *reg; \
6461 vpe_api_main_t * vam = &vpe_api_main; \
6462 unix_shared_memory_queue_t * q; \
6464 /* One registration only... */ \
6465 pool_foreach(reg, vam->nn##_registrations, \
6467 q = vl_api_client_index_to_input_queue (reg->client_index); \
6470 * If the queue is stuffed, turf the msg and complain \
6471 * It's unlikely that the intended recipient is \
6472 * alive; avoid deadlock at all costs. \
6474 if (q->cursize == q->maxsize) { \
6475 clib_warning ("ERROR: receiver queue full, drop msg"); \
6476 vl_msg_api_free (mp); \
6479 vl_msg_api_send_shmem (q, (u8 *)&mp); \
6483 vl_msg_api_free (mp); \
6486 static void setup_message_id_table (api_main_t * am);
6490 * Add vpe's API message handlers to the table.
6491 * vlib has alread mapped shared memory and
6492 * added the client registration handlers.
6493 * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
6495 static clib_error_t *
6496 vpe_api_hookup (vlib_main_t * vm)
6498 api_main_t *am = &api_main;
6501 vl_msg_api_set_handlers(VL_API_##N, #n, \
6502 vl_api_##n##_t_handler, \
6504 vl_api_##n##_t_endian, \
6505 vl_api_##n##_t_print, \
6506 sizeof(vl_api_##n##_t), 1);
6507 foreach_vpe_api_msg;
6511 * Manually register the sr tunnel add del msg, so we trace
6512 * enough bytes to capture a typical segment list
6514 vl_msg_api_set_handlers (VL_API_SR_TUNNEL_ADD_DEL,
6515 "sr_tunnel_add_del",
6516 vl_api_sr_tunnel_add_del_t_handler,
6518 vl_api_sr_tunnel_add_del_t_endian,
6519 vl_api_sr_tunnel_add_del_t_print, 256, 1);
6523 * Manually register the sr policy add del msg, so we trace
6524 * enough bytes to capture a typical tunnel name list
6526 vl_msg_api_set_handlers (VL_API_SR_POLICY_ADD_DEL,
6527 "sr_policy_add_del",
6528 vl_api_sr_policy_add_del_t_handler,
6530 vl_api_sr_policy_add_del_t_endian,
6531 vl_api_sr_policy_add_del_t_print, 256, 1);
6534 * Trace space for 8 MPLS encap labels, classifier mask+match
6536 am->api_trace_cfg[VL_API_MPLS_TUNNEL_ADD_DEL].size += 8 * sizeof (u32);
6537 am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_TABLE].size += 5 * sizeof (u32x4);
6538 am->api_trace_cfg[VL_API_CLASSIFY_ADD_DEL_SESSION].size
6539 += 5 * sizeof (u32x4);
6540 am->api_trace_cfg[VL_API_VXLAN_ADD_DEL_TUNNEL].size += 16 * sizeof (u32);
6543 * Thread-safe API messages
6545 am->is_mp_safe[VL_API_IP_ADD_DEL_ROUTE] = 1;
6546 am->is_mp_safe[VL_API_GET_NODE_GRAPH] = 1;
6549 * Set up the (msg_name, crc, message-id) table
6551 setup_message_id_table (am);
6556 VLIB_API_INIT_FUNCTION (vpe_api_hookup);
6558 static clib_error_t *
6559 vpe_api_init (vlib_main_t * vm)
6561 vpe_api_main_t *am = &vpe_api_main;
6564 am->vnet_main = vnet_get_main ();
6565 am->interface_events_registration_hash = hash_create (0, sizeof (uword));
6566 am->to_netconf_server_registration_hash = hash_create (0, sizeof (uword));
6567 am->from_netconf_server_registration_hash = hash_create (0, sizeof (uword));
6568 am->to_netconf_client_registration_hash = hash_create (0, sizeof (uword));
6569 am->from_netconf_client_registration_hash = hash_create (0, sizeof (uword));
6570 am->oam_events_registration_hash = hash_create (0, sizeof (uword));
6571 am->bfd_events_registration_hash = hash_create (0, sizeof (uword));
6574 vl_set_memory_region_name ("/vpe-api");
6575 vl_enable_disable_memory_api (vm, 1 /* enable it */ );
6580 VLIB_INIT_FUNCTION (vpe_api_init);
6583 static clib_error_t *
6584 api_segment_config (vlib_main_t * vm, unformat_input_t * input)
6587 u64 baseva, size, pvt_heap_size;
6589 const int max_buf_size = 4096;
6591 struct passwd _pw, *pw;
6592 struct group _grp, *grp;
6594 buf = vec_new (char, 128);
6595 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
6597 if (unformat (input, "prefix %s", &chroot_path))
6599 vec_add1 (chroot_path, 0);
6600 vl_set_memory_root_path ((char *) chroot_path);
6602 else if (unformat (input, "uid %d", &uid))
6603 vl_set_memory_uid (uid);
6604 else if (unformat (input, "gid %d", &gid))
6605 vl_set_memory_gid (gid);
6606 else if (unformat (input, "baseva %llx", &baseva))
6607 vl_set_global_memory_baseva (baseva);
6608 else if (unformat (input, "global-size %lldM", &size))
6609 vl_set_global_memory_size (size * (1ULL << 20));
6610 else if (unformat (input, "global-size %lldG", &size))
6611 vl_set_global_memory_size (size * (1ULL << 30));
6612 else if (unformat (input, "global-size %lld", &size))
6613 vl_set_global_memory_size (size);
6614 else if (unformat (input, "global-pvt-heap-size %lldM", &pvt_heap_size))
6615 vl_set_global_pvt_heap_size (pvt_heap_size * (1ULL << 20));
6616 else if (unformat (input, "global-pvt-heap-size size %lld",
6618 vl_set_global_pvt_heap_size (pvt_heap_size);
6619 else if (unformat (input, "api-pvt-heap-size %lldM", &pvt_heap_size))
6620 vl_set_api_pvt_heap_size (pvt_heap_size * (1ULL << 20));
6621 else if (unformat (input, "api-pvt-heap-size size %lld",
6623 vl_set_api_pvt_heap_size (pvt_heap_size);
6624 else if (unformat (input, "api-size %lldM", &size))
6625 vl_set_api_memory_size (size * (1ULL << 20));
6626 else if (unformat (input, "api-size %lldG", &size))
6627 vl_set_api_memory_size (size * (1ULL << 30));
6628 else if (unformat (input, "api-size %lld", &size))
6629 vl_set_api_memory_size (size);
6630 else if (unformat (input, "uid %s", &s))
6632 /* lookup the username */
6635 getpwnam_r (s, &_pw, buf, vec_len (buf), &pw)) == ERANGE)
6636 && (vec_len (buf) <= max_buf_size))
6638 vec_resize (buf, vec_len (buf) * 2);
6642 e = clib_error_return_code (0, rv,
6643 CLIB_ERROR_ERRNO_VALID |
6645 "cannot fetch username %s", s);
6653 clib_error_return_fatal (0, "username %s does not exist", s);
6659 vl_set_memory_uid (pw->pw_uid);
6661 else if (unformat (input, "gid %s", &s))
6663 /* lookup the group name */
6666 getgrnam_r (s, &_grp, buf, vec_len (buf), &grp)) == ERANGE)
6667 && (vec_len (buf) <= max_buf_size))
6669 vec_resize (buf, vec_len (buf) * 2);
6673 e = clib_error_return_code (0, rv,
6674 CLIB_ERROR_ERRNO_VALID |
6676 "cannot fetch group %s", s);
6683 e = clib_error_return_fatal (0, "group %s does not exist", s);
6690 vl_set_memory_gid (grp->gr_gid);
6693 return clib_error_return (0, "unknown input `%U'",
6694 format_unformat_error, input);
6699 VLIB_EARLY_CONFIG_FUNCTION (api_segment_config, "api-segment");
6702 get_unformat_vnet_sw_interface (void)
6704 return (void *) &unformat_vnet_sw_interface;
6708 format_arp_event (u8 * s, va_list * args)
6710 vl_api_ip4_arp_event_t *event = va_arg (*args, vl_api_ip4_arp_event_t *);
6712 s = format (s, "pid %d: ", event->pid);
6714 s = format (s, "bd mac/ip4 binding events");
6716 s = format (s, "resolution for %U", format_ip4_address, &event->address);
6721 format_nd_event (u8 * s, va_list * args)
6723 vl_api_ip6_nd_event_t *event = va_arg (*args, vl_api_ip6_nd_event_t *);
6725 s = format (s, "pid %d: ", event->pid);
6727 s = format (s, "bd mac/ip6 binding events");
6729 s = format (s, "resolution for %U", format_ip6_address, event->address);
6733 static clib_error_t *
6734 show_ip_arp_nd_events_fn (vlib_main_t * vm,
6735 unformat_input_t * input, vlib_cli_command_t * cmd)
6737 vpe_api_main_t *am = &vpe_api_main;
6738 vl_api_ip4_arp_event_t *arp_event;
6739 vl_api_ip6_nd_event_t *nd_event;
6741 if ((pool_elts (am->arp_events) == 0) && (pool_elts (am->nd_events) == 0))
6743 vlib_cli_output (vm, "No active arp or nd event registrations");
6748 pool_foreach (arp_event, am->arp_events,
6750 vlib_cli_output (vm, "%U", format_arp_event, arp_event);
6753 pool_foreach (nd_event, am->nd_events,
6755 vlib_cli_output (vm, "%U", format_nd_event, nd_event);
6763 VLIB_CLI_COMMAND (show_ip_arp_nd_events, static) = {
6764 .path = "show arp-nd-event registrations",
6765 .function = show_ip_arp_nd_events_fn,
6766 .short_help = "Show ip4 arp and ip6 nd event registrations",
6770 #define vl_msg_name_crc_list
6771 #include <vpp-api/vpe_all_api_h.h>
6772 #undef vl_msg_name_crc_list
6775 setup_message_id_table (api_main_t * am)
6777 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
6778 foreach_vl_msg_name_crc_memclnt;
6779 foreach_vl_msg_name_crc_vpe;
6785 * fd.io coding-style-patch-verification: ON
6788 * eval: (c-set-style "gnu")