#include <vppinfra/format.h>
#include <vppinfra/error.h>
+#include <vnet/api_errno.h> // alagalah TODO : committers please pay note, is this ok?
#include <vnet/vnet.h>
#include <vnet/l2/l2_input.h>
#include <vnet/l2/l2_bd.h>
#include <vnet/classify/input_acl.h>
#include <vnet/l2/l2_classify.h>
#include <vnet/vxlan/vxlan.h>
+#include <vnet/gre/gre.h>
#include <vnet/l2/l2_vtr.h>
-#include <vnet/nsh-gre/nsh_gre.h>
-#include <vnet/nsh-vxlan-gpe/nsh_vxlan_gpe.h>
+#include <vnet/vxlan-gpe/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>
+#include <vnet/devices/af_packet/af_packet.h>
+#include <vnet/policer/policer.h>
+#include <vnet/devices/netmap/netmap.h>
#undef BIHASH_TYPE
#undef __included_bihash_template_h__
_(SW_IF_L2TPV3_TUNNEL_DUMP, sw_if_l2tpv3_tunnel_dump) \
_(VXLAN_ADD_DEL_TUNNEL, vxlan_add_del_tunnel) \
_(VXLAN_TUNNEL_DUMP, vxlan_tunnel_dump) \
+_(GRE_ADD_DEL_TUNNEL, gre_add_del_tunnel) \
+_(GRE_TUNNEL_DUMP, gre_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) \
_(IP_DUMP, ip_dump) \
_(SW_INTERFACE_VHOST_USER_DETAILS, sw_interface_vhost_user_details) \
_(SHOW_VERSION, show_version) \
-_(NSH_GRE_ADD_DEL_TUNNEL, nsh_gre_add_del_tunnel) \
_(L2_FIB_TABLE_DUMP, l2_fib_table_dump) \
_(L2_FIB_TABLE_ENTRY, l2_fib_table_entry) \
-_(NSH_VXLAN_GPE_ADD_DEL_TUNNEL, nsh_vxlan_gpe_add_del_tunnel) \
-_(LISP_GPE_ADD_DEL_TUNNEL, lisp_gpe_add_del_tunnel) \
+_(VXLAN_GPE_ADD_DEL_TUNNEL, vxlan_gpe_add_del_tunnel) \
+_(VXLAN_GPE_TUNNEL_DUMP, vxlan_gpe_tunnel_dump) \
_(INTERFACE_NAME_RENUMBER, interface_name_renumber) \
_(WANT_IP4_ARP_EVENTS, want_ip4_arp_events) \
_(INPUT_ACL_SET_INTERFACE, input_acl_set_interface) \
_(LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry) \
_(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver) \
_(LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable) \
+_(LISP_ENABLE_DISABLE, lisp_enable_disable) \
_(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface) \
+_(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping) \
+_(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set) \
_(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)
+_(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump) \
+_(LISP_ENABLE_DISABLE_STATUS_DUMP, \
+ lisp_enable_disable_status_dump) \
+_(SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del) \
+_(AF_PACKET_CREATE, af_packet_create) \
+_(AF_PACKET_DELETE, af_packet_delete) \
+_(POLICER_ADD_DEL, policer_add_del) \
+_(POLICER_DUMP, policer_dump) \
+_(NETMAP_CREATE, netmap_create) \
+_(NETMAP_DELETE, netmap_delete)
#define QUOTE_(x) #x
#define QUOTE(x) QUOTE_(x)
static void send_bridge_domain_details (unix_shared_memory_queue_t *q,
l2_bridge_domain_t * bd_config,
- u32 n_sw_ifs)
+ u32 n_sw_ifs,
+ u32 context)
{
vl_api_bridge_domain_details_t * mp;
mp->arp_term = bd_feature_arp_term (bd_config);
mp->bvi_sw_if_index = ntohl (bd_config->bvi_sw_if_index);
mp->n_sw_ifs = ntohl (n_sw_ifs);
+ mp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&mp);
}
static void send_bd_sw_if_details (l2input_main_t * l2im,
unix_shared_memory_queue_t *q,
- l2_flood_member_t * member, u32 bd_id)
+ l2_flood_member_t * member, u32 bd_id,
+ u32 context)
{
vl_api_bridge_domain_sw_if_details_t * mp;
l2_input_config_t * input_cfg;
mp->sw_if_index = ntohl (member->sw_if_index);
input_cfg = vec_elt_at_index (l2im->configs, member->sw_if_index);
mp->shg = input_cfg->shg;
+ mp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&mp);
}
l2_flood_member_t * m;
n_sw_ifs = vec_len (bd_config->members);
- send_bridge_domain_details (q, bd_config, n_sw_ifs);
+ send_bridge_domain_details (q, bd_config, n_sw_ifs, mp->context);
vec_foreach (m, bd_config->members) {
- send_bd_sw_if_details (l2im, q, m, bd_config->bd_id);
+ send_bd_sw_if_details (l2im, q, m, bd_config->bd_id, mp->context);
}
}
}
a->is_del = (mp->is_add == 0);
a->rx_table_id = ntohl(mp->outer_vrf_id);
a->tx_table_id = ntohl(mp->inner_vrf_id);
-
+
+ a->name = format(0, "%s", mp->name);
+ if (!(vec_len(a->name)))
+ a->name = 0;
+
+ a->policy_name = format(0, "%s", mp->policy_name);
+ if (!(vec_len(a->policy_name)))
+ a->policy_name = 0;
+
/* Yank segments and tags out of the API message */
this_address = (ip6_address_t *)mp->segs_and_tags;
for (i = 0; i < mp->n_segments; i++) {
#endif
}
+static void vl_api_sr_policy_add_del_t_handler
+(vl_api_sr_policy_add_del_t *mp)
+{
+#if IPV6SR == 0
+ clib_warning ("unimplemented");
+#else
+ ip6_sr_add_del_policy_args_t _a, *a=&_a;
+ int rv = 0;
+ vl_api_sr_policy_add_del_reply_t * rmp;
+ int i;
+
+ memset (a, 0, sizeof (*a));
+ a->is_del = (mp->is_add == 0);
+
+ a->name = format(0, "%s", mp->name);
+ if (!(vec_len(a->name)))
+ {
+ rv = VNET_API_ERROR_NO_SUCH_NODE2;
+ goto out;
+ }
+
+ if (!(mp->tunnel_names[0]))
+ {
+ rv = VNET_API_ERROR_NO_SUCH_NODE2;
+ goto out;
+ }
+
+ // start deserializing tunnel_names
+ int num_tunnels = mp->tunnel_names[0]; //number of tunnels
+ u8 * deser_tun_names = mp->tunnel_names;
+ deser_tun_names += 1; //moving along
+
+ u8 * tun_name = 0;
+ int tun_name_len = 0;
+
+ for (i=0; i < num_tunnels; i++)
+ {
+ tun_name_len= *deser_tun_names;
+ deser_tun_names += 1;
+ vec_resize (tun_name, tun_name_len);
+ memcpy(tun_name, deser_tun_names, tun_name_len);
+ vec_add1 (a->tunnel_names, tun_name);
+ deser_tun_names += tun_name_len;
+ tun_name = 0;
+ }
+
+ rv = ip6_sr_add_del_policy (a);
+
+out:
+
+ REPLY_MACRO(VL_API_SR_POLICY_ADD_DEL_REPLY);
+#endif
+}
+
+static void vl_api_sr_multicast_map_add_del_t_handler
+(vl_api_sr_multicast_map_add_del_t *mp)
+{
+#if IPV6SR == 0
+ clib_warning ("unimplemented");
+#else
+ ip6_sr_add_del_multicastmap_args_t _a, *a=&_a;
+ int rv = 0;
+ vl_api_sr_multicast_map_add_del_reply_t * rmp;
+
+ memset (a, 0, sizeof (*a));
+ a->is_del = (mp->is_add == 0);
+
+ a->multicast_address = (ip6_address_t *)&mp->multicast_address;
+ a->policy_name = format(0, "%s", mp->policy_name);
+
+ if (a->multicast_address == 0)
+ {
+ rv = -1 ;
+ goto out;
+ }
+
+ if (!(a->policy_name))
+ {
+ rv = -2 ;
+ goto out;
+ }
+
+#if DPDK > 0 /* Cannot call replicate without DPDK */
+ rv = ip6_sr_add_del_multicastmap (a);
+#else
+ clib_warning ("multicast replication without DPDK not implemented");
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif /* DPDK */
+
+out:
+
+ REPLY_MACRO(VL_API_SR_MULTICAST_MAP_ADD_DEL_REPLY);
+#endif
+}
+
#define foreach_classify_add_del_table_field \
_(table_index) \
_(nbuckets) \
unix_shared_memory_queue_t * q,
u8 * ip,
u16 prefix_length,
- u8 is_ipv6)
+ u8 is_ipv6,
+ u32 context)
{
vl_api_ip_address_details_t * mp;
*tp = ntohl(*(u32*)ip);
}
mp->prefix_length = prefix_length;
+ mp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&mp);
}
ip_lookup_main_t * lm4 = &im4->lookup_main;
ip_interface_address_t * ia = 0;
u32 sw_if_index = ~0;
+ int rv __attribute__ ((unused)) = 0;
+
+ VALIDATE_SW_IF_INDEX(mp);
sw_if_index = ntohl(mp->sw_if_index);
({
r6 = ip_interface_address_get_address (lm6, ia);
u16 prefix_length = ia->address_length;
- send_ip_address_details(am, q, (u8*)r6, prefix_length, 1);
+ send_ip_address_details(am, q, (u8*)r6, prefix_length, 1, mp->context);
}));
} else {
foreach_ip_interface_address (lm4, ia, sw_if_index,
({
r4 = ip_interface_address_get_address (lm4, ia);
u16 prefix_length = ia->address_length;
- send_ip_address_details(am, q, (u8*)r4, prefix_length, 0);
+ send_ip_address_details(am, q, (u8*)r4, prefix_length, 0, mp->context);
}));
}
+ BAD_SW_IF_INDEX_LABEL;
}
static void send_ip_details (vpe_api_main_t * am,
unix_shared_memory_queue_t *q,
- u32 sw_if_index)
+ u32 sw_if_index,
+ u32 context)
{
vl_api_ip_details_t * mp;
mp->_vl_msg_id = ntohs(VL_API_IP_DETAILS);
mp->sw_if_index = ntohl(sw_if_index);
+ mp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&mp);
}
static void send_sw_interface_tap_details (vpe_api_main_t * am,
unix_shared_memory_queue_t *q,
- tapcli_interface_details_t *tap_if)
+ tapcli_interface_details_t *tap_if,
+ u32 context)
{
vl_api_sw_interface_tap_details_t * mp;
mp = vl_msg_api_alloc (sizeof (*mp));
mp->sw_if_index = ntohl(tap_if->sw_if_index);
strncpy((char *)mp->dev_name,
(char *)tap_if->dev_name, ARRAY_LEN(mp->dev_name)-1);
+ mp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&mp);
}
return;
vec_foreach(tap_if, tapifs) {
- send_sw_interface_tap_details(am, q, tap_if);
+ send_sw_interface_tap_details(am, q, tap_if, mp->context);
}
vec_free(tapifs);
continue;
}
sw_if_index = si->sw_if_index;
- send_ip_details(am, q, sw_if_index);
+ send_ip_details(am, q, sw_if_index, mp->context);
}
}
}
encap_fib_index = p[0];
/* Check src & dst are different */
- if ((a->is_ip6 && memcmp(mp->src_address, mp->dst_address, 16) == 0) ||
- (!a->is_ip6 && memcmp(mp->src_address, mp->dst_address, 4) == 0)) {
+ if ((mp->is_ipv6 && memcmp(mp->src_address, mp->dst_address, 16) == 0) ||
+ (!mp->is_ipv6 && memcmp(mp->src_address, mp->dst_address, 4) == 0)) {
rv = VNET_API_ERROR_SAME_SRC_DST;
goto out;
}
}
static void send_vxlan_tunnel_details
-(vxlan_tunnel_t * t, unix_shared_memory_queue_t * q)
+(vxlan_tunnel_t * t, unix_shared_memory_queue_t * q, u32 context)
{
vl_api_vxlan_tunnel_details_t * rmp;
ip4_main_t * im4 = &ip4_main;
rmp->decap_next_index = htonl(t->decap_next_index);
rmp->sw_if_index = htonl(t->sw_if_index);
rmp->is_ipv6 = is_ipv6;
+ rmp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&rmp);
}
if (~0 == sw_if_index) {
pool_foreach (t, vxm->tunnels,
({
- send_vxlan_tunnel_details(t, q);
+ send_vxlan_tunnel_details(t, q, mp->context);
}));
} else {
if ((sw_if_index >= vec_len(vxm->tunnel_index_by_sw_if_index)) ||
return;
}
t = &vxm->tunnels[vxm->tunnel_index_by_sw_if_index[sw_if_index]];
- send_vxlan_tunnel_details(t, q);
+ send_vxlan_tunnel_details(t, q, mp->context);
+ }
+}
+
+static void vl_api_gre_add_del_tunnel_t_handler
+(vl_api_gre_add_del_tunnel_t * mp)
+{
+ vl_api_gre_add_del_tunnel_reply_t * rmp;
+ int rv = 0;
+ vnet_gre_add_del_tunnel_args_t _a, *a = &_a;
+ u32 outer_table_id;
+ uword * p;
+ ip4_main_t * im = &ip4_main;
+ u32 sw_if_index = ~0;
+
+ p = hash_get (im->fib_index_by_table_id, ntohl(mp->outer_table_id));
+ if (! p) {
+ rv = VNET_API_ERROR_NO_SUCH_FIB;
+ goto out;
+ }
+ outer_table_id = p[0];
+
+ /* Check src & dst are different */
+ if (memcmp(&mp->src_address, &mp->dst_address, 4) == 0) {
+ rv = VNET_API_ERROR_SAME_SRC_DST;
+ goto out;
+ }
+
+ memset (a, 0, sizeof (*a));
+
+ a->is_add = mp->is_add;
+
+ /* ip addresses sent in network byte order */
+ a->src.as_u32 = mp->src_address;
+ a->dst.as_u32 = mp->dst_address;
+
+ a->outer_table_id = outer_table_id;
+ rv = vnet_gre_add_del_tunnel (a, &sw_if_index);
+
+out:
+ REPLY_MACRO2(VL_API_GRE_ADD_DEL_TUNNEL_REPLY,
+ ({
+ rmp->sw_if_index = ntohl (sw_if_index);
+ }));
+}
+
+static void send_gre_tunnel_details
+(gre_tunnel_t * t, unix_shared_memory_queue_t * q, u32 context)
+{
+ vl_api_gre_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_GRE_TUNNEL_DETAILS);
+ rmp->src_address = t->tunnel_src.data_u32;
+ rmp->dst_address = t->tunnel_dst.data_u32;
+ rmp->outer_table_id = htonl(im->fibs[t->outer_fib_index].table_id);
+ rmp->sw_if_index = htonl(t->sw_if_index);
+ rmp->context = context;
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void vl_api_gre_tunnel_dump_t_handler
+(vl_api_gre_tunnel_dump_t * mp)
+{
+ unix_shared_memory_queue_t * q;
+ gre_main_t * gm = &gre_main;
+ gre_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, gm->tunnels,
+ ({
+ send_gre_tunnel_details(t, q, mp->context);
+ }));
+ } else {
+ if ((sw_if_index >= vec_len(gm->tunnel_index_by_sw_if_index)) ||
+ (~0 == gm->tunnel_index_by_sw_if_index[sw_if_index])) {
+ return;
+ }
+ t = &gm->tunnels[gm->tunnel_index_by_sw_if_index[sw_if_index]];
+ send_gre_tunnel_details(t, q, mp->context);
}
}
}
static void
-vl_api_nsh_gre_add_del_tunnel_t_handler
-(vl_api_nsh_gre_add_del_tunnel_t * mp)
+vl_api_vxlan_gpe_add_del_tunnel_t_handler
+(vl_api_vxlan_gpe_add_del_tunnel_t * mp)
{
- vl_api_nsh_gre_add_del_tunnel_reply_t * rmp;
+ vl_api_vxlan_gpe_add_del_tunnel_reply_t * rmp;
int rv = 0;
- vnet_nsh_gre_add_del_tunnel_args_t _a, *a = &_a;
+ vnet_vxlan_gpe_add_del_tunnel_args_t _a, *a = &_a;
u32 encap_fib_index, decap_fib_index;
- u32 decap_next_index;
+ u8 protocol;
uword * p;
ip4_main_t * im = &ip4_main;
- u32 * tlvs = 0;
u32 sw_if_index = ~0;
- int i;
+
p = hash_get (im->fib_index_by_table_id, ntohl(mp->encap_vrf_id));
if (! p) {
}
encap_fib_index = p[0];
- decap_next_index = ntohl(mp->decap_next_index);
+ protocol = ntohl(mp->protocol);
/* Interpret decap_vrf_id as an opaque if sending to other-than-ip4-input */
- if (decap_next_index == NSH_INPUT_NEXT_IP4_INPUT) {
+ if (protocol == VXLAN_GPE_INPUT_NEXT_IP4_INPUT) {
p = hash_get (im->fib_index_by_table_id, ntohl(mp->decap_vrf_id));
if (! p) {
rv = VNET_API_ERROR_NO_SUCH_INNER_FIB;
decap_fib_index = ntohl(mp->decap_vrf_id);
}
+ /* Check src & dst are different */
+ if ((mp->is_ipv6 && memcmp(mp->local, mp->remote, 16) == 0) ||
+ (!mp->is_ipv6 && memcmp(mp->local, mp->remote, 4) == 0)) {
+ rv = VNET_API_ERROR_SAME_SRC_DST;
+ goto out;
+ }
memset (a, 0, sizeof (*a));
a->is_add = mp->is_add;
+ a->is_ip6 = mp->is_ipv6;
/* ip addresses sent in network byte order */
- a->src.as_u32 = ntohl(mp->src);
- a->dst.as_u32 = ntohl(mp->dst);
+ if (a->is_ip6) {
+ clib_memcpy(&(a->local.ip6), mp->local, 16);
+ clib_memcpy(&(a->remote.ip6), mp->remote, 16);
+ } else {
+ clib_memcpy(&(a->local.ip4), mp->local, 4);
+ clib_memcpy(&(a->remote.ip4), mp->remote, 4);
+ }
a->encap_fib_index = encap_fib_index;
a->decap_fib_index = decap_fib_index;
- a->decap_next_index = decap_next_index;
- a->ver_o_c = mp->ver_o_c;
- a->length = mp->length;
- a->md_type = mp->md_type;
- a->next_protocol = mp->next_protocol;
- a->spi_si = ntohl(mp->spi_si);
- a->c1 = ntohl(mp->c1);
- a->c2 = ntohl(mp->c2);
- a->c3 = ntohl(mp->c3);
- a->c4 = ntohl(mp->c4);
-
- for (i = 0; i < mp->tlv_len_in_words; i++)
- vec_add1 (tlvs, ntohl(mp->tlvs[i]));
-
- a->tlvs = tlvs;
-
- rv = vnet_nsh_gre_add_del_tunnel (a, &sw_if_index);
+ a->protocol = protocol;
+ a->vni = ntohl(mp->vni);
+ rv = vnet_vxlan_gpe_add_del_tunnel (a, &sw_if_index);
out:
- REPLY_MACRO2(VL_API_NSH_GRE_ADD_DEL_TUNNEL_REPLY,
+ REPLY_MACRO2(VL_API_VXLAN_GPE_ADD_DEL_TUNNEL_REPLY,
({
rmp->sw_if_index = ntohl (sw_if_index);
}));
}
-static void
-vl_api_nsh_vxlan_gpe_add_del_tunnel_t_handler
-(vl_api_nsh_vxlan_gpe_add_del_tunnel_t * mp)
+static void send_vxlan_gpe_tunnel_details
+(vxlan_gpe_tunnel_t * t, unix_shared_memory_queue_t * q, u32 context)
{
- vl_api_nsh_vxlan_gpe_add_del_tunnel_reply_t * rmp;
- int rv = 0;
- vnet_nsh_vxlan_gpe_add_del_tunnel_args_t _a, *a = &_a;
- u32 encap_fib_index, decap_fib_index;
- u32 decap_next_index;
- uword * p;
- ip4_main_t * im = &ip4_main;
- u32 * tlvs = 0;
- u32 sw_if_index = ~0;
- int i;
-
- p = hash_get (im->fib_index_by_table_id, ntohl(mp->encap_vrf_id));
- if (! p) {
- rv = VNET_API_ERROR_NO_SUCH_FIB;
- goto out;
- }
- encap_fib_index = p[0];
-
- decap_next_index = ntohl(mp->decap_next_index);
+ vl_api_vxlan_gpe_tunnel_details_t * rmp;
+ ip4_main_t * im4 = &ip4_main;
+ ip6_main_t * im6 = &ip6_main;
+ u8 is_ipv6 = !(t->flags & VXLAN_GPE_TUNNEL_IS_IPV4);
- /* Interpret decap_vrf_id as an opaque if sending to other-than-ip4-input */
- if (decap_next_index == NSH_INPUT_NEXT_IP4_INPUT) {
- p = hash_get (im->fib_index_by_table_id, ntohl(mp->decap_vrf_id));
- if (! p) {
- rv = VNET_API_ERROR_NO_SUCH_INNER_FIB;
- goto out;
- }
- decap_fib_index = p[0];
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_VXLAN_GPE_TUNNEL_DETAILS);
+ if (is_ipv6) {
+ memcpy(rmp->local, &(t->local.ip6), 16);
+ memcpy(rmp->remote, &(t->remote.ip6), 16);
+ rmp->encap_vrf_id = htonl(im6->fibs[t->encap_fib_index].table_id);
+ rmp->decap_vrf_id = htonl(im6->fibs[t->decap_fib_index].table_id);
} else {
- decap_fib_index = ntohl(mp->decap_vrf_id);
+ memcpy(rmp->local, &(t->local.ip4), 4);
+ memcpy(rmp->remote, &(t->remote.ip4), 4);
+ rmp->encap_vrf_id = htonl(im4->fibs[t->encap_fib_index].table_id);
+ rmp->decap_vrf_id = htonl(im4->fibs[t->decap_fib_index].table_id);
}
+ rmp->vni = htonl(t->vni);
+ rmp->protocol = t->protocol;
+ rmp->sw_if_index = htonl(t->sw_if_index);
+ rmp->is_ipv6 = is_ipv6;
+ rmp->context = context;
- memset (a, 0, sizeof (*a));
-
- a->is_add = mp->is_add;
- /* ip addresses sent in network byte order */
- a->src.as_u32 = ntohl(mp->src);
- a->dst.as_u32 = ntohl(mp->dst);
- a->encap_fib_index = encap_fib_index;
- a->decap_fib_index = decap_fib_index;
- a->decap_next_index = decap_next_index;
- a->vni = ntohl(mp->vni);
- a->ver_o_c = mp->ver_o_c;
- a->length = mp->length;
- a->md_type = mp->md_type;
- a->next_protocol = mp->next_protocol;
- a->spi_si = ntohl(mp->spi_si);
- a->c1 = ntohl(mp->c1);
- a->c2 = ntohl(mp->c2);
- a->c3 = ntohl(mp->c3);
- a->c4 = ntohl(mp->c4);
-
- for (i = 0; i < mp->tlv_len_in_words; i++)
- vec_add1 (tlvs, ntohl(mp->tlvs[i]));
-
- a->tlvs = tlvs;
-
- rv = vnet_nsh_vxlan_gpe_add_del_tunnel (a, &sw_if_index);
-
-out:
- REPLY_MACRO2(VL_API_NSH_VXLAN_GPE_ADD_DEL_TUNNEL_REPLY,
- ({
- rmp->sw_if_index = ntohl (sw_if_index);
- }));
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
}
-static void
-vl_api_lisp_gpe_add_del_tunnel_t_handler
-(vl_api_lisp_gpe_add_del_tunnel_t * mp)
+static void vl_api_vxlan_gpe_tunnel_dump_t_handler
+(vl_api_vxlan_gpe_tunnel_dump_t * mp)
{
- vl_api_lisp_gpe_add_del_tunnel_reply_t * rmp;
- int rv = 0;
- vnet_lisp_gpe_add_del_tunnel_args_t _a, *a = &_a;
- u32 encap_fib_index, decap_fib_index;
- u32 decap_next_index;
- uword * p;
- ip4_main_t * im = &ip4_main;
- u32 sw_if_index = ~0;
+ unix_shared_memory_queue_t * q;
+ vxlan_gpe_main_t * vgm = &vxlan_gpe_main;
+ vxlan_gpe_tunnel_t * t;
+ u32 sw_if_index;
- p = hash_get (im->fib_index_by_table_id, ntohl(mp->encap_vrf_id));
- if (! p) {
- rv = VNET_API_ERROR_NO_SUCH_FIB;
- goto out;
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
}
- encap_fib_index = p[0];
- decap_next_index = ntohl(mp->decap_next_index);
+ sw_if_index = ntohl(mp->sw_if_index);
- /* Interpret decap_vrf_id as an opaque if sending to other-than-ip4-input */
- if (decap_next_index == NSH_INPUT_NEXT_IP4_INPUT) {
- p = hash_get (im->fib_index_by_table_id, ntohl(mp->decap_vrf_id));
- if (! p) {
- rv = VNET_API_ERROR_NO_SUCH_INNER_FIB;
- goto out;
- }
- decap_fib_index = p[0];
+ if (~0 == sw_if_index) {
+ pool_foreach (t, vgm->tunnels,
+ ({
+ send_vxlan_gpe_tunnel_details(t, q, mp->context);
+ }));
} else {
- decap_fib_index = ntohl(mp->decap_vrf_id);
+ if ((sw_if_index >= vec_len(vgm->tunnel_index_by_sw_if_index)) ||
+ (~0 == vgm->tunnel_index_by_sw_if_index[sw_if_index])) {
+ return;
+ }
+ t = &vgm->tunnels[vgm->tunnel_index_by_sw_if_index[sw_if_index]];
+ send_vxlan_gpe_tunnel_details(t, q, mp->context);
}
-
- memset (a, 0, sizeof (*a));
-
- a->is_add = mp->is_add;
- /* ip addresses sent in network byte order */
- a->src.as_u32 = mp->src;
- a->dst.as_u32 = mp->dst;
- a->encap_fib_index = encap_fib_index;
- a->decap_fib_index = decap_fib_index;
- a->decap_next_index = decap_next_index;
- a->flags = mp->flags;
- a->ver_res = mp->ver_res;
- a->res = mp->res;
- a->next_protocol = mp->next_protocol;
- a->vni = clib_net_to_host_u32 (mp->iid);
-
- rv = vnet_lisp_gpe_add_del_tunnel (a, &sw_if_index);
-
-out:
- REPLY_MACRO2(VL_API_LISP_GPE_ADD_DEL_TUNNEL_REPLY,
- ({
- rmp->sw_if_index = ntohl (sw_if_index);
- }));
}
static void
a->is_add = mp->is_add;
a->local = 1;
- rv = vnet_lisp_add_del_locator_set_name(a, &ls_index);
+ rv = vnet_lisp_add_del_locator_set(a, &ls_index);
vec_free(locator_name);
a->is_add = mp->is_add;
a->local = 1;
- rv = vnet_lisp_add_del_locator(a, &ls_index);
+ rv = vnet_lisp_add_del_locator(a, NULL, &ls_index);
vec_free(locators);
vec_free(locator_name);
prefp = &gid_address_ippref(&eid);
ip_eid = &ip_prefix_addr(prefp);
- gid_address_type (&eid) = IP_PREFIX;
+ gid_address_type (&eid) = GID_ADDR_IP_PREFIX;
if (mp->is_ipv6) {
clib_memcpy(&ip_addr_v6(ip_eid), mp->ip_address,
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;
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);
REPLY_MACRO(VL_API_LISP_GPE_ENABLE_DISABLE_REPLY);
}
+static void
+vl_api_lisp_enable_disable_t_handler(
+ vl_api_lisp_enable_disable_t *mp)
+{
+ vl_api_lisp_enable_disable_reply_t *rmp;
+ int rv = 0;
+
+ vnet_lisp_enable_disable (mp->is_en);
+ REPLY_MACRO(VL_API_LISP_ENABLE_DISABLE_REPLY);
+}
+
static void
vl_api_lisp_gpe_add_del_iface_t_handler(
vl_api_lisp_gpe_add_del_iface_t *mp)
REPLY_MACRO(VL_API_LISP_GPE_ADD_DEL_IFACE_REPLY);
}
+static void
+vl_api_lisp_pitr_set_locator_set_t_handler(
+ vl_api_lisp_pitr_set_locator_set_t *mp)
+{
+ vl_api_lisp_pitr_set_locator_set_reply_t *rmp;
+ int rv = 0;
+ u8 * ls_name = 0;
+
+ ls_name = format (0, "%s", mp->ls_name);
+ rv = vnet_lisp_pitr_set_locator_set (ls_name, mp->is_add);
+ vec_free (ls_name);
+
+ REPLY_MACRO(VL_API_LISP_PITR_SET_LOCATOR_SET_REPLY);
+}
+
+/** Used for transferring locators via VPP API */
+typedef CLIB_PACKED(struct
+{
+ u8 is_ip4; /**< is locator an IPv4 address */
+ u8 addr[16]; /**< IPv4/IPv6 address */
+}) rloc_t;
+
+static void
+send_lisp_locator_set_details_set_address
+(vl_api_lisp_locator_set_details_t *rmp,
+ gid_address_t *gid_address)
+{
+ ip_prefix_t *ip_addr;
+
+ if (gid_address_type(gid_address) != GID_ADDR_IP_PREFIX) {
+ return;
+ }
+
+ ip_addr = &gid_address_ippref(gid_address);
+ rmp->prefix_len = ip_prefix_len(ip_addr);
+ rmp->is_ipv6 = ip_prefix_version(ip_addr);
+ ip_address_copy_addr(rmp->ip_address, &ip_prefix_addr(ip_addr));
+}
+
+static void
+vl_api_lisp_add_del_remote_mapping_t_handler (
+ vl_api_lisp_add_del_remote_mapping_t *mp)
+{
+ u32 i;
+ ip_address_t rloc, * rlocs = 0;
+ vl_api_lisp_add_del_remote_mapping_reply_t * rmp;
+ int rv = 0;
+ gid_address_t _seid, * seid = &_seid;
+ gid_address_t _deid, * deid = &_deid;
+ ip_prefix_t * seid_pref = &gid_address_ippref(seid);
+ ip_prefix_t * deid_pref = &gid_address_ippref(deid);
+
+ gid_address_type(seid) = GID_ADDR_IP_PREFIX;
+ gid_address_type(deid) = GID_ADDR_IP_PREFIX;
+ ip_address_t * seid_addr = &ip_prefix_addr(seid_pref);
+ ip_address_t * deid_addr = &ip_prefix_addr(deid_pref);
+ ip_prefix_len(seid_pref) = mp->seid_len;
+ ip_prefix_len(deid_pref) = mp->deid_len;
+ gid_address_set_vni (seid, ntohl (mp->vni));
+ gid_address_set_vni (deid, ntohl (mp->vni));
+
+ if (mp->eid_is_ip4) {
+ ip_prefix_version(seid_pref) = IP4;
+ ip_prefix_version(deid_pref) = IP4;
+ clib_memcpy (&ip_addr_v4(seid_addr),
+ mp->seid, sizeof (ip_addr_v4(seid_addr)));
+ clib_memcpy (&ip_addr_v4(deid_addr),
+ mp->deid, sizeof (ip_addr_v4(deid_addr)));
+ } else {
+ ip_prefix_version(seid_pref) = IP6;
+ ip_prefix_version(deid_pref) = IP6;
+ clib_memcpy (&ip_addr_v6(seid_addr),
+ mp->seid, sizeof (ip_addr_v6(seid_addr)));
+ clib_memcpy (&ip_addr_v6(deid_addr),
+ mp->deid, sizeof (ip_addr_v6(deid_addr)));
+ }
+
+ for (i = 0; i < mp->rloc_num; i++) {
+ rloc_t * r = &((rloc_t *) mp->rlocs)[i];
+ if (r->is_ip4) {
+ clib_memcpy (&ip_addr_v4(&rloc), &r->addr, sizeof (rloc_t));
+ ip_addr_version (&rloc) = IP4;
+ } else {
+ clib_memcpy (&ip_addr_v6(&rloc), &r->addr, sizeof (rloc_t));
+ ip_addr_version (&rloc) = IP6;
+ }
+ vec_add1 (rlocs, rloc);
+ }
+
+ rv = vnet_lisp_add_del_remote_mapping (deid, seid, rlocs,
+ mp->action, mp->is_add);
+ vec_free (rlocs);
+ 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)
+ unix_shared_memory_queue_t *q,
+ u32 context,
+ u32 index)
{
vl_api_lisp_locator_set_details_t *rmp;
locator_t *loc = NULL;
u32 * locit = NULL;
+ u8 * str = 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->local = lsit->local;
+ if (lsit->local) {
+ ASSERT(lsit->name != NULL);
+ 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);
+ } else {
+ str = format(0, "remote-%d", index);
+ strncpy((char *) rmp->locator_set_name, (char *) str,
+ ARRAY_LEN(rmp->locator_set_name) - 1);
+ send_lisp_locator_set_details_set_address(rmp, &loc->address);
+
+ vec_free(str);
+ }
rmp->priority = loc->priority;
rmp->weight = loc->weight;
+ rmp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&rmp);
}
unix_shared_memory_queue_t * q = NULL;
lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
locator_set_t * lsit = NULL;
+ u32 index;
q = vl_api_client_index_to_input_queue (mp->client_index);
if (q == 0) {
return;
}
+ index = 0;
pool_foreach (lsit, lcm->locator_set_pool,
({
- send_lisp_locator_set_details(lcm, lsit, q);
+ send_lisp_locator_set_details(lcm, lsit, q, mp->context, index++);
}));
}
static void
send_lisp_local_eid_table_details (mapping_t *mapit,
- unix_shared_memory_queue_t *q)
+ unix_shared_memory_queue_t *q,
+ u32 context)
{
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 * str = NULL;
u8 type = ~0;
ls = pool_elt_at_index (lcm->locator_set_pool,
gid = &mapit->eid;
type = gid_address_type(gid);
- if (type != IP_PREFIX) {
+ if (type != GID_ADDR_IP_PREFIX) {
return;
}
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);
+ if (ls->local) {
+ ASSERT(ls->name != NULL);
+ strncpy((char *) rmp->locator_set_name,
+ (char *) ls->name, ARRAY_LEN(rmp->locator_set_name) - 1);
+ } else {
+ str = format(0, "remote-%d", mapit->locator_set_index);
+ strncpy((char *) rmp->locator_set_name, (char *) str,
+ ARRAY_LEN(rmp->locator_set_name) - 1);
+ vec_free(str);
+ }
switch (ip_prefix_version(ip_prefix)) {
case IP4:
ASSERT(0);
}
rmp->eid_prefix_len = ip_prefix_len(ip_prefix);
+ rmp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&rmp);
}
pool_foreach (mapit, lcm->mapping_pool,
({
- send_lisp_local_eid_table_details(mapit, q);
+ send_lisp_local_eid_table_details(mapit, q, mp->context);
}));
}
static void
send_lisp_gpe_tunnel_details (lisp_gpe_tunnel_t *tunnel,
- unix_shared_memory_queue_t *q)
+ unix_shared_memory_queue_t *q,
+ u32 context)
{
vl_api_lisp_gpe_tunnel_details_t *rmp;
lisp_gpe_main_t * lgm = &lisp_gpe_main;
rmp->ver_res = tunnel->ver_res;
rmp->res = tunnel->res;
rmp->iid = htonl(tunnel->vni);
+ rmp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&rmp);
}
pool_foreach(tunnel, lgm->tunnels,
({
- send_lisp_gpe_tunnel_details(tunnel, q);
+ send_lisp_gpe_tunnel_details(tunnel, q, mp->context);
}));
}
static void
send_lisp_map_resolver_details (ip_address_t *ip,
- unix_shared_memory_queue_t *q)
+ unix_shared_memory_queue_t *q,
+ u32 context)
{
vl_api_lisp_map_resolver_details_t *rmp = NULL;
default:
ASSERT(0);
}
+ rmp->context = context;
vl_msg_api_send_shmem (q, (u8 *)&rmp);
}
}
vec_foreach(ip, lcm->map_resolvers) {
- send_lisp_map_resolver_details(ip, q);
+ send_lisp_map_resolver_details(ip, q, mp->context);
}
}
+static void
+send_lisp_enable_disable_details (unix_shared_memory_queue_t *q,
+ u32 context)
+{
+ vl_api_lisp_enable_disable_status_details_t *rmp = NULL;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_LISP_ENABLE_DISABLE_STATUS_DETAILS);
+
+ rmp->gpe_status = vnet_lisp_gpe_enable_disable_status ();
+ rmp->feature_status = vnet_lisp_enable_disable_status ();
+ rmp->context = context;
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void
+vl_api_lisp_enable_disable_status_dump_t_handler
+(vl_api_lisp_enable_disable_status_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q = NULL;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ send_lisp_enable_disable_details(q, mp->context);
+}
+
static void
vl_api_interface_name_renumber_t_handler (vl_api_interface_name_renumber_t *mp)
{
/*
* 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_validate (vector, 16384);
vec_reset_length (vector);
- vector = vlib_node_serialize (&vm->node_main, vector);
+ /* $$$$ FIXME */
+ vector = vlib_node_serialize (&vm->node_main, vector,
+ (u32)~0 /* all threads */,
+ 1 /* include nexts */,
+ 1 /* include stats */);
svm_pop_heap (oldheap);
pthread_mutex_unlock (&am->vlib_rp->mutex);
REPLY_MACRO(VL_API_TRACE_PROFILE_DEL_REPLY);
}
+static void
+vl_api_af_packet_create_t_handler
+(vl_api_af_packet_create_t *mp)
+{
+ vlib_main_t *vm = vlib_get_main();
+ vl_api_af_packet_create_reply_t *rmp;
+ int rv = 0;
+ u8 *host_if_name = NULL;
+
+ host_if_name = format(0, "%s", mp->host_if_name);
+ vec_add1 (host_if_name, 0);
+
+ rv = af_packet_create_if(vm, host_if_name,
+ mp->use_random_hw_addr ? 0 : mp->hw_addr, 0);
+
+ vec_free(host_if_name);
+
+ REPLY_MACRO(VL_API_AF_PACKET_CREATE_REPLY);
+}
+
+static void
+vl_api_af_packet_delete_t_handler
+(vl_api_af_packet_delete_t *mp)
+{
+ vlib_main_t * vm = vlib_get_main();
+ vl_api_af_packet_delete_reply_t *rmp;
+ int rv = 0;
+ u8 *host_if_name = NULL;
+
+ host_if_name = format(0, "%s", mp->host_if_name);
+ vec_add1 (host_if_name, 0);
+
+ rv = af_packet_delete_if(vm, host_if_name);
+
+ vec_free(host_if_name);
+
+ REPLY_MACRO(VL_API_AF_PACKET_DELETE_REPLY);
+}
+
+static void
+vl_api_policer_add_del_t_handler
+(vl_api_policer_add_del_t *mp)
+{
+ vlib_main_t * vm = vlib_get_main();
+ vl_api_policer_add_del_reply_t *rmp;
+ int rv = 0;
+ u8 *name = NULL;
+ sse2_qos_pol_cfg_params_st cfg;
+ clib_error_t * error;
+
+ name = format(0, "%s", mp->name);
+
+ memset (&cfg, 0, sizeof (cfg));
+ cfg.rfc = mp->type;
+ cfg.rnd_type = mp->round_type;
+ cfg.rate_type = mp->rate_type;
+ cfg.rb.kbps.cir_kbps = mp->cir;
+ cfg.rb.kbps.eir_kbps = mp->eir;
+ cfg.rb.kbps.cb_bytes = mp->cb;
+ cfg.rb.kbps.eb_bytes = mp->eb;
+
+ error = policer_add_del(vm, name, &cfg, mp->is_add);
+
+ if (error)
+ rv = VNET_API_ERROR_UNSPECIFIED;
+
+ REPLY_MACRO(VL_API_POLICER_ADD_DEL_REPLY);
+}
+
+static void
+send_policer_details (u8 *name,
+ sse2_qos_pol_cfg_params_st *config,
+ policer_read_response_type_st *templ,
+ unix_shared_memory_queue_t *q,
+ u32 context)
+{
+ vl_api_policer_details_t * mp;
+
+ mp = vl_msg_api_alloc (sizeof (*mp));
+ memset (mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs (VL_API_POLICER_DETAILS);
+ mp->context = context;
+ mp->cir = htonl(config->rb.kbps.cir_kbps);
+ mp->eir = htonl(config->rb.kbps.eir_kbps);
+ mp->cb = htonl(config->rb.kbps.cb_bytes);
+ mp->eb = htonl(config->rb.kbps.eb_bytes);
+ mp->rate_type = config->rate_type;
+ mp->round_type = config->rnd_type;
+ mp->type = config->rfc;
+ mp->single_rate = templ->single_rate ? 1 : 0;
+ mp->color_aware = templ->color_aware ? 1 : 0;
+ mp->scale = htonl(templ->scale);
+ mp->cir_tokens_per_period = htonl(templ->cir_tokens_per_period);
+ mp->pir_tokens_per_period = htonl(templ->pir_tokens_per_period);
+ mp->current_limit = htonl(templ->current_limit);
+ mp->current_bucket = htonl(templ->current_bucket);
+ mp->extended_limit = htonl(templ->extended_limit);
+ mp->extended_bucket = htonl(templ->extended_bucket);
+ mp->last_update_time = clib_host_to_net_u64(templ->last_update_time);
+
+ strncpy ((char *) mp->name, (char *) name, ARRAY_LEN(mp->name) - 1);
+
+ vl_msg_api_send_shmem (q, (u8 *)&mp);
+}
+
+static void
+vl_api_policer_dump_t_handler
+(vl_api_policer_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q;
+ vnet_policer_main_t * pm = &vnet_policer_main;
+ hash_pair_t * hp;
+ uword * p;
+ u32 pool_index;
+ u8 * match_name = 0;
+ u8 * name;
+ sse2_qos_pol_cfg_params_st *config;
+ policer_read_response_type_st *templ;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0)
+ return;
+
+ if (mp->match_name_valid) {
+ match_name = format(0, "%s%c", mp->match_name, 0);
+ }
+
+ if (mp->match_name_valid) {
+ p = hash_get_mem (pm->policer_config_by_name, match_name);
+ if (p) {
+ pool_index = p[0];
+ config = pool_elt_at_index (pm->configs, pool_index);
+ templ = pool_elt_at_index (pm->policer_templates, pool_index);
+ send_policer_details(match_name, config, templ, q, mp->context);
+ }
+ } else {
+ hash_foreach_pair (hp, pm->policer_config_by_name,
+ ({
+ name = (u8 *) hp->key;
+ pool_index = hp->value[0];
+ config = pool_elt_at_index (pm->configs, pool_index);
+ templ = pool_elt_at_index (pm->policer_templates, pool_index);
+ send_policer_details(name, config, templ, q, mp->context);
+ }));
+ }
+}
+
+static void
+vl_api_netmap_create_t_handler
+(vl_api_netmap_create_t *mp)
+{
+ vlib_main_t *vm = vlib_get_main();
+ vl_api_netmap_create_reply_t *rmp;
+ int rv = 0;
+ u8 *if_name = NULL;
+
+ if_name = format(0, "%s", mp->netmap_if_name);
+ vec_add1 (if_name, 0);
+
+ rv = netmap_create_if(vm, if_name, mp->use_random_hw_addr ? 0 : mp->hw_addr,
+ mp->is_pipe, mp->is_master, 0);
+
+ vec_free(if_name);
+
+ REPLY_MACRO(VL_API_NETMAP_CREATE_REPLY);
+}
+
+static void
+vl_api_netmap_delete_t_handler
+(vl_api_netmap_delete_t *mp)
+{
+ vlib_main_t * vm = vlib_get_main();
+ vl_api_netmap_delete_reply_t *rmp;
+ int rv = 0;
+ u8 *if_name = NULL;
+
+ if_name = format(0, "%s", mp->netmap_if_name);
+ vec_add1 (if_name, 0);
+
+ rv = netmap_delete_if(vm, if_name);
+
+ vec_free(if_name);
+
+ REPLY_MACRO(VL_API_NETMAP_DELETE_REPLY);
+}
#define BOUNCE_HANDLER(nn) \
static void vl_api_##nn##_t_handler ( \
vl_api_sr_tunnel_add_del_t_print,
256, 1);
+
+ /*
+ * Manually register the sr policy add del msg, so we trace
+ * enough bytes to capture a typical tunnel name list
+ */
+ vl_msg_api_set_handlers (VL_API_SR_POLICY_ADD_DEL,
+ "sr_policy_add_del",
+ vl_api_sr_policy_add_del_t_handler,
+ vl_noop_handler,
+ vl_api_sr_policy_add_del_t_endian,
+ vl_api_sr_policy_add_del_t_print,
+ 256, 1);
+
/*
* Trace space for 8 MPLS encap labels, classifier mask+match
*/
am->api_trace_cfg [VL_API_VXLAN_ADD_DEL_TUNNEL].size
+= 16 * sizeof (u32);
- /*
- * trace space for 4 nsh-gre variable TLV words
- */
- 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;
+ am->is_mp_safe [VL_API_GET_NODE_GRAPH] = 1;
return 0;
}