u16 vl_client_get_first_plugin_msg_id (char * plugin_name)
{
vl_api_get_first_msg_id_t * mp;
api_main_t * am = &api_main;
memory_client_main_t * mm = &memory_client_main;
f64 timeout;
void * old_handler;
clib_time_t clib_time;
u16 rv = ~0;
if (strlen(plugin_name) + 1 > sizeof (mp->name))
return (rv);
memset (&clib_time, 0, sizeof (clib_time));
clib_time_init (&clib_time);
/* Push this plugin's first_msg_id_reply handler */
old_handler = am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY];
am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = (void *)
vl_api_get_first_msg_id_reply_t_handler;
/* Ask the data-plane for the message-ID base of the indicated plugin */
mm->first_msg_id_reply_ready = 0;
mp = vl_msg_api_alloc (sizeof(*mp));
memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs(VL_API_GET_FIRST_MSG_ID);
mp->client_index = am->my_client_index;
strncpy ((char *) mp->name, plugin_name, sizeof (mp->name) - 1);
vl_msg_api_send_shmem (am->shmem_hdr->vl_input_queue, (u8 *)&mp);
/* Synchronously wait for the answer */
do {
timeout = clib_time_now (&clib_time) + 1.0;
while (clib_time_now (&clib_time) < timeout) {
if (mm->first_msg_id_reply_ready == 1) {
rv = mm->first_msg_id_reply;
goto result;
}
}
/* Restore old handler */
am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
return rv;
} while(0);
result:
/* Restore the old handler */
am->msg_handlers[VL_API_GET_FIRST_MSG_ID_REPLY] = old_handler;
if (rv == (u16) ~0)
clib_warning ("plugin '%s' not registered", plugin_name);
return rv;
}
void
ping (test_main_t * tm)
{
vl_api_control_ping_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_CONTROL_PING);
mp->client_index = tm->my_client_index;
mp->context = 0xdeadbeef;
vl_msg_api_send_shmem (tm->vl_input_queue, (u8 *) & mp);
}
/*
* WARNING: replicated pending api refactor completion
*/
static void
send_sw_interface_event_deleted (vpe_api_main_t * am,
vl_api_registration_t * reg, u32 sw_if_index)
{
vl_api_sw_interface_event_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_EVENT);
mp->sw_if_index = ntohl (sw_if_index);
mp->admin_up_down = 0;
mp->link_up_down = 0;
mp->deleted = 1;
vl_api_send_msg (reg, (u8 *) mp);
}
static void
send_udp_encap_details (const udp_encap_t * ue, vl_api_registration_t * reg,
u32 context)
{
vl_api_udp_encap_details_t *mp;
mp = vl_msg_api_alloc (sizeof (*mp));
clib_memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_UDP_ENCAP_DETAILS);
mp->context = context;
if (FIB_PROTOCOL_IP4 == ue->ue_ip_proto)
{
clib_memcpy (&mp->udp_encap.src_ip.un.ip4,
&ue->ue_hdrs.ip4.ue_ip4.src_address, 4);
clib_memcpy (&mp->udp_encap.dst_ip.un.ip4,
&ue->ue_hdrs.ip4.ue_ip4.dst_address, 4);
mp->udp_encap.dst_ip.af = clib_host_to_net_u32 (ADDRESS_IP4);
mp->udp_encap.src_ip.af = clib_host_to_net_u32 (ADDRESS_IP4);
/* ports aren't byte swapped because they are stored in network
* byte order */
mp->udp_encap.src_port = ue->ue_hdrs.ip4.ue_udp.src_port;
mp->udp_encap.dst_port = ue->ue_hdrs.ip4.ue_udp.dst_port;
}
else
{
clib_memcpy (&mp->udp_encap.src_ip.un.ip6,
&ue->ue_hdrs.ip6.ue_ip6.src_address, 16);
clib_memcpy (&mp->udp_encap.dst_ip.un.ip6,
&ue->ue_hdrs.ip6.ue_ip6.dst_address, 16);
mp->udp_encap.dst_ip.af = clib_host_to_net_u32 (ADDRESS_IP6);
mp->udp_encap.src_ip.af = clib_host_to_net_u32 (ADDRESS_IP6);
/* ports aren't byte swapped because they are stored in network
* byte order */
mp->udp_encap.src_port = ue->ue_hdrs.ip6.ue_udp.src_port;
mp->udp_encap.dst_port = ue->ue_hdrs.ip6.ue_udp.dst_port;
}
mp->udp_encap.table_id =
htonl (fib_table_get_table_id (ue->ue_fib_index, ue->ue_ip_proto));
mp->udp_encap.id = htonl (ue - udp_encap_pool);
vl_api_send_msg (reg, (u8 *) mp);
}
void vl_client_disconnect_from_vlib (void)
{
memory_client_main_t *mm = &memory_client_main;
api_main_t *am = &api_main;
uword junk;
if (mm->rx_thread_jmpbuf_valid) {
vl_api_rx_thread_exit_t *ep;
ep = vl_msg_api_alloc (sizeof (*ep));
ep->_vl_msg_id = ntohs(VL_API_RX_THREAD_EXIT);
vl_msg_api_send_shmem (am->vl_input_queue, (u8 *)&ep);
pthread_join (mm->rx_thread_handle, (void **) &junk);
}
if (mm->connected_to_vlib) {
vl_client_disconnect();
vl_client_api_unmap();
}
memset (mm, 0, sizeof (*mm));
}
static void send_vxlan_gbp_tunnel_details
(vxlan_gbp_tunnel_t * t, vl_api_registration_t * reg, u32 context)
{
vl_api_vxlan_gbp_tunnel_details_t *rmp;
ip46_type_t itype = (ip46_address_is_ip4 (&t->dst) ?
IP46_TYPE_IP4 : IP46_TYPE_IP6);
rmp = vl_msg_api_alloc (sizeof (*rmp));
clib_memset (rmp, 0, sizeof (*rmp));
rmp->_vl_msg_id = ntohs (VL_API_VXLAN_GBP_TUNNEL_DETAILS);
ip_address_encode (&t->src, itype, &rmp->tunnel.src);
ip_address_encode (&t->dst, itype, &rmp->tunnel.dst);
rmp->tunnel.encap_table_id =
fib_table_get_table_id (t->encap_fib_index, fib_proto_from_ip46 (itype));
rmp->tunnel.instance = htonl (t->user_instance);
rmp->tunnel.mcast_sw_if_index = htonl (t->mcast_sw_if_index);
rmp->tunnel.vni = htonl (t->vni);
rmp->tunnel.sw_if_index = htonl (t->sw_if_index);
rmp->context = context;
vl_api_send_msg (reg, (u8 *) rmp);
}
static uword
dhcp6_pd_reply_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
vlib_frame_t * f)
{
/* These cross the longjmp boundary (vlib_process_wait_for_event)
* and need to be volatile - to prevent them from being optimized into
* a register - which could change during suspension */
while (1)
{
vlib_process_wait_for_event (vm);
uword event_type = DHCP6_PD_DP_REPLY_REPORT;
void *event_data = vlib_process_get_event_data (vm, &event_type);
int i;
if (event_type == DHCP6_PD_DP_REPLY_REPORT)
{
prefix_report_t *events = event_data;
for (i = 0; i < vec_len (events); i++)
{
u32 event_size =
sizeof (vl_api_dhcp6_pd_reply_event_t) +
vec_len (events[i].prefixes) *
sizeof (vl_api_dhcp6_pd_prefix_info_t);
vl_api_dhcp6_pd_reply_event_t *event =
clib_mem_alloc (event_size);
clib_memset (event, 0, event_size);
event->sw_if_index = htonl (events[i].body.sw_if_index);
event->server_index = htonl (events[i].body.server_index);
event->msg_type = events[i].body.msg_type;
event->T1 = htonl (events[i].body.T1);
event->T2 = htonl (events[i].body.T2);
event->inner_status_code =
htons (events[i].body.inner_status_code);
event->status_code = htons (events[i].body.status_code);
event->preference = events[i].body.preference;
event->n_prefixes = htonl (vec_len (events[i].prefixes));
vl_api_dhcp6_pd_prefix_info_t *prefix =
(typeof (prefix)) event->prefixes;
u32 j;
for (j = 0; j < vec_len (events[i].prefixes); j++)
{
dhcp6_prefix_info_t *info = &events[i].prefixes[j];
memcpy (prefix->prefix, &info->prefix, 16);
prefix->prefix_length = info->prefix_length;
prefix->valid_time = htonl (info->valid_time);
prefix->preferred_time = htonl (info->preferred_time);
prefix++;
}
vec_free (events[i].prefixes);
dhcp6_pd_client_public_main_t *dpcpm =
&dhcp6_pd_client_public_main;
call_dhcp6_pd_reply_event_callbacks (event, dpcpm->functions);
vpe_client_registration_t *reg;
/* *INDENT-OFF* */
pool_foreach(reg, vpe_api_main.dhcp6_pd_reply_events_registrations,
({
vl_api_registration_t *vl_reg;
vl_reg =
vl_api_client_index_to_registration (reg->client_index);
if (vl_reg && vl_api_can_send_msg (vl_reg))
{
vl_api_dhcp6_pd_reply_event_t *msg =
vl_msg_api_alloc (event_size);
clib_memcpy (msg, event, event_size);
msg->_vl_msg_id = htons (VL_API_DHCP6_PD_REPLY_EVENT);
msg->client_index = reg->client_index;
msg->pid = reg->client_pid;
vl_api_send_msg (vl_reg, (u8 *) msg);
}
}));
/* *INDENT-ON* */
clib_mem_free (event);
}
}
