+ 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_enable_disable_t_handler(
+ vl_api_lisp_enable_disable_t *mp)
+{
+ vl_api_lisp_enable_disable_reply_t *rmp;
+ int rv = 0;
+
+ vnet_lisp_enable_disable (mp->is_en);
+ REPLY_MACRO(VL_API_LISP_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;
+ rv = vnet_lisp_gpe_add_del_iface (a, 0);
+
+ REPLY_MACRO(VL_API_LISP_GPE_ADD_DEL_IFACE_REPLY);
+}
+
+static void
+vl_api_lisp_pitr_set_locator_set_t_handler(
+ vl_api_lisp_pitr_set_locator_set_t *mp)
+{
+ vl_api_lisp_pitr_set_locator_set_reply_t *rmp;
+ int rv = 0;
+ u8 * ls_name = 0;
+
+ ls_name = format (0, "%s", mp->ls_name);
+ rv = vnet_lisp_pitr_set_locator_set (ls_name, mp->is_add);
+ vec_free (ls_name);
+
+ REPLY_MACRO(VL_API_LISP_PITR_SET_LOCATOR_SET_REPLY);
+}
+
+static void
+vl_api_lisp_add_del_map_request_itr_rlocs_t_handler
+(vl_api_lisp_add_del_map_request_itr_rlocs_t *mp)
+{
+ vl_api_lisp_add_del_map_request_itr_rlocs_reply_t *rmp;
+ int rv = 0;
+ u8 * locator_set_name = NULL;
+ vnet_lisp_add_del_mreq_itr_rloc_args_t _a, * a = &_a;
+
+ locator_set_name = format (0, "%s", mp->locator_set_name);
+
+ a->is_add = mp->is_add;
+ a->locator_set_name = locator_set_name;
+
+ rv = vnet_lisp_add_del_mreq_itr_rlocs(a);
+
+ vec_free(locator_set_name);
+
+ REPLY_MACRO(VL_API_LISP_ADD_DEL_MAP_REQUEST_ITR_RLOCS_REPLY);
+}
+
+/** Used for transferring locators via VPP API */
+typedef CLIB_PACKED(struct
+{
+ u8 is_ip4; /**< is locator an IPv4 address */
+ u8 addr[16]; /**< IPv4/IPv6 address */
+}) rloc_t;
+
+static void
+send_lisp_locator_set_details_set_address
+(vl_api_lisp_locator_set_details_t *rmp,
+ gid_address_t *gid_address)
+{
+ ip_prefix_t *ip_addr;
+
+ if (gid_address_type(gid_address) != GID_ADDR_IP_PREFIX) {
+ return;
+ }
+
+ ip_addr = &gid_address_ippref(gid_address);
+ rmp->prefix_len = ip_prefix_len(ip_addr);
+ rmp->is_ipv6 = ip_prefix_version(ip_addr);
+ ip_address_copy_addr(rmp->ip_address, &ip_prefix_addr(ip_addr));
+}
+
+static void
+vl_api_lisp_add_del_remote_mapping_t_handler (
+ vl_api_lisp_add_del_remote_mapping_t *mp)
+{
+ u32 i;
+ ip_address_t rloc, * rlocs = 0;
+ vl_api_lisp_add_del_remote_mapping_reply_t * rmp;
+ int rv = 0;
+ gid_address_t _seid, * seid = &_seid;
+ gid_address_t _deid, * deid = &_deid;
+ ip_prefix_t * seid_pref = &gid_address_ippref(seid);
+ ip_prefix_t * deid_pref = &gid_address_ippref(deid);
+
+ gid_address_type(seid) = GID_ADDR_IP_PREFIX;
+ gid_address_type(deid) = GID_ADDR_IP_PREFIX;
+ ip_address_t * seid_addr = &ip_prefix_addr(seid_pref);
+ ip_address_t * deid_addr = &ip_prefix_addr(deid_pref);
+ ip_prefix_len(seid_pref) = mp->seid_len;
+ ip_prefix_len(deid_pref) = mp->deid_len;
+ gid_address_vni (seid) = ntohl (mp->vni);
+ gid_address_vni (deid) = ntohl (mp->vni);
+
+ if (mp->eid_is_ip4) {
+ ip_prefix_version(seid_pref) = IP4;
+ ip_prefix_version(deid_pref) = IP4;
+ clib_memcpy (&ip_addr_v4(seid_addr),
+ mp->seid, sizeof (ip_addr_v4(seid_addr)));
+ clib_memcpy (&ip_addr_v4(deid_addr),
+ mp->deid, sizeof (ip_addr_v4(deid_addr)));
+ } else {
+ ip_prefix_version(seid_pref) = IP6;
+ ip_prefix_version(deid_pref) = IP6;
+ clib_memcpy (&ip_addr_v6(seid_addr),
+ mp->seid, sizeof (ip_addr_v6(seid_addr)));
+ clib_memcpy (&ip_addr_v6(deid_addr),
+ mp->deid, sizeof (ip_addr_v6(deid_addr)));
+ }
+
+ for (i = 0; i < mp->rloc_num; i++) {
+ rloc_t * r = &((rloc_t *) mp->rlocs)[i];
+ if (r->is_ip4) {
+ clib_memcpy (&ip_addr_v4(&rloc), &r->addr, sizeof (rloc_t));
+ ip_addr_version (&rloc) = IP4;
+ } else {
+ clib_memcpy (&ip_addr_v6(&rloc), &r->addr, sizeof (rloc_t));
+ ip_addr_version (&rloc) = IP6;
+ }
+ vec_add1 (rlocs, rloc);
+ }
+
+ rv = vnet_lisp_add_del_remote_mapping (deid, seid, rlocs, mp->action,
+ mp->is_add, mp->del_all);
+ vec_free (rlocs);
+ 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,
+ u32 context,
+ u32 index)
+{
+ vl_api_lisp_locator_set_details_t *rmp;
+ locator_t *loc = NULL;
+ u32 * locit = NULL;
+ u8 * str = 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);
+ rmp->local = lsit->local;
+ if (lsit->local) {
+ ASSERT(lsit->name != NULL);
+ 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);
+ } else {
+ str = format(0, "remote-%d", index);
+ strncpy((char *) rmp->locator_set_name, (char *) str,
+ ARRAY_LEN(rmp->locator_set_name) - 1);
+ send_lisp_locator_set_details_set_address(rmp, &loc->address);
+
+ vec_free(str);
+ }
+ rmp->priority = loc->priority;
+ rmp->weight = loc->weight;
+ rmp->context = context;
+
+ 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;
+ u32 index;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ index = 0;
+ pool_foreach (lsit, lcm->locator_set_pool,
+ ({
+ send_lisp_locator_set_details(lcm, lsit, q, mp->context, index++);
+ }));
+}
+
+static void
+send_lisp_local_eid_table_details (mapping_t *mapit,
+ unix_shared_memory_queue_t *q,
+ u32 context)
+{
+ 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 * str = 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);
+ if (ls->local) {
+ ASSERT(ls->name != NULL);
+ strncpy((char *) rmp->locator_set_name,
+ (char *) ls->name, ARRAY_LEN(rmp->locator_set_name) - 1);
+ } else {
+ str = format(0, "remote-%d", mapit->locator_set_index);
+ strncpy((char *) rmp->locator_set_name, (char *) str,
+ ARRAY_LEN(rmp->locator_set_name) - 1);
+ vec_free(str);
+ }
+
+ 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);
+ rmp->context = context;
+ rmp->vni = clib_host_to_net_u32 (gid_address_vni (gid));
+ 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, mp->context);
+ }));
+}
+
+static void
+send_lisp_gpe_tunnel_details (lisp_gpe_tunnel_t *tunnel,
+ unix_shared_memory_queue_t *q,
+ u32 context)
+{
+ 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);
+ rmp->context = context;
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void
+vl_api_lisp_gpe_tunnel_dump_t_handler (
+ vl_api_lisp_gpe_tunnel_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, mp->context);
+ }));
+}
+
+static void
+send_lisp_map_resolver_details (ip_address_t *ip,
+ unix_shared_memory_queue_t *q,
+ u32 context)
+{
+ 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);
+ }
+ rmp->context = context;
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void
+vl_api_lisp_map_resolver_dump_t_handler (
+ vl_api_lisp_map_resolver_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, mp->context);
+ }
+
+}
+
+static void
+vl_api_lisp_eid_table_map_dump_t_handler (
+ vl_api_lisp_eid_table_map_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q = NULL;
+ lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+ hash_pair_t * p;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+ hash_foreach_pair (p, lcm->table_id_by_vni, {
+ vl_api_lisp_eid_table_map_details_t * rmp = NULL;
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_LISP_EID_TABLE_MAP_DETAILS);
+ rmp->vni = p->key;
+ rmp->vrf = p->value[0];
+ rmp->context = mp->context;
+ });
+}
+
+static void
+send_lisp_enable_disable_details (unix_shared_memory_queue_t *q,
+ u32 context)
+{
+ vl_api_lisp_enable_disable_status_details_t *rmp = NULL;
+
+ rmp = vl_msg_api_alloc (sizeof (*rmp));
+ memset (rmp, 0, sizeof (*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_LISP_ENABLE_DISABLE_STATUS_DETAILS);
+
+ rmp->gpe_status = vnet_lisp_gpe_enable_disable_status ();
+ rmp->feature_status = vnet_lisp_enable_disable_status ();
+ rmp->context = context;
+
+ vl_msg_api_send_shmem (q, (u8 *)&rmp);
+}
+
+static void
+vl_api_lisp_enable_disable_status_dump_t_handler
+(vl_api_lisp_enable_disable_status_dump_t *mp)
+{
+ unix_shared_memory_queue_t * q = NULL;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ send_lisp_enable_disable_details(q, mp->context);
+}
+
+static void
+vl_api_lisp_get_map_request_itr_rlocs_t_handler (
+ vl_api_lisp_get_map_request_itr_rlocs_t *mp)
+{
+ unix_shared_memory_queue_t * q = NULL;
+ vl_api_lisp_get_map_request_itr_rlocs_reply_t *rmp = NULL;
+ lisp_cp_main_t * lcm = vnet_lisp_cp_get_main();
+ locator_set_t * loc_set = 0;
+ u8 * tmp_str = 0;
+ int rv = 0;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ if (~0 == lcm->mreq_itr_rlocs) {
+ tmp_str = format(0, " ");
+ } else {
+ loc_set = pool_elt_at_index (lcm->locator_set_pool, lcm->mreq_itr_rlocs);
+ tmp_str = format(0, "%s", loc_set->name);
+ }
+
+ REPLY_MACRO2(VL_API_LISP_GET_MAP_REQUEST_ITR_RLOCS_REPLY,
+ ({
+ strncpy((char *) rmp->locator_set_name, (char *) tmp_str,
+ ARRAY_LEN(rmp->locator_set_name) - 1);
+ }));
+
+ vec_free(tmp_str);
+}
+
+static void
+vl_api_interface_name_renumber_t_handler (vl_api_interface_name_renumber_t *mp)
+{
+ vl_api_interface_name_renumber_reply_t * rmp;
+ int rv = 0;
+
+ VALIDATE_SW_IF_INDEX(mp);
+
+ rv = vnet_interface_name_renumber
+ (ntohl(mp->sw_if_index), ntohl(mp->new_show_dev_instance));
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO(VL_API_INTERFACE_NAME_RENUMBER_REPLY);
+}
+
+static int arp_change_data_callback (u32 pool_index, u8 * new_mac,
+ u32 sw_if_index, u32 address)
+{
+ 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);
+ if (memcmp (&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) ||
+ /* for BD case, also check IP address with 10 sec timeout */
+ ((address == event->address) &&
+ ((now - arp_event_last_time) < 10.0))))
+ return 1;
+ }
+
+ arp_event_last_time = now;
+ event->sw_if_index = sw_if_index;
+ if (address) event->address = address;
+ return 0;
+}
+
+static int arp_change_delete_callback (u32 pool_index, u8 * notused)
+{
+ vpe_api_main_t * am = &vpe_api_main;
+
+ if (pool_is_free_index (am->arp_events, pool_index))
+ return 1;
+
+ pool_put_index (am->arp_events, pool_index);
+ return 0;
+}
+
+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;
+ vl_api_ip4_arp_event_t * event;
+ int rv;
+
+ if (mp->enable_disable) {
+ pool_get (am->arp_events, event);
+ memset (event, 0, sizeof (*event));
+
+ event->_vl_msg_id = ntohs(VL_API_IP4_ARP_EVENT);
+ event->client_index = mp->client_index;
+ event->context = mp->context;
+ event->address = mp->address;
+ event->pid = mp->pid;
+
+ rv = vnet_add_del_ip4_arp_change_event
+ (vnm, arp_change_data_callback,
+ mp->pid,
+ &mp->address /* addr, in net byte order */,
+ vpe_resolver_process_node.index,
+ IP4_ARP_EVENT, event - am->arp_events, 1 /* is_add */);
+ } else {
+ rv = vnet_add_del_ip4_arp_change_event
+ (vnm, arp_change_delete_callback,
+ mp->pid,
+ &mp->address /* addr, in net byte order */,
+ vpe_resolver_process_node.index,
+ IP4_ARP_EVENT, ~0 /* pool index */, 0 /* is_add */);
+ }
+ REPLY_MACRO(VL_API_WANT_IP4_ARP_EVENTS_REPLY);
+}
+
+static void vl_api_input_acl_set_interface_t_handler
+(vl_api_input_acl_set_interface_t * mp)
+{
+ vlib_main_t *vm = vlib_get_main();
+ vl_api_input_acl_set_interface_reply_t * rmp;
+ int rv;
+ u32 sw_if_index, ip4_table_index, ip6_table_index, l2_table_index;
+
+ ip4_table_index = ntohl(mp->ip4_table_index);
+ ip6_table_index = ntohl(mp->ip6_table_index);
+ l2_table_index = ntohl(mp->l2_table_index);
+ sw_if_index = ntohl(mp->sw_if_index);
+
+ VALIDATE_SW_IF_INDEX(mp);
+
+ rv = vnet_set_input_acl_intfc (vm, sw_if_index, ip4_table_index,
+ ip6_table_index, l2_table_index,
+ mp->is_add);
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO(VL_API_INPUT_ACL_SET_INTERFACE_REPLY);
+}
+
+static void vl_api_ipsec_spd_add_del_t_handler
+(vl_api_ipsec_spd_add_del_t * mp)
+{
+#if IPSEC == 0
+ clib_warning ("unimplemented");
+#else
+
+ vlib_main_t *vm __attribute__((unused)) = vlib_get_main();
+ vl_api_ipsec_spd_add_del_reply_t * rmp;
+ int rv;
+
+#if DPDK > 0
+ rv = ipsec_add_del_spd (vm, ntohl(mp->spd_id), mp->is_add);
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif
+
+ REPLY_MACRO(VL_API_IPSEC_SPD_ADD_DEL_REPLY);
+#endif
+}
+
+static void vl_api_ipsec_interface_add_del_spd_t_handler
+(vl_api_ipsec_interface_add_del_spd_t * mp)
+{
+ vlib_main_t *vm __attribute__((unused)) = vlib_get_main();
+ vl_api_ipsec_interface_add_del_spd_reply_t * rmp;
+ int rv;
+ u32 sw_if_index __attribute__((unused));
+ u32 spd_id __attribute__((unused));
+
+ sw_if_index = ntohl(mp->sw_if_index);
+ spd_id = ntohl(mp->spd_id);
+
+ VALIDATE_SW_IF_INDEX(mp);
+
+#if IPSEC > 0
+ rv = ipsec_set_interface_spd(vm, sw_if_index, spd_id, mp->is_add);
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO(VL_API_IPSEC_INTERFACE_ADD_DEL_SPD_REPLY);
+}
+
+static void vl_api_ipsec_spd_add_del_entry_t_handler
+(vl_api_ipsec_spd_add_del_entry_t * mp)
+{
+ vlib_main_t *vm __attribute__((unused)) = vlib_get_main();
+ vl_api_ipsec_spd_add_del_entry_reply_t * rmp;
+ int rv;
+
+#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;
+
+ 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);
+ p.rport.stop = ntohs(mp->remote_port_stop);
+ p.lport.start = ntohs(mp->local_port_start);
+ p.lport.stop = ntohs(mp->local_port_stop);
+ /* policy action resolve unsupported */
+ if (mp->policy == IPSEC_POLICY_ACTION_RESOLVE) {
+ clib_warning("unsupported action: 'resolve'");
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+ goto out;
+ }
+ p.policy = mp->policy;
+ p.sa_id = ntohl(mp->sa_id);
+
+ rv = ipsec_add_del_policy(vm, &p, mp->is_add);
+ if (rv)
+ goto out;
+
+ if (mp->is_ip_any) {
+ p.is_ipv6 = 1;
+ rv = ipsec_add_del_policy(vm, &p, mp->is_add);
+ }
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+ goto out;
+#endif
+
+out:
+ REPLY_MACRO(VL_API_IPSEC_SPD_ADD_DEL_ENTRY_REPLY);
+}
+
+static void vl_api_ipsec_sad_add_del_entry_t_handler
+(vl_api_ipsec_sad_add_del_entry_t * mp)
+{
+ vlib_main_t *vm __attribute__((unused)) = vlib_get_main();
+ vl_api_ipsec_sad_add_del_entry_reply_t * rmp;
+ int rv;
+#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 */
+ if (mp->protocol == IPSEC_PROTOCOL_AH) {
+ clib_warning("unsupported security protocol 'AH'");
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+ goto out;
+ }
+ sa.protocol = mp->protocol;
+ /* 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,
+ mp->crypto_algorithm);
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+ goto out;
+ }
+ sa.crypto_alg = mp->crypto_algorithm;
+ sa.crypto_key_len = mp->crypto_key_length;
+ 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) {
+ clib_warning("unsupported integ-alg: '%U'", format_ipsec_integ_alg,
+ mp->integrity_algorithm);
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+ goto out;
+ }
+ sa.integ_alg = mp->integrity_algorithm;
+ sa.integ_key_len = mp->integrity_key_length;
+ 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;
+ 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
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+ goto out;
+#endif
+
+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)
+{
+ vl_api_map_add_domain_reply_t * rmp;
+ int rv = 0;
+ u32 index;
+ u8 flags = mp->is_translation ? MAP_DOMAIN_TRANSLATION : 0;
+ rv = map_create_domain((ip4_address_t *)&mp->ip4_prefix, mp->ip4_prefix_len,
+ (ip6_address_t *)&mp->ip6_prefix, mp->ip6_prefix_len,
+ (ip6_address_t *)&mp->ip6_src, mp->ip6_src_prefix_len,
+ mp->ea_bits_len, mp->psid_offset, mp->psid_length, &index, ntohs(mp->mtu), flags);
+
+ REPLY_MACRO2(VL_API_MAP_ADD_DOMAIN_REPLY,
+ ({
+ rmp->index = ntohl(index);
+ }));
+}
+
+static void
+vl_api_map_del_domain_t_handler
+(vl_api_map_del_domain_t * mp)
+{
+ vl_api_map_del_domain_reply_t * rmp;
+ int rv = 0;
+
+ rv = map_delete_domain(ntohl(mp->index));
+
+ REPLY_MACRO(VL_API_MAP_DEL_DOMAIN_REPLY);
+}
+
+static void
+vl_api_map_add_del_rule_t_handler
+(vl_api_map_add_del_rule_t * mp)
+{
+ vl_api_map_del_domain_reply_t * rmp;
+ int rv = 0;
+
+ rv = map_add_del_psid(ntohl(mp->index), ntohs(mp->psid), (ip6_address_t *)mp->ip6_dst, mp->is_add);
+
+ REPLY_MACRO(VL_API_MAP_ADD_DEL_RULE_REPLY);
+}
+
+static void
+vl_api_map_domain_dump_t_handler
+(vl_api_map_domain_dump_t * mp)
+{
+ vl_api_map_domain_details_t * rmp;
+ map_main_t *mm = &map_main;
+ map_domain_t *d;
+ unix_shared_memory_queue_t * q;
+
+ if (pool_elts (mm->domains) == 0)
+ return;
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ pool_foreach(d, mm->domains, ({
+ /* Make sure every field is initiated (or don't skip the memset()) */
+ rmp = vl_msg_api_alloc (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;
+ clib_memcpy(rmp->ip4_prefix, &d->ip4_prefix, sizeof(rmp->ip4_prefix));
+ rmp->ip4_prefix_len = d->ip4_prefix_len;
+ clib_memcpy(rmp->ip6_prefix, &d->ip6_prefix, sizeof(rmp->ip6_prefix));
+ rmp->ip6_prefix_len = d->ip6_prefix_len;
+ 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);
+ }));
+}
+
+static void
+vl_api_map_rule_dump_t_handler
+(vl_api_map_rule_dump_t * mp)
+{
+ unix_shared_memory_queue_t * q;
+ u16 i;
+ ip6_address_t dst;
+ vl_api_map_rule_details_t * rmp;
+ map_main_t *mm = &map_main;
+ u32 domain_index = ntohl(mp->domain_index);
+ map_domain_t *d;
+
+ if (pool_elts (mm->domains) == 0)
+ return;
+
+ d = pool_elt_at_index(mm->domains, domain_index);
+ if (!d || !d->rules) {
+ return;
+ }
+
+ q = vl_api_client_index_to_input_queue (mp->client_index);
+ if (q == 0) {
+ return;
+ }
+
+ for (i = 0; i < (0x1 << d->psid_length); i++) {
+ dst = d->rules[i];
+ if (dst.as_u64[0] == 0 && dst.as_u64[1] == 0) {
+ continue;
+ }
+ rmp = vl_msg_api_alloc(sizeof(*rmp));
+ memset(rmp, 0, sizeof(*rmp));
+ rmp->_vl_msg_id = ntohs(VL_API_MAP_RULE_DETAILS);
+ rmp->psid = htons(i);
+ clib_memcpy(rmp->ip6_dst, &dst, sizeof(rmp->ip6_dst));
+ rmp->context = mp->context;
+ vl_msg_api_send_shmem(q, (u8 *)&rmp);
+ }
+}
+
+static void
+vl_api_map_summary_stats_t_handler (
+ vl_api_map_summary_stats_t *mp)
+{
+ vl_api_map_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];
+ map_main_t *mm = &map_main;
+ 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_MAP_SUMMARY_STATS_REPLY);
+ rmp->context = mp->context;
+ rmp->retval = 0;
+
+ memset (total_pkts, 0, sizeof (total_pkts));
+ memset (total_bytes, 0, sizeof (total_bytes));
+
+ map_domain_counter_lock (mm);
+ vec_foreach(cm, mm->domain_counters) {
+ which = cm - mm->domain_counters;
+
+ for (i = 0; i < vec_len(cm->maxi); i++) {
+ vlib_get_combined_counter (cm, i, &v);
+ total_pkts[which] += v.packets;
+ total_bytes[which] += v.bytes;
+ }
+ }
+
+ map_domain_counter_unlock (mm);
+
+ /* 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] = 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);
+}
+
+static void vl_api_ipsec_sa_set_key_t_handler
+(vl_api_ipsec_sa_set_key_t * mp)
+{
+ vlib_main_t *vm __attribute__((unused)) = vlib_get_main();
+ vl_api_ipsec_sa_set_key_reply_t *rmp;
+ int rv;
+#if IPSEC > 0
+ ipsec_sa_t sa;
+ sa.id = ntohl(mp->sa_id);
+ sa.crypto_key_len = mp->crypto_key_length;
+ clib_memcpy(&sa.crypto_key, mp->crypto_key, sizeof(sa.crypto_key));
+ sa.integ_key_len = mp->integrity_key_length;
+ clib_memcpy(&sa.integ_key, mp->integrity_key, sizeof(sa.integ_key));
+
+ rv = ipsec_set_sa_key(vm, &sa);
+#else
+ rv = VNET_API_ERROR_UNIMPLEMENTED;
+#endif
+
+ REPLY_MACRO(VL_API_IPSEC_SA_SET_KEY_REPLY);
+}
+
+static void vl_api_cop_interface_enable_disable_t_handler
+(vl_api_cop_interface_enable_disable_t * mp)
+{
+ vl_api_cop_interface_enable_disable_reply_t * rmp;
+ int rv;
+ u32 sw_if_index = ntohl(mp->sw_if_index);
+ int enable_disable;
+
+ VALIDATE_SW_IF_INDEX(mp);
+
+ enable_disable = (int) mp->enable_disable;
+
+ rv = cop_interface_enable_disable (sw_if_index, enable_disable);
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO(VL_API_COP_INTERFACE_ENABLE_DISABLE_REPLY);
+}
+
+static void vl_api_cop_whitelist_enable_disable_t_handler
+(vl_api_cop_whitelist_enable_disable_t * mp)
+{
+ vl_api_cop_whitelist_enable_disable_reply_t * rmp;
+ cop_whitelist_enable_disable_args_t _a, *a=&_a;
+ u32 sw_if_index = ntohl(mp->sw_if_index);
+ int rv;
+
+ VALIDATE_SW_IF_INDEX(mp);
+
+ a->sw_if_index = sw_if_index;
+ a->ip4 = mp->ip4;
+ a->ip6 = mp->ip6;
+ a->default_cop = mp->default_cop;
+ a->fib_id = ntohl(mp->fib_id);
+
+ rv = cop_whitelist_enable_disable (a);
+
+ BAD_SW_IF_INDEX_LABEL;
+
+ REPLY_MACRO(VL_API_COP_WHITELIST_ENABLE_DISABLE_REPLY);
+}
+
+static void vl_api_get_node_graph_t_handler
+(vl_api_get_node_graph_t * mp)
+{
+ int rv = 0;
+ u8 * vector = 0;
+ api_main_t * am = &api_main;
+ vlib_main_t * vm = vlib_get_main();
+ void * oldheap;
+ vl_api_get_node_graph_reply_t * rmp;
+
+ pthread_mutex_lock (&am->vlib_rp->mutex);
+ oldheap = svm_push_data_heap (am->vlib_rp);
+
+ /*
+ * Keep the number of memcpy ops to a minimum (e.g. 1).
+ */
+ vec_validate (vector, 16384);
+ vec_reset_length (vector);