#include <vnet/l2/l2_bd.h>
#include <vpp/api/vpe_msg_enum.h>
#include <vnet/span/span.h>
-#include <vnet/fib/ip6_fib.h>
-#include <vnet/fib/ip4_fib.h>
#include <vnet/fib/fib_api.h>
#include <vnet/dpo/drop_dpo.h>
#include <vnet/dpo/receive_dpo.h>
#define foreach_vpe_api_msg \
_(WANT_OAM_EVENTS, want_oam_events) \
_(OAM_ADD_DEL, oam_add_del) \
-_(IS_ADDRESS_REACHABLE, is_address_reachable) \
_(SW_INTERFACE_SET_MPLS_ENABLE, sw_interface_set_mpls_enable) \
_(SW_INTERFACE_SET_VPATH, sw_interface_set_vpath) \
_(SW_INTERFACE_SET_L2_XCONNECT, sw_interface_set_l2_xconnect) \
_(CREATE_SUBIF, create_subif) \
_(PROXY_ARP_ADD_DEL, proxy_arp_add_del) \
_(PROXY_ARP_INTFC_ENABLE_DISABLE, proxy_arp_intfc_enable_disable) \
-_(VNET_GET_SUMMARY_STATS, vnet_get_summary_stats) \
_(RESET_FIB, reset_fib) \
_(CREATE_LOOPBACK, create_loopback) \
_(CREATE_LOOPBACK_INSTANCE, create_loopback_instance) \
_(CONTROL_PING, control_ping) \
-_(CLI_REQUEST, cli_request) \
+_(CLI, cli) \
_(CLI_INBAND, cli_inband) \
_(SET_ARP_NEIGHBOR_LIMIT, set_arp_neighbor_limit) \
_(L2_PATCH_ADD_DEL, l2_patch_add_del) \
ip_source_and_port_range_check_interface_add_del) \
_(DELETE_SUBIF, delete_subif) \
_(PUNT, punt) \
+_(PUNT_SOCKET_REGISTER, punt_socket_register) \
+_(PUNT_SOCKET_DEREGISTER, punt_socket_deregister) \
_(FEATURE_ENABLE_DISABLE, feature_enable_disable)
#define QUOTE_(x) #x
resolver_process (vlib_main_t * vm,
vlib_node_runtime_t * rt, vlib_frame_t * f)
{
- uword event_type;
- uword *event_data = 0;
- f64 timeout = 100.0;
- int i;
+ volatile f64 timeout = 100.0;
+ volatile uword *event_data = 0;
while (1)
{
vlib_process_wait_for_event_or_clock (vm, timeout);
- event_type = vlib_process_get_events (vm, &event_data);
+ uword event_type =
+ vlib_process_get_events (vm, (uword **) & event_data);
+ int i;
switch (event_type)
{
case RESOLUTION_PENDING_EVENT:
if (mp->enable)
{
+ VALIDATE_BD_ID (mp);
u32 bd_id = ntohl (mp->bd_id);
u32 bd_index = bd_find_or_add_bd_index (bdm, bd_id);
u32 bvi = mp->bvi;
}
BAD_RX_SW_IF_INDEX_LABEL;
+ BAD_BD_ID_LABEL;
REPLY_MACRO (VL_API_SW_INTERFACE_SET_L2_BRIDGE_REPLY);
}
BAD_SW_IF_INDEX_LABEL;
-out:
REPLY_MACRO (VL_API_PROXY_ARP_INTFC_ENABLE_DISABLE_REPLY);
}
-static void
-vl_api_is_address_reachable_t_handler (vl_api_is_address_reachable_t * mp)
-{
-#if 0
- vpe_main_t *rm = &vpe_main;
- ip4_main_t *im4 = &ip4_main;
- ip6_main_t *im6 = &ip6_main;
- ip_lookup_main_t *lm;
- union
- {
- ip4_address_t ip4;
- ip6_address_t ip6;
- } addr;
- u32 adj_index, sw_if_index;
- vl_api_is_address_reachable_t *rmp;
- ip_adjacency_t *adj;
- unix_shared_memory_queue_t *q;
-
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (!q)
- {
- increment_missing_api_client_counter (rm->vlib_main);
- return;
- }
-
- rmp = vl_msg_api_alloc (sizeof (*rmp));
- clib_memcpy (rmp, mp, sizeof (*rmp));
-
- sw_if_index = mp->next_hop_sw_if_index;
- clib_memcpy (&addr, mp->address, sizeof (addr));
- if (mp->is_ipv6)
- {
- lm = &im6->lookup_main;
- adj_index = ip6_fib_lookup (im6, sw_if_index, &addr.ip6);
- }
- else
- {
- lm = &im4->lookup_main;
- // FIXME NOT an ADJ
- adj_index = ip4_fib_lookup (im4, sw_if_index, &addr.ip4);
- }
- if (adj_index == ~0)
- {
- rmp->is_error = 1;
- goto send;
- }
- adj = ip_get_adjacency (lm, adj_index);
-
- if (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE
- && adj->rewrite_header.sw_if_index == sw_if_index)
- {
- rmp->is_known = 1;
- }
- else
- {
- if (adj->lookup_next_index == IP_LOOKUP_NEXT_ARP
- && adj->rewrite_header.sw_if_index == sw_if_index)
- {
- if (mp->is_ipv6)
- ip6_probe_neighbor (rm->vlib_main, &addr.ip6, sw_if_index);
- else
- ip4_probe_neighbor (rm->vlib_main, &addr.ip4, sw_if_index);
- }
- else if (adj->lookup_next_index == IP_LOOKUP_NEXT_DROP)
- {
- rmp->is_known = 1;
- goto send;
- }
- rmp->is_known = 0;
- }
-
-send:
- vl_msg_api_send_shmem (q, (u8 *) & rmp);
-#endif
-}
-
static void
vl_api_sw_interface_set_mpls_enable_t_handler
(vl_api_sw_interface_set_mpls_enable_t * mp)
VALIDATE_SW_IF_INDEX (mp);
- mpls_sw_interface_enable_disable (&mpls_main,
- ntohl (mp->sw_if_index), mp->enable);
+ rv = mpls_sw_interface_enable_disable (&mpls_main,
+ ntohl (mp->sw_if_index),
+ mp->enable, 1);
BAD_SW_IF_INDEX_LABEL;
REPLY_MACRO (VL_API_SW_INTERFACE_SET_MPLS_ENABLE_REPLY);
REPLY_MACRO (VL_API_OAM_ADD_DEL_REPLY);
}
-static void
-vl_api_vnet_get_summary_stats_t_handler (vl_api_vnet_get_summary_stats_t * mp)
-{
- stats_main_t *sm = &stats_main;
- vnet_interface_main_t *im = sm->interface_main;
- vl_api_vnet_summary_stats_reply_t *rmp;
- vlib_combined_counter_main_t *cm;
- vlib_counter_t v;
- int i, which;
- u64 total_pkts[VLIB_N_RX_TX];
- u64 total_bytes[VLIB_N_RX_TX];
-
- unix_shared_memory_queue_t *q =
- vl_api_client_index_to_input_queue (mp->client_index);
-
- if (!q)
- return;
-
- rmp = vl_msg_api_alloc (sizeof (*rmp));
- rmp->_vl_msg_id = ntohs (VL_API_VNET_SUMMARY_STATS_REPLY);
- rmp->context = mp->context;
- rmp->retval = 0;
-
- memset (total_pkts, 0, sizeof (total_pkts));
- memset (total_bytes, 0, sizeof (total_bytes));
-
- vnet_interface_counter_lock (im);
-
- vec_foreach (cm, im->combined_sw_if_counters)
- {
- which = cm - im->combined_sw_if_counters;
-
- for (i = 0; i < vlib_combined_counter_n_counters (cm); i++)
- {
- vlib_get_combined_counter (cm, i, &v);
- total_pkts[which] += v.packets;
- total_bytes[which] += v.bytes;
- }
- }
- vnet_interface_counter_unlock (im);
-
- 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);
-}
-
-/* *INDENT-OFF* */
-typedef CLIB_PACKED (struct {
- ip4_address_t address;
- u32 address_length: 6;
- u32 index:26;
-}) ip4_route_t;
-/* *INDENT-ON* */
static int
ip4_reset_fib_t_handler (vl_api_reset_fib_t * mp)
static void
-vl_api_cli_request_t_handler (vl_api_cli_request_t * mp)
+vl_api_cli_t_handler (vl_api_cli_t * mp)
{
vl_api_cli_reply_t *rp;
unix_shared_memory_queue_t *q;
{
vl_api_cli_inband_reply_t *rmp;
int rv = 0;
- unix_shared_memory_queue_t *q;
vlib_main_t *vm = vlib_get_main ();
unformat_input_t input;
u8 *out_vec = 0;
- q = vl_api_client_index_to_input_queue (mp->client_index);
- if (!q)
- return;
-
unformat_init_string (&input, (char *) mp->cmd, ntohl (mp->length));
vlib_cli_input (vm, &input, inband_cli_output, (uword) & out_vec);
char *vpe_api_get_version (void);
char *vpe_api_get_build_date (void);
- unix_shared_memory_queue_t *q =
- vl_api_client_index_to_input_queue (mp->client_index);
-
- if (!q)
- return;
-
/* *INDENT-OFF* */
REPLY_MACRO2(VL_API_SHOW_VERSION_REPLY,
({
vpe_api_main_t *am = &vpe_api_main;
vlib_main_t *vm = am->vlib_main;
vl_api_ip4_arp_event_t *event;
- static f64 arp_event_last_time;
- f64 now = vlib_time_now (vm);
if (pool_is_free_index (am->arp_events, pool_index))
return 1;
event = pool_elt_at_index (am->arp_events, pool_index);
- /* *INDENT-OFF* */
- if (memcmp (&event->new_mac, new_mac, sizeof (event->new_mac)))
+ if (eth_mac_equal (event->new_mac, new_mac) &&
+ sw_if_index == ntohl (event->sw_if_index))
{
- clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac));
- }
- else
- { /* same mac */
- if (sw_if_index == ntohl(event->sw_if_index) &&
- (!event->mac_ip ||
- /* for BD case, also check IP address with 10 sec timeout */
- (address == event->address &&
- (now - arp_event_last_time) < 10.0)))
- return 1;
+ return 1;
}
- /* *INDENT-ON* */
- arp_event_last_time = now;
+ clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac));
event->sw_if_index = htonl (sw_if_index);
- if (event->mac_ip)
- event->address = address;
return 0;
}
vpe_api_main_t *am = &vpe_api_main;
vlib_main_t *vm = am->vlib_main;
vl_api_ip6_nd_event_t *event;
- static f64 nd_event_last_time;
- f64 now = vlib_time_now (vm);
if (pool_is_free_index (am->nd_events, pool_index))
return 1;
event = pool_elt_at_index (am->nd_events, pool_index);
-
- /* *INDENT-OFF* */
- if (memcmp (&event->new_mac, new_mac, sizeof (event->new_mac)))
+ if (eth_mac_equal (event->new_mac, new_mac) &&
+ sw_if_index == ntohl (event->sw_if_index))
{
- clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac));
+ return 1;
}
- else
- { /* same mac */
- if (sw_if_index == ntohl(event->sw_if_index) &&
- (!event->mac_ip ||
- /* for BD case, also check IP address with 10 sec timeout */
- (ip6_address_is_equal (address,
- (ip6_address_t *) event->address) &&
- (now - nd_event_last_time) < 10.0)))
- return 1;
- }
- /* *INDENT-ON* */
- nd_event_last_time = now;
+ clib_memcpy (event->new_mac, new_mac, sizeof (event->new_mac));
event->sw_if_index = htonl (sw_if_index);
- if (event->mac_ip)
- clib_memcpy (event->address, address, sizeof (event->address));
return 0;
}
return 0;
}
+static vlib_node_registration_t wc_arp_process_node;
+
+enum
+{ WC_ARP_REPORT, WC_ND_REPORT };
+
+static uword
+wc_arp_process (vlib_main_t * vm, vlib_node_runtime_t * rt, vlib_frame_t * f)
+{
+ /* These cross the longjmp boundry (vlib_process_wait_for_event)
+ * and need to be volatile - to prevent them from being optimized into
+ * a register - which could change during suspension */
+
+ volatile wc_arp_report_t arp_prev = { 0 };
+ volatile wc_nd_report_t nd_prev = { 0 };
+ volatile f64 last_arp = vlib_time_now (vm);
+ volatile f64 last_nd = vlib_time_now (vm);
+
+ while (1)
+ {
+ vlib_process_wait_for_event (vm);
+ uword event_type;
+ void *event_data = vlib_process_get_event_data (vm, &event_type);
+
+ f64 now = vlib_time_now (vm);
+ int i;
+ if (event_type == WC_ARP_REPORT)
+ {
+ wc_arp_report_t *arp_events = event_data;
+ for (i = 0; i < vec_len (arp_events); i++)
+ {
+ /* discard dup event */
+ if (arp_prev.ip4 == arp_events[i].ip4 &&
+ eth_mac_equal ((u8 *) arp_prev.mac, arp_events[i].mac) &&
+ arp_prev.sw_if_index == arp_events[i].sw_if_index &&
+ (now - last_arp) < 10.0)
+ {
+ continue;
+ }
+ arp_prev = arp_events[i];
+ last_arp = now;
+ vpe_client_registration_t *reg;
+ /* *INDENT-OFF* */
+ pool_foreach(reg, vpe_api_main.wc_ip4_arp_events_registrations,
+ ({
+ unix_shared_memory_queue_t *q;
+ q = vl_api_client_index_to_input_queue (reg->client_index);
+ if (q && q->cursize < q->maxsize)
+ {
+ vl_api_ip4_arp_event_t * event = vl_msg_api_alloc (sizeof *event);
+ memset (event, 0, sizeof *event);
+ event->_vl_msg_id = htons (VL_API_IP4_ARP_EVENT);
+ event->client_index = reg->client_index;
+ event->pid = reg->client_pid;
+ event->mac_ip = 1;
+ event->address = arp_events[i].ip4;
+ event->sw_if_index = htonl(arp_events[i].sw_if_index);
+ memcpy(event->new_mac, arp_events[i].mac, sizeof event->new_mac);
+ vl_msg_api_send_shmem (q, (u8 *) &event);
+ }
+ }));
+ /* *INDENT-ON* */
+ }
+ }
+ else if (event_type == WC_ND_REPORT)
+ {
+ wc_nd_report_t *nd_events = event_data;
+ for (i = 0; i < vec_len (nd_events); i++)
+ {
+ /* discard dup event */
+ if (ip6_address_is_equal
+ ((ip6_address_t *) & nd_prev.ip6, &nd_events[i].ip6)
+ && eth_mac_equal ((u8 *) nd_prev.mac, nd_events[i].mac)
+ && nd_prev.sw_if_index == nd_events[i].sw_if_index
+ && (now - last_nd) < 10.0)
+ {
+ continue;
+ }
+ nd_prev = nd_events[i];
+ last_nd = now;
+ vpe_client_registration_t *reg;
+ /* *INDENT-OFF* */
+ pool_foreach(reg, vpe_api_main.wc_ip6_nd_events_registrations,
+ ({
+ unix_shared_memory_queue_t *q;
+ q = vl_api_client_index_to_input_queue (reg->client_index);
+ if (q && q->cursize < q->maxsize)
+ {
+ vl_api_ip6_nd_event_t * event = vl_msg_api_alloc (sizeof *event);
+ memset (event, 0, sizeof *event);
+ event->_vl_msg_id = htons (VL_API_IP6_ND_EVENT);
+ event->client_index = reg->client_index;
+ event->pid = reg->client_pid;
+ event->mac_ip = 1;
+ memcpy(event->address, nd_events[i].ip6.as_u8, sizeof event->address);
+ event->sw_if_index = htonl(nd_events[i].sw_if_index);
+ memcpy(event->new_mac, nd_events[i].mac, sizeof event->new_mac);
+ vl_msg_api_send_shmem (q, (u8 *) &event);
+ }
+ }));
+ /* *INDENT-ON* */
+ }
+ }
+ vlib_process_put_event_data (vm, event_data);
+ }
+
+ return 0;
+}
+
+/* *INDENT-OFF* */
+VLIB_REGISTER_NODE (wc_arp_process_node,static) = {
+ .function = wc_arp_process,
+ .type = VLIB_NODE_TYPE_PROCESS,
+ .name = "wildcard-ip4-arp-publisher-process",
+};
+/* *INDENT-ON* */
+
static void
vl_api_want_ip4_arp_events_t_handler (vl_api_want_ip4_arp_events_t * mp)
{
vpe_api_main_t *am = &vpe_api_main;
vnet_main_t *vnm = vnet_get_main ();
vl_api_want_ip4_arp_events_reply_t *rmp;
- int rv;
+ int rv = 0;
+
+ if (mp->address == 0)
+ {
+ uword *p =
+ hash_get (am->wc_ip4_arp_events_registration_hash, mp->client_index);
+ vpe_client_registration_t *rp;
+ if (p)
+ {
+ if (mp->enable_disable)
+ {
+ clib_warning ("pid %d: already enabled...", mp->pid);
+ rv = VNET_API_ERROR_INVALID_REGISTRATION;
+ goto reply;
+ }
+ else
+ {
+ 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,
+ mp->client_index);
+ if (pool_elts (am->wc_ip4_arp_events_registrations) == 0)
+ wc_arp_set_publisher_node (~0, WC_ARP_REPORT);
+ goto reply;
+ }
+ }
+ if (mp->enable_disable == 0)
+ {
+ clib_warning ("pid %d: already disabled...", mp->pid);
+ rv = VNET_API_ERROR_INVALID_REGISTRATION;
+ goto reply;
+ }
+ pool_get (am->wc_ip4_arp_events_registrations, rp);
+ rp->client_index = mp->client_index;
+ rp->client_pid = mp->pid;
+ hash_set (am->wc_ip4_arp_events_registration_hash, rp->client_index,
+ rp - am->wc_ip4_arp_events_registrations);
+ wc_arp_set_publisher_node (wc_arp_process_node.index, WC_ARP_REPORT);
+ goto reply;
+ }
if (mp->enable_disable)
{
if (rv)
{
pool_put (am->arp_events, event);
- goto out;
+ goto reply;
}
memset (event, 0, sizeof (*event));
- event->_vl_msg_id = ntohs (VL_API_IP4_ARP_EVENT);
+ /* Python API expects events to have no context */
+ event->_vl_msg_id = htons (VL_API_IP4_ARP_EVENT);
event->client_index = mp->client_index;
- event->context = mp->context;
event->address = mp->address;
event->pid = mp->pid;
if (mp->address == 0)
vpe_resolver_process_node.index,
IP4_ARP_EVENT, ~0 /* pool index */ , 0 /* is_add */ );
}
-out:
+reply:
REPLY_MACRO (VL_API_WANT_IP4_ARP_EVENTS_REPLY);
}
vpe_api_main_t *am = &vpe_api_main;
vnet_main_t *vnm = vnet_get_main ();
vl_api_want_ip6_nd_events_reply_t *rmp;
- int rv;
+ int rv = 0;
+
+ if (ip6_address_is_zero ((ip6_address_t *) mp->address))
+ {
+ uword *p =
+ hash_get (am->wc_ip6_nd_events_registration_hash, mp->client_index);
+ vpe_client_registration_t *rp;
+ if (p)
+ {
+ if (mp->enable_disable)
+ {
+ clib_warning ("pid %d: already enabled...", mp->pid);
+ rv = VNET_API_ERROR_INVALID_REGISTRATION;
+ goto reply;
+ }
+ else
+ {
+ 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,
+ mp->client_index);
+ if (pool_elts (am->wc_ip6_nd_events_registrations) == 0)
+ wc_nd_set_publisher_node (~0, 2);
+ goto reply;
+ }
+ }
+ if (mp->enable_disable == 0)
+ {
+ clib_warning ("pid %d: already disabled...", mp->pid);
+ rv = VNET_API_ERROR_INVALID_REGISTRATION;
+ goto reply;
+ }
+ pool_get (am->wc_ip6_nd_events_registrations, rp);
+ rp->client_index = mp->client_index;
+ rp->client_pid = mp->pid;
+ hash_set (am->wc_ip6_nd_events_registration_hash, rp->client_index,
+ rp - am->wc_ip6_nd_events_registrations);
+ wc_nd_set_publisher_node (wc_arp_process_node.index, WC_ND_REPORT);
+ goto reply;
+ }
if (mp->enable_disable)
{
if (rv)
{
pool_put (am->nd_events, event);
- goto out;
+ goto reply;
}
memset (event, 0, sizeof (*event));
event->_vl_msg_id = ntohs (VL_API_IP6_ND_EVENT);
event->client_index = mp->client_index;
- event->context = mp->context;
- clib_memcpy (event->address, mp->address, 16);
+ clib_memcpy (event->address, mp->address, sizeof event->address);
event->pid = mp->pid;
- if (ip6_address_is_zero ((ip6_address_t *) mp->address))
- event->mac_ip = 1;
-
}
else
{
vpe_resolver_process_node.index,
IP6_ND_EVENT, ~0 /* pool index */ , 0 /* is_add */ );
}
-out:
+reply:
REPLY_MACRO (VL_API_WANT_IP6_ND_EVENTS_REPLY);
}
REPLY_MACRO (VL_API_PUNT_REPLY);
}
+static void
+vl_api_punt_socket_register_t_handler (vl_api_punt_socket_register_t * mp)
+{
+ vl_api_punt_socket_register_reply_t *rmp;
+ vlib_main_t *vm = vlib_get_main ();
+ int rv = 0;
+ clib_error_t *error;
+ unix_shared_memory_queue_t *q;
+ u32 handle;
+
+ error = vnet_punt_socket_add (vm, ntohl (mp->header_version),
+ mp->is_ip4, mp->l4_protocol,
+ ntohs (mp->l4_port), (char *) mp->pathname);
+ if (error)
+ {
+ rv = -1;
+ clib_error_report (error);
+ }
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (!q)
+ return;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ rmp->_vl_msg_id = htons (VL_API_PUNT_SOCKET_REGISTER_REPLY);
+ rmp->context = mp->context;
+ rmp->retval = htonl (rv);
+ char *p = vnet_punt_get_server_pathname ();
+ /* Abstract pathnames start with \0 */
+ memcpy ((char *) rmp->pathname, p, sizeof (rmp->pathname));
+ vl_msg_api_send_shmem (q, (u8 *) & rmp);
+}
+
+static void
+vl_api_punt_socket_deregister_t_handler (vl_api_punt_socket_deregister_t * mp)
+{
+ vl_api_punt_socket_deregister_reply_t *rmp;
+ vlib_main_t *vm = vlib_get_main ();
+ int rv = 0;
+ clib_error_t *error;
+ unix_shared_memory_queue_t *q;
+ u32 handle;
+
+ error = vnet_punt_socket_del (vm, mp->is_ip4, mp->l4_protocol,
+ ntohs (mp->l4_port));
+ if (error)
+ {
+ rv = -1;
+ clib_error_report (error);
+ }
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (!q)
+ return;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ rmp->_vl_msg_id = htons (VL_API_PUNT_SOCKET_DEREGISTER_REPLY);
+ rmp->context = mp->context;
+ rmp->retval = htonl (rv);
+ vl_msg_api_send_shmem (q, (u8 *) & rmp);
+}
+
static void
vl_api_feature_enable_disable_t_handler (vl_api_feature_enable_disable_t * mp)
{
am->vlib_main = vm;
am->vnet_main = vnet_get_main ();
- am->interface_events_registration_hash = hash_create (0, sizeof (uword));
- am->to_netconf_server_registration_hash = hash_create (0, sizeof (uword));
- am->from_netconf_server_registration_hash = hash_create (0, sizeof (uword));
- am->to_netconf_client_registration_hash = hash_create (0, sizeof (uword));
- am->from_netconf_client_registration_hash = hash_create (0, sizeof (uword));
- am->oam_events_registration_hash = hash_create (0, sizeof (uword));
- am->bfd_events_registration_hash = hash_create (0, sizeof (uword));
+#define _(a) \
+ am->a##_registration_hash = hash_create (0, sizeof (uword));
+ foreach_registration_hash;
+#undef _
vl_set_memory_region_name ("/vpe-api");
vl_enable_disable_memory_api (vm, 1 /* enable it */ );
vl_api_ip4_arp_event_t *event = va_arg (*args, vl_api_ip4_arp_event_t *);
s = format (s, "pid %d: ", ntohl (event->pid));
- if (event->mac_ip)
- s = format (s, "bd mac/ip4 binding events");
- else
- s = format (s, "resolution for %U", format_ip4_address, &event->address);
+ s = format (s, "resolution for %U", format_ip4_address, &event->address);
return s;
}
vl_api_ip6_nd_event_t *event = va_arg (*args, vl_api_ip6_nd_event_t *);
s = format (s, "pid %d: ", ntohl (event->pid));
- if (event->mac_ip)
- s = format (s, "bd mac/ip6 binding events");
- else
- s = format (s, "resolution for %U", format_ip6_address, event->address);
+ s = format (s, "resolution for %U", format_ip6_address, event->address);
return s;
}
vl_api_ip4_arp_event_t *arp_event;
vl_api_ip6_nd_event_t *nd_event;
- if ((pool_elts (am->arp_events) == 0) && (pool_elts (am->nd_events) == 0))
+ if (pool_elts (am->arp_events) == 0 && pool_elts (am->nd_events) == 0 &&
+ pool_elts (am->wc_ip4_arp_events_registrations) == 0 &&
+ pool_elts (am->wc_ip6_nd_events_registrations) == 0)
{
vlib_cli_output (vm, "No active arp or nd event registrations");
return 0;
vlib_cli_output (vm, "%U", format_arp_event, arp_event);
}));
+ vpe_client_registration_t *reg;
+ pool_foreach(reg, am->wc_ip4_arp_events_registrations,
+ ({
+ vlib_cli_output (vm, "pid %d: bd mac/ip4 binding events",
+ ntohl (reg->client_pid));
+ }));
+
pool_foreach (nd_event, am->nd_events,
({
vlib_cli_output (vm, "%U", format_nd_event, nd_event);
}));
+
+ pool_foreach(reg, am->wc_ip6_nd_events_registrations,
+ ({
+ vlib_cli_output (vm, "pid %d: bd mac/ip6 binding events",
+ ntohl (reg->client_pid));
+ }));
/* *INDENT-ON* */
return 0;
foreach_vl_msg_name_crc_memclnt;
foreach_vl_msg_name_crc_vpe;
#undef _
+
+#define vl_api_version_tuple(n,mj, mi, p) \
+ vl_msg_api_add_version (am, #n, mj, mi, p);
+#include <vpp/api/vpe_all_api_h.h>
+#undef vl_api_version_tuple
}