diff options
| -rw-r--r-- | vnet/vnet/api_errno.h | 3 | ||||
| -rw-r--r-- | vnet/vnet/lisp-cp/control.c | 246 | ||||
| -rw-r--r-- | vnet/vnet/lisp-cp/control.h | 7 | ||||
| -rw-r--r-- | vnet/vnet/lisp-cp/lisp_types.h | 2 | ||||
| -rw-r--r-- | vpp-api-test/vat/api_format.c | 795 | ||||
| -rw-r--r-- | vpp/api/api.c | 449 | ||||
| -rw-r--r-- | vpp/api/vpe.api | 246 |
7 files changed, 1726 insertions, 22 deletions
diff --git a/vnet/vnet/api_errno.h b/vnet/vnet/api_errno.h index e59efd70c4e..77c14a4a4fa 100644 --- a/vnet/vnet/api_errno.h +++ b/vnet/vnet/api_errno.h @@ -70,7 +70,8 @@ _(INVALID_DECAP_NEXT, -76, "Invalid decap-next") \ _(RESPONSE_NOT_READY, -77, "Response not ready") \ _(NOT_CONNECTED, -78, "Not connected to the data plane") \ _(IF_ALREADY_EXISTS, -79, "Interface already exists") \ -_(BOND_SLAVE_NOT_ALLOWED, -80, "Operation not allowed on slave of BondEthernet") +_(BOND_SLAVE_NOT_ALLOWED, -80, "Operation not allowed on slave of BondEthernet") \ +_(VALUE_EXIST, -81, "Value already exists") typedef enum { #define _(a,b,c) VNET_API_ERROR_##a = (b), diff --git a/vnet/vnet/lisp-cp/control.c b/vnet/vnet/lisp-cp/control.c index c1873972517..f60405e7519 100644 --- a/vnet/vnet/lisp-cp/control.c +++ b/vnet/vnet/lisp-cp/control.c @@ -35,7 +35,7 @@ vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a, if (mi != GID_LOOKUP_MISS) { clib_warning("eid %U found in the eid-table", format_ip_address, &a->deid); - return -1; + return VNET_API_ERROR_VALUE_EXIST; } pool_get(lcm->mapping_pool, m); @@ -52,7 +52,7 @@ vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a, { clib_warning("Locator set with index %d doesn't exist", a->locator_set_index); - return -1; + return VNET_API_ERROR_INVALID_VALUE; } /* add eid to list of eids supported by locator-set */ @@ -72,10 +72,10 @@ vnet_lisp_add_del_mapping (vnet_lisp_add_del_mapping_args_t * a, } else { - if (mi != ~0) { + if (mi == GID_LOOKUP_MISS) { clib_warning("eid %U not found in the eid-table", format_ip_address, &a->deid); - return -1; + return VNET_API_ERROR_INVALID_VALUE; } /* clear locator-set to eids binding */ @@ -236,19 +236,6 @@ clean_locator_to_locator_set (lisp_cp_main_t * lcm, u32 lsi) /* delete locator if it's part of no locator-set */ if (vec_len (ls_indexes[0]) == 0) pool_put_index(lcm->locator_pool, loc_indexp[0]); - - /* remove from local locator-set vector */ - if (ls->local) - { - u32 k, *llocp; - for (k = 0; k < vec_len(lcm->local_locator_set_indexes); k++) - { - llocp = vec_elt_at_index(lcm->local_locator_set_indexes, k); - if (llocp[0] == lsi) - break; - } - vec_del1(lcm->local_locator_set_indexes, k); - } } } int @@ -260,6 +247,7 @@ vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a, locator_t * loc, * itloc; uword _p = (u32)~0, * p = &_p; u32 loc_index, ls_index, ** ls_indexes; + u32 **eid_indexes; if (a->is_add) { @@ -358,6 +346,151 @@ vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a, // return -1; // } + if (vec_len(lcm->locator_set_to_eids) != 0) + { + eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids, p[0]); + if (vec_len(eid_indexes[0]) != 0) + { + clib_warning ("Can't delete a locator that supports a mapping!"); + return -1; + } + } + + /* clean locator to locator-sets data */ + clean_locator_to_locator_set (lcm, p[0]); + + if (ls->local) + { + u32 it, lsi; + + vec_foreach_index(it, lcm->local_locator_set_indexes) + { + lsi = vec_elt(lcm->local_locator_set_indexes, it); + if (lsi == p[0]) + { + vec_del1(lcm->local_locator_set_indexes, it); + break; + } + } + hash_unset_mem(lcm->locator_set_index_by_name, ls->name); + vec_free(ls->name); + } + pool_put(lcm->locator_set_pool, ls); + } + return 0; +} + +static inline +uword *vnet_lisp_get_locator(vnet_lisp_add_del_locator_set_args_t * a, + uword *p) +{ + lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); + + ASSERT(a != NULL); + ASSERT(p != NULL); + + /* find locator-set */ + if (a->local) + { + p = hash_get_mem(lcm->locator_set_index_by_name, a->name); + } + else + { + *p = a->index; + } + + return p; +} + +int +vnet_lisp_add_del_locator_set_name (vnet_lisp_add_del_locator_set_args_t * a, + u32 * ls_result) +{ + lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); + locator_set_t * ls; + uword _p = (u32)~0, * p = &_p; + u32 ls_index = ~0; + u32 **eid_indexes = NULL; + + ASSERT(a != NULL); + ASSERT(ls_result != NULL); + + p = vnet_lisp_get_locator(a, p); + + if (a->is_add) + { + /* overwrite */ + if (p && p[0] != (u32)~0) + { + ls = pool_elt_at_index(lcm->locator_set_pool, p[0]); + if (!ls) + { + clib_warning("locator-set %d to be overwritten doesn't exist!", + p[0]); + return VNET_API_ERROR_UNSPECIFIED; + } + + /* clean locator to locator-set vectors and remove locators if + * they're not part of another locator-set */ + clean_locator_to_locator_set (lcm, p[0]); + + /* remove locator indices from locator set */ + vec_free(ls->locator_indices); + + ls_index = p[0]; + + if (ls_result) + ls_result[0] = p[0]; + } + /* new locator-set */ + else + { + pool_get(lcm->locator_set_pool, ls); + ls_index = ls - lcm->locator_set_pool; + + if (a->local) + { + ls->name = vec_dup(a->name); + + if (!lcm->locator_set_index_by_name) + lcm->locator_set_index_by_name = hash_create_vec( + /* size */0, sizeof(ls->name[0]), sizeof(uword)); + hash_set_mem(lcm->locator_set_index_by_name, ls->name, ls_index); + + /* mark as local locator-set */ + vec_add1(lcm->local_locator_set_indexes, ls_index); + } + ls->local = a->local; + ls->locator_indices = NULL; + if (ls_result) + ls_result[0] = ls_index; + } + } + else + { + if (!p) + { + clib_warning("locator-set %v doesn't exists", a->name); + return VNET_API_ERROR_INVALID_ARGUMENT; + } + + ls = pool_elt_at_index(lcm->locator_set_pool, p[0]); + if (!ls) + { + clib_warning("locator-set with index %d doesn't exists", p[0]); + return VNET_API_ERROR_INVALID_ARGUMENT; + } + + if (vec_len(lcm->locator_set_to_eids) != 0) + { + eid_indexes = vec_elt_at_index(lcm->locator_set_to_eids, p[0]); + if (vec_len(eid_indexes[0]) != 0) + { + clib_warning ("Can't delete a locator that supports a mapping!"); + return -1; + } + } + /* clean locator to locator-sets data */ clean_locator_to_locator_set (lcm, p[0]); @@ -382,6 +515,85 @@ vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a, return 0; } +int +vnet_lisp_add_del_locator (vnet_lisp_add_del_locator_set_args_t *a, + u32 *ls_result) +{ + lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); + locator_set_t *ls = NULL; + locator_t *loc = NULL, *itloc = NULL; + uword _p = (u32)~0, * p = &_p; + u32 loc_index = ~0, ls_index = ~0, *locit = NULL, **ls_indexes = NULL; + u32 i = ~0; + + ASSERT(a != NULL); + ASSERT(ls_result != NULL); + + p = vnet_lisp_get_locator(a, p); + if (!p) { + clib_warning("locator-set %v doesn't exists", a->name); + return VNET_API_ERROR_INVALID_ARGUMENT; + } + + ls_index = p[0]; + + if (a->is_add) + { + ls = pool_elt_at_index(lcm->locator_set_pool, p[0]); + if (!ls) + { + clib_warning("locator-set %d to be overwritten doesn't exist!", + p[0]); + return VNET_API_ERROR_INVALID_ARGUMENT; + } + + if (ls_result) + ls_result[0] = p[0]; + + /* allocate locators */ + itloc = a->locators; + pool_get(lcm->locator_pool, loc); + loc[0] = itloc[0]; + loc_index = loc - lcm->locator_pool; + + vec_add1(ls->locator_indices, loc_index); + + vec_validate (lcm->locator_to_locator_sets, loc_index); + ls_indexes = vec_elt_at_index(lcm->locator_to_locator_sets, + loc_index); + vec_add1(ls_indexes[0], ls_index); + } + else + { + ls = pool_elt_at_index(lcm->locator_set_pool, p[0]); + if (!ls) + { + clib_warning("locator-set with index %d doesn't exists", p[0]); + return VNET_API_ERROR_INVALID_ARGUMENT; + } + + if (ls->local) + { + itloc = a->locators; + i = 0; + vec_foreach (locit, ls->locator_indices) + { + loc = pool_elt_at_index(lcm->locator_pool, locit[0]); + if (loc->local && loc->sw_if_index == itloc->sw_if_index) + { + ls_indexes = vec_elt_at_index(lcm->locator_to_locator_sets, + locit[0]); + pool_put_index(lcm->locator_pool, locit[0]); + vec_del1(ls->locator_indices, i); + vec_del1(ls_indexes[0], ls_index); + } + i++; + } + } + } + return 0; +} + static clib_error_t * lisp_add_del_locator_set_command_fn (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) diff --git a/vnet/vnet/lisp-cp/control.h b/vnet/vnet/lisp-cp/control.h index 713dce6a5b8..53d90fca8e5 100644 --- a/vnet/vnet/lisp-cp/control.h +++ b/vnet/vnet/lisp-cp/control.h @@ -123,6 +123,13 @@ int vnet_lisp_add_del_locator_set (vnet_lisp_add_del_locator_set_args_t * a, u32 * ls_index); +int +vnet_lisp_add_del_locator_set_name (vnet_lisp_add_del_locator_set_args_t * a, + u32 * ls_index); +int +vnet_lisp_add_del_locator (vnet_lisp_add_del_locator_set_args_t * a, + u32 * ls_index); + typedef struct { u8 is_add; diff --git a/vnet/vnet/lisp-cp/lisp_types.h b/vnet/vnet/lisp-cp/lisp_types.h index 63adaa0e9a3..0e8b38ec71e 100644 --- a/vnet/vnet/lisp-cp/lisp_types.h +++ b/vnet/vnet/lisp-cp/lisp_types.h @@ -35,6 +35,8 @@ typedef struct ip_address_type_t version; } ip_address_t; +int ip_address_cmp (ip_address_t * ip1, ip_address_t * ip2); + typedef struct { ip_address_t addr; diff --git a/vpp-api-test/vat/api_format.c b/vpp-api-test/vat/api_format.c index be36cb1da1e..704237be225 100644 --- a/vpp-api-test/vat/api_format.c +++ b/vpp-api-test/vat/api_format.c @@ -1863,6 +1863,218 @@ static void vl_api_get_node_graph_reply_t_handler_json vam->result_ready = 1; } +static void +vl_api_lisp_locator_set_details_t_handler ( + vl_api_lisp_locator_set_details_t *mp) +{ + vat_main_t *vam = &vat_main; + + fformat(vam->ofp, "%=20s%=16d%=16d%=16d\n", + mp->locator_set_name, + ntohl(mp->sw_if_index), + mp->priority, + mp->weight); +} + +static void +vl_api_lisp_locator_set_details_t_handler_json ( + vl_api_lisp_locator_set_details_t *mp) +{ + vat_main_t *vam = &vat_main; + vat_json_node_t *node = NULL; + + if (VAT_JSON_ARRAY != vam->json_tree.type) { + ASSERT(VAT_JSON_NONE == vam->json_tree.type); + vat_json_init_array(&vam->json_tree); + } + node = vat_json_array_add(&vam->json_tree); + + vat_json_init_object(node); + vat_json_object_add_string_copy(node, "locator-set", mp->locator_set_name); + vat_json_object_add_uint(node, "locator", ntohl(mp->sw_if_index)); + vat_json_object_add_uint(node, "priority", mp->priority); + vat_json_object_add_uint(node, "weight", mp->weight); +} + +static void +vl_api_lisp_local_eid_table_details_t_handler ( + vl_api_lisp_local_eid_table_details_t *mp) +{ + vat_main_t *vam = &vat_main; + u8 *prefix; + + prefix = format(0, "%U/%d", + mp->eid_is_ipv6 ? format_ip6_address : format_ip4_address, + mp->eid_ip_address, + mp->eid_prefix_len); + + fformat(vam->ofp, "%=20s%=30s\n", + mp->locator_set_name, prefix); + + vec_free(prefix); +} + +static void +vl_api_lisp_local_eid_table_details_t_handler_json ( + vl_api_lisp_local_eid_table_details_t *mp) +{ + vat_main_t *vam = &vat_main; + vat_json_node_t *node = NULL; + struct in6_addr ip6; + struct in_addr ip4; + + if (VAT_JSON_ARRAY != vam->json_tree.type) { + ASSERT(VAT_JSON_NONE == vam->json_tree.type); + vat_json_init_array(&vam->json_tree); + } + node = vat_json_array_add(&vam->json_tree); + + vat_json_init_object(node); + vat_json_object_add_string_copy(node, "locator-set", mp->locator_set_name); + if (mp->eid_is_ipv6) { + memcpy(&ip6, mp->eid_ip_address, sizeof(ip6)); + vat_json_object_add_ip6(node, "eid address", ip6); + } else { + memcpy(&ip4, mp->eid_ip_address, sizeof(ip4)); + vat_json_object_add_ip4(node, "eid address", ip4); + } + vat_json_object_add_uint(node, "eid prefix len", mp->eid_prefix_len); +} + +static u8 * +format_decap_next (u8 * s, va_list * args) +{ + u32 next_index = va_arg (*args, u32); + + switch (next_index) + { + case LISP_GPE_INPUT_NEXT_DROP: + return format (s, "drop"); + case LISP_GPE_INPUT_NEXT_IP4_INPUT: + return format (s, "ip4"); + case LISP_GPE_INPUT_NEXT_IP6_INPUT: + return format (s, "ip6"); + case LISP_GPE_INPUT_NEXT_LISP_GPE_ENCAP: + return format (s, "nsh-lisp-gpe"); + default: + return format (s, "unknown %d", next_index); + } + return s; +} + +static void +vl_api_lisp_gpe_tunnel_details_t_handler (vl_api_lisp_gpe_tunnel_details_t *mp) +{ + vat_main_t *vam = &vat_main; + u8 *iid_str; + u8 *flag_str = NULL; + + iid_str = format(0, "%d (0x%x)", ntohl(mp->iid), ntohl(mp->iid)); + +#define _(n,v) if (mp->flags & v) flag_str = format (flag_str, "%s-bit ", #n); + foreach_lisp_gpe_flag_bit; +#undef _ + + fformat(vam->ofp, "%=20d%=30U%=16U%=16d%=16d%=16U" + "%=16d%=16d%=16sd=16d%=16s%=16s\n", + mp->tunnels, + mp->is_ipv6 ? format_ip6_address : format_ip4_address, + mp->source_ip, + mp->is_ipv6 ? format_ip6_address : format_ip4_address, + mp->destination_ip, + ntohl(mp->encap_fib_id), + ntohl(mp->decap_fib_id), + format_decap_next, ntohl(mp->dcap_next), + mp->ver_res >> 6, + flag_str, + mp->next_protocol, + mp->ver_res, + mp->res, + iid_str); + + vec_free(iid_str); +} + +static void +vl_api_lisp_gpe_tunnel_details_t_handler_json ( + vl_api_lisp_gpe_tunnel_details_t *mp) +{ + vat_main_t *vam = &vat_main; + vat_json_node_t *node = NULL; + struct in6_addr ip6; + struct in_addr ip4; + u8 *next_decap_str; + + next_decap_str = format(0, "%U", format_decap_next, htonl(mp->dcap_next)); + + if (VAT_JSON_ARRAY != vam->json_tree.type) { + ASSERT(VAT_JSON_NONE == vam->json_tree.type); + vat_json_init_array(&vam->json_tree); + } + node = vat_json_array_add(&vam->json_tree); + + vat_json_init_object(node); + vat_json_object_add_uint(node, "tunel", mp->tunnels); + if (mp->is_ipv6) { + memcpy(&ip6, mp->source_ip, sizeof(ip6)); + vat_json_object_add_ip6(node, "source address", ip6); + memcpy(&ip6, mp->destination_ip, sizeof(ip6)); + vat_json_object_add_ip6(node, "destination address", ip6); + } else { + memcpy(&ip4, mp->source_ip, sizeof(ip4)); + vat_json_object_add_ip4(node, "source address", ip4); + memcpy(&ip4, mp->destination_ip, sizeof(ip4)); + vat_json_object_add_ip4(node, "destination address", ip4); + } + vat_json_object_add_uint(node, "fib encap", ntohl(mp->encap_fib_id)); + vat_json_object_add_uint(node, "fib decap", ntohl(mp->decap_fib_id)); + vat_json_object_add_string_copy(node, "decap next", next_decap_str); + vat_json_object_add_uint(node, "lisp version", mp->ver_res >> 6); + vat_json_object_add_uint(node, "flags", mp->flags); + vat_json_object_add_uint(node, "next protocol", mp->next_protocol); + vat_json_object_add_uint(node, "ver_res", mp->ver_res); + vat_json_object_add_uint(node, "res", mp->res); + vat_json_object_add_uint(node, "iid", ntohl(mp->iid)); + + vec_free(next_decap_str); +} + +static void +vl_api_lisp_map_resolver_details_t_handler ( + vl_api_lisp_map_resolver_details_t *mp) +{ + vat_main_t *vam = &vat_main; + + fformat(vam->ofp, "%=20U\n", + mp->is_ipv6 ? format_ip6_address : format_ip4_address, + mp->ip_address); +} + +static void +vl_api_lisp_map_resolver_details_t_handler_json ( + vl_api_lisp_map_resolver_details_t *mp) +{ + vat_main_t *vam = &vat_main; + vat_json_node_t *node = NULL; + struct in6_addr ip6; + struct in_addr ip4; + + if (VAT_JSON_ARRAY != vam->json_tree.type) { + ASSERT(VAT_JSON_NONE == vam->json_tree.type); + vat_json_init_array(&vam->json_tree); + } + node = vat_json_array_add(&vam->json_tree); + + vat_json_init_object(node); + if (mp->is_ipv6) { + memcpy(&ip6, mp->ip_address, sizeof(ip6)); + vat_json_object_add_ip6(node, "map resolver", ip6); + } else { + memcpy(&ip4, mp->ip_address, sizeof(ip4)); + vat_json_object_add_ip4(node, "map resolver", ip4); + } +} + #define vl_api_vnet_ip4_fib_counters_t_endian vl_noop_handler #define vl_api_vnet_ip4_fib_counters_t_print vl_noop_handler #define vl_api_vnet_ip6_fib_counters_t_endian vl_noop_handler @@ -1943,7 +2155,13 @@ _(cop_whitelist_enable_disable_reply) \ _(sw_interface_clear_stats_reply) \ _(trace_profile_add_reply) \ _(trace_profile_apply_reply) \ -_(trace_profile_del_reply) +_(trace_profile_del_reply) \ +_(lisp_add_del_locator_set_reply) \ +_(lisp_add_del_locator_reply) \ +_(lisp_add_del_local_eid_reply) \ +_(lisp_gpe_add_del_fwd_entry_reply) \ +_(lisp_add_del_map_resolver_reply) \ +_(lisp_gpe_add_del_iface_reply) #define _(n) \ static void vl_api_##n##_t_handler \ @@ -2105,7 +2323,17 @@ _(GET_NODE_GRAPH_REPLY, get_node_graph_reply) \ _(SW_INTERFACE_CLEAR_STATS_REPLY, sw_interface_clear_stats_reply) \ _(TRACE_PROFILE_ADD_REPLY, trace_profile_add_reply) \ _(TRACE_PROFILE_APPLY_REPLY, trace_profile_apply_reply) \ -_(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) +_(TRACE_PROFILE_DEL_REPLY, trace_profile_del_reply) \ +_(LISP_ADD_DEL_LOCATOR_SET_REPLY, lisp_add_del_locator_set_reply) \ +_(LISP_ADD_DEL_LOCATOR_REPLY, lisp_add_del_locator_reply) \ +_(LISP_ADD_DEL_LOCAL_EID_REPLY, lisp_add_del_local_eid_reply) \ +_(LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY, lisp_gpe_add_del_fwd_entry_reply) \ +_(LISP_ADD_DEL_MAP_RESOLVER_REPLY, lisp_add_del_map_resolver_reply) \ +_(LISP_GPE_ADD_DEL_IFACE_REPLY, lisp_gpe_add_del_iface_reply) \ +_(LISP_LOCATOR_SET_DETAILS, lisp_locator_set_details) \ +_(LISP_LOCAL_EID_TABLE_DETAILS, lisp_local_eid_table_details) \ +_(LISP_GPE_TUNNEL_DETAILS, lisp_gpe_tunnel_details) \ +_(LISP_MAP_RESOLVER_DETAILS, lisp_map_resolver_details) /* M: construct, but don't yet send a message */ @@ -9128,6 +9356,553 @@ static int api_get_node_graph (vat_main_t * vam) W; } +static int +api_lisp_add_del_locator_set(vat_main_t * vam) +{ + unformat_input_t * input = vam->input; + vl_api_lisp_add_del_locator_set_t *mp; + f64 timeout = ~0; + u8 is_add = 1; + u8 *locator_set_name = NULL; + u8 locator_set_name_set = 0; + + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { + if (unformat(input, "del")) { + is_add = 0; + } else if (unformat(input, "locator-set %s", &locator_set_name)) { + locator_set_name_set = 1; + } else + break; + } + + if (locator_set_name_set == 0) { + errmsg ("missing locator-set name"); + return -99; + } + + if (vec_len(locator_set_name) > 64) { + errmsg ("locator-set name too long\n"); + vec_free(locator_set_name); + return -99; + } + vec_add1(locator_set_name, 0); + + /* Construct the API message */ + M(LISP_ADD_DEL_LOCATOR_SET, lisp_add_del_locator_set); + + mp->is_add = is_add; + memcpy(mp->locator_set_name, locator_set_name, + vec_len(locator_set_name)); + vec_free(locator_set_name); + + /* send it... */ + S; + + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_add_del_locator(vat_main_t * vam) +{ + unformat_input_t * input = vam->input; + vl_api_lisp_add_del_locator_t *mp; + f64 timeout = ~0; + u32 tmp_if_index = ~0; + u32 sw_if_index = ~0; + u8 sw_if_index_set = 0; + u8 sw_if_index_if_name_set = 0; + u8 priority = ~0; + u8 priority_set = 0; + u8 weight = ~0; + u8 weight_set = 0; + u8 is_add = 1; + u8 *locator_set_name = NULL; + u8 locator_set_name_set = 0; + + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { + if (unformat(input, "del")) { + is_add = 0; + } else if (unformat(input, "locator-set %s", &locator_set_name)) { + locator_set_name_set = 1; + } else if (unformat(input, "iface %U", unformat_sw_if_index, vam, + &tmp_if_index)) { + sw_if_index_if_name_set = 1; + sw_if_index = tmp_if_index; + } else if (unformat(input,"sw_if_index %d", &tmp_if_index)) { + sw_if_index_set = 1; + sw_if_index = tmp_if_index; + } else if (unformat(input, "p %d", &priority)) { + priority_set = 1; + } else if (unformat(input, "w %d", &weight)) { + weight_set = 1; + } else + break; + } + + if (locator_set_name_set == 0) { + errmsg ("missing locator-set name"); + return -99; + } + + if (sw_if_index_set == 0 && sw_if_index_if_name_set == 0) { + errmsg ("missing sw_if_index"); + vec_free(locator_set_name); + return -99; + } + + if (sw_if_index_set != 0 && sw_if_index_if_name_set != 0) { + errmsg ("cannot use both params interface name and sw_if_index"); + vec_free(locator_set_name); + return -99; + } + + if (priority_set == 0) { + errmsg ("missing locator-set priority\n"); + vec_free(locator_set_name); + return -99; + } + + if (weight_set == 0) { + errmsg ("missing locator-set weight\n"); + vec_free(locator_set_name); + return -99; + } + + if (vec_len(locator_set_name) > 64) { + errmsg ("locator-set name too long\n"); + vec_free(locator_set_name); + return -99; + } + vec_add1(locator_set_name, 0); + + /* Construct the API message */ + M(LISP_ADD_DEL_LOCATOR, lisp_add_del_locator); + + mp->is_add = is_add; + mp->sw_if_index = ntohl(sw_if_index); + mp->priority = priority; + mp->weight = weight; + memcpy(mp->locator_set_name, locator_set_name, + vec_len(locator_set_name)); + vec_free(locator_set_name); + + /* send it... */ + S; + + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_add_del_local_eid(vat_main_t * vam) +{ + unformat_input_t * input = vam->input; + vl_api_lisp_add_del_local_eid_t *mp; + f64 timeout = ~0; + u8 is_add = 1; + u8 eidv4_set = 0; + u8 eidv6_set = 0; + ip4_address_t eidv4; + ip6_address_t eidv6; + u8 tmp_eid_lenght = ~0; + u8 eid_lenght = ~0; + u8 *locator_set_name = NULL; + u8 locator_set_name_set = 0; + + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { + if (unformat(input, "del")) { + is_add = 0; + } else if (unformat(input, "eid %U/%d", unformat_ip4_address, + &eidv4, &tmp_eid_lenght)) { + eid_lenght = tmp_eid_lenght; + eidv4_set = 1; + } else if (unformat(input, "eid %U/%d", unformat_ip6_address, + &eidv6, &tmp_eid_lenght)) { + eid_lenght = tmp_eid_lenght; + eidv6_set = 1; + } else if (unformat(input, "locator-set %s", &locator_set_name)) { + locator_set_name_set = 1; + } else + break; + } + + if (locator_set_name_set == 0) { + errmsg ("missing locator-set name\n"); + return -99; + } + + if (vec_len(locator_set_name) > 64) { + errmsg ("locator-set name too long\n"); + vec_free(locator_set_name); + return -99; + } + vec_add1(locator_set_name, 0); + + if (eidv4_set && eidv6_set) { + errmsg ("both eid v4 and v6 addresses set\n"); + vec_free(locator_set_name); + return -99; + } + + if (!eidv4_set && !eidv6_set) { + errmsg ("eid addresses not set\n"); + vec_free(locator_set_name); + return -99; + } + + /* Construct the API message */ + M(LISP_ADD_DEL_LOCAL_EID, lisp_add_del_local_eid); + + mp->is_add = is_add; + if (eidv6_set) { + mp->is_ipv6 = 1; + memcpy(mp->ip_address, &eidv6, sizeof(eidv6)); + } else { + mp->is_ipv6 = 0; + memcpy(mp->ip_address, &eidv4, sizeof(eidv4)); + } + mp->prefix_len = eid_lenght; + memcpy(mp->locator_set_name, locator_set_name, + vec_len(locator_set_name)); + vec_free(locator_set_name); + + /* send it... */ + S; + + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_gpe_add_del_fwd_entry(vat_main_t * vam) +{ + unformat_input_t * input = vam->input; + vl_api_lisp_gpe_add_del_fwd_entry_t *mp; + f64 timeout = ~0; + u8 is_add = 1; + u8 eidv4_set = 0, slocv4_set = 0, dlocv4_set = 0; + u8 eidv6_set = 0, slocv6_set = 0, dlocv6_set = 0; + ip4_address_t eidv4, slocv4, dlocv4; + ip6_address_t eidv6, slocv6, dlocv6; + u8 tmp_eid_lenght = ~0; + u8 eid_lenght = ~0; + + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { + if (unformat(input, "del")) { + is_add = 0; + } else if (unformat(input, "eid %U/%d", unformat_ip4_address, + &eidv4, &tmp_eid_lenght)) { + eid_lenght = tmp_eid_lenght; + eidv4_set = 1; + } else if (unformat(input, "eid %U/%d", unformat_ip6_address, + &eidv6, &tmp_eid_lenght)) { + eid_lenght = tmp_eid_lenght; + eidv6_set = 1; + } else if (unformat(input, "sloc %U", unformat_ip4_address, &slocv4)) { + slocv4_set = 1; + } else if (unformat(input, "sloc %U", unformat_ip6_address, &slocv6)) { + slocv6_set = 1; + } else if (unformat(input, "dloc %U", unformat_ip4_address, &dlocv4)) { + dlocv4_set = 1; + } else if (unformat(input, "dloc %U", unformat_ip6_address, &dlocv6)) { + dlocv6_set = 1; + } else + break; + } + + if (eidv4_set && eidv6_set) { + errmsg ("both eid v4 and v6 addresses set\n"); + return -99; + } + + if (!eidv4_set && !eidv6_set) { + errmsg ("eid addresses not set\n"); + return -99; + } + + if (slocv4_set && slocv6_set) { + errmsg ("both source v4 and v6 addresses set\n"); + return -99; + } + + if (!slocv4_set && !slocv6_set) { + errmsg ("source addresses not set\n"); + return -99; + } + + if (dlocv4_set && dlocv6_set) { + errmsg ("both destination v4 and v6 addresses set\n"); + return -99; + } + + if (dlocv4_set && dlocv6_set) { + errmsg ("destination addresses not set\n"); + return -99; + } + + if (!(slocv4_set == dlocv4_set && slocv6_set == dlocv6_set)) { + errmsg ("mixing type of source and destination address\n"); + return -99; + } + + /* Construct the API message */ + M(LISP_GPE_ADD_DEL_FWD_ENTRY, lisp_gpe_add_del_fwd_entry); + + mp->is_add = is_add; + if (eidv6_set) { + mp->eid_is_ipv6 = 1; + memcpy(mp->eid_ip_address, &eidv6, sizeof(eidv6)); + } else { + mp->eid_is_ipv6 = 0; + memcpy(mp->eid_ip_address, &eidv4, sizeof(eidv4)); + } + mp->eid_prefix_len = eid_lenght; + if (slocv6_set) { + mp->address_is_ipv6 = 1; + memcpy(mp->source_ip_address, &slocv6, sizeof(slocv6)); + memcpy(mp->destination_ip_address, &dlocv6, sizeof(dlocv6)); + } else { + mp->address_is_ipv6 = 0; + memcpy(mp->source_ip_address, &slocv4, sizeof(slocv4)); + memcpy(mp->destination_ip_address, &dlocv4, sizeof(dlocv4)); + } + + /* send it... */ + S; + + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_add_del_map_resolver(vat_main_t * vam) +{ + unformat_input_t * input = vam->input; + vl_api_lisp_add_del_map_resolver_t *mp; + f64 timeout = ~0; + u8 is_add = 1; + u8 ipv4_set = 0; + u8 ipv6_set = 0; + ip4_address_t ipv4; + ip6_address_t ipv6; + + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { + if (unformat(input, "del")) { + is_add = 0; + } else if (unformat(input, "%U", unformat_ip4_address, &ipv4)) { + ipv4_set = 1; + } else if (unformat(input, "%U", unformat_ip6_address, &ipv6)) { + ipv6_set = 1; + } else + break; + } + + if (ipv4_set && ipv6_set) { + errmsg ("both eid v4 and v6 addresses set\n"); + return -99; + } + + if (!ipv4_set && !ipv6_set) { + errmsg ("eid addresses not set\n"); + return -99; + } + + /* Construct the API message */ + M(LISP_ADD_DEL_MAP_RESOLVER, lisp_add_del_map_resolver); + + mp->is_add = is_add; + if (ipv6_set) { + mp->is_ipv6 = 1; + memcpy(mp->ip_address, &ipv6, sizeof(ipv6)); + } else { + mp->is_ipv6 = 0; + memcpy(mp->ip_address, &ipv4, sizeof(ipv4)); + } + + /* send it... */ + S; + + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_gpe_add_del_iface(vat_main_t * vam) +{ + unformat_input_t * input = vam->input; + vl_api_lisp_gpe_add_del_iface_t *mp; + f64 timeout = ~0; + u8 is_set = 0; + u8 is_add = 1; + + /* Parse args required to build the message */ + while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) { + if (unformat(input, "up")) { + is_set = 1; + is_add = 1; + } else if (unformat(input, "down")) { + is_set = 1; + is_add = 0; + } else + break; + } + + if (is_set == 0) { + errmsg("Value not set\n"); + return -99; + } + + /* Construct the API message */ + M(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface); + + mp->is_add = is_add; + + /* send it... */ + S; + + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_locator_set_dump(vat_main_t *vam) +{ + vl_api_lisp_locator_set_dump_t *mp; + f64 timeout = ~0; + + if (!vam->json_output) { + fformat(vam->ofp, "%=20s%=16s%=16s%=16s\n", + "Locator-set", "Locator", "Priority", "Weight"); + } + + M(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump); + /* send it... */ + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t * mp; + M(CONTROL_PING, control_ping); + S; + } + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_local_eid_table_dump(vat_main_t *vam) +{ + vl_api_lisp_local_eid_table_dump_t *mp; + f64 timeout = ~0; + + if (!vam->json_output) { + fformat(vam->ofp, "%=20s%=30s\n", + "Locator-set", "Eid"); + } + + M(LISP_LOCAL_EID_TABLE_DUMP, lisp_local_eid_table_dump); + /* send it... */ + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t * mp; + M(CONTROL_PING, control_ping); + S; + } + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_gpe_tunnel_dump(vat_main_t *vam) +{ + vl_api_lisp_gpe_tunnel_dump_t *mp; + f64 timeout = ~0; + + if (!vam->json_output) { + fformat(vam->ofp, "%=20s%=30s%=16s%=16s%=16s%=16s" + "%=16s%=16s%=16s%=16s%=16s\n", + "Tunel", "Source", "Destination", "Fib encap", "Fib decap", + "Decap next", "Lisp version", "Flags", "Next protocol", + "ver_res", "res", "iid"); + } + + M(LISP_GPE_TUNNEL_DUMP, lisp_gpe_tunnel_dump); + /* send it... */ + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t * mp; + M(CONTROL_PING, control_ping); + S; + } + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + +static int +api_lisp_map_resolver_dump(vat_main_t *vam) +{ + vl_api_lisp_map_resolver_dump_t *mp; + f64 timeout = ~0; + + if (!vam->json_output) { + fformat(vam->ofp, "%=20s\n", + "Map resolver"); + } + + M(LISP_MAP_RESOLVER_DUMP, lisp_map_resolver_dump); + /* send it... */ + S; + + /* Use a control ping for synchronization */ + { + vl_api_control_ping_t * mp; + M(CONTROL_PING, control_ping); + S; + } + /* Wait for a reply... */ + W; + + /* NOTREACHED */ + return 0; +} + static int q_or_quit (vat_main_t * vam) { longjmp (vam->jump_buf, 1); @@ -9597,7 +10372,21 @@ _(trace_profile_add, "id <nn> trace-type <0x1f|0x3|0x9|0x11|0x19> " \ "app-data <app_data in hex> [pow] [ppc <encap|decap>]") \ _(trace_profile_apply, "id <nn> <ip6-address>/<width>" \ " vrf_id <nn> add | pop | none") \ -_(trace_profile_del, "") +_(trace_profile_del, "") \ +_(lisp_add_del_locator_set, "locator-set <locator_name> [del]") \ +_(lisp_add_del_locator, "locator-set <locator_name> " \ + "iface <intf> | sw_if_index <sw_if_index> " \ + "p <priority> w <weight> [del]") \ +_(lisp_add_del_local_eid, "<ipv4|ipv6>/<prefix> " \ + "locator-set <locator_name> [del]") \ +_(lisp_gpe_add_del_fwd_entry, "eid <ip4|6-addr>/<prefix> " \ + "sloc <ip4/6-addr> dloc <ip4|6-addr> [del]") \ +_(lisp_add_del_map_resolver, "<ip4|6-addr> [del]") \ +_(lisp_gpe_add_del_iface, "up|down") \ +_(lisp_locator_set_dump, "") \ +_(lisp_local_eid_table_dump, "") \ +_(lisp_gpe_tunnel_dump, "") \ +_(lisp_map_resolver_dump, "") /* List of command functions, CLI names map directly to functions */ #define foreach_cli_function \ diff --git a/vpp/api/api.c b/vpp/api/api.c index f9e69024ae0..32be34f7c01 100644 --- a/vpp/api/api.c +++ b/vpp/api/api.c @@ -68,6 +68,7 @@ #include <vnet/nsh-gre/nsh_gre.h> #include <vnet/nsh-vxlan-gpe/nsh_vxlan_gpe.h> #include <vnet/lisp-gpe/lisp_gpe.h> +#include <vnet/lisp-cp/control.h> #include <vnet/map/map.h> #include <vnet/cop/cop.h> #include <vnet/ip/ip6_hop_by_hop.h> @@ -322,7 +323,17 @@ _(GET_NODE_GRAPH, get_node_graph) \ _(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) +_(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_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) #define QUOTE_(x) #x #define QUOTE(x) QUOTE_(x) @@ -4477,6 +4488,442 @@ 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) = IP_PREFIX; + + if (mp->is_ipv6) { + memcpy(&ip_addr_v6(ip_eid), mp->ip_address, + sizeof(ip_addr_v6(ip_eid))); + ip_addr_version(ip_eid) = IP6; + } else { + 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_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) { + memcpy(&ip_addr_v6(ip_eid), mp->eid_ip_address, + sizeof(ip_addr_v6(ip_eid))); + ip_addr_version(ip_eid) = IP6; + } else { + 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) { + memcpy(&ip_addr_v6(slocator), mp->source_ip_address, + sizeof(ip_addr_v6(slocator))); + ip_addr_version(slocator) = IP6; + memcpy(&ip_addr_v6(dlocator), mp->destination_ip_address, + sizeof(ip_addr_v6(dlocator))); + ip_addr_version(dlocator) = IP6; + } else { + memcpy(&ip_addr_v4(slocator), mp->source_ip_address, + sizeof(ip_addr_v4(slocator))); + ip_addr_version(slocator) = IP4; + 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) { + memcpy(&ip_addr_v6(ip_addr), mp->ip_address, + sizeof(ip_addr_v6(ip_addr))); + ip_addr_version(ip_addr) = IP6; + } else { + 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_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; + 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 != 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; + memcpy(rmp->eid_ip_address, &ip_prefix_v4(ip_prefix), + sizeof(ip_prefix_v4(ip_prefix))); + break; + + case IP6: + rmp->eid_is_ipv6 = 1; + 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; + ip4_address_t *ip4 = NULL; + + 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; + + /*list_gpe_tunnel now support only IPv4*/ + rmp->is_ipv6 = 0; + ip4 = &tunnel->src; + memcpy(rmp->source_ip, ip4, sizeof(*ip4)); + ip4 = &tunnel->dst; + memcpy(rmp->destination_ip, ip4, sizeof(*ip4)); + + 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->iid); + + 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; + memcpy(rmp->ip_address, &ip_addr_v4(ip), sizeof(ip_addr_v4(ip))); + break; + + case IP6: + rmp->is_ipv6 = 1; + 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) { diff --git a/vpp/api/vpe.api b/vpp/api/vpe.api index d9e62e2ab12..4414a7f7ade 100644 --- a/vpp/api/vpe.api +++ b/vpp/api/vpe.api @@ -2184,6 +2184,252 @@ define lisp_gpe_add_del_tunnel_reply { u32 sw_if_index; }; +/** \brief add or delete locator_set + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_add - add address if non-zero, else delete + @param locator_set_name - locator name +*/ +define lisp_add_del_locator_set { + u32 client_index; + u32 context; + u8 is_add; + u8 locator_set_name[64]; +}; + +/** \brief Reply for locator_set add/del + @param context - returned sender context, to match reply w/ request + @param retval - return code +*/ +define lisp_add_del_locator_set_reply { + u32 context; + i32 retval; +}; + +/** \brief add or delete locator for locator_set + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_add - add address if non-zero, else delete + @param locator_set_name - name of locator_set to add/del locator + @param sw_if_index - index of the interface + @param priority - priority of the lisp locator + @param weight - weight of the lisp locator +*/ +define lisp_add_del_locator { + u32 client_index; + u32 context; + u8 is_add; + u8 locator_set_name[64]; + u32 sw_if_index; + u8 priority; + u8 weight; +}; + +/** \brief Reply for locator add/del + @param context - returned sender context, to match reply w/ request + @param retval - return code +*/ +define lisp_add_del_locator_reply { + u32 context; + i32 retval; +}; + +/** \brief add or delete lisp eid-table + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_add - add address if non-zero, else delete + @param is_ipv6 - if non-zero the address is ipv6, else ipv4 + @param ip_address - array of address bytes + @param prefix_len - prefix len + @param locator_set_name - name of locator_set to add/del eid-table +*/ +define lisp_add_del_local_eid { + u32 client_index; + u32 context; + u8 is_add; + u8 is_ipv6; + u8 ip_address[16]; + u8 prefix_len; + u8 locator_set_name[64]; +}; + +/** \brief Reply for local_eid add/del + @param context - returned sender context, to match reply w/ request + @param retval - return code +*/ +define lisp_add_del_local_eid_reply { + u32 context; + i32 retval; +}; + +/** \brief add or delete lisp gpe maptunel + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_add - add address if non-zero, else delete + @param eid_is_ipv6 - if non-zero the address is ipv6, else ipv4 + @param eid_ip_address - array of address bytes + @param eid_prefix_len - prefix len + @param address_is_ipv6 - if non-zero the address is ipv6, else ipv4 + @param source_ip_address - array of address bytes + @param destination_ip_address - array of address bytes +*/ +define lisp_gpe_add_del_fwd_entry { + u32 client_index; + u32 context; + u8 is_add; + u8 eid_is_ipv6; + u8 eid_ip_address[16]; + u8 eid_prefix_len; + u8 address_is_ipv6; + u8 source_ip_address[16]; + u8 destination_ip_address[16]; +}; + +/** \brief Reply for gpe_fwd_entry add/del + @param context - returned sender context, to match reply w/ request + @param retval - return code +*/ +define lisp_gpe_add_del_fwd_entry_reply { + u32 context; + i32 retval; +}; + +/** \brief add or delete map-resolver + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_add - add address if non-zero, else delete + @param is_ipv6 - if non-zero the address is ipv6, else ipv4 + @param ip_address - array of address bytes +*/ +define lisp_add_del_map_resolver { + u32 client_index; + u32 context; + u8 is_add; + u8 is_ipv6; + u8 ip_address[16]; +}; + +/** \brief Reply for map_resolver add/del + @param context - returned sender context, to match reply w/ request + @param retval - return code +*/ +define lisp_add_del_map_resolver_reply { + u32 context; + i32 retval; +}; + +/** \brief add or delete gpe_iface + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + @param is_add - add address if non-zero, else delete +*/ +define lisp_gpe_add_del_iface { + u32 client_index; + u32 context; + u8 is_add; +}; + +/** \brief Reply for gpe_iface add/del + @param context - returned sender context, to match reply w/ request + @param retval - return code +*/ +define lisp_gpe_add_del_iface_reply { + u32 context; + i32 retval; +}; + +/** \brief LISP locator_set status + @param locator_set_name - name of the locator_set + @param sw_if_index - sw_if_index of the locator + @param priority - locator priority + @param weight - locator weight + */ +manual_java define lisp_locator_set_details { + u32 context; + u8 locator_set_name[64]; + u32 sw_if_index; + u8 priority; + u8 weight; +}; + +/** \brief Request for locator_set summary status + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + */ +define lisp_locator_set_dump { + u32 client_index; + u32 context; +}; + +/** \brief LISP local eid table status + @param locator_set_name - name of the locator_set + @param eid_is_ipv6 - if non-zero the address is ipv6, else ipv4 + @param eid_ip_address - array of address bytes + @param eid_prefix_len - prefix len + */ +manual_java define lisp_local_eid_table_details { + u32 context; + u8 locator_set_name[64]; + u8 eid_is_ipv6; + u8 eid_ip_address[16]; + u8 eid_prefix_len; +}; + +/** \brief Request for local eid table summary status + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + */ +define lisp_local_eid_table_dump { + u32 client_index; + u32 context; +}; + +manual_java define lisp_gpe_tunnel_details { + u32 context; + u32 tunnels; + u8 is_ipv6; + u8 source_ip[16]; + u8 destination_ip[16]; + u32 encap_fib_id; + u32 decap_fib_id; + u32 dcap_next; + u8 lisp_ver; + u8 next_protocol; + u8 flags; + u8 ver_res; + u8 res; + u32 iid; +}; + +/** \brief Request for gpe tunnel summary status + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + */ +define lisp_gpe_tunnel_dump { + u32 client_index; + u32 context; +}; + +/** \brief LISP map resolver status + @param locator_set_name - name of the locator_set + @param is_ipv6 - if non-zero the address is ipv6, else ipv4 + @param ip_address - array of address bytes + */ +manual_java define lisp_map_resolver_details { + u32 context; + u8 is_ipv6; + u8 ip_address[16]; +}; + +/** \brief Request for map resolver summary status + @param client_index - opaque cookie to identify the sender + @param context - sender context, to match reply w/ request + */ +define lisp_map_resolver_dump { + u32 client_index; + u32 context; +}; + /* Gross kludge, DGMS */ define interface_name_renumber { u32 client_index; |