X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vpp%2Fapi%2Fapi.c;h=41f576025507671f58b60a922b3f4b1c47445716;hb=52fc44d61bcebb898dc19ab818ff60e617055694;hp=40cfa27bb11d25d6c8f71f5711cd49ab53e985a5;hpb=00bbf276be22fa0458366d4dd3f4daf4e55d13e7;p=vpp.git diff --git a/vpp/api/api.c b/vpp/api/api.c index 40cfa27bb11..41f57602550 100644 --- a/vpp/api/api.c +++ b/vpp/api/api.c @@ -42,6 +42,7 @@ #include #include +#include // alagalah TODO : committers please pay note, is this ok? #include #include #include @@ -64,12 +65,15 @@ #include #include #include +#include #include #include #include #include +#include #include #include +#include #undef BIHASH_TYPE #undef __included_bihash_template_h__ @@ -77,6 +81,7 @@ #if IPSEC > 0 #include +#include #endif /* IPSEC */ #if DPDK > 0 #include @@ -205,14 +210,6 @@ bad_tx_sw_if_index: \ #define foreach_vpe_api_msg \ _(WANT_INTERFACE_EVENTS, want_interface_events) \ -_(WANT_FROM_NETCONF_SERVER, want_from_netconf_server) \ -_(WANT_TO_NETCONF_SERVER, want_to_netconf_server) \ -_(WANT_FROM_NETCONF_CLIENT, want_from_netconf_client) \ -_(WANT_TO_NETCONF_CLIENT, want_to_netconf_client) \ -_(FROM_NETCONF_SERVER, from_netconf_server) \ -_(TO_NETCONF_SERVER, to_netconf_server) \ -_(FROM_NETCONF_CLIENT, from_netconf_client) \ -_(TO_NETCONF_CLIENT, to_netconf_client) \ _(WANT_OAM_EVENTS, want_oam_events) \ _(OAM_ADD_DEL, oam_add_del) \ _(SW_INTERFACE_DUMP, sw_interface_dump) \ @@ -277,6 +274,8 @@ _(L2TPV3_SET_LOOKUP_KEY, l2tpv3_set_lookup_key) \ _(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) \ @@ -301,6 +300,11 @@ _(IPSEC_INTERFACE_ADD_DEL_SPD, ipsec_interface_add_del_spd) \ _(IPSEC_SPD_ADD_DEL_ENTRY, ipsec_spd_add_del_entry) \ _(IPSEC_SAD_ADD_DEL_ENTRY, ipsec_sad_add_del_entry) \ _(IPSEC_SA_SET_KEY, ipsec_sa_set_key) \ +_(IKEV2_PROFILE_ADD_DEL, ikev2_profile_add_del) \ +_(IKEV2_PROFILE_SET_AUTH, ikev2_profile_set_auth) \ +_(IKEV2_PROFILE_SET_ID, ikev2_profile_set_id) \ +_(IKEV2_PROFILE_SET_TS, ikev2_profile_set_ts) \ +_(IKEV2_SET_LOCAL_KEY, ikev2_set_local_key) \ _(DELETE_LOOPBACK, delete_loopback) \ _(BD_IP_MAC_ADD_DEL, bd_ip_mac_add_del) \ _(MAP_ADD_DOMAIN, map_add_domain) \ @@ -312,7 +316,22 @@ _(MAP_SUMMARY_STATS, map_summary_stats) \ _(COP_INTERFACE_ENABLE_DISABLE, cop_interface_enable_disable) \ _(COP_WHITELIST_ENABLE_DISABLE, cop_whitelist_enable_disable) \ _(GET_NODE_GRAPH, get_node_graph) \ -_(SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats) +_(SW_INTERFACE_CLEAR_STATS, sw_interface_clear_stats) \ +_(TRACE_PROFILE_ADD, trace_profile_add) \ +_(TRACE_PROFILE_APPLY, trace_profile_apply) \ +_(TRACE_PROFILE_DEL, trace_profile_del) \ +_(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set) \ +_(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator) \ +_(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid) \ +_(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_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface) \ +_(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) \ +_(SR_MULTICAST_MAP_ADD_DEL, sr_multicast_map_add_del) #define QUOTE_(x) #x #define QUOTE(x) QUOTE_(x) @@ -549,10 +568,6 @@ reply: \ } pub_sub_handler (interface_events,INTERFACE_EVENTS) -pub_sub_handler (from_netconf_server,FROM_NETCONF_SERVER) -pub_sub_handler (to_netconf_server,TO_NETCONF_SERVER) -pub_sub_handler (from_netconf_client,FROM_NETCONF_CLIENT) -pub_sub_handler (to_netconf_client,TO_NETCONF_CLIENT) pub_sub_handler (oam_events,OAM_EVENTS) #define RESOLUTION_EVENT 1 @@ -591,7 +606,7 @@ void handle_ip4_arp_event (u32 pool_index) if (q->cursize < q->maxsize) { mp = vl_msg_api_alloc (sizeof (*mp)); - memcpy (mp, event, sizeof (*mp)); + clib_memcpy (mp, event, sizeof (*mp)); vl_msg_api_send_shmem (q, (u8 *)&mp); } else { static f64 last_time; @@ -834,7 +849,7 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) ntohl(mp->next_hop_sw_if_index))) return VNET_API_ERROR_NO_MATCHING_INTERFACE; - memcpy (next_hop_address.data, mp->next_hop_address, + clib_memcpy (next_hop_address.data, mp->next_hop_address, sizeof (next_hop_address.data)); /* Arp for the next_hop if necessary */ @@ -851,7 +866,7 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) pool_get (vam->pending_routes, pr); pr->resolve_type = RESOLVE_IP4_ADD_DEL_ROUTE; adr = &pr->r; - memcpy (adr, mp, sizeof (*adr)); + clib_memcpy (adr, mp, sizeof (*adr)); /* recursion block, "just in case" */ adr->resolve_if_needed = 0; adr->resolve_attempts = ntohl(mp->resolve_attempts); @@ -901,7 +916,7 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) } memset (&a, 0, sizeof (a)); - memcpy (a.dst_address.data, mp->dst_address, sizeof (a.dst_address.data)); + clib_memcpy (a.dst_address.data, mp->dst_address, sizeof (a.dst_address.data)); a.dst_address_length = mp->dst_address_length; @@ -925,8 +940,8 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) ip_adjacency_t cadj; memset(&cadj, 0, sizeof(cadj)); cadj.lookup_next_index = IP_LOOKUP_NEXT_CLASSIFY; - cadj.classify_table_index = ntohl(mp->classify_table_index); - if (pool_is_free_index (cm->tables, cadj.classify_table_index)) { + cadj.classify.table_index = ntohl(mp->classify_table_index); + if (pool_is_free_index (cm->tables, cadj.classify.table_index)) { dsunlock(sm); return VNET_API_ERROR_NO_SUCH_TABLE; } @@ -1029,7 +1044,7 @@ static int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) ntohl(mp->next_hop_sw_if_index))) return VNET_API_ERROR_NO_MATCHING_INTERFACE; - memcpy (next_hop_address.as_u8, mp->next_hop_address, + clib_memcpy (next_hop_address.as_u8, mp->next_hop_address, sizeof (next_hop_address.as_u8)); /* Arp for the next_hop if necessary */ @@ -1046,7 +1061,7 @@ static int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) pool_get (vam->pending_routes, pr); adr = &pr->r; pr->resolve_type = RESOLVE_IP6_ADD_DEL_ROUTE; - memcpy (adr, mp, sizeof (*adr)); + clib_memcpy (adr, mp, sizeof (*adr)); /* recursion block, "just in case" */ adr->resolve_if_needed = 0; adr->resolve_attempts = ntohl(mp->resolve_attempts); @@ -1095,7 +1110,7 @@ static int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) } memset (&a, 0, sizeof (a)); - memcpy (a.dst_address.as_u8, mp->dst_address, sizeof (a.dst_address.as_u8)); + clib_memcpy (a.dst_address.as_u8, mp->dst_address, sizeof (a.dst_address.as_u8)); a.dst_address_length = mp->dst_address_length; @@ -1203,7 +1218,7 @@ void api_config_default_ip_route (u8 is_ipv6, u8 is_add, u32 vrf_id, mp.is_ipv6 = is_ipv6; mp.next_hop_weight = 1; - memcpy (&mp.next_hop_address[0], next_hop_addr, 16); + clib_memcpy (&mp.next_hop_address[0], next_hop_addr, 16); if (is_ipv6) rv = ip6_add_del_route_t_handler (&mp); @@ -1855,6 +1870,11 @@ vl_api_create_subif_t_handler (vl_api_create_subif_t * mp) si = vnet_get_sup_sw_interface (vnm, ntohl(mp->sw_if_index)); hi = vnet_get_sup_hw_interface (vnm, ntohl(mp->sw_if_index)); + if (hi->bond_info == VNET_HW_INTERFACE_BOND_INFO_SLAVE) { + rv = VNET_API_ERROR_BOND_SLAVE_NOT_ALLOWED; + goto out; + } + sw_if_index = si->sw_if_index; sub_id = ntohl(mp->sub_id); @@ -2015,7 +2035,7 @@ static int mpls_ethernet_add_del_tunnel_2_t_handler pool_get (vam->pending_routes, pr); pr->resolve_type = RESOLVE_MPLS_ETHERNET_ADD_DEL; pme = &pr->t; - memcpy (pme, mp, sizeof (*pme)); + clib_memcpy (pme, mp, sizeof (*pme)); /* recursion block, "just in case" */ pme->resolve_if_needed = 0; pme->resolve_attempts = ntohl(mp->resolve_attempts); @@ -2198,7 +2218,7 @@ vl_api_ip_neighbor_add_del_t_handler (vl_api_ip_neighbor_add_del_t *mp, vlib_mai 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->mac_address, sizeof (mp->mac_address), mp->is_static); else rv = vnet_unset_ip6_ethernet_neighbor (vm, ntohl(mp->sw_if_index), @@ -2239,8 +2259,8 @@ vl_api_ip_neighbor_add_del_t_handler (vl_api_ip_neighbor_add_del_t *mp, vlib_mai } } - memcpy (&a.ethernet, mp->mac_address, 6); - memcpy (&a.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), @@ -2280,10 +2300,10 @@ vl_api_is_address_reachable_t_handler (vl_api_is_address_reachable_t *mp) } rmp = vl_msg_api_alloc (sizeof (*rmp)); - memcpy (rmp, mp, sizeof (*rmp)); + clib_memcpy (rmp, mp, sizeof (*rmp)); sw_if_index = mp->next_hop_sw_if_index; - memcpy (&addr, mp->address, sizeof (addr)); + clib_memcpy (&addr, mp->address, sizeof (addr)); if (mp->is_ipv6) { lm = &im6->lookup_main; adj_index = @@ -2413,7 +2433,8 @@ static void vl_api_sw_interface_clear_stats_t_handler ( static void send_sw_interface_details (vpe_api_main_t * am, unix_shared_memory_queue_t *q, vnet_sw_interface_t * swif, - u8 * interface_name) + u8 * interface_name, + u32 context) { vl_api_sw_interface_details_t * mp; vnet_hw_interface_t * hi; @@ -2434,6 +2455,7 @@ static void send_sw_interface_details (vpe_api_main_t * am, mp->link_speed = ((hi->flags & VNET_HW_INTERFACE_FLAG_SPEED_MASK) >> VNET_HW_INTERFACE_FLAG_SPEED_SHIFT); mp->link_mtu = ntohs(hi->max_packet_bytes); + mp->context = context; strncpy ((char *) mp->interface_name, (char *) interface_name, ARRAY_LEN(mp->interface_name)-1); @@ -2446,7 +2468,7 @@ static void send_sw_interface_details (vpe_api_main_t * am, ei = pool_elt_at_index (em->interfaces, hi->hw_instance); ASSERT (sizeof (mp->l2_address) >= sizeof (ei->address)); - memcpy (mp->l2_address, ei->address, sizeof (ei->address)); + clib_memcpy (mp->l2_address, ei->address, sizeof (ei->address)); mp->l2_address_length = ntohl(sizeof (ei->address)); } else if (swif->sup_sw_if_index != swif->sw_if_index) { vnet_sub_interface_t *sub = &swif->sub; @@ -2553,7 +2575,7 @@ static void vl_api_sw_interface_dump_t_handler ( if (mp->name_filter_valid == 0 || strcasestr((char *) name_string, (char *) filter_string)) { - send_sw_interface_details (am, q, swif, name_string); + send_sw_interface_details (am, q, swif, name_string, mp->context); send_sw_interface_flags (am, q, swif); } _vec_len (name_string) = 0; @@ -2576,7 +2598,7 @@ void send_oam_event (oam_target_t * t) if (q) { mp = vl_msg_api_alloc (sizeof (*mp)); mp->_vl_msg_id = ntohs (VL_API_OAM_EVENT); - memcpy (mp->dst_address, &t->dst_address, sizeof (mp->dst_address)); + clib_memcpy (mp->dst_address, &t->dst_address, sizeof (mp->dst_address)); mp->state = t->state; vl_msg_api_send_shmem (q, (u8 *)&mp); } @@ -2987,11 +3009,11 @@ void dhcp_compl_event_callback (u32 client_index, u32 pid, u8 * hostname, mp->client_index = client_index; mp->pid = pid; mp->is_ipv6 = is_ipv6; - memcpy (&mp->hostname, hostname, vec_len(hostname)); + clib_memcpy (&mp->hostname, hostname, vec_len(hostname)); mp->hostname[vec_len(hostname) + 1] = '\n'; - memcpy (&mp->host_address[0], host_address, 16); - memcpy (&mp->router_address[0], router_address, 16); - memcpy (&mp->host_mac[0], host_mac, 6); + clib_memcpy (&mp->host_address[0], host_address, 16); + clib_memcpy (&mp->router_address[0], router_address, 16); + clib_memcpy (&mp->host_mac[0], host_mac, 6); mp->_vl_msg_id = ntohs (VL_API_DHCP_COMPL_EVENT); @@ -3272,7 +3294,7 @@ static void shmem_cli_output (uword arg, u8 * buffer, uword buffer_bytes) vec_validate (shmem_vec, offset + buffer_bytes - 1); - memcpy (shmem_vec + offset, buffer, buffer_bytes); + clib_memcpy (shmem_vec + offset, buffer, buffer_bytes); svm_pop_heap (oldheap); pthread_mutex_unlock (&am->vlib_rp->mutex); @@ -3300,7 +3322,7 @@ static void vl_api_cli_request_t_handler rp->_vl_msg_id = ntohs(VL_API_CLI_REPLY); rp->context = mp->context; - unformat_init_vector (&input, (u8 *)mp->cmd_in_shmem); + unformat_init_vector (&input, (u8 *)(uword)mp->cmd_in_shmem); vlib_cli_input (vm, &input, shmem_cli_output, (uword)&shmem_vec); @@ -3369,17 +3391,25 @@ static void vl_api_sr_tunnel_add_del_t_handler 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++) { vec_add2 (segments, seg, 1); - memcpy (seg->as_u8, this_address->as_u8, sizeof (*this_address)); + clib_memcpy (seg->as_u8, this_address->as_u8, sizeof (*this_address)); this_address++; } for (i = 0; i < mp->n_tags; i++) { vec_add2 (tags, tag, 1); - memcpy (tag->as_u8, this_address->as_u8, sizeof (*this_address)); + clib_memcpy (tag->as_u8, this_address->as_u8, sizeof (*this_address)); this_address++; } @@ -3394,6 +3424,96 @@ out: #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)) + { + 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; + } + + rv = ip6_sr_add_del_multicastmap (a); + +out: + + REPLY_MACRO(VL_API_SR_MULTICAST_MAP_ADD_DEL_REPLY); +#endif +} + #define foreach_classify_add_del_table_field \ _(table_index) \ _(nbuckets) \ @@ -3675,7 +3795,8 @@ static void vl_api_sw_interface_vhost_user_details_t_handler ( #if DPDK > 0 static void send_sw_interface_vhost_user_details (vpe_api_main_t * am, unix_shared_memory_queue_t *q, - vhost_user_intf_details_t * vui) + vhost_user_intf_details_t * vui, + u32 context) { vl_api_sw_interface_vhost_user_details_t * mp; @@ -3688,6 +3809,7 @@ static void send_sw_interface_vhost_user_details (vpe_api_main_t * am, mp->is_server = vui->is_server; mp->num_regions = ntohl(vui->num_regions); mp->sock_errno = ntohl(vui->sock_errno); + mp->context = context; strncpy ((char *) mp->sock_filename, (char *) vui->sock_filename, ARRAY_LEN(mp->sock_filename)-1); @@ -3720,7 +3842,7 @@ vl_api_sw_interface_vhost_user_dump_t_handler ( return; vec_foreach (vuid, ifaces) { - send_sw_interface_vhost_user_details (am, q, vuid); + send_sw_interface_vhost_user_details (am, q, vuid, mp->context); } vec_free(ifaces); #endif @@ -3729,7 +3851,8 @@ vl_api_sw_interface_vhost_user_dump_t_handler ( static void send_sw_if_l2tpv3_tunnel_details (vpe_api_main_t * am, unix_shared_memory_queue_t *q, l2t_session_t *s, - l2t_main_t * lm) + l2t_main_t * lm, + u32 context) { vl_api_sw_if_l2tpv3_tunnel_details_t * mp; u8 * if_name = NULL; @@ -3751,9 +3874,10 @@ static void send_sw_if_l2tpv3_tunnel_details (vpe_api_main_t * am, mp->local_cookie[0] = s->local_cookie[0]; mp->local_cookie[1] = s->local_cookie[1]; mp->remote_cookie = s->remote_cookie; - memcpy(mp->client_address, &s->client_address, sizeof(s->client_address)); - memcpy(mp->our_address, &s->our_address, sizeof(s->our_address)); + clib_memcpy(mp->client_address, &s->client_address, sizeof(s->client_address)); + clib_memcpy(mp->our_address, &s->our_address, sizeof(s->our_address)); mp->l2_sublayer_present = s->l2_sublayer_present; + mp->context = context; vl_msg_api_send_shmem (q, (u8 *)&mp); } @@ -3771,7 +3895,7 @@ static void send_ip_address_details (vpe_api_main_t * am, mp->_vl_msg_id = ntohs(VL_API_IP_ADDRESS_DETAILS); if (is_ipv6) { - memcpy(&mp->ip, ip, sizeof(mp->ip)); + clib_memcpy(&mp->ip, ip, sizeof(mp->ip)); } else { u32 * tp = (u32 *)mp->ip; *tp = ntohl(*(u32*)ip); @@ -3851,7 +3975,7 @@ vl_api_sw_if_l2tpv3_tunnel_dump_t_handler ( pool_foreach (session, lm->sessions, ({ - send_sw_if_l2tpv3_tunnel_details (am, q, session, lm); + send_sw_if_l2tpv3_tunnel_details (am, q, session, lm, mp->context); })); } @@ -3937,7 +4061,8 @@ static void vl_api_l2_fib_table_entry_t_handler ( static void send_l2fib_table_entry (vpe_api_main_t * am, unix_shared_memory_queue_t *q, l2fib_entry_key_t * l2fe_key, - l2fib_entry_result_t * l2fe_res) + l2fib_entry_result_t * l2fe_res, + u32 context) { vl_api_l2_fib_table_entry_t * mp; @@ -3952,6 +4077,7 @@ static void send_l2fib_table_entry (vpe_api_main_t * am, mp->static_mac = l2fe_res->fields.static_mac; mp->filter_mac = l2fe_res->fields.filter; mp->bvi_mac = l2fe_res->fields.bvi; + mp->context = context; vl_msg_api_send_shmem (q, (u8 *)&mp); } @@ -3987,7 +4113,7 @@ vl_api_l2_fib_table_dump_t_handler (vl_api_l2_fib_table_dump_t *mp) vec_foreach_index (ni, l2fe_key) { send_l2fib_table_entry (am, q, vec_elt_at_index(l2fe_key, ni), - vec_elt_at_index(l2fe_res, ni)); + vec_elt_at_index(l2fe_res, ni), mp->context); } vec_free(l2fe_key); vec_free(l2fe_res); @@ -4173,13 +4299,25 @@ static void vl_api_vxlan_add_del_tunnel_t_handler } 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)) { + 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 = mp->src_address; - a->dst.as_u32 = mp->dst_address; + if (a->is_ip6) { + memcpy(&(a->src.ip6), mp->src_address, 16); + memcpy(&(a->dst.ip6), mp->dst_address, 16); + } else { + memcpy(&(a->src.ip4), mp->src_address, 4); + memcpy(&(a->dst.ip4), mp->dst_address, 4); + } a->encap_fib_index = encap_fib_index; a->decap_next_index = ntohl(mp->decap_next_index); @@ -4197,17 +4335,26 @@ static void send_vxlan_tunnel_details (vxlan_tunnel_t * t, unix_shared_memory_queue_t * q) { vl_api_vxlan_tunnel_details_t * rmp; - ip4_main_t * im = &ip4_main; + ip4_main_t * im4 = &ip4_main; + ip6_main_t * im6 = &ip6_main; + u8 is_ipv6 = !(t->flags & VXLAN_TUNNEL_IS_IPV4); rmp = vl_msg_api_alloc (sizeof (*rmp)); memset (rmp, 0, sizeof (*rmp)); rmp->_vl_msg_id = ntohs(VL_API_VXLAN_TUNNEL_DETAILS); - rmp->src_address = t->src.data_u32; - rmp->dst_address = t->dst.data_u32; - rmp->encap_vrf_id = htonl(im->fibs[t->encap_fib_index].table_id); + if (is_ipv6) { + memcpy(rmp->src_address, &(t->src.ip6), 16); + memcpy(rmp->dst_address, &(t->dst.ip6), 16); + rmp->encap_vrf_id = htonl(im6->fibs[t->encap_fib_index].table_id); + } else { + memcpy(rmp->src_address, &(t->src.ip4), 4); + memcpy(rmp->dst_address, &(t->dst.ip4), 4); + rmp->encap_vrf_id = htonl(im4->fibs[t->encap_fib_index].table_id); + } rmp->vni = htonl(t->vni); rmp->decap_next_index = htonl(t->decap_next_index); rmp->sw_if_index = htonl(t->sw_if_index); + rmp->is_ipv6 = is_ipv6; vl_msg_api_send_shmem (q, (u8 *)&rmp); } @@ -4242,6 +4389,95 @@ static void vl_api_vxlan_tunnel_dump_t_handler } } +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) +{ + 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); + + 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); + })); + } 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); + } +} + static void vl_api_l2_patch_add_del_t_handler (vl_api_l2_patch_add_del_t *mp) { @@ -4451,7 +4687,7 @@ vl_api_lisp_gpe_add_del_tunnel_t_handler a->ver_res = mp->ver_res; a->res = mp->res; a->next_protocol = mp->next_protocol; - a->iid = clib_net_to_host_u32 (mp->iid); + a->vni = clib_net_to_host_u32 (mp->iid); rv = vnet_lisp_gpe_add_del_tunnel (a, &sw_if_index); @@ -4462,6 +4698,454 @@ out: })); } +static void +vl_api_lisp_add_del_locator_set_t_handler(vl_api_lisp_add_del_locator_set_t *mp) +{ + vl_api_lisp_add_del_locator_set_reply_t *rmp; + int rv = 0; + vnet_lisp_add_del_locator_set_args_t _a, *a = &_a; + u32 ls_index = ~0; + u8 *locator_name = NULL; + + memset(a, 0, sizeof(a[0])); + + locator_name = format(0, "%s", mp->locator_set_name); + + a->name = locator_name; + a->locators = NULL; + a->is_add = mp->is_add; + a->local = 1; + + rv = vnet_lisp_add_del_locator_set_name(a, &ls_index); + + vec_free(locator_name); + + REPLY_MACRO(VL_API_LISP_ADD_DEL_LOCATOR_SET_REPLY); +} + +static void +vl_api_lisp_add_del_locator_t_handler( + vl_api_lisp_add_del_locator_t *mp) +{ + vl_api_lisp_add_del_locator_reply_t *rmp; + int rv = 0; + locator_t locator, *locators = NULL; + vnet_lisp_add_del_locator_set_args_t _a, *a = &_a; + u32 ls_index = ~0; + u8 *locator_name = NULL; + + memset(&locator, 0, sizeof(locator)); + memset(a, 0, sizeof(a[0])); + + locator.sw_if_index = ntohl(mp->sw_if_index); + locator.priority = mp->priority; + locator.weight = mp->weight; + locator.local = 1; + vec_add1(locators, locator); + + locator_name = format(0, "%s", mp->locator_set_name); + + a->name = locator_name; + a->locators = locators; + a->is_add = mp->is_add; + a->local = 1; + + rv = vnet_lisp_add_del_locator(a, &ls_index); + + vec_free(locators); + vec_free(locator_name); + + REPLY_MACRO(VL_API_LISP_ADD_DEL_LOCATOR_REPLY); +} + +static void +vl_api_lisp_add_del_local_eid_t_handler( + vl_api_lisp_add_del_local_eid_t *mp) +{ + vl_api_lisp_add_del_local_eid_reply_t *rmp; + lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); + int rv = 0; + ip_prefix_t *prefp = NULL; + ip_address_t *ip_eid = NULL; + gid_address_t eid; + uword * p = NULL; + u32 locator_set_index = ~0, map_index = ~0; + vnet_lisp_add_del_mapping_args_t _a, *a = &_a; + u8 *name = NULL; + + prefp = &gid_address_ippref(&eid); + ip_eid = &ip_prefix_addr(prefp); + gid_address_type (&eid) = GID_ADDR_IP_PREFIX; + + if (mp->is_ipv6) { + clib_memcpy(&ip_addr_v6(ip_eid), mp->ip_address, + sizeof(ip_addr_v6(ip_eid))); + ip_addr_version(ip_eid) = IP6; + } else { + clib_memcpy(&ip_addr_v4(ip_eid), mp->ip_address, + sizeof(ip_addr_v4(ip_eid))); + ip_addr_version(ip_eid) = IP4; + } + ip_prefix_len(prefp) = mp->prefix_len; + + name = format(0, "%s", mp->locator_set_name); + p = hash_get_mem(lcm->locator_set_index_by_name, name); + if (!p) { + rv = VNET_API_ERROR_INVALID_VALUE; + goto out; + } + locator_set_index = p[0]; + + /* XXX treat batch configuration */ + a->is_add = mp->is_add; + a->deid = eid; + a->locator_set_index = locator_set_index; + a->local = 1; + + rv = vnet_lisp_add_del_local_mapping(a, &map_index); + +out: + vec_free(name); + + REPLY_MACRO(VL_API_LISP_ADD_DEL_LOCAL_EID_REPLY); +} + +static void +lisp_gpe_add_del_fwd_entry_set_address( + vl_api_lisp_gpe_add_del_fwd_entry_t *mp, + ip_address_t *slocator, + ip_address_t *dlocator, + gid_address_t *eid) +{ + ip_address_t *ip_eid = NULL; + ip_prefix_t *prefp = NULL; + + prefp = &gid_address_ippref(eid); + ip_eid = &ip_prefix_addr(prefp); + + if (mp->eid_is_ipv6) { + clib_memcpy(&ip_addr_v6(ip_eid), mp->eid_ip_address, + sizeof(ip_addr_v6(ip_eid))); + ip_addr_version(ip_eid) = IP6; + } else { + clib_memcpy(&ip_addr_v4(ip_eid), mp->eid_ip_address, + sizeof(ip_addr_v4(ip_eid))); + ip_addr_version(ip_eid) = IP4; + } + ip_prefix_len(prefp) = mp->eid_prefix_len; + + if (mp->address_is_ipv6) { + clib_memcpy(&ip_addr_v6(slocator), mp->source_ip_address, + sizeof(ip_addr_v6(slocator))); + ip_addr_version(slocator) = IP6; + clib_memcpy(&ip_addr_v6(dlocator), mp->destination_ip_address, + sizeof(ip_addr_v6(dlocator))); + ip_addr_version(dlocator) = IP6; + } else { + clib_memcpy(&ip_addr_v4(slocator), mp->source_ip_address, + sizeof(ip_addr_v4(slocator))); + ip_addr_version(slocator) = IP4; + clib_memcpy(&ip_addr_v4(dlocator), mp->destination_ip_address, + sizeof(ip_addr_v4(dlocator))); + ip_addr_version(dlocator) = IP4; + } +} + +static void +vl_api_lisp_gpe_add_del_fwd_entry_t_handler( + vl_api_lisp_gpe_add_del_fwd_entry_t *mp) +{ + 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; + + lisp_gpe_add_del_fwd_entry_set_address(mp, &slocator, &dlocator, &eid); + + memset (&a, 0, sizeof(a)); + + a.is_add = mp->is_add; + 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); +} + +static void +vl_api_lisp_add_del_map_resolver_t_handler( + vl_api_lisp_add_del_map_resolver_t *mp) +{ + vl_api_lisp_add_del_map_resolver_reply_t *rmp; + int rv = 0; + ip_address_t *ip_addr = NULL; + vnet_lisp_add_del_map_resolver_args_t _a, * a = &_a; + + a->is_add = mp->is_add; + ip_addr = &a->address; + + if (mp->is_ipv6) { + clib_memcpy(&ip_addr_v6(ip_addr), mp->ip_address, + sizeof(ip_addr_v6(ip_addr))); + ip_addr_version(ip_addr) = IP6; + } else { + clib_memcpy(&ip_addr_v4(ip_addr), mp->ip_address, + sizeof(ip_addr_v4(ip_addr))); + ip_addr_version(ip_addr) = IP4; + } + + rv = vnet_lisp_add_del_map_resolver (a); + + REPLY_MACRO(VL_API_LISP_ADD_DEL_MAP_RESOLVER_REPLY); +} + +static void +vl_api_lisp_gpe_enable_disable_t_handler( + vl_api_lisp_gpe_enable_disable_t *mp) +{ + vl_api_lisp_gpe_enable_disable_reply_t *rmp; + int rv = 0; + vnet_lisp_gpe_enable_disable_args_t _a, * a = &_a; + + a->is_en = mp->is_en; + vnet_lisp_gpe_enable_disable (a); + + REPLY_MACRO(VL_API_LISP_GPE_ENABLE_DISABLE_REPLY); +} + +static void +vl_api_lisp_gpe_add_del_iface_t_handler( + vl_api_lisp_gpe_add_del_iface_t *mp) +{ + vl_api_lisp_gpe_add_del_iface_reply_t *rmp; + int rv = 0; + vnet_lisp_gpe_add_del_iface_args_t _a, * a = &_a; + + a->is_add = mp->is_add; + a->table_id = mp->table_id; + a->vni = mp->vni; + vnet_lisp_gpe_add_del_iface (a, 0); + + 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) +{ + vl_api_lisp_locator_set_details_t *rmp; + locator_t *loc = NULL; + u32 * locit = 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->priority = loc->priority; + rmp->weight = loc->weight; + + vl_msg_api_send_shmem (q, (u8 *)&rmp); + } +} + +static void +vl_api_lisp_locator_set_dump_t_handler (vl_api_lisp_locator_set_dump_t *mp) +{ + unix_shared_memory_queue_t * q = NULL; + lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); + locator_set_t * lsit = NULL; + + q = vl_api_client_index_to_input_queue (mp->client_index); + if (q == 0) { + return; + } + + pool_foreach (lsit, lcm->locator_set_pool, + ({ + send_lisp_locator_set_details(lcm, lsit, q); + })); +} + +static void +send_lisp_local_eid_table_details (mapping_t *mapit, + unix_shared_memory_queue_t *q) +{ + 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 type = ~0; + + ls = pool_elt_at_index (lcm->locator_set_pool, + mapit->locator_set_index); + + gid = &mapit->eid; + type = gid_address_type(gid); + + if (type != GID_ADDR_IP_PREFIX) { + return; + } + + ip_prefix = &gid_address_ippref(gid); + + 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); + + switch (ip_prefix_version(ip_prefix)) { + case IP4: + rmp->eid_is_ipv6 = 0; + clib_memcpy(rmp->eid_ip_address, &ip_prefix_v4(ip_prefix), + sizeof(ip_prefix_v4(ip_prefix))); + break; + + case IP6: + rmp->eid_is_ipv6 = 1; + clib_memcpy(rmp->eid_ip_address, &ip_prefix_v6(ip_prefix), + sizeof(ip_prefix_v6(ip_prefix))); + break; + + default: + ASSERT(0); + } + rmp->eid_prefix_len = ip_prefix_len(ip_prefix); + + vl_msg_api_send_shmem (q, (u8 *)&rmp); +} + +static void +vl_api_lisp_local_eid_table_dump_t_handler ( + vl_api_lisp_local_eid_table_dump_t *mp) +{ + unix_shared_memory_queue_t * q = NULL; + lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); + mapping_t * mapit = NULL; + + q = vl_api_client_index_to_input_queue (mp->client_index); + if (q == 0) { + return; + } + + pool_foreach (mapit, lcm->mapping_pool, + ({ + send_lisp_local_eid_table_details(mapit, q); + })); +} + +static void +send_lisp_gpe_tunnel_details (lisp_gpe_tunnel_t *tunnel, + unix_shared_memory_queue_t *q) +{ + vl_api_lisp_gpe_tunnel_details_t *rmp; + lisp_gpe_main_t * lgm = &lisp_gpe_main; + + rmp = vl_msg_api_alloc (sizeof (*rmp)); + memset (rmp, 0, sizeof (*rmp)); + rmp->_vl_msg_id = ntohs(VL_API_LISP_GPE_TUNNEL_DETAILS); + + rmp->tunnels = tunnel - lgm->tunnels; + + rmp->is_ipv6 = ip_addr_version(&tunnel->src) == IP6 ? 1 : 0; + ip_address_copy_addr(rmp->source_ip, &tunnel->src); + ip_address_copy_addr(rmp->destination_ip, &tunnel->dst); + + rmp->encap_fib_id = htonl(tunnel->encap_fib_index); + rmp->decap_fib_id = htonl(tunnel->decap_fib_index); + rmp->dcap_next = htonl(tunnel->decap_next_index); + rmp->lisp_ver = tunnel->ver_res; + rmp->next_protocol = tunnel->next_protocol; + rmp->flags = tunnel->flags; + rmp->ver_res = tunnel->ver_res; + rmp->res = tunnel->res; + rmp->iid = htonl(tunnel->vni); + + vl_msg_api_send_shmem (q, (u8 *)&rmp); +} + +static void +vl_api_lisp_gpe_tunnel_dump_t_handler ( + vl_api_lisp_local_eid_table_dump_t *mp) +{ + unix_shared_memory_queue_t * q = NULL; + lisp_gpe_main_t * lgm = &lisp_gpe_main; + lisp_gpe_tunnel_t * tunnel = NULL; + + if (pool_elts(lgm->tunnels) == 0) { + return; + } + + q = vl_api_client_index_to_input_queue (mp->client_index); + if (q == 0) { + return; + } + + pool_foreach(tunnel, lgm->tunnels, + ({ + send_lisp_gpe_tunnel_details(tunnel, q); + })); +} + +static void +send_lisp_map_resolver_details (ip_address_t *ip, + unix_shared_memory_queue_t *q) +{ + vl_api_lisp_map_resolver_details_t *rmp = NULL; + + rmp = vl_msg_api_alloc (sizeof (*rmp)); + memset (rmp, 0, sizeof (*rmp)); + rmp->_vl_msg_id = ntohs(VL_API_LISP_MAP_RESOLVER_DETAILS); + + switch (ip_addr_version(ip)) { + case IP4: + rmp->is_ipv6 = 0; + clib_memcpy(rmp->ip_address, &ip_addr_v4(ip), sizeof(ip_addr_v4(ip))); + break; + + case IP6: + rmp->is_ipv6 = 1; + clib_memcpy(rmp->ip_address, &ip_addr_v6(ip), sizeof(ip_addr_v6(ip))); + break; + + default: + ASSERT(0); + } + + vl_msg_api_send_shmem (q, (u8 *)&rmp); +} + +static void +vl_api_lisp_map_resolver_dump_t_handler ( + vl_api_lisp_local_eid_table_dump_t *mp) +{ + unix_shared_memory_queue_t * q = NULL; + lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); + ip_address_t *ip = NULL; + + q = vl_api_client_index_to_input_queue (mp->client_index); + if (q == 0) { + return; + } + + vec_foreach(ip, lcm->map_resolvers) { + send_lisp_map_resolver_details(ip, q); + } + +} + static void vl_api_interface_name_renumber_t_handler (vl_api_interface_name_renumber_t *mp) { @@ -4492,7 +5176,7 @@ static int arp_change_data_callback (u32 pool_index, u8 * new_mac, event = pool_elt_at_index (am->arp_events, pool_index); if (memcmp (&event->new_mac, new_mac, sizeof (event->new_mac))) { - memcpy (event->new_mac, new_mac, sizeof(event->new_mac)); + clib_memcpy (event->new_mac, new_mac, sizeof(event->new_mac)); } else { /* same mac */ if ((sw_if_index == event->sw_if_index) && ((address == 0) || @@ -4615,7 +5299,7 @@ static void vl_api_ipsec_interface_add_del_spd_t_handler VALIDATE_SW_IF_INDEX(mp); -#if IPSEC > 0 +#if IPSEC > 0 rv = ipsec_set_interface_spd(vm, sw_if_index, spd_id, mp->is_add); #else rv = VNET_API_ERROR_UNIMPLEMENTED; @@ -4633,18 +5317,20 @@ static void vl_api_ipsec_spd_add_del_entry_t_handler vl_api_ipsec_spd_add_del_entry_reply_t * rmp; int rv; -#if IPSEC > 0 +#if IPSEC > 0 ipsec_policy_t p; + memset(&p, 0, sizeof(p)); + p.id = ntohl(mp->spd_id); p.priority = ntohl(mp->priority); p.is_outbound = mp->is_outbound; p.is_ipv6 = mp->is_ipv6; - memcpy(&p.raddr.start, mp->remote_address_start, 16); - memcpy(&p.raddr.stop, mp->remote_address_stop, 16); - memcpy(&p.laddr.start, mp->local_address_start, 16); - memcpy(&p.laddr.stop, mp->local_address_stop, 16); + clib_memcpy(&p.raddr.start, mp->remote_address_start, 16); + clib_memcpy(&p.raddr.stop, mp->remote_address_stop, 16); + clib_memcpy(&p.laddr.start, mp->local_address_start, 16); + clib_memcpy(&p.laddr.stop, mp->local_address_stop, 16); p.protocol = mp->protocol; p.rport.start = ntohs(mp->remote_port_start); @@ -4686,6 +5372,8 @@ static void vl_api_ipsec_sad_add_del_entry_t_handler #if IPSEC > 0 ipsec_sa_t sa; + memset(&sa, 0, sizeof(sa)); + sa.id = ntohl(mp->sad_id); sa.spi = ntohl(mp->spi); /* security protocol AH unsupported */ @@ -4698,14 +5386,14 @@ static void vl_api_ipsec_sad_add_del_entry_t_handler /* check for unsupported crypto-alg */ if (mp->crypto_algorithm < IPSEC_CRYPTO_ALG_AES_CBC_128 || mp->crypto_algorithm > IPSEC_CRYPTO_ALG_AES_CBC_256) { - clib_warning("unsupported crypto-alg: '%U'", format_ipsec_crypto_alg, + clib_warning("unsupported crypto-alg: '%U'", format_ipsec_crypto_alg, mp->crypto_algorithm); rv = VNET_API_ERROR_UNIMPLEMENTED; goto out; } sa.crypto_alg = mp->crypto_algorithm; sa.crypto_key_len = mp->crypto_key_length; - memcpy(&sa.crypto_key, mp->crypto_key, sizeof(sa.crypto_key)); + clib_memcpy(&sa.crypto_key, mp->crypto_key, sizeof(sa.crypto_key)); /* check for unsupported integ-alg */ if (mp->integrity_algorithm < IPSEC_INTEG_ALG_SHA1_96 || mp->integrity_algorithm > IPSEC_INTEG_ALG_SHA_512_256) { @@ -4716,12 +5404,12 @@ static void vl_api_ipsec_sad_add_del_entry_t_handler } sa.integ_alg = mp->integrity_algorithm; sa.integ_key_len = mp->integrity_key_length; - memcpy(&sa.integ_key, mp->integrity_key, sizeof(sa.integ_key)); + clib_memcpy(&sa.integ_key, mp->integrity_key, sizeof(sa.integ_key)); sa.use_esn = mp->use_extended_sequence_number; sa.is_tunnel = mp->is_tunnel; sa.is_tunnel_ip6 = mp->is_tunnel_ipv6; - memcpy(&sa.tunnel_src_addr, mp->tunnel_src_address, 16); - memcpy(&sa.tunnel_dst_addr, mp->tunnel_dst_address, 16); + clib_memcpy(&sa.tunnel_src_addr, mp->tunnel_src_address, 16); + clib_memcpy(&sa.tunnel_dst_addr, mp->tunnel_dst_address, 16); rv = ipsec_add_del_sa(vm, &sa, mp->is_add); #else @@ -4732,6 +5420,124 @@ static void vl_api_ipsec_sad_add_del_entry_t_handler out: REPLY_MACRO(VL_API_IPSEC_SAD_ADD_DEL_ENTRY_REPLY); } + +static void +vl_api_ikev2_profile_add_del_t_handler +(vl_api_ikev2_profile_add_del_t * mp) +{ + vl_api_ikev2_profile_add_del_reply_t * rmp; + int rv = 0; + +#if IPSEC > 0 + vlib_main_t * vm = vlib_get_main(); + clib_error_t * error; + u8 * tmp = format(0, "%s", mp->name); + error = ikev2_add_del_profile(vm, tmp, mp->is_add); + vec_free (tmp); + if (error) + rv = VNET_API_ERROR_UNSPECIFIED; +#else + rv = VNET_API_ERROR_UNIMPLEMENTED; +#endif + + REPLY_MACRO(VL_API_IKEV2_PROFILE_ADD_DEL_REPLY); +} + +static void +vl_api_ikev2_profile_set_auth_t_handler +(vl_api_ikev2_profile_set_auth_t * mp) +{ + vl_api_ikev2_profile_set_auth_reply_t * rmp; + int rv = 0; + +#if IPSEC > 0 + vlib_main_t * vm = vlib_get_main(); + clib_error_t * error; + u8 * tmp = format(0, "%s", mp->name); + u8 * data = vec_new (u8, mp->data_len); + clib_memcpy(data, mp->data, mp->data_len); + error = ikev2_set_profile_auth(vm, tmp, mp->auth_method, data, mp->is_hex); + vec_free (tmp); + vec_free (data); + if (error) + rv = VNET_API_ERROR_UNSPECIFIED; +#else + rv = VNET_API_ERROR_UNIMPLEMENTED; +#endif + + REPLY_MACRO(VL_API_IKEV2_PROFILE_SET_AUTH_REPLY); +} + +static void +vl_api_ikev2_profile_set_id_t_handler +(vl_api_ikev2_profile_set_id_t * mp) +{ + vl_api_ikev2_profile_add_del_reply_t * rmp; + int rv = 0; + +#if IPSEC > 0 + vlib_main_t * vm = vlib_get_main(); + clib_error_t * error; + u8 * tmp = format(0, "%s", mp->name); + u8 * data = vec_new (u8, mp->data_len); + clib_memcpy(data, mp->data, mp->data_len); + error = ikev2_set_profile_id(vm, tmp, mp->id_type, data, mp->is_local); + vec_free (tmp); + vec_free (data); + if (error) + rv = VNET_API_ERROR_UNSPECIFIED; +#else + rv = VNET_API_ERROR_UNIMPLEMENTED; +#endif + + REPLY_MACRO(VL_API_IKEV2_PROFILE_SET_ID_REPLY); +} + +static void +vl_api_ikev2_profile_set_ts_t_handler +(vl_api_ikev2_profile_set_ts_t * mp) +{ + vl_api_ikev2_profile_set_ts_reply_t * rmp; + int rv = 0; + +#if IPSEC > 0 + vlib_main_t * vm = vlib_get_main(); + clib_error_t * error; + u8 * tmp = format(0, "%s", mp->name); + error = ikev2_set_profile_ts(vm, tmp, mp->proto, mp->start_port, + mp->end_port, (ip4_address_t) mp->start_addr, + (ip4_address_t) mp->end_addr, mp->is_local); + vec_free (tmp); + if (error) + rv = VNET_API_ERROR_UNSPECIFIED; +#else + rv = VNET_API_ERROR_UNIMPLEMENTED; +#endif + + REPLY_MACRO(VL_API_IKEV2_PROFILE_SET_TS_REPLY); +} + +static void +vl_api_ikev2_set_local_key_t_handler +(vl_api_ikev2_set_local_key_t * mp) +{ + vl_api_ikev2_profile_set_ts_reply_t * rmp; + int rv = 0; + +#if IPSEC > 0 + vlib_main_t * vm = vlib_get_main(); + clib_error_t * error; + + error = ikev2_set_local_key(vm, mp->key_file); + if (error) + rv = VNET_API_ERROR_UNSPECIFIED; +#else + rv = VNET_API_ERROR_UNIMPLEMENTED; +#endif + + REPLY_MACRO(VL_API_IKEV2_SET_LOCAL_KEY_REPLY); +} + static void vl_api_map_add_domain_t_handler (vl_api_map_add_domain_t * mp) @@ -4793,21 +5599,22 @@ vl_api_map_domain_dump_t_handler } pool_foreach(d, mm->domains, ({ + /* Make sure every field is initiated (or don't skip the memset()) */ rmp = vl_msg_api_alloc (sizeof (*rmp)); - memset (rmp, 0, sizeof (*rmp)); rmp->_vl_msg_id = ntohs(VL_API_MAP_DOMAIN_DETAILS); rmp->domain_index = htonl(d - mm->domains); rmp->ea_bits_len = d->ea_bits_len; rmp->psid_offset = d->psid_offset; rmp->psid_length = d->psid_length; - memcpy(rmp->ip4_prefix, &d->ip4_prefix, sizeof(rmp->ip4_prefix)); + clib_memcpy(rmp->ip4_prefix, &d->ip4_prefix, sizeof(rmp->ip4_prefix)); rmp->ip4_prefix_len = d->ip4_prefix_len; - memcpy(rmp->ip6_prefix, &d->ip6_prefix, sizeof(rmp->ip6_prefix)); + clib_memcpy(rmp->ip6_prefix, &d->ip6_prefix, sizeof(rmp->ip6_prefix)); rmp->ip6_prefix_len = d->ip6_prefix_len; - memcpy(rmp->ip6_src, &d->ip6_src, sizeof(rmp->ip6_src)); + clib_memcpy(rmp->ip6_src, &d->ip6_src, sizeof(rmp->ip6_src)); rmp->ip6_src_len = d->ip6_src_len; rmp->mtu = htons(d->mtu); rmp->is_translation = (d->flags & MAP_DOMAIN_TRANSLATION); + rmp->context = mp->context; vl_msg_api_send_shmem (q, (u8 *)&rmp); })); @@ -4847,7 +5654,8 @@ vl_api_map_rule_dump_t_handler memset(rmp, 0, sizeof(*rmp)); rmp->_vl_msg_id = ntohs(VL_API_MAP_RULE_DETAILS); rmp->psid = htons(i); - memcpy(rmp->ip6_dst, &dst, sizeof(rmp->ip6_dst)); + clib_memcpy(rmp->ip6_dst, &dst, sizeof(rmp->ip6_dst)); + rmp->context = mp->context; vl_msg_api_send_shmem(q, (u8 *)&rmp); } } @@ -4890,15 +5698,15 @@ vl_api_map_summary_stats_t_handler ( map_domain_counter_unlock (mm); - /* Note: in HOST byte order! */ - rmp->total_pkts[MAP_DOMAIN_COUNTER_RX] = total_pkts[MAP_DOMAIN_COUNTER_RX]; - rmp->total_bytes[MAP_DOMAIN_COUNTER_RX] = total_bytes[MAP_DOMAIN_COUNTER_RX]; - rmp->total_pkts[MAP_DOMAIN_COUNTER_TX] = total_pkts[MAP_DOMAIN_COUNTER_TX]; - rmp->total_bytes[MAP_DOMAIN_COUNTER_TX] = total_bytes[MAP_DOMAIN_COUNTER_TX]; - rmp->total_bindings = pool_elts(mm->domains); + /* Note: in network byte order! */ + rmp->total_pkts[MAP_DOMAIN_COUNTER_RX] = clib_host_to_net_u64(total_pkts[MAP_DOMAIN_COUNTER_RX]); + rmp->total_bytes[MAP_DOMAIN_COUNTER_RX] = clib_host_to_net_u64(total_bytes[MAP_DOMAIN_COUNTER_RX]); + rmp->total_pkts[MAP_DOMAIN_COUNTER_TX] = clib_host_to_net_u64(total_pkts[MAP_DOMAIN_COUNTER_TX]); + rmp->total_bytes[MAP_DOMAIN_COUNTER_TX] = clib_host_to_net_u64(total_bytes[MAP_DOMAIN_COUNTER_TX]); + rmp->total_bindings = clib_host_to_net_u64(pool_elts(mm->domains)); rmp->total_ip4_fragments = 0; // Not yet implemented. Should be a simple counter. - rmp->total_security_check[MAP_DOMAIN_COUNTER_TX] = map_error_counter_get(ip4_map_node.index, MAP_ERROR_ENCAP_SEC_CHECK); - rmp->total_security_check[MAP_DOMAIN_COUNTER_RX] = map_error_counter_get(ip4_map_node.index, MAP_ERROR_DECAP_SEC_CHECK); + rmp->total_security_check[MAP_DOMAIN_COUNTER_TX] = clib_host_to_net_u64(map_error_counter_get(ip4_map_node.index, MAP_ERROR_ENCAP_SEC_CHECK)); + rmp->total_security_check[MAP_DOMAIN_COUNTER_RX] = clib_host_to_net_u64(map_error_counter_get(ip4_map_node.index, MAP_ERROR_DECAP_SEC_CHECK)); vl_msg_api_send_shmem(q, (u8 *)&rmp); } @@ -4913,9 +5721,9 @@ static void vl_api_ipsec_sa_set_key_t_handler ipsec_sa_t sa; sa.id = ntohl(mp->sa_id); sa.crypto_key_len = mp->crypto_key_length; - memcpy(&sa.crypto_key, mp->crypto_key, sizeof(sa.crypto_key)); + clib_memcpy(&sa.crypto_key, mp->crypto_key, sizeof(sa.crypto_key)); sa.integ_key_len = mp->integrity_key_length; - memcpy(&sa.integ_key, mp->integrity_key, sizeof(sa.integ_key)); + clib_memcpy(&sa.integ_key, mp->integrity_key, sizeof(sa.integ_key)); rv = ipsec_set_sa_key(vm, &sa); #else @@ -4997,6 +5805,63 @@ static void vl_api_get_node_graph_t_handler rmp->reply_in_shmem = (uword) vector); } +static void vl_api_trace_profile_add_t_handler +(vl_api_trace_profile_add_t *mp) +{ + int rv = 0; + vl_api_trace_profile_add_reply_t * rmp; + clib_error_t *error; + + /* Ignoring the profile id as currently a single profile + * is supported */ + error = ip6_ioam_trace_profile_set(mp->trace_num_elt, mp->trace_type, + ntohl(mp->node_id), ntohl(mp->trace_app_data), + mp->pow_enable, mp->trace_tsp, + mp->trace_ppc); + if (error) { + clib_error_report(error); + rv = clib_error_get_code(error); + } + + REPLY_MACRO(VL_API_TRACE_PROFILE_ADD_REPLY); +} + +static void vl_api_trace_profile_apply_t_handler +(vl_api_trace_profile_apply_t *mp) +{ + int rv = 0; + vl_api_trace_profile_apply_reply_t * rmp; + + if (mp->enable != 0) { + rv = ip6_ioam_set_destination ((ip6_address_t *)(&mp->dest_ipv6), + ntohl(mp->prefix_length), + ntohl(mp->vrf_id), + mp->trace_op == IOAM_HBYH_ADD, + mp->trace_op == IOAM_HBYH_POP, + mp->trace_op == IOAM_HBYH_MOD); + } else { + //ip6_ioam_clear_destination(&ip6, mp->prefix_length, mp->vrf_id); + } + REPLY_MACRO(VL_API_TRACE_PROFILE_APPLY_REPLY); +} + +static void vl_api_trace_profile_del_t_handler +(vl_api_trace_profile_del_t *mp) +{ + int rv = 0; + vl_api_trace_profile_del_reply_t * rmp; + clib_error_t *error; + + error = clear_ioam_rewrite_fn(); + if (error) { + clib_error_report(error); + rv = clib_error_get_code(error); + } + + REPLY_MACRO(VL_API_TRACE_PROFILE_DEL_REPLY); +} + + #define BOUNCE_HANDLER(nn) \ static void vl_api_##nn##_t_handler ( \ vl_api_##nn##_t *mp) \ @@ -5027,11 +5892,6 @@ static void vl_api_##nn##_t_handler ( \ vl_msg_api_free (mp); \ } -BOUNCE_HANDLER(to_netconf_server); -BOUNCE_HANDLER(from_netconf_server); -BOUNCE_HANDLER(to_netconf_client); -BOUNCE_HANDLER(from_netconf_client); - /* * vpe_api_hookup * Add vpe's API message handlers to the table. @@ -5067,10 +5927,18 @@ vpe_api_hookup (vlib_main_t *vm) vl_api_sr_tunnel_add_del_t_print, 256, 1); - am->message_bounce [VL_API_FROM_NETCONF_SERVER] = 1; - am->message_bounce [VL_API_TO_NETCONF_SERVER] = 1; - am->message_bounce [VL_API_FROM_NETCONF_CLIENT] = 1; - am->message_bounce [VL_API_TO_NETCONF_CLIENT] = 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 @@ -5089,6 +5957,11 @@ vpe_api_hookup (vlib_main_t *vm) 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; + return 0; }