#include <vnet/mpls-gre/mpls.h>
#include <vnet/dhcp/proxy.h>
#include <vnet/dhcp/client.h>
+#if IPV6SR > 0
#include <vnet/sr/sr.h>
+#endif
#include <vnet/dhcpv6/proxy.h>
#include <vlib/vlib.h>
#include <vlib/unix/unix.h>
#include <vnet/nsh-gre/nsh_gre.h>
#include <vnet/nsh-vxlan-gpe/nsh_vxlan_gpe.h>
#include <vnet/lisp-gpe/lisp_gpe.h>
+#include <vnet/lisp-cp/control.h>
#include <vnet/map/map.h>
+#include <vnet/cop/cop.h>
+#include <vnet/ip/ip6_hop_by_hop.h>
#undef BIHASH_TYPE
#undef __included_bihash_template_h__
#include <vnet/l2/l2_fib.h>
-#if DPDK > 0
+#if IPSEC > 0
#include <vnet/ipsec/ipsec.h>
+#include <vnet/ipsec/ikev2.h>
+#endif /* IPSEC */
+#if DPDK > 0
#include <vnet/devices/virtio/vhost-user.h>
#endif
#define foreach_vpe_api_msg \
_(WANT_INTERFACE_EVENTS, want_interface_events) \
-_(WANT_FROM_NETCONF_SERVER, want_from_netconf_server) \
-_(WANT_TO_NETCONF_SERVER, want_to_netconf_server) \
-_(WANT_FROM_NETCONF_CLIENT, want_from_netconf_client) \
-_(WANT_TO_NETCONF_CLIENT, want_to_netconf_client) \
-_(FROM_NETCONF_SERVER, from_netconf_server) \
-_(TO_NETCONF_SERVER, to_netconf_server) \
-_(FROM_NETCONF_CLIENT, from_netconf_client) \
-_(TO_NETCONF_CLIENT, to_netconf_client) \
_(WANT_OAM_EVENTS, want_oam_events) \
_(OAM_ADD_DEL, oam_add_del) \
_(SW_INTERFACE_DUMP, sw_interface_dump) \
_(L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key) \
_(SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump) \
_(VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel) \
+_(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump) \
_(L2_FIB_CLEAR_TABLE, l2_fib_clear_table) \
_(L2_INTERFACE_EFP_FILTER, l2_interface_efp_filter) \
_(L2_INTERFACE_VLAN_TAG_REWRITE, l2_interface_vlan_tag_rewrite) \
_(IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry) \
_(IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry) \
_(IPSEC_SA_SET_KEY, ipsec_sa_set_key) \
+_(IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del) \
+_(IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth) \
+_(IKEV2_PROFILE_SET_ID, ikev2_profile_set_id) \
+_(IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts) \
+_(IKEV2_SET_LOCAL_KEY, ikev2_set_local_key) \
_(DELETE_LOOPBACK, delete_loopback) \
_(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del) \
_(MAP_ADD_DOMAIN, map_add_domain) \
_(MAP_ADD_DEL_RULE, map_add_del_rule) \
_(MAP_DOMAIN_DUMP, map_domain_dump) \
_(MAP_RULE_DUMP, map_rule_dump) \
-_(MAP_SUMMARY_STATS, map_summary_stats)
+_(MAP_SUMMARY_STATS, map_summary_stats) \
+_(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable) \
+_(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable) \
+_(GET_NODE_GRAPH, get_node_graph) \
+_(SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats) \
+_(TRACE_PROFILE_ADD, trace_profile_add) \
+_(TRACE_PROFILE_APPLY, trace_profile_apply) \
+_(TRACE_PROFILE_DEL, trace_profile_del) \
+_(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set) \
+_(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator) \
+_(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid) \
+_(LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry) \
+_(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver) \
+_(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface) \
+_(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump) \
+_(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump) \
+_(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump) \
+_(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump)
#define QUOTE_(x) #x
#define QUOTE(x) QUOTE_(x)
}
pub_sub_handler (interface_events,INTERFACE_EVENTS)
-pub_sub_handler (from_netconf_server,FROM_NETCONF_SERVER)
-pub_sub_handler (to_netconf_server,TO_NETCONF_SERVER)
-pub_sub_handler (from_netconf_client,FROM_NETCONF_CLIENT)
-pub_sub_handler (to_netconf_client,TO_NETCONF_CLIENT)
pub_sub_handler (oam_events,OAM_EVENTS)
#define RESOLUTION_EVENT 1
ip_adjacency_t cadj;
memset(&cadj, 0, sizeof(cadj));
cadj.lookup_next_index = IP_LOOKUP_NEXT_CLASSIFY;
- cadj.classify_table_index = ntohl(mp->classify_table_index);
- if (pool_is_free_index (cm->tables, cadj.classify_table_index)) {
+ cadj.classify.table_index = ntohl(mp->classify_table_index);
+ if (pool_is_free_index (cm->tables, cadj.classify.table_index)) {
dsunlock(sm);
return VNET_API_ERROR_NO_SUCH_TABLE;
}
kp = clib_mem_alloc (sizeof (*kp));
*kp = sup_and_sub_key;
+ memset (&template, 0, sizeof (template));
template.type = VNET_SW_INTERFACE_TYPE_SUB;
template.sup_sw_if_index = hi->sw_if_index;
template.sub.id = id;
si = vnet_get_sup_sw_interface (vnm, ntohl(mp->sw_if_index));
hi = vnet_get_sup_hw_interface (vnm, ntohl(mp->sw_if_index));
+ if (hi->bond_info == VNET_HW_INTERFACE_BOND_INFO_SLAVE) {
+ rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED;
+ goto out;
+ }
+
sw_if_index = si->sw_if_index;
sub_id = ntohl(mp->sub_id);
REPLY_MACRO(VL_API_SW_INTERFACE_SET_FLAGS_REPLY);
}
+static void vl_api_sw_interface_clear_stats_t_handler (
+ vl_api_sw_interface_clear_stats_t * mp)
+{
+ vl_api_sw_interface_clear_stats_reply_t *rmp;
+
+ vnet_main_t * vnm = vnet_get_main();
+ vnet_interface_main_t * im = &vnm->interface_main;
+ vlib_simple_counter_main_t * sm;
+ vlib_combined_counter_main_t * cm;
+ static vnet_main_t ** my_vnet_mains;
+ int i, j, n_counters;
+
+ int rv = 0;
+
+ vec_reset_length (my_vnet_mains);
+
+ for (i = 0; i < vec_len (vnet_mains); i++)
+ {
+ if (vnet_mains[i])
+ vec_add1 (my_vnet_mains, vnet_mains[i]);
+ }
+
+ if (vec_len (vnet_mains) == 0)
+ vec_add1 (my_vnet_mains, vnm);
+
+ n_counters = vec_len (im->combined_sw_if_counters);
+
+ for (j = 0; j < n_counters; j++)
+ {
+ for (i = 0; i < vec_len(my_vnet_mains); i++)
+ {
+ im = &my_vnet_mains[i]->interface_main;
+ cm = im->combined_sw_if_counters + j;
+ if (mp->sw_if_index == (u32)~0)
+ vlib_clear_combined_counters (cm);
+ else
+ vlib_zero_combined_counter (cm, ntohl(mp->sw_if_index));
+ }
+ }
+
+ n_counters = vec_len (im->sw_if_counters);
+
+ for (j = 0; j < n_counters; j++)
+ {
+ for (i = 0; i < vec_len(my_vnet_mains); i++)
+ {
+ im = &my_vnet_mains[i]->interface_main;
+ sm = im->sw_if_counters + j;
+ if (mp->sw_if_index == (u32)~0)
+ vlib_clear_simple_counters (sm);
+ else
+ vlib_zero_simple_counter (sm, ntohl(mp->sw_if_index));
+ }
+ }
+
+ REPLY_MACRO(VL_API_SW_INTERFACE_CLEAR_STATS_REPLY);
+}
+
static void send_sw_interface_details (vpe_api_main_t * am,
unix_shared_memory_queue_t *q,
vnet_sw_interface_t * swif,
VNET_HW_INTERFACE_FLAG_DUPLEX_SHIFT);
mp->link_speed = ((hi->flags & VNET_HW_INTERFACE_FLAG_SPEED_MASK) >>
VNET_HW_INTERFACE_FLAG_SPEED_SHIFT);
+ mp->link_mtu = ntohs(hi->max_packet_bytes);
strncpy ((char *) mp->interface_name,
(char *) interface_name, ARRAY_LEN(mp->interface_name)-1);
rp->_vl_msg_id = ntohs(VL_API_CLI_REPLY);
rp->context = mp->context;
- unformat_init_vector (&input, (u8 *)mp->cmd_in_shmem);
+ unformat_init_vector (&input, (u8 *)(uword)mp->cmd_in_shmem);
vlib_cli_input (vm, &input, shmem_cli_output,
(uword)&shmem_vec);
static void vl_api_sr_tunnel_add_del_t_handler
(vl_api_sr_tunnel_add_del_t *mp)
{
+#if IPV6SR == 0
+ clib_warning ("unimplemented");
+#else
ip6_sr_add_del_tunnel_args_t _a, *a=&_a;
int rv = 0;
vl_api_sr_tunnel_add_del_reply_t * rmp;
out:
REPLY_MACRO(VL_API_SR_TUNNEL_ADD_DEL_REPLY);
+#endif
}
#define foreach_classify_add_del_table_field \
rv = dpdk_vhost_user_create_if(vnm, vm, (char *)mp->sock_filename,
mp->is_server, &sw_if_index, (u64)~0,
- mp->renumber, ntohl(mp->custom_dev_instance));
+ mp->renumber, ntohl(mp->custom_dev_instance),
+ (mp->use_custom_mac)?mp->mac_address:NULL);
REPLY_MACRO2(VL_API_CREATE_VHOST_USER_IF_REPLY,
({
}));
}
+static void send_vxlan_tunnel_details
+(vxlan_tunnel_t * t, unix_shared_memory_queue_t * q)
+{
+ vl_api_vxlan_tunnel_details_t * rmp;
+ ip4_main_t * im = &ip4_main;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_VXLAN_TUNNEL_DETAILS);
+ rmp->src_address = t->src.data_u32;
+ rmp->dst_address = t->dst.data_u32;
+ rmp->encap_vrf_id = htonl(im->fibs[t->encap_fib_index].table_id);
+ rmp->vni = htonl(t->vni);
+ rmp->decap_next_index = htonl(t->decap_next_index);
+ rmp->sw_if_index = htonl(t->sw_if_index);
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void vl_api_vxlan_tunnel_dump_t_handler
+(vl_api_vxlan_tunnel_dump_t * mp)
+{
+ unix_shared_memory_queue_t * q;
+ vxlan_main_t * vxm = &vxlan_main;
+ vxlan_tunnel_t * t;
+ u32 sw_if_index;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ sw_if_index = ntohl(mp->sw_if_index);
+
+ if (~0 == sw_if_index) {
+ pool_foreach (t, vxm->tunnels,
+ ({
+ send_vxlan_tunnel_details(t, q);
+ }));
+ } else {
+ if ((sw_if_index >= vec_len(vxm->tunnel_index_by_sw_if_index)) ||
+ (~0 == vxm->tunnel_index_by_sw_if_index[sw_if_index])) {
+ return;
+ }
+ t = &vxm->tunnels[vxm->tunnel_index_by_sw_if_index[sw_if_index]];
+ send_vxlan_tunnel_details(t, q);
+ }
+}
+
static void
vl_api_l2_patch_add_del_t_handler (vl_api_l2_patch_add_del_t *mp)
{
}));
}
+static void
+vl_api_lisp_add_del_locator_set_t_handler(vl_api_lisp_add_del_locator_set_t *mp)
+{
+ vl_api_lisp_add_del_locator_set_reply_t *rmp;
+ int rv = 0;
+ vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
+ u32 ls_index = ~0;
+ u8 *locator_name = NULL;
+
+ memset(a, 0, sizeof(a[0]));
+
+ locator_name = format(0, "%s", mp->locator_set_name);
+
+ a->name = locator_name;
+ a->locators = NULL;
+ a->is_add = mp->is_add;
+ a->local = 1;
+
+ rv = vnet_lisp_add_del_locator_set_name(a, &ls_index);
+
+ vec_free(locator_name);
+
+ REPLY_MACRO(VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY);
+}
+
+static void
+vl_api_lisp_add_del_locator_t_handler(
+ vl_api_lisp_add_del_locator_t *mp)
+{
+ vl_api_lisp_add_del_locator_reply_t *rmp;
+ int rv = 0;
+ locator_t locator, *locators = NULL;
+ vnet_lisp_add_del_locator_set_args_t _a, *a = &_a;
+ u32 ls_index = ~0;
+ u8 *locator_name = NULL;
+
+ memset(&locator, 0, sizeof(locator));
+ memset(a, 0, sizeof(a[0]));
+
+ locator.sw_if_index = ntohl(mp->sw_if_index);
+ locator.priority = mp->priority;
+ locator.weight = mp->weight;
+ locator.local = 1;
+ vec_add1(locators, locator);
+
+ locator_name = format(0, "%s", mp->locator_set_name);
+
+ a->name = locator_name;
+ a->locators = locators;
+ a->is_add = mp->is_add;
+ a->local = 1;
+
+ rv = vnet_lisp_add_del_locator(a, &ls_index);
+
+ vec_free(locators);
+ vec_free(locator_name);
+
+ REPLY_MACRO(VL_API_LISP_ADD_DEL_LOCATOR_REPLY);
+}
+
+static void
+vl_api_lisp_add_del_local_eid_t_handler(
+ vl_api_lisp_add_del_local_eid_t *mp)
+{
+ vl_api_lisp_add_del_local_eid_reply_t *rmp;
+ lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+ int rv = 0;
+ ip_prefix_t *prefp = NULL;
+ ip_address_t *ip_eid = NULL;
+ gid_address_t eid;
+ uword * p = NULL;
+ u32 locator_set_index = ~0, map_index = ~0;
+ vnet_lisp_add_del_mapping_args_t _a, *a = &_a;
+ u8 *name = NULL;
+
+ prefp = &gid_address_ippref(&eid);
+ ip_eid = &ip_prefix_addr(prefp);
+ gid_address_type (&eid) = IP_PREFIX;
+
+ if (mp->is_ipv6) {
+ memcpy(&ip_addr_v6(ip_eid), mp->ip_address,
+ sizeof(ip_addr_v6(ip_eid)));
+ ip_addr_version(ip_eid) = IP6;
+ } else {
+ memcpy(&ip_addr_v4(ip_eid), mp->ip_address,
+ sizeof(ip_addr_v4(ip_eid)));
+ ip_addr_version(ip_eid) = IP4;
+ }
+ ip_prefix_len(prefp) = mp->prefix_len;
+
+ name = format(0, "%s", mp->locator_set_name);
+ p = hash_get_mem(lcm->locator_set_index_by_name, name);
+ if (!p) {
+ rv = VNET_API_ERROR_INVALID_VALUE;
+ goto out;
+ }
+ locator_set_index = p[0];
+
+ /* XXX treat batch configuration */
+ a->is_add = mp->is_add;
+ a->deid = eid;
+ a->locator_set_index = locator_set_index;
+ a->local = 1;
+
+ rv = vnet_lisp_add_del_mapping(a, &map_index);
+
+out:
+ vec_free(name);
+
+ REPLY_MACRO(VL_API_LISP_ADD_DEL_LOCAL_EID_REPLY);
+}
+
+static void
+lisp_gpe_add_del_fwd_entry_set_address(
+ vl_api_lisp_gpe_add_del_fwd_entry_t *mp,
+ ip_address_t *slocator,
+ ip_address_t *dlocator,
+ gid_address_t *eid)
+{
+ ip_address_t *ip_eid = NULL;
+ ip_prefix_t *prefp = NULL;
+
+ prefp = &gid_address_ippref(eid);
+ ip_eid = &ip_prefix_addr(prefp);
+
+ if (mp->eid_is_ipv6) {
+ memcpy(&ip_addr_v6(ip_eid), mp->eid_ip_address,
+ sizeof(ip_addr_v6(ip_eid)));
+ ip_addr_version(ip_eid) = IP6;
+ } else {
+ memcpy(&ip_addr_v4(ip_eid), mp->eid_ip_address,
+ sizeof(ip_addr_v4(ip_eid)));
+ ip_addr_version(ip_eid) = IP4;
+ }
+ ip_prefix_len(prefp) = mp->eid_prefix_len;
+
+ if (mp->address_is_ipv6) {
+ memcpy(&ip_addr_v6(slocator), mp->source_ip_address,
+ sizeof(ip_addr_v6(slocator)));
+ ip_addr_version(slocator) = IP6;
+ memcpy(&ip_addr_v6(dlocator), mp->destination_ip_address,
+ sizeof(ip_addr_v6(dlocator)));
+ ip_addr_version(dlocator) = IP6;
+ } else {
+ memcpy(&ip_addr_v4(slocator), mp->source_ip_address,
+ sizeof(ip_addr_v4(slocator)));
+ ip_addr_version(slocator) = IP4;
+ memcpy(&ip_addr_v4(dlocator), mp->destination_ip_address,
+ sizeof(ip_addr_v4(dlocator)));
+ ip_addr_version(dlocator) = IP4;
+ }
+}
+
+static void
+vl_api_lisp_gpe_add_del_fwd_entry_t_handler(
+ vl_api_lisp_gpe_add_del_fwd_entry_t *mp)
+{
+ vl_api_lisp_gpe_add_del_fwd_entry_reply_t *rmp;
+ int rv = 0;
+ ip_address_t slocator, dlocator;
+ ip_prefix_t * prefp = NULL;
+ gid_address_t eid;
+ vnet_lisp_gpe_add_del_fwd_entry_args_t a;
+
+ lisp_gpe_add_del_fwd_entry_set_address(mp, &slocator, &dlocator, &eid);
+
+ memset (&a, 0, sizeof(a));
+
+ a.is_add = mp->is_add;
+ a.deid = eid;
+ a.slocator = slocator;
+ a.dlocator = dlocator;
+ prefp = &gid_address_ippref(&a.deid);
+ a.decap_next_index = (ip_prefix_version(prefp) == IP4) ?
+ LISP_GPE_INPUT_NEXT_IP4_INPUT : LISP_GPE_INPUT_NEXT_IP6_INPUT;
+ rv = vnet_lisp_gpe_add_del_fwd_entry (&a, 0);
+
+ REPLY_MACRO(VL_API_LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY);
+}
+
+static void
+vl_api_lisp_add_del_map_resolver_t_handler(
+ vl_api_lisp_add_del_map_resolver_t *mp)
+{
+ vl_api_lisp_add_del_map_resolver_reply_t *rmp;
+ int rv = 0;
+ ip_address_t *ip_addr = NULL;
+ vnet_lisp_add_del_map_resolver_args_t _a, * a = &_a;
+
+ a->is_add = mp->is_add;
+ ip_addr = &a->address;
+
+ if (mp->is_ipv6) {
+ memcpy(&ip_addr_v6(ip_addr), mp->ip_address,
+ sizeof(ip_addr_v6(ip_addr)));
+ ip_addr_version(ip_addr) = IP6;
+ } else {
+ memcpy(&ip_addr_v4(ip_addr), mp->ip_address,
+ sizeof(ip_addr_v4(ip_addr)));
+ ip_addr_version(ip_addr) = IP4;
+ }
+
+ rv = vnet_lisp_add_del_map_resolver (a);
+
+ REPLY_MACRO(VL_API_LISP_ADD_DEL_MAP_RESOLVER_REPLY);
+}
+
+static void
+vl_api_lisp_gpe_add_del_iface_t_handler(
+ vl_api_lisp_gpe_add_del_iface_t *mp)
+{
+ vl_api_lisp_gpe_add_del_iface_reply_t *rmp;
+ int rv = 0;
+ vnet_lisp_gpe_add_del_iface_args_t _a, * a = &_a;
+
+ a->is_add = mp->is_add;
+ vnet_lisp_gpe_add_del_iface (a, 0);
+
+ REPLY_MACRO(VL_API_LISP_GPE_ADD_DEL_IFACE_REPLY);
+}
+
+static void
+send_lisp_locator_set_details (lisp_cp_main_t *lcm,
+ locator_set_t *lsit,
+ unix_shared_memory_queue_t *q)
+{
+ vl_api_lisp_locator_set_details_t *rmp;
+ locator_t *loc = NULL;
+ u32 * locit = NULL;
+
+ vec_foreach (locit, lsit->locator_indices) {
+ loc = pool_elt_at_index (lcm->locator_pool, locit[0]);
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_LISP_LOCATOR_SET_DETAILS);
+ strncpy((char *) rmp->locator_set_name,
+ (char *) lsit->name, ARRAY_LEN(rmp->locator_set_name) - 1);
+ rmp->sw_if_index = htonl(loc->sw_if_index);
+ rmp->priority = loc->priority;
+ rmp->weight = loc->weight;
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+ }
+}
+
+static void
+vl_api_lisp_locator_set_dump_t_handler (vl_api_lisp_locator_set_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q = NULL;
+ lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+ locator_set_t * lsit = NULL;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ pool_foreach (lsit, lcm->locator_set_pool,
+ ({
+ send_lisp_locator_set_details(lcm, lsit, q);
+ }));
+}
+
+static void
+send_lisp_local_eid_table_details (mapping_t *mapit,
+ unix_shared_memory_queue_t *q)
+{
+ vl_api_lisp_local_eid_table_details_t *rmp = NULL;
+ lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+ locator_set_t *ls = NULL;
+ gid_address_t *gid = NULL;
+ ip_prefix_t *ip_prefix = NULL;
+ u8 type = ~0;
+
+ ls = pool_elt_at_index (lcm->locator_set_pool,
+ mapit->locator_set_index);
+
+ gid = &mapit->eid;
+ type = gid_address_type(gid);
+
+ if (type != IP_PREFIX) {
+ return;
+ }
+
+ ip_prefix = &gid_address_ippref(gid);
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_LISP_LOCAL_EID_TABLE_DETAILS);
+ strncpy((char *) rmp->locator_set_name,
+ (char *) ls->name, ARRAY_LEN(rmp->locator_set_name) - 1);
+
+ switch (ip_prefix_version(ip_prefix)) {
+ case IP4:
+ rmp->eid_is_ipv6 = 0;
+ memcpy(rmp->eid_ip_address, &ip_prefix_v4(ip_prefix),
+ sizeof(ip_prefix_v4(ip_prefix)));
+ break;
+
+ case IP6:
+ rmp->eid_is_ipv6 = 1;
+ memcpy(rmp->eid_ip_address, &ip_prefix_v6(ip_prefix),
+ sizeof(ip_prefix_v6(ip_prefix)));
+ break;
+
+ default:
+ ASSERT(0);
+ }
+ rmp->eid_prefix_len = ip_prefix_len(ip_prefix);
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void
+vl_api_lisp_local_eid_table_dump_t_handler (
+ vl_api_lisp_local_eid_table_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q = NULL;
+ lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+ mapping_t * mapit = NULL;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ pool_foreach (mapit, lcm->mapping_pool,
+ ({
+ send_lisp_local_eid_table_details(mapit, q);
+ }));
+}
+
+static void
+send_lisp_gpe_tunnel_details (lisp_gpe_tunnel_t *tunnel,
+ unix_shared_memory_queue_t *q)
+{
+ vl_api_lisp_gpe_tunnel_details_t *rmp;
+ lisp_gpe_main_t * lgm = &lisp_gpe_main;
+ ip4_address_t *ip4 = NULL;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_LISP_GPE_TUNNEL_DETAILS);
+
+ rmp->tunnels = tunnel - lgm->tunnels;
+
+ /*list_gpe_tunnel now support only IPv4*/
+ rmp->is_ipv6 = 0;
+ ip4 = &tunnel->src;
+ memcpy(rmp->source_ip, ip4, sizeof(*ip4));
+ ip4 = &tunnel->dst;
+ memcpy(rmp->destination_ip, ip4, sizeof(*ip4));
+
+ rmp->encap_fib_id = htonl(tunnel->encap_fib_index);
+ rmp->decap_fib_id = htonl(tunnel->decap_fib_index);
+ rmp->dcap_next = htonl(tunnel->decap_next_index);
+ rmp->lisp_ver = tunnel->ver_res;
+ rmp->next_protocol = tunnel->next_protocol;
+ rmp->flags = tunnel->flags;
+ rmp->ver_res = tunnel->ver_res;
+ rmp->res = tunnel->res;
+ rmp->iid = htonl(tunnel->iid);
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void
+vl_api_lisp_gpe_tunnel_dump_t_handler (
+ vl_api_lisp_local_eid_table_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q = NULL;
+ lisp_gpe_main_t * lgm = &lisp_gpe_main;
+ lisp_gpe_tunnel_t * tunnel = NULL;
+
+ if (pool_elts(lgm->tunnels) == 0) {
+ return;
+ }
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ pool_foreach(tunnel, lgm->tunnels,
+ ({
+ send_lisp_gpe_tunnel_details(tunnel, q);
+ }));
+}
+
+static void
+send_lisp_map_resolver_details (ip_address_t *ip,
+ unix_shared_memory_queue_t *q)
+{
+ vl_api_lisp_map_resolver_details_t *rmp = NULL;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_LISP_MAP_RESOLVER_DETAILS);
+
+ switch (ip_addr_version(ip)) {
+ case IP4:
+ rmp->is_ipv6 = 0;
+ memcpy(rmp->ip_address, &ip_addr_v4(ip), sizeof(ip_addr_v4(ip)));
+ break;
+
+ case IP6:
+ rmp->is_ipv6 = 1;
+ memcpy(rmp->ip_address, &ip_addr_v6(ip), sizeof(ip_addr_v6(ip)));
+ break;
+
+ default:
+ ASSERT(0);
+ }
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void
+vl_api_lisp_map_resolver_dump_t_handler (
+ vl_api_lisp_local_eid_table_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q = NULL;
+ lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+ ip_address_t *ip = NULL;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ vec_foreach(ip, lcm->map_resolvers) {
+ send_lisp_map_resolver_details(ip, q);
+ }
+
+}
+
static void
vl_api_interface_name_renumber_t_handler (vl_api_interface_name_renumber_t *mp)
{
static void vl_api_ipsec_spd_add_del_t_handler
(vl_api_ipsec_spd_add_del_t * mp)
{
+#if IPSEC == 0
+ clib_warning ("unimplemented");
+#else
+
vlib_main_t *vm __attribute__((unused)) = vlib_get_main();
vl_api_ipsec_spd_add_del_reply_t * rmp;
int rv;
#endif
REPLY_MACRO(VL_API_IPSEC_SPD_ADD_DEL_REPLY);
+#endif
}
static void vl_api_ipsec_interface_add_del_spd_t_handler
VALIDATE_SW_IF_INDEX(mp);
-#if DPDK > 0
+#if IPSEC > 0
rv = ipsec_set_interface_spd(vm, sw_if_index, spd_id, mp->is_add);
#else
rv = VNET_API_ERROR_UNIMPLEMENTED;
vl_api_ipsec_spd_add_del_entry_reply_t * rmp;
int rv;
-#if DPDK > 0
+#if IPSEC > 0
ipsec_policy_t p;
+ memset(&p, 0, sizeof(p));
+
p.id = ntohl(mp->spd_id);
p.priority = ntohl(mp->priority);
p.is_outbound = mp->is_outbound;
vlib_main_t *vm __attribute__((unused)) = vlib_get_main();
vl_api_ipsec_sad_add_del_entry_reply_t * rmp;
int rv;
-#if DPDK > 0
+#if IPSEC > 0
ipsec_sa_t sa;
+ memset(&sa, 0, sizeof(sa));
+
sa.id = ntohl(mp->sad_id);
sa.spi = ntohl(mp->spi);
/* security protocol AH unsupported */
/* check for unsupported crypto-alg */
if (mp->crypto_algorithm < IPSEC_CRYPTO_ALG_AES_CBC_128 ||
mp->crypto_algorithm > IPSEC_CRYPTO_ALG_AES_CBC_256) {
- clib_warning("unsupported crypto-alg: '%U'", format_ipsec_crypto_alg,
+ clib_warning("unsupported crypto-alg: '%U'", format_ipsec_crypto_alg,
mp->crypto_algorithm);
rv = VNET_API_ERROR_UNIMPLEMENTED;
goto out;
out:
REPLY_MACRO(VL_API_IPSEC_SAD_ADD_DEL_ENTRY_REPLY);
}
+
+static void
+vl_api_ikev2_profile_add_del_t_handler
+(vl_api_ikev2_profile_add_del_t * mp)
+{
+ vl_api_ikev2_profile_add_del_reply_t * rmp;
+ int rv = 0;
+
+#if IPSEC > 0
+ vlib_main_t * vm = vlib_get_main();
+ clib_error_t * error;
+ u8 * tmp = format(0, "%s", mp->name);
+ error = ikev2_add_del_profile(vm, tmp, mp->is_add);
+ vec_free (tmp);
+ if (error)
+ rv = VNET_API_ERROR_UNSPECIFIED;
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif
+
+ REPLY_MACRO(VL_API_IKEV2_PROFILE_ADD_DEL_REPLY);
+}
+
+static void
+vl_api_ikev2_profile_set_auth_t_handler
+(vl_api_ikev2_profile_set_auth_t * mp)
+{
+ vl_api_ikev2_profile_set_auth_reply_t * rmp;
+ int rv = 0;
+
+#if IPSEC > 0
+ vlib_main_t * vm = vlib_get_main();
+ clib_error_t * error;
+ u8 * tmp = format(0, "%s", mp->name);
+ u8 * data = vec_new (u8, mp->data_len);
+ memcpy(data, mp->data, mp->data_len);
+ error = ikev2_set_profile_auth(vm, tmp, mp->auth_method, data, mp->is_hex);
+ vec_free (tmp);
+ vec_free (data);
+ if (error)
+ rv = VNET_API_ERROR_UNSPECIFIED;
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif
+
+ REPLY_MACRO(VL_API_IKEV2_PROFILE_SET_AUTH_REPLY);
+}
+
+static void
+vl_api_ikev2_profile_set_id_t_handler
+(vl_api_ikev2_profile_set_id_t * mp)
+{
+ vl_api_ikev2_profile_add_del_reply_t * rmp;
+ int rv = 0;
+
+#if IPSEC > 0
+ vlib_main_t * vm = vlib_get_main();
+ clib_error_t * error;
+ u8 * tmp = format(0, "%s", mp->name);
+ u8 * data = vec_new (u8, mp->data_len);
+ memcpy(data, mp->data, mp->data_len);
+ error = ikev2_set_profile_id(vm, tmp, mp->id_type, data, mp->is_local);
+ vec_free (tmp);
+ vec_free (data);
+ if (error)
+ rv = VNET_API_ERROR_UNSPECIFIED;
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif
+
+ REPLY_MACRO(VL_API_IKEV2_PROFILE_SET_ID_REPLY);
+}
+
+static void
+vl_api_ikev2_profile_set_ts_t_handler
+(vl_api_ikev2_profile_set_ts_t * mp)
+{
+ vl_api_ikev2_profile_set_ts_reply_t * rmp;
+ int rv = 0;
+
+#if IPSEC > 0
+ vlib_main_t * vm = vlib_get_main();
+ clib_error_t * error;
+ u8 * tmp = format(0, "%s", mp->name);
+ error = ikev2_set_profile_ts(vm, tmp, mp->proto, mp->start_port,
+ mp->end_port, (ip4_address_t) mp->start_addr,
+ (ip4_address_t) mp->end_addr, mp->is_local);
+ vec_free (tmp);
+ if (error)
+ rv = VNET_API_ERROR_UNSPECIFIED;
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif
+
+ REPLY_MACRO(VL_API_IKEV2_PROFILE_SET_TS_REPLY);
+}
+
+static void
+vl_api_ikev2_set_local_key_t_handler
+(vl_api_ikev2_set_local_key_t * mp)
+{
+ vl_api_ikev2_profile_set_ts_reply_t * rmp;
+ int rv = 0;
+
+#if IPSEC > 0
+ vlib_main_t * vm = vlib_get_main();
+ clib_error_t * error;
+
+ error = ikev2_set_local_key(vm, mp->key_file);
+ if (error)
+ rv = VNET_API_ERROR_UNSPECIFIED;
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif
+
+ REPLY_MACRO(VL_API_IKEV2_SET_LOCAL_KEY_REPLY);
+}
+
static void
vl_api_map_add_domain_t_handler
(vl_api_map_add_domain_t * mp)
vlib_main_t *vm __attribute__((unused)) = vlib_get_main();
vl_api_ipsec_sa_set_key_reply_t *rmp;
int rv;
-#if DPDK > 0
+#if IPSEC > 0
ipsec_sa_t sa;
sa.id = ntohl(mp->sa_id);
sa.crypto_key_len = mp->crypto_key_length;
REPLY_MACRO(VL_API_IPSEC_SA_SET_KEY_REPLY);
}
+static void vl_api_cop_interface_enable_disable_t_handler
+(vl_api_cop_interface_enable_disable_t * mp)
+{
+ vl_api_cop_interface_enable_disable_reply_t * rmp;
+ int rv;
+ u32 sw_if_index = ntohl(mp->sw_if_index);
+ int enable_disable;
+
+ VALIDATE_SW_IF_INDEX(mp);
+
+ enable_disable = (int) mp->enable_disable;
+
+ rv = cop_interface_enable_disable (sw_if_index, enable_disable);
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO(VL_API_COP_INTERFACE_ENABLE_DISABLE_REPLY);
+}
+
+static void vl_api_cop_whitelist_enable_disable_t_handler
+(vl_api_cop_whitelist_enable_disable_t * mp)
+{
+ vl_api_cop_whitelist_enable_disable_reply_t * rmp;
+ cop_whitelist_enable_disable_args_t _a, *a=&_a;
+ u32 sw_if_index = ntohl(mp->sw_if_index);
+ int rv;
+
+ VALIDATE_SW_IF_INDEX(mp);
+
+ a->sw_if_index = sw_if_index;
+ a->ip4 = mp->ip4;
+ a->ip6 = mp->ip6;
+ a->default_cop = mp->default_cop;
+ a->fib_id = ntohl(mp->fib_id);
+
+ rv = cop_whitelist_enable_disable (a);
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO(VL_API_COP_WHITELIST_ENABLE_DISABLE_REPLY);
+}
+
+static void vl_api_get_node_graph_t_handler
+(vl_api_get_node_graph_t * mp)
+{
+ int rv = 0;
+ u8 * vector = 0;
+ api_main_t * am = &api_main;
+ vlib_main_t * vm = vlib_get_main();
+ void * oldheap;
+ vl_api_get_node_graph_reply_t * rmp;
+
+ pthread_mutex_lock (&am->vlib_rp->mutex);
+ oldheap = svm_push_data_heap (am->vlib_rp);
+
+ /*
+ * Keep the number of memcpy ops to a minimum (e.g. 1).
+ * The current size of the serialized vector is
+ * slightly under 4K.
+ */
+ vec_validate (vector, 4095);
+ vec_reset_length (vector);
+
+ vector = vlib_node_serialize (&vm->node_main, vector);
+
+ svm_pop_heap (oldheap);
+ pthread_mutex_unlock (&am->vlib_rp->mutex);
+
+ REPLY_MACRO2(VL_API_GET_NODE_GRAPH_REPLY,
+ rmp->reply_in_shmem = (uword) vector);
+}
+
+static void vl_api_trace_profile_add_t_handler
+(vl_api_trace_profile_add_t *mp)
+{
+ int rv = 0;
+ vl_api_trace_profile_add_reply_t * rmp;
+ clib_error_t *error;
+
+ /* Ignoring the profile id as currently a single profile
+ * is supported */
+ error = ip6_ioam_trace_profile_set(mp->trace_num_elt, mp->trace_type,
+ ntohl(mp->node_id), ntohl(mp->trace_app_data),
+ mp->pow_enable, mp->trace_tsp,
+ mp->trace_ppc);
+ if (error) {
+ clib_error_report(error);
+ rv = clib_error_get_code(error);
+ }
+
+ REPLY_MACRO(VL_API_TRACE_PROFILE_ADD_REPLY);
+}
+
+static void vl_api_trace_profile_apply_t_handler
+(vl_api_trace_profile_apply_t *mp)
+{
+ int rv = 0;
+ vl_api_trace_profile_apply_reply_t * rmp;
+
+ if (mp->enable != 0) {
+ rv = ip6_ioam_set_destination ((ip6_address_t *)(&mp->dest_ipv6),
+ ntohl(mp->prefix_length),
+ ntohl(mp->vrf_id),
+ mp->trace_op == IOAM_HBYH_ADD,
+ mp->trace_op == IOAM_HBYH_POP,
+ mp->trace_op == IOAM_HBYH_MOD);
+ } else {
+ //ip6_ioam_clear_destination(&ip6, mp->prefix_length, mp->vrf_id);
+ }
+ REPLY_MACRO(VL_API_TRACE_PROFILE_APPLY_REPLY);
+}
+
+static void vl_api_trace_profile_del_t_handler
+(vl_api_trace_profile_del_t *mp)
+{
+ int rv = 0;
+ vl_api_trace_profile_del_reply_t * rmp;
+ clib_error_t *error;
+
+ error = clear_ioam_rewrite_fn();
+ if (error) {
+ clib_error_report(error);
+ rv = clib_error_get_code(error);
+ }
+
+ REPLY_MACRO(VL_API_TRACE_PROFILE_DEL_REPLY);
+}
+
+
#define BOUNCE_HANDLER(nn) \
static void vl_api_##nn##_t_handler ( \
vl_api_##nn##_t *mp) \
vl_msg_api_free (mp); \
}
-BOUNCE_HANDLER(to_netconf_server);
-BOUNCE_HANDLER(from_netconf_server);
-BOUNCE_HANDLER(to_netconf_client);
-BOUNCE_HANDLER(from_netconf_client);
-
/*
* vpe_api_hookup
* Add vpe's API message handlers to the table.
vl_api_sr_tunnel_add_del_t_print,
256, 1);
- am->message_bounce [VL_API_FROM_NETCONF_SERVER] = 1;
- am->message_bounce [VL_API_TO_NETCONF_SERVER] = 1;
- am->message_bounce [VL_API_FROM_NETCONF_CLIENT] = 1;
- am->message_bounce [VL_API_TO_NETCONF_CLIENT] = 1;
-
/*
* Trace space for 8 MPLS encap labels, classifier mask+match
*/
am->api_trace_cfg [VL_API_NSH_GRE_ADD_DEL_TUNNEL].size
+= 4 * sizeof (u32);
+ /*
+ * Thread-safe API messages
+ */
+ am->is_mp_safe [VL_API_IP_ADD_DEL_ROUTE] = 1;
+
return 0;
}
VLIB_INIT_FUNCTION(vpe_api_init);
+static clib_error_t *
+chroot_config (vlib_main_t * vm, unformat_input_t * input)
+{
+ u8 * chroot_path;
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "prefix %s", &chroot_path))
+ {
+ vec_add1 (chroot_path, 0);
+ vl_set_memory_root_path ((char *)chroot_path);
+ }
+ else
+ return clib_error_return (0, "unknown input `%U'",
+ format_unformat_error, input);
+ }
+ return 0;
+}
+VLIB_EARLY_CONFIG_FUNCTION (chroot_config, "chroot");
+
void * get_unformat_vnet_sw_interface (void)
{
return (void *) &unformat_vnet_sw_interface;
Code Review / vpp.git / blobdiff