#include <vnet/vnet.h>
#include <vlibmemory/api.h>
-#include <vpp/stats/stats.h>
#include <vnet/interface.h>
#include <vnet/api_errno.h>
#include <vnet/ethernet/ethernet.h>
#include <vnet/ip/ip6_hop_by_hop.h>
#include <vnet/ip/ip4_reassembly.h>
#include <vnet/ip/ip6_reassembly.h>
+#include <vnet/ethernet/arp.h>
+#include <vnet/ip/ip_types_api.h>
#include <vnet/vnet_msg_enum.h>
_(IP_MROUTE_ADD_DEL, ip_mroute_add_del) \
_(MFIB_SIGNAL_DUMP, mfib_signal_dump) \
_(IP_ADDRESS_DUMP, ip_address_dump) \
+_(IP_UNNUMBERED_DUMP, ip_unnumbered_dump) \
_(IP_DUMP, ip_dump) \
_(IP_NEIGHBOR_ADD_DEL, ip_neighbor_add_del) \
_(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit) \
_(WANT_IP6_ND_EVENTS, want_ip6_nd_events) \
_(WANT_IP6_RA_EVENTS, want_ip6_ra_events) \
_(PROXY_ARP_ADD_DEL, proxy_arp_add_del) \
+_(PROXY_ARP_DUMP, proxy_arp_dump) \
_(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable) \
+ _(PROXY_ARP_INTFC_DUMP, proxy_arp_intfc_dump) \
_(RESET_FIB, reset_fib) \
_(IP_ADD_DEL_ROUTE, ip_add_del_route) \
_(IP_TABLE_ADD_DEL, ip_table_add_del) \
_(SW_INTERFACE_IP6_SET_LINK_LOCAL_ADDRESS, \
sw_interface_ip6_set_link_local_address) \
_(IP_CONTAINER_PROXY_ADD_DEL, ip_container_proxy_add_del) \
+_(IP_CONTAINER_PROXY_DUMP, ip_container_proxy_dump) \
_(IOAM_ENABLE, ioam_enable) \
_(IOAM_DISABLE, ioam_disable) \
_(IP_SOURCE_AND_PORT_RANGE_CHECK_ADD_DEL, \
vec_foreach (n, ns)
{
send_ip_neighbor_details
- (sw_if_index, mp->is_ipv6,
+ (n->key.sw_if_index, mp->is_ipv6,
((n->flags & IP6_NEIGHBOR_FLAG_STATIC) ? 1 : 0),
(u8 *) n->link_layer_address,
(u8 *) & (n->key.ip6_address.as_u8),
/* *INDENT-OFF* */
vec_foreach (n, ns)
{
- send_ip_neighbor_details (sw_if_index, mp->is_ipv6,
+ send_ip_neighbor_details (n->sw_if_index, mp->is_ipv6,
((n->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC) ? 1 : 0),
(u8*) n->ethernet_address,
(u8*) & (n->ip4_address.as_u8),
clib_min (vec_len (table->ft_desc), sizeof (mp->table_name)));
mp->address_length = pfx->fp_len;
memcpy (mp->address, &pfx->fp_addr.ip4, sizeof (pfx->fp_addr.ip4));
+ mp->stats_index =
+ htonl (fib_table_entry_get_stats_index (table->ft_index, pfx));
mp->count = htonl (path_count);
fp = mp->path;
ip4_main_t *im = &ip4_main;
fib_table_t *fib_table;
fib_node_index_t *lfeip;
- fib_prefix_t pfx;
+ const fib_prefix_t *pfx;
u32 fib_index;
fib_route_path_encode_t *api_rpaths;
vl_api_ip_fib_dump_walk_ctx_t ctx = {
vec_foreach (lfeip, ctx.feis)
{
- fib_entry_get_prefix (*lfeip, &pfx);
+ pfx = fib_entry_get_prefix (*lfeip);
fib_index = fib_entry_get_fib_index (*lfeip);
- fib_table = fib_table_get (fib_index, pfx.fp_proto);
+ fib_table = fib_table_get (fib_index, pfx->fp_proto);
api_rpaths = NULL;
fib_entry_encode (*lfeip, &api_rpaths);
- send_ip_fib_details (am, reg, fib_table, &pfx, api_rpaths, mp->context);
+ send_ip_fib_details (am, reg, fib_table, pfx, api_rpaths, mp->context);
vec_free (api_rpaths);
}
memcpy (mp->address, &pfx->fp_addr.ip6, sizeof (pfx->fp_addr.ip6));
memcpy (mp->table_name, table->ft_desc,
clib_min (vec_len (table->ft_desc), sizeof (mp->table_name)));
+ mp->stats_index =
+ htonl (fib_table_entry_get_stats_index (table->ft_index, pfx));
mp->count = htonl (path_count);
fp = mp->path;
.entries = NULL,
};
fib_route_path_encode_t *api_rpaths;
- fib_prefix_t pfx;
+ const fib_prefix_t *pfx;
BV (clib_bihash_foreach_key_value_pair)
((BVT (clib_bihash) *) & im6->ip6_table[IP6_FIB_TABLE_NON_FWDING].
vec_foreach (fib_entry_index, ctx.entries)
{
- fib_entry_get_prefix (*fib_entry_index, &pfx);
+ pfx = fib_entry_get_prefix (*fib_entry_index);
api_rpaths = NULL;
fib_entry_encode (*fib_entry_index, &api_rpaths);
- send_ip6_fib_details (am, reg, fib_table, &pfx, api_rpaths, mp->context);
+ send_ip6_fib_details (am, reg, fib_table, pfx, api_rpaths, mp->context);
vec_free (api_rpaths);
}
vl_api_ip_neighbor_add_del_t_handler (vl_api_ip_neighbor_add_del_t * mp,
vlib_main_t * vm)
{
+ ip46_address_t ip = ip46_address_initializer;
vl_api_ip_neighbor_add_del_reply_t *rmp;
- vnet_main_t *vnm = vnet_get_main ();
+ ip_neighbor_flags_t flags;
+ u32 stats_index = ~0;
int rv = 0;
VALIDATE_SW_IF_INDEX (mp);
stats_dslock_with_hint (1 /* release hint */ , 7 /* tag */ );
- /*
- * there's no validation here of the ND/ARP entry being added.
- * The expectation is that the FIB will ensure that nothing bad
- * will come of adding bogus entries.
- */
+ flags = IP_NEIGHBOR_FLAG_NODE;
+ if (mp->is_static)
+ flags |= IP_NEIGHBOR_FLAG_STATIC;
+ if (mp->is_no_adj_fib)
+ flags |= IP_NEIGHBOR_FLAG_NO_ADJ_FIB;
+
if (mp->is_ipv6)
- {
- if (mp->is_add)
- rv = vnet_set_ip6_ethernet_neighbor
- (vm, ntohl (mp->sw_if_index),
- (ip6_address_t *) (mp->dst_address),
- mp->mac_address, sizeof (mp->mac_address), mp->is_static,
- mp->is_no_adj_fib);
- else
- rv = vnet_unset_ip6_ethernet_neighbor
- (vm, ntohl (mp->sw_if_index),
- (ip6_address_t *) (mp->dst_address),
- mp->mac_address, sizeof (mp->mac_address));
- }
+ clib_memcpy (&ip.ip6, mp->dst_address, 16);
else
- {
- ethernet_arp_ip4_over_ethernet_address_t a;
+ clib_memcpy (&ip.ip4, mp->dst_address, 4);
- clib_memcpy (&a.ethernet, mp->mac_address, 6);
- clib_memcpy (&a.ip4, mp->dst_address, 4);
-
- if (mp->is_add)
- rv = vnet_arp_set_ip4_over_ethernet (vnm, ntohl (mp->sw_if_index),
- &a, mp->is_static,
- mp->is_no_adj_fib);
- else
- rv =
- vnet_arp_unset_ip4_over_ethernet (vnm, ntohl (mp->sw_if_index), &a);
- }
+ if (mp->is_add)
+ rv = ip_neighbor_add (&ip, mp->is_ipv6, mp->mac_address,
+ ntohl (mp->sw_if_index), flags, &stats_index);
+ else
+ rv = ip_neighbor_del (&ip, mp->is_ipv6, ntohl (mp->sw_if_index));
stats_dsunlock ();
BAD_SW_IF_INDEX_LABEL;
- REPLY_MACRO (VL_API_IP_NEIGHBOR_ADD_DEL_REPLY);
+
+ /* *INDENT-OFF* */
+ REPLY_MACRO2 (VL_API_IP_NEIGHBOR_ADD_DEL_REPLY,
+ ({
+ rmp->stats_index = htonl (stats_index);
+ }));
+ /* *INDENT-ON* */
}
void
path.frp_flags = path_flags;
- if (is_multipath)
- {
- stats_dslock_with_hint (1 /* release hint */ , 10 /* tag */ );
-
-
- vec_add1 (paths, path);
-
- if (is_add)
- fib_table_entry_path_add2 (fib_index,
- prefix,
- FIB_SOURCE_API, entry_flags, paths);
- else
- fib_table_entry_path_remove2 (fib_index,
- prefix, FIB_SOURCE_API, paths);
-
- vec_free (paths);
- stats_dsunlock ();
- return 0;
- }
-
stats_dslock_with_hint (1 /* release hint */ , 2 /* tag */ );
if (is_drop || is_local || is_classify || is_unreach || is_prohibit)
fib_table_entry_special_remove (fib_index, prefix, FIB_SOURCE_API);
}
}
+ else if (is_multipath)
+ {
+ vec_add1 (paths, path);
+
+ if (is_add)
+ fib_table_entry_path_add2 (fib_index,
+ prefix,
+ FIB_SOURCE_API, entry_flags, paths);
+ else
+ fib_table_entry_path_remove2 (fib_index,
+ prefix, FIB_SOURCE_API, paths);
+
+ vec_free (paths);
+ }
else
{
if (is_add)
}
static int
-ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp)
+ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp,
+ u32 * stats_index)
{
u32 fib_index, next_hop_fib_index;
fib_mpls_label_t *label_stack = NULL;
}
}
- return (add_del_route_t_handler (mp->is_multipath,
- mp->is_add,
- mp->is_drop,
- mp->is_unreach,
- mp->is_prohibit,
- mp->is_local, 0,
- mp->is_classify,
- mp->classify_table_index,
- mp->is_resolve_host,
- mp->is_resolve_attached, 0, 0,
- mp->is_dvr,
- mp->is_source_lookup,
- mp->is_udp_encap,
- fib_index, &pfx, DPO_PROTO_IP4,
- &nh,
- ntohl (mp->next_hop_id),
- ntohl (mp->next_hop_sw_if_index),
- next_hop_fib_index,
- mp->next_hop_weight,
- mp->next_hop_preference,
- ntohl (mp->next_hop_via_label),
- label_stack));
+ rv = add_del_route_t_handler (mp->is_multipath,
+ mp->is_add,
+ mp->is_drop,
+ mp->is_unreach,
+ mp->is_prohibit,
+ mp->is_local, 0,
+ mp->is_classify,
+ mp->classify_table_index,
+ mp->is_resolve_host,
+ mp->is_resolve_attached, 0, 0,
+ mp->is_dvr,
+ mp->is_source_lookup,
+ mp->is_udp_encap,
+ fib_index, &pfx, DPO_PROTO_IP4,
+ &nh,
+ ntohl (mp->next_hop_id),
+ ntohl (mp->next_hop_sw_if_index),
+ next_hop_fib_index,
+ mp->next_hop_weight,
+ mp->next_hop_preference,
+ ntohl (mp->next_hop_via_label), label_stack);
+
+ if (mp->is_add && 0 == rv)
+ *stats_index = fib_table_entry_get_stats_index (fib_index, &pfx);
+
+ return (rv);
}
-int
-ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp)
+static int
+ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp,
+ u32 * stats_index)
{
fib_mpls_label_t *label_stack = NULL;
u32 fib_index, next_hop_fib_index;
}
}
- return (add_del_route_t_handler (mp->is_multipath,
- mp->is_add,
- mp->is_drop,
- mp->is_unreach,
- mp->is_prohibit,
- mp->is_local, 0,
- mp->is_classify,
- mp->classify_table_index,
- mp->is_resolve_host,
- mp->is_resolve_attached, 0, 0,
- mp->is_dvr,
- mp->is_source_lookup,
- mp->is_udp_encap,
- fib_index, &pfx, DPO_PROTO_IP6,
- &nh, ntohl (mp->next_hop_id),
- ntohl (mp->next_hop_sw_if_index),
- next_hop_fib_index,
- mp->next_hop_weight,
- mp->next_hop_preference,
- ntohl (mp->next_hop_via_label),
- label_stack));
+ rv = add_del_route_t_handler (mp->is_multipath,
+ mp->is_add,
+ mp->is_drop,
+ mp->is_unreach,
+ mp->is_prohibit,
+ mp->is_local, 0,
+ mp->is_classify,
+ mp->classify_table_index,
+ mp->is_resolve_host,
+ mp->is_resolve_attached, 0, 0,
+ mp->is_dvr,
+ mp->is_source_lookup,
+ mp->is_udp_encap,
+ fib_index, &pfx, DPO_PROTO_IP6,
+ &nh, ntohl (mp->next_hop_id),
+ ntohl (mp->next_hop_sw_if_index),
+ next_hop_fib_index,
+ mp->next_hop_weight,
+ mp->next_hop_preference,
+ ntohl (mp->next_hop_via_label), label_stack);
+
+ if (mp->is_add && 0 == rv)
+ *stats_index = fib_table_entry_get_stats_index (fib_index, &pfx);
+
+ return (rv);
}
void
vl_api_ip_add_del_route_t_handler (vl_api_ip_add_del_route_t * mp)
{
vl_api_ip_add_del_route_reply_t *rmp;
+ u32 stats_index;
int rv;
vnet_main_t *vnm = vnet_get_main ();
vnm->api_errno = 0;
+ stats_index = ~0;
if (mp->is_ipv6)
- rv = ip6_add_del_route_t_handler (mp);
+ rv = ip6_add_del_route_t_handler (mp, &stats_index);
else
- rv = ip4_add_del_route_t_handler (mp);
+ rv = ip4_add_del_route_t_handler (mp, &stats_index);
rv = (rv == 0) ? vnm->api_errno : rv;
- REPLY_MACRO (VL_API_IP_ADD_DEL_ROUTE_REPLY);
+ /* *INDENT-OFF* */
+ REPLY_MACRO2 (VL_API_IP_ADD_DEL_ROUTE_REPLY,
+ ({
+ rmp->stats_index = htonl (stats_index);
+ }))
+ /* *INDENT-ON* */
}
void
return (0);
}
-static int
+static fib_node_index_t
mroute_add_del_handler (u8 is_add,
u8 is_local,
u32 fib_index,
u32 next_hop_sw_if_index,
ip46_address_t * nh, u32 itf_flags, u32 bier_imp)
{
+ fib_node_index_t mfib_entry_index = ~0;
+
stats_dslock_with_hint (1 /* release hint */ , 2 /* tag */ );
fib_route_path_t path = {
}
else if (!is_local && ~0 == next_hop_sw_if_index)
{
- mfib_table_entry_update (fib_index, prefix,
- MFIB_SOURCE_API, rpf_id, entry_flags);
+ mfib_entry_index = mfib_table_entry_update (fib_index, prefix,
+ MFIB_SOURCE_API,
+ rpf_id, entry_flags);
goto done;
}
if (is_add)
{
- mfib_table_entry_path_update (fib_index, prefix,
- MFIB_SOURCE_API, &path, itf_flags);
+ mfib_entry_index = mfib_table_entry_path_update (fib_index, prefix,
+ MFIB_SOURCE_API,
+ &path, itf_flags);
}
else
{
done:
stats_dsunlock ();
- return (0);
+ return (mfib_entry_index);
}
static int
-api_mroute_add_del_t_handler (vl_api_ip_mroute_add_del_t * mp)
+api_mroute_add_del_t_handler (vl_api_ip_mroute_add_del_t * mp,
+ u32 * stats_index)
{
+ fib_node_index_t mfib_entry_index;
fib_protocol_t fproto;
dpo_proto_t nh_proto;
ip46_address_t nh;
sizeof (pfx.fp_src_addr.ip4));
memset (&nh.ip6, 0, sizeof (nh.ip6));
clib_memcpy (&nh.ip4, mp->nh_address, sizeof (nh.ip4));
+ if (!ip46_address_is_zero (&pfx.fp_src_addr))
+ pfx.fp_len = 64;
}
else
{
clib_memcpy (&pfx.fp_src_addr.ip6, mp->src_address,
sizeof (pfx.fp_src_addr.ip6));
clib_memcpy (&nh.ip6, mp->nh_address, sizeof (nh.ip6));
+ if (!ip46_address_is_zero (&pfx.fp_src_addr))
+ pfx.fp_len = 256;
}
- return (mroute_add_del_handler (mp->is_add,
- mp->is_local,
- fib_index, &pfx,
- nh_proto,
- ntohl (mp->entry_flags),
- ntohl (mp->rpf_id),
- ntohl (mp->next_hop_sw_if_index),
- &nh,
- ntohl (mp->itf_flags),
- ntohl (mp->bier_imp)));
+ mfib_entry_index = mroute_add_del_handler (mp->is_add,
+ mp->is_local,
+ fib_index, &pfx,
+ nh_proto,
+ ntohl (mp->entry_flags),
+ ntohl (mp->rpf_id),
+ ntohl (mp->next_hop_sw_if_index),
+ &nh,
+ ntohl (mp->itf_flags),
+ ntohl (mp->bier_imp));
+
+ if (~0 != mfib_entry_index)
+ *stats_index = mfib_entry_get_stats_index (mfib_entry_index);
+
+ return (rv);
}
void
vl_api_ip_mroute_add_del_t_handler (vl_api_ip_mroute_add_del_t * mp)
{
vl_api_ip_mroute_add_del_reply_t *rmp;
+ vnet_main_t *vnm;
+ u32 stats_index;
int rv;
- vnet_main_t *vnm = vnet_get_main ();
+ vnm = vnet_get_main ();
vnm->api_errno = 0;
+ stats_index = ~0;
- rv = api_mroute_add_del_t_handler (mp);
-
- rv = (rv == 0) ? vnm->api_errno : rv;
+ rv = api_mroute_add_del_t_handler (mp, &stats_index);
- REPLY_MACRO (VL_API_IP_MROUTE_ADD_DEL_REPLY);
+ /* *INDENT-OFF* */
+ REPLY_MACRO2 (VL_API_IP_MROUTE_ADD_DEL_REPLY,
+ ({
+ rmp->stats_index = htonl (stats_index);
+ }));
+ /* *INDENT-ON* */
}
static void
if (mp->is_ipv6)
{
/* *INDENT-OFF* */
- foreach_ip_interface_address (lm6, ia, sw_if_index,
- 1 /* honor unnumbered */,
+ /* Do not send subnet details of the IP-interface for
+ * unnumbered interfaces. otherwise listening clients
+ * will be confused that the subnet is applied on more
+ * than one interface */
+ foreach_ip_interface_address (lm6, ia, sw_if_index, 0,
({
r6 = ip_interface_address_get_address (lm6, ia);
u16 prefix_length = ia->address_length;
else
{
/* *INDENT-OFF* */
- foreach_ip_interface_address (lm4, ia, sw_if_index,
- 1 /* honor unnumbered */,
+ foreach_ip_interface_address (lm4, ia, sw_if_index, 0,
({
r4 = ip_interface_address_get_address (lm4, ia);
u16 prefix_length = ia->address_length;
}));
/* *INDENT-ON* */
}
+
+ BAD_SW_IF_INDEX_LABEL;
+}
+
+static void
+send_ip_unnumbered_details (vpe_api_main_t * am,
+ vl_api_registration_t * reg,
+ u32 sw_if_index, u32 ip_sw_if_index, u32 context)
+{
+ vl_api_ip_unnumbered_details_t *mp;
+
+ mp = vl_msg_api_alloc (sizeof (*mp));
+ memset (mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs (VL_API_IP_UNNUMBERED_DETAILS);
+
+ mp->context = context;
+ mp->sw_if_index = htonl (sw_if_index);
+ mp->ip_sw_if_index = htonl (ip_sw_if_index);
+
+ vl_api_send_msg (reg, (u8 *) mp);
+}
+
+static void
+vl_api_ip_unnumbered_dump_t_handler (vl_api_ip_unnumbered_dump_t * mp)
+{
+ vnet_main_t *vnm = vnet_get_main ();
+ vnet_interface_main_t *im = &vnm->interface_main;
+ int rv __attribute__ ((unused)) = 0;
+ vpe_api_main_t *am = &vpe_api_main;
+ vl_api_registration_t *reg;
+ vnet_sw_interface_t *si;
+ u32 sw_if_index;
+
+ sw_if_index = ntohl (mp->sw_if_index);
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ if (~0 != sw_if_index)
+ {
+ VALIDATE_SW_IF_INDEX (mp);
+
+ si = vnet_get_sw_interface (vnm, ntohl (mp->sw_if_index));
+
+ if (!(si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED))
+ {
+ send_ip_unnumbered_details (am, reg,
+ sw_if_index,
+ si->unnumbered_sw_if_index,
+ mp->context);
+ }
+ }
+ else
+ {
+ /* *INDENT-OFF* */
+ pool_foreach (si, im->sw_interfaces,
+ ({
+ if ((si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED))
+ {
+ send_ip_unnumbered_details(am, reg,
+ si->sw_if_index,
+ si->unnumbered_sw_if_index,
+ mp->context);
+ }
+ }));
+ /* *INDENT-ON* */
+ }
+
BAD_SW_IF_INDEX_LABEL;
}
.indices = NULL,
};
fib_node_index_t *feip;
- fib_prefix_t pfx;
+ const fib_prefix_t *pfx;
vl_api_registration_t *reg;
reg = vl_api_client_index_to_registration (mp->client_index);
vec_foreach (feip, ctx.indices)
{
- fib_entry_get_prefix (*feip, &pfx);
+ pfx = fib_entry_get_prefix (*feip);
send_ip6nd_proxy_details (reg,
mp->context,
- &pfx.fp_addr,
+ &pfx->fp_addr,
fib_entry_get_resolving_interface (*feip));
}
REPLY_MACRO (VL_API_IP_CONTAINER_PROXY_ADD_DEL_REPLY);
}
+typedef struct ip_container_proxy_walk_ctx_t_
+{
+ vl_api_registration_t *reg;
+ u32 context;
+} ip_container_proxy_walk_ctx_t;
+
+static int
+ip_container_proxy_send_details (const fib_prefix_t * pfx, u32 sw_if_index,
+ void *args)
+{
+ vl_api_ip_container_proxy_details_t *mp;
+ ip_container_proxy_walk_ctx_t *ctx = args;
+
+ mp = vl_msg_api_alloc (sizeof (*mp));
+ if (!mp)
+ return 1;
+
+ memset (mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs (VL_API_IP_CONTAINER_PROXY_DETAILS);
+ mp->context = ctx->context;
+
+ mp->sw_if_index = ntohl (sw_if_index);
+ ip_prefix_encode (pfx, &mp->prefix);
+
+ vl_api_send_msg (ctx->reg, (u8 *) mp);
+
+ return 1;
+}
+
+static void
+vl_api_ip_container_proxy_dump_t_handler (vl_api_ip_container_proxy_dump_t *
+ mp)
+{
+ vl_api_registration_t *reg;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ ip_container_proxy_walk_ctx_t ctx = {
+ .context = mp->context,
+ .reg = reg,
+ };
+
+ ip_container_proxy_walk (ip_container_proxy_send_details, &ctx);
+}
+
static void
vl_api_ioam_enable_t_handler (vl_api_ioam_enable_t * mp)
{
}
}
-void
+static void
handle_ip6_nd_event (u32 pool_index)
{
vpe_api_main_t *vam = &vpe_api_main;
vl_api_send_msg (vl_reg, (u8 *) event);
}
}));
- /* *INDENT-ON* */
+ /* *INDENT-ON* */
+ vec_free (ra_events[i].prefixes);
}
}
vlib_process_put_event_data (vm, event_data);
REPLY_MACRO (VL_API_WANT_IP4_ARP_EVENTS_REPLY);
}
+static clib_error_t *
+want_ip4_arp_events_reaper (u32 client_index)
+{
+ vpe_client_registration_t *rp;
+ vl_api_ip4_arp_event_t *event;
+ u32 *to_delete, *event_id;
+ vpe_api_main_t *am;
+ vnet_main_t *vnm;
+ uword *p;
+
+ am = &vpe_api_main;
+ vnm = vnet_get_main ();
+ to_delete = NULL;
+
+ /* clear out all of its pending resolutions */
+ /* *INDENT-OFF* */
+ pool_foreach(event, am->arp_events,
+ ({
+ if (event->client_index == client_index)
+ {
+ vec_add1(to_delete, event - am->arp_events);
+ }
+ }));
+ /* *INDENT-ON* */
+
+ vec_foreach (event_id, to_delete)
+ {
+ event = pool_elt_at_index (am->arp_events, *event_id);
+ vnet_add_del_ip4_arp_change_event
+ (vnm, arp_change_delete_callback,
+ event->pid, &event->address,
+ ip_resolver_process_node.index, IP4_ARP_EVENT,
+ ~0 /* pool index, notused */ , 0 /* is_add */ );
+ }
+ vec_free (to_delete);
+
+ /* remove from the registration hash */
+ p = hash_get (am->wc_ip4_arp_events_registration_hash, client_index);
+
+ if (p)
+ {
+ rp = pool_elt_at_index (am->wc_ip4_arp_events_registrations, p[0]);
+ pool_put (am->wc_ip4_arp_events_registrations, rp);
+ hash_unset (am->wc_ip4_arp_events_registration_hash, client_index);
+ if (pool_elts (am->wc_ip4_arp_events_registrations) == 0)
+ wc_arp_set_publisher_node (~0, REPORT_MAX);
+ }
+ return (NULL);
+}
+
+VL_MSG_API_REAPER_FUNCTION (want_ip4_arp_events_reaper);
+
static void
vl_api_want_ip6_nd_events_t_handler (vl_api_want_ip6_nd_events_t * mp)
{
REPLY_MACRO (VL_API_WANT_IP6_ND_EVENTS_REPLY);
}
+static clib_error_t *
+want_ip6_nd_events_reaper (u32 client_index)
+{
+
+ vpe_client_registration_t *rp;
+ vl_api_ip6_nd_event_t *event;
+ u32 *to_delete, *event_id;
+ vpe_api_main_t *am;
+ vnet_main_t *vnm;
+ uword *p;
+
+ am = &vpe_api_main;
+ vnm = vnet_get_main ();
+ to_delete = NULL;
+
+ /* clear out all of its pending resolutions */
+ /* *INDENT-OFF* */
+ pool_foreach(event, am->nd_events,
+ ({
+ if (event->client_index == client_index)
+ {
+ vec_add1(to_delete, event - am->nd_events);
+ }
+ }));
+ /* *INDENT-ON* */
+
+ vec_foreach (event_id, to_delete)
+ {
+ event = pool_elt_at_index (am->nd_events, *event_id);
+ vnet_add_del_ip6_nd_change_event
+ (vnm, nd_change_delete_callback,
+ event->pid, &event->address,
+ ip_resolver_process_node.index, IP6_ND_EVENT,
+ ~0 /* pool index, notused */ , 0 /* is_add */ );
+ }
+ vec_free (to_delete);
+
+ /* remove from the registration hash */
+ p = hash_get (am->wc_ip6_nd_events_registration_hash, client_index);
+
+ if (p)
+ {
+ rp = pool_elt_at_index (am->wc_ip6_nd_events_registrations, p[0]);
+ pool_put (am->wc_ip6_nd_events_registrations, rp);
+ hash_unset (am->wc_ip6_nd_events_registration_hash, client_index);
+ if (pool_elts (am->wc_ip6_nd_events_registrations) == 0)
+ wc_nd_set_publisher_node (~0, REPORT_MAX);
+ }
+ return (NULL);
+}
+
+VL_MSG_API_REAPER_FUNCTION (want_ip6_nd_events_reaper);
+
static void
vl_api_want_ip6_ra_events_t_handler (vl_api_want_ip6_ra_events_t * mp)
{
REPLY_MACRO (VL_API_WANT_IP6_RA_EVENTS_REPLY);
}
+static clib_error_t *
+want_ip6_ra_events_reaper (u32 client_index)
+{
+ vpe_api_main_t *am = &vpe_api_main;
+ vpe_client_registration_t *rp;
+ uword *p;
+
+ p = hash_get (am->ip6_ra_events_registration_hash, client_index);
+
+ if (p)
+ {
+ rp = pool_elt_at_index (am->ip6_ra_events_registrations, p[0]);
+ pool_put (am->ip6_ra_events_registrations, rp);
+ hash_unset (am->ip6_ra_events_registration_hash, client_index);
+ }
+ return (NULL);
+}
+
+VL_MSG_API_REAPER_FUNCTION (want_ip6_ra_events_reaper);
+
static void
vl_api_proxy_arp_add_del_t_handler (vl_api_proxy_arp_add_del_t * mp)
{
u32 fib_index;
int rv;
ip4_main_t *im = &ip4_main;
- int vnet_proxy_arp_add_del (ip4_address_t * lo_addr,
- ip4_address_t * hi_addr,
- u32 fib_index, int is_del);
uword *p;
stats_dslock_with_hint (1 /* release hint */ , 6 /* tag */ );
- p = hash_get (im->fib_index_by_table_id, ntohl (mp->vrf_id));
+ p = hash_get (im->fib_index_by_table_id, ntohl (mp->proxy.vrf_id));
if (!p)
{
fib_index = p[0];
- rv = vnet_proxy_arp_add_del ((ip4_address_t *) mp->low_address,
- (ip4_address_t *) mp->hi_address,
+ rv = vnet_proxy_arp_add_del ((ip4_address_t *) mp->proxy.low_address,
+ (ip4_address_t *) mp->proxy.hi_address,
fib_index, mp->is_add == 0);
out:
REPLY_MACRO (VL_API_PROXY_ARP_ADD_DEL_REPLY);
}
+typedef struct proxy_arp_walk_ctx_t_
+{
+ vl_api_registration_t *reg;
+ u32 context;
+} proxy_arp_walk_ctx_t;
+
+static walk_rc_t
+send_proxy_arp_details (const ip4_address_t * lo_addr,
+ const ip4_address_t * hi_addr,
+ u32 fib_index, void *data)
+{
+ vl_api_proxy_arp_details_t *mp;
+ proxy_arp_walk_ctx_t *ctx;
+
+ ctx = data;
+
+ mp = vl_msg_api_alloc (sizeof (*mp));
+ memset (mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs (VL_API_PROXY_ARP_DETAILS);
+ mp->context = ctx->context;
+ mp->proxy.vrf_id = htonl (fib_index);
+ clib_memcpy (mp->proxy.low_address, lo_addr,
+ sizeof (mp->proxy.low_address));
+ clib_memcpy (mp->proxy.hi_address, hi_addr, sizeof (mp->proxy.hi_address));
+
+ vl_api_send_msg (ctx->reg, (u8 *) mp);
+
+ return (WALK_CONTINUE);
+}
+
+static void
+vl_api_proxy_arp_dump_t_handler (vl_api_proxy_arp_dump_t * mp)
+{
+ vl_api_registration_t *reg;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ proxy_arp_walk_ctx_t wctx = {
+ .reg = reg,
+ .context = mp->context,
+ };
+
+ proxy_arp_walk (send_proxy_arp_details, &wctx);
+}
+
+static walk_rc_t
+send_proxy_arp_intfc_details (vnet_main_t * vnm,
+ vnet_sw_interface_t * si, void *data)
+{
+ vl_api_proxy_arp_intfc_details_t *mp;
+ proxy_arp_walk_ctx_t *ctx;
+
+ if (!(si->flags & VNET_SW_INTERFACE_FLAG_PROXY_ARP))
+ return (WALK_CONTINUE);
+
+ ctx = data;
+
+ mp = vl_msg_api_alloc (sizeof (*mp));
+ memset (mp, 0, sizeof (*mp));
+ mp->_vl_msg_id = ntohs (VL_API_PROXY_ARP_INTFC_DETAILS);
+ mp->context = ctx->context;
+ mp->sw_if_index = htonl (si->sw_if_index);
+
+ vl_api_send_msg (ctx->reg, (u8 *) mp);
+
+ return (WALK_CONTINUE);
+}
+
+static void
+vl_api_proxy_arp_intfc_dump_t_handler (vl_api_proxy_arp_intfc_dump_t * mp)
+{
+ vl_api_registration_t *reg;
+
+ reg = vl_api_client_index_to_registration (mp->client_index);
+ if (!reg)
+ return;
+
+ proxy_arp_walk_ctx_t wctx = {
+ .reg = reg,
+ .context = mp->context,
+ };
+
+ vnet_sw_interface_walk (vnet_get_main (),
+ send_proxy_arp_intfc_details, &wctx);
+}
+
static void
vl_api_proxy_arp_intfc_enable_disable_t_handler
(vl_api_proxy_arp_intfc_enable_disable_t * mp)
if (mp->is_ipv6)
error = ip6_probe_neighbor (vm, (ip6_address_t *) mp->dst_address,
- sw_if_index);
+ sw_if_index, 0);
else
error = ip4_probe_neighbor (vm, (ip4_address_t *) mp->dst_address,
- sw_if_index);
+ sw_if_index, 0);
if (error)
{
Code Review / vpp.git / blobdiff