#include <vnet/policer/policer.h>
#include <vnet/devices/netmap/netmap.h>
#include <vnet/flow/flow_report.h>
+#include <vnet/ipsec-gre/ipsec_gre.h>
#undef BIHASH_TYPE
#undef __included_bihash_template_h__
#include <vnet/ipsec/ipsec.h>
#include <vnet/ipsec/ikev2.h>
#endif /* IPSEC */
-#if DPDK > 0
#include <vnet/devices/virtio/vhost-user.h>
-#endif
#include <stats/stats.h>
#include <oam/oam.h>
_(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump) \
_(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump) \
_(LISP_EID_TABLE_MAP_DUMP, lisp_eid_table_map_dump) \
+_(LISP_EID_TABLE_VNI_DUMP, lisp_eid_table_vni_dump) \
_(SHOW_LISP_STATUS, show_lisp_status) \
_(LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS, \
lisp_add_del_map_request_itr_rlocs) \
_(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, \
ip_source_and_port_range_check_add_del) \
_(IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL, \
- ip_source_and_port_range_check_interface_add_del)
+ ip_source_and_port_range_check_interface_add_del) \
+_(IPSEC_GRE_ADD_DEL_TUNNEL, ipsec_gre_add_del_tunnel) \
+_(IPSEC_GRE_TUNNEL_DUMP, ipsec_gre_tunnel_dump)
#define QUOTE_(x) #x
#define QUOTE(x) QUOTE_(x)
ip6_main_t *ip6m = &ip6_main;
ip_lookup_main_t *ip4lm = &ip4m->lookup_main;
ip_lookup_main_t *ip6lm = &ip6m->lookup_main;
- ip_config_main_t *rx_cm4u = &ip4lm->rx_config_mains[VNET_UNICAST];
- ip_config_main_t *rx_cm4m = &ip4lm->rx_config_mains[VNET_MULTICAST];
- ip_config_main_t *rx_cm6u = &ip6lm->rx_config_mains[VNET_UNICAST];
- ip_config_main_t *rx_cm6m = &ip6lm->rx_config_mains[VNET_MULTICAST];
+ ip_config_main_t *rx_cm4u =
+ &ip4lm->feature_config_mains[VNET_IP_RX_UNICAST_FEAT];
+ ip_config_main_t *rx_cm4m =
+ &ip4lm->feature_config_mains[VNET_IP_RX_MULTICAST_FEAT];
+ ip_config_main_t *rx_cm6u =
+ &ip6lm->feature_config_mains[VNET_IP_RX_UNICAST_FEAT];
+ ip_config_main_t *rx_cm6m =
+ &ip6lm->feature_config_mains[VNET_IP_RX_MULTICAST_FEAT];
VALIDATE_SW_IF_INDEX (mp);
vlib_combined_counter_main_t *cm;
static vnet_main_t **my_vnet_mains;
int i, j, n_counters;
-
int rv = 0;
+ if (mp->sw_if_index != ~0)
+ VALIDATE_SW_IF_INDEX (mp);
+
vec_reset_length (my_vnet_mains);
for (i = 0; i < vec_len (vnet_mains); i++)
}
}
+ BAD_SW_IF_INDEX_LABEL;
+
REPLY_MACRO (VL_API_SW_INTERFACE_CLEAR_STATS_REPLY);
}
}
vnet_interface_counter_unlock (im);
- /* Note: in HOST byte order! */
- rmp->total_pkts[VLIB_RX] = total_pkts[VLIB_RX];
- rmp->total_bytes[VLIB_RX] = total_bytes[VLIB_RX];
- rmp->total_pkts[VLIB_TX] = total_pkts[VLIB_TX];
- rmp->total_bytes[VLIB_TX] = total_bytes[VLIB_TX];
- rmp->vector_rate = vlib_last_vector_length_per_node (sm->vlib_main);
+ rmp->total_pkts[VLIB_RX] = clib_host_to_net_u64 (total_pkts[VLIB_RX]);
+ rmp->total_bytes[VLIB_RX] = clib_host_to_net_u64 (total_bytes[VLIB_RX]);
+ rmp->total_pkts[VLIB_TX] = clib_host_to_net_u64 (total_pkts[VLIB_TX]);
+ rmp->total_bytes[VLIB_TX] = clib_host_to_net_u64 (total_bytes[VLIB_TX]);
+ rmp->vector_rate =
+ clib_host_to_net_u64 (vlib_last_vector_length_per_node (sm->vlib_main));
vl_msg_api_send_shmem (q, (u8 *) & rmp);
}
{
int rv = 0;
vl_api_create_vhost_user_if_reply_t *rmp;
-#if DPDK > 0
u32 sw_if_index = (u32) ~ 0;
vnet_main_t *vnm = vnet_get_main ();
vlib_main_t *vm = vlib_get_main ();
- rv = 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->use_custom_mac) ? mp->mac_address : NULL);
+#if DPDK > 0 && DPDK_VHOST_USER
+ rv = dpdk_vhost_user_create_if (
+#else
+ rv = vhost_user_create_if (
+#endif
+ vnm, vm, (char *) mp->sock_filename,
+ mp->is_server, &sw_if_index, (u64) ~ 0,
+ mp->renumber, ntohl (mp->custom_dev_instance),
+ (mp->use_custom_mac) ? mp->mac_address : NULL);
/* *INDENT-OFF* */
REPLY_MACRO2(VL_API_CREATE_VHOST_USER_IF_REPLY,
rmp->sw_if_index = ntohl (sw_if_index);
}));
/* *INDENT-ON* */
-#else
- rv = VNET_API_ERROR_UNIMPLEMENTED;
- REPLY_MACRO (VL_API_CREATE_VHOST_USER_IF_REPLY);
-#endif
}
static void
{
int rv = 0;
vl_api_modify_vhost_user_if_reply_t *rmp;
-#if DPDK > 0 && DPDK_VHOST_USER
u32 sw_if_index = ntohl (mp->sw_if_index);
vnet_main_t *vnm = vnet_get_main ();
vlib_main_t *vm = vlib_get_main ();
- rv = dpdk_vhost_user_modify_if (vnm, vm, (char *) mp->sock_filename,
- mp->is_server, sw_if_index, (u64) ~ 0,
- mp->renumber,
- ntohl (mp->custom_dev_instance));
+#if DPDK > 0 && DPDK_VHOST_USER
+ rv = dpdk_vhost_user_modify_if (
#else
- rv = VNET_API_ERROR_UNIMPLEMENTED;
+ rv = vhost_user_modify_if (
#endif
+ vnm, vm, (char *) mp->sock_filename,
+ mp->is_server, sw_if_index, (u64) ~ 0,
+ mp->renumber, ntohl (mp->custom_dev_instance));
REPLY_MACRO (VL_API_MODIFY_VHOST_USER_IF_REPLY);
}
{
int rv = 0;
vl_api_delete_vhost_user_if_reply_t *rmp;
-#if DPDK > 0 && DPDK_VHOST_USER
vpe_api_main_t *vam = &vpe_api_main;
u32 sw_if_index = ntohl (mp->sw_if_index);
vnet_main_t *vnm = vnet_get_main ();
vlib_main_t *vm = vlib_get_main ();
+#if DPDK > 0 && DPDK_VHOST_USER
rv = dpdk_vhost_user_delete_if (vnm, vm, sw_if_index);
+#else
+ rv = vhost_user_delete_if (vnm, vm, sw_if_index);
+#endif
REPLY_MACRO (VL_API_DELETE_VHOST_USER_IF_REPLY);
if (!rv)
send_sw_interface_flags_deleted (vam, q, sw_if_index);
}
-#else
- rv = VNET_API_ERROR_UNIMPLEMENTED;
- REPLY_MACRO (VL_API_DELETE_VHOST_USER_IF_REPLY);
-#endif
}
static void
clib_warning ("BUG");
}
-#if DPDK > 0 && DPDK_VHOST_USER
static void
send_sw_interface_vhost_user_details (vpe_api_main_t * am,
unix_shared_memory_queue_t * q,
vl_msg_api_send_shmem (q, (u8 *) & mp);
}
-#endif
static void
vl_api_sw_interface_vhost_user_dump_t_handler
(vl_api_sw_interface_vhost_user_dump_t * mp)
{
-#if DPDK > 0 && DPDK_VHOST_USER
int rv = 0;
vpe_api_main_t *am = &vpe_api_main;
vnet_main_t *vnm = vnet_get_main ();
if (q == 0)
return;
+#if DPDK > 0 && DPDK_VHOST_USER
rv = dpdk_vhost_user_dump_ifs (vnm, vm, &ifaces);
+#else
+ rv = vhost_user_dump_ifs (vnm, vm, &ifaces);
+#endif
if (rv)
return;
send_sw_interface_vhost_user_details (am, q, vuid, mp->context);
}
vec_free (ifaces);
-#endif
}
static void
vec_free (locator_name);
vec_free (a->locators);
- REPLY_MACRO (VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY);
+ /* *INDENT-OFF* */
+ REPLY_MACRO2 (VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY,
+ ({
+ rmp->ls_index = clib_host_to_net_u32 (ls_index);
+ }));
+ /* *INDENT-ON* */
}
static void
/* NOTE: for now this works as a static remote mapping, i.e.,
* not authoritative and ttl infinite. */
rv = vnet_lisp_add_del_mapping (eid, rlocs, mp->action, 0, ~0,
- mp->is_add, 0);
+ mp->is_add, 1 /* is_static */ , 0);
if (mp->del_all)
vnet_lisp_clear_all_remote_adjacencies ();
u32 context, u8 filter)
{
vl_api_lisp_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;
u8 *mac = 0;
ip_prefix_t *ip_prefix = NULL;
- ls = pool_elt_at_index (lcm->locator_set_pool, mapit->locator_set_index);
-
switch (filter)
{
- case 0:
+ case 0: /* all mappings */
break;
- case 1:
- if (!ls->local)
- {
- return;
- }
+
+ case 1: /* local only */
+ if (!mapit->local)
+ return;
break;
- case 2:
- if (ls->local)
- {
- return;
- }
+ case 2: /* remote only */
+ if (mapit->local)
+ return;
break;
default:
- clib_warning ("Filter error, unknown filter: %d\n", filter);
+ clib_warning ("Filter error, unknown filter: %d", filter);
return;
}
memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_DETAILS);
rmp->locator_set_index = mapit->locator_set_index;
- rmp->is_local = ls->local;
+ rmp->is_local = mapit->local;
rmp->ttl = mapit->ttl;
rmp->authoritative = mapit->authoritative;
{
memset (eid, 0, sizeof (*eid));
- unformat_lisp_eid_api (eid, mp->eid_type,
- clib_net_to_host_u32 (mp->vni), mp->eid,
- mp->prefix_length);
+ unformat_lisp_eid_api (eid, clib_net_to_host_u32 (mp->vni),
+ mp->eid_type, mp->eid, mp->prefix_length);
mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid);
if ((u32) ~ 0 == mi)
return;
mapit = pool_elt_at_index (lcm->mapping_pool, mi);
- send_lisp_eid_table_details (mapit, q, mp->context, mp->filter);
+ send_lisp_eid_table_details (mapit, q, mp->context,
+ 0 /* ignore filter */ );
}
else
{
{
unix_shared_memory_queue_t *q = NULL;
lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
- ip_address_t *ip = NULL;
+ map_resolver_t *mr;
q = vl_api_client_index_to_input_queue (mp->client_index);
if (q == 0)
return;
}
- vec_foreach (ip, lcm->map_resolvers)
+ vec_foreach (mr, lcm->map_resolvers)
{
- send_lisp_map_resolver_details (ip, q, mp->context);
+ send_lisp_map_resolver_details (&mr->address, q, mp->context);
}
-
}
static void
/* *INDENT-ON* */
}
+static void
+send_eid_table_vni (u32 vni, unix_shared_memory_queue_t * q, u32 context)
+{
+ vl_api_lisp_eid_table_vni_details_t *rmp = 0;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs (VL_API_LISP_EID_TABLE_VNI_DETAILS);
+ rmp->context = context;
+ rmp->vni = clib_host_to_net_u32 (vni);
+ vl_msg_api_send_shmem (q, (u8 *) & rmp);
+}
+
+static void
+vl_api_lisp_eid_table_vni_dump_t_handler (vl_api_lisp_eid_table_vni_dump_t *
+ mp)
+{
+ hash_pair_t *p;
+ u32 *vnis = 0;
+ unix_shared_memory_queue_t *q = 0;
+ lisp_cp_main_t *lcm = vnet_lisp_cp_get_main ();
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0)
+ {
+ return;
+ }
+
+ /* *INDENT-OFF* */
+ hash_foreach_pair (p, lcm->table_id_by_vni,
+ ({
+ hash_set (vnis, p->key, 0);
+ }));
+
+ hash_foreach_pair (p, lcm->bd_id_by_vni,
+ ({
+ hash_set (vnis, p->key, 0);
+ }));
+
+ hash_foreach_pair (p, vnis,
+ ({
+ send_eid_table_vni (p->key, q, mp->context);
+ }));
+ /* *INDENT-ON* */
+
+ hash_free (vnis);
+}
+
static void
vl_api_show_lisp_status_t_handler (vl_api_show_lisp_status_t * mp)
{
mpls_gre_tunnel_t * gt, u32 index, u32 context)
{
vl_api_mpls_gre_tunnel_details_t *mp;
-
- mp = vl_msg_api_alloc (sizeof (*mp));
- memset (mp, 0, sizeof (*mp));
- mp->_vl_msg_id = ntohs (VL_API_MPLS_GRE_TUNNEL_DETAILS);
- mp->context = context;
-
- if (gt != NULL)
- {
- mp->tunnel_index = htonl (index);
- mp->tunnel_src = gt->tunnel_src.as_u32;
- mp->tunnel_dst = gt->tunnel_dst.as_u32;
- mp->intfc_address = gt->intfc_address.as_u32;
- mp->mask_width = htonl (gt->mask_width);
- mp->inner_fib_index = htonl (gt->inner_fib_index);
- mp->outer_fib_index = htonl (gt->outer_fib_index);
- mp->encap_index = htonl (gt->encap_index);
- mp->hw_if_index = htonl (gt->hw_if_index);
- mp->l2_only = htonl (gt->l2_only);
- }
-
mpls_main_t *mm = &mpls_main;
mpls_encap_t *e;
int i;
- u32 len = 0;
+ u32 nlabels;
e = pool_elt_at_index (mm->encaps, gt->encap_index);
- len = vec_len (e->labels);
- mp->nlabels = htonl (len);
+ nlabels = vec_len (e->labels);
+
+ mp = vl_msg_api_alloc (sizeof (*mp) + nlabels * sizeof (u32));
+ memset (mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs (VL_API_MPLS_GRE_TUNNEL_DETAILS);
+ mp->context = context;
+
+ mp->tunnel_index = htonl (index);
+ mp->tunnel_src = gt->tunnel_src.as_u32;
+ mp->tunnel_dst = gt->tunnel_dst.as_u32;
+ mp->intfc_address = gt->intfc_address.as_u32;
+ mp->mask_width = htonl (gt->mask_width);
+ mp->inner_fib_index = htonl (gt->inner_fib_index);
+ mp->outer_fib_index = htonl (gt->outer_fib_index);
+ mp->encap_index = htonl (gt->encap_index);
+ mp->hw_if_index = htonl (gt->hw_if_index);
+ mp->l2_only = htonl (gt->l2_only);
+ mp->nlabels = htonl (nlabels);
- for (i = 0; i < len; i++)
+ for (i = 0; i < nlabels; i++)
{
mp->labels[i] =
htonl (vnet_mpls_uc_get_label
{
vpe_api_main_t *am = &vpe_api_main;
unix_shared_memory_queue_t *q;
- vlib_main_t *vm = &vlib_global_main;
mpls_main_t *mm = &mpls_main;
mpls_gre_tunnel_t *gt;
u32 index = ntohl (mp->tunnel_index);
if (q == 0)
return;
- if (pool_elts (mm->gre_tunnels))
+ if (index != ~0)
{
- if (mp->tunnel_index >= 0)
+ if (!pool_is_free_index (mm->gre_tunnels, index))
{
- vlib_cli_output (vm, "MPLS-GRE tunnel %u", index);
gt = pool_elt_at_index (mm->gre_tunnels, index);
send_mpls_gre_tunnel_entry (am, q, gt, gt - mm->gre_tunnels,
mp->context);
}
- else
- {
- vlib_cli_output (vm, "MPLS-GRE tunnels");
- /* *INDENT-OFF* */
- pool_foreach (gt, mm->gre_tunnels,
- ({
- send_mpls_gre_tunnel_entry (am, q, gt, gt - mm->gre_tunnels,
- mp->context);
- }));
- /* *INDENT-ON* */
- }
}
else
{
- vlib_cli_output (vm, "No MPLS-GRE tunnels");
+ /* *INDENT-OFF* */
+ pool_foreach (gt, mm->gre_tunnels,
+ ({
+ send_mpls_gre_tunnel_entry (am, q, gt, gt - mm->gre_tunnels,
+ mp->context);
+ }));
+ /* *INDENT-ON* */
}
}
unix_shared_memory_queue_t * q,
mpls_eth_tunnel_t * et, u32 index, u32 context)
{
+ mpls_main_t *mm = &mpls_main;
+ mpls_encap_t *e;
+ int i;
+ u32 nlabels;
vl_api_mpls_eth_tunnel_details_t *mp;
- mp = vl_msg_api_alloc (sizeof (*mp));
+ e = pool_elt_at_index (mm->encaps, et->encap_index);
+ nlabels = vec_len (e->labels);
+
+ mp = vl_msg_api_alloc (sizeof (*mp) + nlabels * sizeof (u32));
memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_MPLS_ETH_TUNNEL_DETAILS);
mp->context = context;
- if (et != NULL)
- {
- mp->tunnel_index = htonl (index);
- memcpy (mp->tunnel_dst_mac, et->tunnel_dst, 6);
- mp->intfc_address = et->intfc_address.as_u32;
- mp->tx_sw_if_index = htonl (et->tx_sw_if_index);
- mp->inner_fib_index = htonl (et->inner_fib_index);
- mp->mask_width = htonl (et->mask_width);
- mp->encap_index = htonl (et->encap_index);
- mp->hw_if_index = htonl (et->hw_if_index);
- mp->l2_only = htonl (et->l2_only);
- }
-
- mpls_main_t *mm = &mpls_main;
- mpls_encap_t *e;
- int i;
- u32 len = 0;
+ mp->tunnel_index = htonl (index);
+ memcpy (mp->tunnel_dst_mac, et->tunnel_dst, 6);
+ mp->intfc_address = et->intfc_address.as_u32;
+ mp->tx_sw_if_index = htonl (et->tx_sw_if_index);
+ mp->inner_fib_index = htonl (et->inner_fib_index);
+ mp->mask_width = htonl (et->mask_width);
+ mp->encap_index = htonl (et->encap_index);
+ mp->hw_if_index = htonl (et->hw_if_index);
+ mp->l2_only = htonl (et->l2_only);
+ mp->nlabels = htonl (nlabels);
- e = pool_elt_at_index (mm->encaps, et->encap_index);
- len = vec_len (e->labels);
- mp->nlabels = htonl (len);
-
- for (i = 0; i < len; i++)
+ for (i = 0; i < nlabels; i++)
{
mp->labels[i] =
htonl (vnet_mpls_uc_get_label
{
vpe_api_main_t *am = &vpe_api_main;
unix_shared_memory_queue_t *q;
- vlib_main_t *vm = &vlib_global_main;
mpls_main_t *mm = &mpls_main;
mpls_eth_tunnel_t *et;
u32 index = ntohl (mp->tunnel_index);
if (q == 0)
return;
- clib_warning ("Received mpls_eth_tunnel_dump");
- clib_warning ("Received tunnel index: %u from client %u", index,
- mp->client_index);
-
- if (pool_elts (mm->eth_tunnels))
+ if (index != ~0)
{
- if (mp->tunnel_index >= 0)
+ if (!pool_is_free_index (mm->eth_tunnels, index))
{
- vlib_cli_output (vm, "MPLS-Ethernet tunnel %u", index);
et = pool_elt_at_index (mm->eth_tunnels, index);
send_mpls_eth_tunnel_entry (am, q, et, et - mm->eth_tunnels,
mp->context);
}
- else
- {
- clib_warning ("MPLS-Ethernet tunnels");
- /* *INDENT-OFF* */
- pool_foreach (et, mm->eth_tunnels,
- ({
- send_mpls_eth_tunnel_entry (am, q, et, et - mm->eth_tunnels,
- mp->context);
- }));
- /* *INDENT-ON* */
- }
}
else
{
- clib_warning ("No MPLS-Ethernet tunnels");
+ /* *INDENT-OFF* */
+ pool_foreach (et, mm->eth_tunnels,
+ ({
+ send_mpls_eth_tunnel_entry (am, q, et, et - mm->eth_tunnels,
+ mp->context);
+ }));
+ /* *INDENT-ON* */
}
}
show_mpls_fib_t * s, u32 context)
{
vl_api_mpls_fib_encap_details_t *mp;
+ mpls_main_t *mm = &mpls_main;
+ mpls_encap_t *e;
+ int i;
+ u32 nlabels;
- mp = vl_msg_api_alloc (sizeof (*mp));
+ e = pool_elt_at_index (mm->encaps, s->entry_index);
+ nlabels = vec_len (e->labels);
+
+ mp = vl_msg_api_alloc (sizeof (*mp) + nlabels * sizeof (u32));
memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_MPLS_FIB_ENCAP_DETAILS);
mp->context = context;
mp->dest = s->dest;
mp->s_bit = htonl (s->s_bit);
- mpls_main_t *mm = &mpls_main;
- mpls_encap_t *e;
- int i;
- u32 len = 0;
-
- e = pool_elt_at_index (mm->encaps, s->entry_index);
- len = vec_len (e->labels);
- mp->nlabels = htonl (len);
+ mp->nlabels = htonl (nlabels);
- for (i = 0; i < len; i++)
+ for (i = 0; i < nlabels; i++)
{
mp->labels[i] =
htonl (vnet_mpls_uc_get_label
vl_api_ipfix_details_t *rmp;
q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (!q)
+ return;
rmp = vl_msg_api_alloc (sizeof (*rmp));
memset (rmp, 0, sizeof (*rmp));
}
// Validate mask_length
- if (mask_length < 0 ||
- (is_ipv6 && mask_length > 128) || (!is_ipv6 && mask_length > 32))
+ if ((is_ipv6 && mask_length > 128) || (!is_ipv6 && mask_length > 32))
{
rv = VNET_API_ERROR_ADDRESS_LENGTH_MISMATCH;
goto reply;
REPLY_MACRO (VL_API_IP_SOURCE_AND_PORT_RANGE_CHECK_INTERFACE_ADD_DEL_REPLY);
}
+static void
+vl_api_ipsec_gre_add_del_tunnel_t_handler (vl_api_ipsec_gre_add_del_tunnel_t *
+ mp)
+{
+ vl_api_ipsec_gre_add_del_tunnel_reply_t *rmp;
+ int rv = 0;
+ vnet_ipsec_gre_add_del_tunnel_args_t _a, *a = &_a;
+ u32 sw_if_index = ~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));
+
+ /* ip addresses sent in network byte order */
+ clib_memcpy (&(a->src), mp->src_address, 4);
+ clib_memcpy (&(a->dst), mp->dst_address, 4);
+ a->is_add = mp->is_add;
+ a->lsa = ntohl (mp->local_sa_id);
+ a->rsa = ntohl (mp->remote_sa_id);
+
+ rv = vnet_ipsec_gre_add_del_tunnel (a, &sw_if_index);
+
+out:
+ /* *INDENT-OFF* */
+ REPLY_MACRO2(VL_API_GRE_ADD_DEL_TUNNEL_REPLY,
+ ({
+ rmp->sw_if_index = ntohl (sw_if_index);
+ }));
+ /* *INDENT-ON* */
+}
+
+static void send_ipsec_gre_tunnel_details
+ (ipsec_gre_tunnel_t * t, unix_shared_memory_queue_t * q, u32 context)
+{
+ vl_api_ipsec_gre_tunnel_details_t *rmp;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs (VL_API_IPSEC_GRE_TUNNEL_DETAILS);
+ clib_memcpy (rmp->src_address, &(t->tunnel_src), 4);
+ clib_memcpy (rmp->dst_address, &(t->tunnel_dst), 4);
+ rmp->sw_if_index = htonl (t->sw_if_index);
+ rmp->local_sa_id = htonl (t->local_sa_id);
+ rmp->remote_sa_id = htonl (t->remote_sa_id);
+ rmp->context = context;
+
+ vl_msg_api_send_shmem (q, (u8 *) & rmp);
+}
+
+static void vl_api_ipsec_gre_tunnel_dump_t_handler
+ (vl_api_ipsec_gre_tunnel_dump_t * mp)
+{
+ unix_shared_memory_queue_t *q;
+ ipsec_gre_main_t *igm = &ipsec_gre_main;
+ ipsec_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)
+ {
+ /* *INDENT-OFF* */
+ pool_foreach (t, igm->tunnels,
+ ({
+ send_ipsec_gre_tunnel_details(t, q, mp->context);
+ }));
+ /* *INDENT-ON* */
+ }
+ else
+ {
+ if ((sw_if_index >= vec_len (igm->tunnel_index_by_sw_if_index)) ||
+ (~0 == igm->tunnel_index_by_sw_if_index[sw_if_index]))
+ {
+ return;
+ }
+ t = &igm->tunnels[igm->tunnel_index_by_sw_if_index[sw_if_index]];
+ send_ipsec_gre_tunnel_details (t, q, mp->context);
+ }
+}
+
#define BOUNCE_HANDLER(nn) \
static void vl_api_##nn##_t_handler ( \
vl_api_##nn##_t *mp) \
api_segment_config (vlib_main_t * vm, unformat_input_t * input)
{
u8 *chroot_path;
+ u64 baseva, size, pvt_heap_size;
int uid, gid, rv;
- char *s, buf[128];
+ const int max_buf_size = 4096;
+ char *s, *buf;
struct passwd _pw, *pw;
struct group _grp, *grp;
clib_error_t *e;
-
+ buf = vec_new (char, 128);
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "prefix %s", &chroot_path))
vl_set_memory_uid (uid);
else if (unformat (input, "gid %d", &gid))
vl_set_memory_gid (gid);
+ else if (unformat (input, "baseva %llx", &baseva))
+ vl_set_global_memory_baseva (baseva);
+ else if (unformat (input, "global-size %lldM", &size))
+ vl_set_global_memory_size (size * (1ULL << 20));
+ else if (unformat (input, "global-size %lldG", &size))
+ vl_set_global_memory_size (size * (1ULL << 30));
+ else if (unformat (input, "global-size %lld", &size))
+ vl_set_global_memory_size (size);
+ else if (unformat (input, "global-pvt-heap-size %lldM", &pvt_heap_size))
+ vl_set_global_pvt_heap_size (pvt_heap_size * (1ULL << 20));
+ else if (unformat (input, "global-pvt-heap-size size %lld",
+ &pvt_heap_size))
+ vl_set_global_pvt_heap_size (pvt_heap_size);
+ else if (unformat (input, "api-pvt-heap-size %lldM", &pvt_heap_size))
+ vl_set_api_pvt_heap_size (pvt_heap_size * (1ULL << 20));
+ else if (unformat (input, "api-pvt-heap-size size %lld",
+ &pvt_heap_size))
+ vl_set_api_pvt_heap_size (pvt_heap_size);
+ else if (unformat (input, "api-size %lldM", &size))
+ vl_set_api_memory_size (size * (1ULL << 20));
+ else if (unformat (input, "api-size %lldG", &size))
+ vl_set_api_memory_size (size * (1ULL << 30));
+ else if (unformat (input, "api-size %lld", &size))
+ vl_set_api_memory_size (size);
else if (unformat (input, "uid %s", &s))
{
/* lookup the username */
pw = NULL;
- rv = getpwnam_r (s, &_pw, buf, sizeof (buf), &pw);
+ while (((rv =
+ getpwnam_r (s, &_pw, buf, vec_len (buf), &pw)) == ERANGE)
+ && (vec_len (buf) <= max_buf_size))
+ {
+ vec_resize (buf, vec_len (buf) * 2);
+ }
if (rv < 0)
{
e = clib_error_return_code (0, rv,
CLIB_ERROR_FATAL,
"cannot fetch username %s", s);
vec_free (s);
+ vec_free (buf);
return e;
}
if (pw == NULL)
e =
clib_error_return_fatal (0, "username %s does not exist", s);
vec_free (s);
+ vec_free (buf);
return e;
}
vec_free (s);
{
/* lookup the group name */
grp = NULL;
- rv = getgrnam_r (s, &_grp, buf, sizeof (buf), &grp);
+ while (((rv =
+ getgrnam_r (s, &_grp, buf, vec_len (buf), &grp)) == ERANGE)
+ && (vec_len (buf) <= max_buf_size))
+ {
+ vec_resize (buf, vec_len (buf) * 2);
+ }
if (rv != 0)
{
e = clib_error_return_code (0, rv,
CLIB_ERROR_FATAL,
"cannot fetch group %s", s);
vec_free (s);
+ vec_free (buf);
return e;
}
if (grp == NULL)
{
e = clib_error_return_fatal (0, "group %s does not exist", s);
vec_free (s);
+ vec_free (buf);
return e;
}
vec_free (s);
+ vec_free (buf);
vl_set_memory_gid (grp->gr_gid);
}
else
Code Review / vpp.git / blobdiff