X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=vpp%2Fvpp-api%2Fapi.c;h=f7338af5db1e48849227f8d58f5bf0c53c1d2cad;hb=4d5cabde54f847bccd365c64682e428aead30550;hp=2ea92df019e6c39cc7e67a3ce0e58a6eec01bea2;hpb=aa6920e0a80d8271be1dda59f613a1d2b0e1d3e6;p=vpp.git diff --git a/vpp/vpp-api/api.c b/vpp/vpp-api/api.c index 2ea92df019e..f7338af5db1 100644 --- a/vpp/vpp-api/api.c +++ b/vpp/vpp-api/api.c @@ -79,6 +79,7 @@ #include #include #include +#include #undef BIHASH_TYPE #undef __included_bihash_template_h__ @@ -333,6 +334,7 @@ _(LISP_GPE_ENABLE_DISABLE, lisp_gpe_enable_disable) \ _(LISP_ENABLE_DISABLE, lisp_enable_disable) \ _(LISP_GPE_ADD_DEL_IFACE, lisp_gpe_add_del_iface) \ _(LISP_ADD_DEL_REMOTE_MAPPING, lisp_add_del_remote_mapping) \ +_(LISP_ADD_DEL_ADJACENCY, lisp_add_del_adjacency) \ _(LISP_PITR_SET_LOCATOR_SET, lisp_pitr_set_locator_set) \ _(LISP_EID_TABLE_ADD_DEL_MAP, lisp_eid_table_add_del_map) \ _(LISP_LOCATOR_SET_DUMP, lisp_locator_set_dump) \ @@ -364,7 +366,9 @@ _(CLASSIFY_TABLE_IDS,classify_table_ids) \ _(CLASSIFY_TABLE_BY_INTERFACE, classify_table_by_interface) \ _(CLASSIFY_TABLE_INFO,classify_table_info) \ _(CLASSIFY_SESSION_DUMP,classify_session_dump) \ -_(CLASSIFY_SESSION_DETAILS,classify_session_details) +_(CLASSIFY_SESSION_DETAILS,classify_session_details) \ +_(IPFIX_ENABLE,ipfix_enable) \ +_(IPFIX_DUMP,ipfix_dump) #define QUOTE_(x) #x #define QUOTE(x) QUOTE_(x) @@ -861,7 +865,7 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) uword * p; clib_error_t * e; u32 ai; - ip_adjacency_t *nh_adj, *add_adj = 0; + ip_adjacency_t *adj; p = hash_get (im->fib_index_by_table_id, ntohl(mp->vrf_id)); if (!p) { @@ -878,7 +882,8 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) fib_index = p[0]; } - if (pool_is_free_index (vnm->interface_main.sw_interfaces, + if (~0 != mp->next_hop_sw_if_index && + pool_is_free_index (vnm->interface_main.sw_interfaces, ntohl(mp->next_hop_sw_if_index))) return VNET_API_ERROR_NO_MATCHING_INTERFACE; @@ -886,7 +891,7 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) sizeof (next_hop_address.data)); /* Arp for the next_hop if necessary */ - if (mp->is_add && mp->resolve_if_needed) { + if (mp->is_add && mp->resolve_if_needed && ~0 != mp->next_hop_sw_if_index) { u32 lookup_result; ip_adjacency_t * adj; @@ -970,50 +975,43 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) else if (mp->is_local) ai = lm->local_adj_index; else if (mp->is_classify) { - 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)) { + if (pool_is_free_index (cm->tables, ntohl(mp->classify_table_index))) { dsunlock(sm); return VNET_API_ERROR_NO_SUCH_TABLE; } - vec_add1 (add_adj, cadj); - goto do_add_del; - } - else { - ai = ip4_fib_lookup_with_table - (im, fib_index, &next_hop_address, - 1 /* disable default route */); - if (ai == lm->miss_adj_index) { - dsunlock(sm); - return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB; - } - } + adj = ip_add_adjacency (lm, + /* template */ 0, + /* block size */ 1, + &ai); - nh_adj = ip_get_adjacency (lm, ai); - if (nh_adj->lookup_next_index == IP_LOOKUP_NEXT_ARP && - nh_adj->arp.next_hop.ip4.as_u32 == 0) { - /* the next-hop resovles via a glean adj. create and use - * a ARP adj for the next-hop */ - a.adj_index = vnet_arp_glean_add(fib_index, &next_hop_address); - a.add_adj = NULL; - a.n_add_adj = 0; - ip4_add_del_route (im, &a); - - goto done; + adj->lookup_next_index = IP_LOOKUP_NEXT_CLASSIFY; + adj->classify.table_index = ntohl(mp->classify_table_index); } - vec_add1 (add_adj, nh_adj[0]); - if (mp->lookup_in_vrf) { + else if (mp->lookup_in_vrf) { p = hash_get (im->fib_index_by_table_id, ntohl(mp->lookup_in_vrf)); - if (p) - add_adj[0].explicit_fib_index = p[0]; + if (p) { + adj = ip_add_adjacency (lm, + /* template */ 0, + /* block size */ 1, + &ai); + adj->explicit_fib_index = p[0]; + } else { - vec_free (add_adj); dsunlock(sm); - return VNET_API_ERROR_NO_SUCH_INNER_FIB; - } - } + return VNET_API_ERROR_NO_SUCH_INNER_FIB; + } + } + else + ai = ip4_route_get_next_hop_adj (im, + fib_index, + &next_hop_address, + ntohl(mp->next_hop_sw_if_index), + fib_index); + + if (ai == lm->miss_adj_index) { + dsunlock(sm); + return VNET_API_ERROR_NO_SUCH_INNER_FIB; + } } else { ip_adjacency_t * adj; int disable_default_route = 1; @@ -1037,15 +1035,9 @@ static int ip4_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) } } -do_add_del: - a.adj_index = ~0; - a.add_adj = add_adj; - a.n_add_adj = vec_len(add_adj); + a.adj_index = ai; ip4_add_del_route (im, &a); - vec_free (add_adj); - -done: dsunlock (sm); return 0; } @@ -1066,7 +1058,7 @@ static int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) u32 fib_index; uword * p; clib_error_t * e; - ip_adjacency_t * nh_adj, * add_adj = 0; + ip_adjacency_t *adj = 0; u32 ai; p = hash_get (im->fib_index_by_table_id, ntohl(mp->vrf_id)); @@ -1085,7 +1077,8 @@ static int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) fib_index = p[0]; } - if (pool_is_free_index (vnm->interface_main.sw_interfaces, + if (~0 != mp->next_hop_sw_if_index && + pool_is_free_index (vnm->interface_main.sw_interfaces, ntohl(mp->next_hop_sw_if_index))) return VNET_API_ERROR_NO_MATCHING_INTERFACE; @@ -1093,7 +1086,7 @@ static int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) sizeof (next_hop_address.as_u8)); /* Arp for the next_hop if necessary */ - if (mp->is_add && mp->resolve_if_needed) { + if (mp->is_add && mp->resolve_if_needed && ~0 != mp->next_hop_sw_if_index) { u32 lookup_result; ip_adjacency_t * adj; @@ -1175,27 +1168,30 @@ static int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) ai = lm->drop_adj_index; else if (mp->is_local) ai = lm->local_adj_index; - else { - ai = ip6_fib_lookup_with_table - (im, fib_index, &next_hop_address); - if (ai == lm->miss_adj_index) { - dsunlock(sm); - return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB; - } - } - - nh_adj = ip_get_adjacency (lm, ai); - vec_add1 (add_adj, nh_adj[0]); - if (mp->lookup_in_vrf) { + else if (mp->lookup_in_vrf) { p = hash_get (im->fib_index_by_table_id, ntohl(mp->lookup_in_vrf)); - if (p) - add_adj[0].explicit_fib_index = p[0]; + if (p) { + adj = ip_add_adjacency (lm, + /* template */ 0, + /* block size */ 1, + &ai); + adj->explicit_fib_index = p[0]; + } else { - vec_free (add_adj); - dsunlock(sm); + dsunlock(sm); return VNET_API_ERROR_NO_SUCH_INNER_FIB; - } - } + } + } + else + ai = ip6_route_get_next_hop_adj (im, + fib_index, + &next_hop_address, + ntohl(mp->next_hop_sw_if_index), + fib_index); + if (ai == lm->miss_adj_index) { + dsunlock(sm); + return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB; + } } else { ip_adjacency_t * adj; @@ -1212,13 +1208,9 @@ static int ip6_add_del_route_t_handler (vl_api_ip_add_del_route_t *mp) } } - a.adj_index = ~0; - a.add_adj = add_adj; - a.n_add_adj = vec_len(add_adj); + a.adj_index = ai; ip6_add_del_route (im, &a); - vec_free (add_adj); - dsunlock (sm); return 0; } @@ -1651,6 +1643,7 @@ vl_api_l2fib_add_del_t_handler ( u32 bd_index; u32 static_mac; u32 filter_mac; + u32 bvi_mac; uword * p; mac = mp->mac; @@ -1677,8 +1670,9 @@ vl_api_l2fib_add_del_t_handler ( } static_mac = mp->static_mac ? 1 : 0; filter_mac = mp->filter_mac ? 1 : 0; + bvi_mac = mp->bvi_mac ? 1 : 0; l2fib_add_entry(mac, bd_index, sw_if_index, static_mac, filter_mac, - 0 /* bvi_mac */); + bvi_mac); } else { l2fib_del_entry(mac, bd_index); } @@ -3111,10 +3105,10 @@ vl_api_sw_interface_ip6nd_ra_config_t_handler { vl_api_sw_interface_ip6nd_ra_config_reply_t * rmp; int rv = 0; - u8 is_no, surpress, managed, other, ll_option, send_unicast, cease, default_router; + u8 is_no, suppress, managed, other, ll_option, send_unicast, cease, default_router; is_no = mp->is_no == 1; - surpress = mp->surpress == 1; + suppress = mp->suppress == 1; managed = mp->managed == 1; other = mp->other == 1; ll_option = mp->ll_option == 1; @@ -3125,7 +3119,7 @@ vl_api_sw_interface_ip6nd_ra_config_t_handler VALIDATE_SW_IF_INDEX(mp); rv = ip6_neighbor_ra_config(vm, ntohl(mp->sw_if_index), - surpress, managed, other, + suppress, managed, other, ll_option, send_unicast, cease, default_router, ntohl (mp->lifetime), ntohl(mp->initial_count), ntohl(mp->initial_interval), @@ -4781,26 +4775,37 @@ vl_api_lisp_add_del_local_eid_t_handler( ip_prefix_t *prefp = NULL; ip_address_t *ip_eid = NULL; gid_address_t eid; + u8 * mac = gid_address_mac (&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; memset (a, 0, sizeof (a[0])); + memset (&eid, 0, sizeof (eid)); 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; + switch (mp->eid_type) + { + case 0: /* ipv4*/ + gid_address_type (&eid) = GID_ADDR_IP_PREFIX; + ip_address_set(ip_eid, mp->eid, IP4); + ip_prefix_len(prefp) = mp->prefix_len; + break; + case 1: /* ipv6 */ + gid_address_type (&eid) = GID_ADDR_IP_PREFIX; + ip_address_set(ip_eid, mp->eid, IP6); + ip_prefix_len(prefp) = mp->prefix_len; + break; + case 2: /* l2 mac */ + gid_address_type (&eid) = GID_ADDR_MAC; + clib_memcpy(mac, mp->eid, 6); + break; + default: + rv = VNET_API_ERROR_INVALID_EID_TYPE; + goto out; + } name = format(0, "%s", mp->locator_set_name); p = hash_get_mem(lcm->locator_set_index_by_name, name); @@ -4813,14 +4818,14 @@ vl_api_lisp_add_del_local_eid_t_handler( /* XXX treat batch configuration */ a->is_add = mp->is_add; gid_address_vni (&eid) = clib_net_to_host_u32 (mp->vni); - a->deid = eid; + gid_address_copy (&a->eid, &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); - gid_address_free (&a->deid); + gid_address_free (&a->eid); REPLY_MACRO(VL_API_LISP_ADD_DEL_LOCAL_EID_REPLY); } @@ -5008,6 +5013,8 @@ vl_api_lisp_add_del_map_request_itr_rlocs_t_handler typedef CLIB_PACKED(struct { u8 is_ip4; /**< is locator an IPv4 address */ + u8 priority; /**< locator priority */ + u8 weight; /**< locator weight */ u8 addr[16]; /**< IPv4/IPv6 address */ }) rloc_t; @@ -5033,7 +5040,7 @@ 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; + locator_t rloc, * rlocs = 0; vl_api_lisp_add_del_remote_mapping_reply_t * rmp; int rv = 0; gid_address_t _seid, * seid = &_seid; @@ -5041,47 +5048,161 @@ vl_api_lisp_add_del_remote_mapping_t_handler ( 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; + /* TODO remove seid from API */ + memset (seid, 0, sizeof (seid[0])); + memset (deid, 0, sizeof (deid[0])); 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; + u8 * seid_mac = gid_address_mac (seid); + u8 * deid_mac = gid_address_mac (deid); 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))); - } + switch (mp->eid_type) + { + case 0: /* ipv4 */ + gid_address_type(seid) = GID_ADDR_IP_PREFIX; + gid_address_type(deid) = GID_ADDR_IP_PREFIX; + ip_address_set (seid_addr, mp->seid, IP4); + ip_address_set (deid_addr, mp->deid, IP4); + break; + case 1: /* ipv6 */ + gid_address_type(seid) = GID_ADDR_IP_PREFIX; + gid_address_type(deid) = GID_ADDR_IP_PREFIX; + ip_address_set (seid_addr, mp->seid, IP6); + ip_address_set (deid_addr, mp->deid, IP6); + break; + case 2: /* l2 mac */ + gid_address_type(seid) = GID_ADDR_MAC; + gid_address_type(deid) = GID_ADDR_MAC; + clib_memcpy (seid_mac, mp->seid, 6); + clib_memcpy (deid_mac, mp->deid, 6); + break; + default: + rv = VNET_API_ERROR_INVALID_EID_TYPE; + goto send_reply; + } 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; - } + memset(&rloc, 0, sizeof(rloc)); + ip_address_set(&gid_address_ip(&rloc.address), &r->addr, + r->is_ip4 ? IP4 : IP6); + gid_address_ippref_len(&rloc.address) = r->is_ip4 ? 32: 128; + gid_address_type(&rloc.address) = GID_ADDR_IP_PREFIX; + rloc.priority = r->priority; + rloc.weight = r->weight; vec_add1 (rlocs, rloc); } - rv = vnet_lisp_add_del_remote_mapping (deid, seid, rlocs, mp->action, - mp->is_add, mp->del_all); + /* TODO Uncomment once https://gerrit.fd.io/r/#/c/1802 is merged and CSIT + * is switched to lisp_add_del_adjacency */ +// if (!mp->is_add) { +// vnet_lisp_add_del_adjacency_args_t _a, * a = &_a; +// gid_address_copy(&a->deid, deid); +// a->is_add = 0; +// rv = vnet_lisp_add_del_adjacency (a); +// } else { +// /* NOTE: for now this works as a static remote mapping, i.e., +// * not authoritative and ttl infinite. */ +// rv = vnet_lisp_add_del_mapping (deid, rlocs, mp->action, 0, ~0, +// mp->is_add, 0); +// } + + /* TODO: remove once the above is merged */ + vnet_lisp_add_del_adjacency_args_t _a, * a = &_a; + a->is_add = mp->is_add; + a->authoritative = 0; + a->action = mp->action; + a->locators = rlocs; + gid_address_copy(&a->seid, seid); + gid_address_copy(&a->deid, deid); + rv = vnet_lisp_add_del_adjacency (a); + + if (mp->del_all) + vnet_lisp_clear_all_remote_adjacencies (); + vec_free (rlocs); - REPLY_MACRO(VL_API_LISP_GPE_ADD_DEL_IFACE_REPLY); +send_reply: + REPLY_MACRO(VL_API_LISP_ADD_DEL_REMOTE_MAPPING_REPLY); +} + +static void +vl_api_lisp_add_del_adjacency_t_handler ( + vl_api_lisp_add_del_adjacency_t *mp) +{ + u32 i; + locator_t rloc; + vl_api_lisp_add_del_adjacency_reply_t * rmp; + vnet_lisp_add_del_adjacency_args_t _a, * a = &_a; + + int rv = 0; + memset(a, 0, sizeof(a[0])); + + ip_prefix_t * seid_pref = &gid_address_ippref(&a->seid); + ip_prefix_t * deid_pref = &gid_address_ippref(&a->deid); + + 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; + u8 * seid_mac = gid_address_mac (&a->seid); + u8 * deid_mac = gid_address_mac (&a->deid); + gid_address_vni(&a->seid) = ntohl (mp->vni); + gid_address_vni(&a->deid) = ntohl (mp->vni); + + switch (mp->eid_type) + { + case 0: /* ipv4 */ + gid_address_type(&a->seid) = GID_ADDR_IP_PREFIX; + gid_address_type(&a->deid) = GID_ADDR_IP_PREFIX; + ip_address_set (seid_addr, mp->seid, IP4); + ip_address_set (deid_addr, mp->deid, IP4); + break; + case 1: /* ipv6 */ + gid_address_type(&a->seid) = GID_ADDR_IP_PREFIX; + gid_address_type(&a->deid) = GID_ADDR_IP_PREFIX; + ip_address_set (seid_addr, mp->seid, IP6); + ip_address_set (deid_addr, mp->deid, IP6); + break; + case 2: /* l2 mac */ + gid_address_type(&a->seid) = GID_ADDR_MAC; + gid_address_type(&a->deid) = GID_ADDR_MAC; + clib_memcpy (seid_mac, mp->seid, 6); + clib_memcpy (deid_mac, mp->deid, 6); + break; + default: + rv = VNET_API_ERROR_INVALID_EID_TYPE; + goto send_reply; + } + + for (i = 0; i < mp->rloc_num; i++) { + rloc_t * r = &((rloc_t *) mp->rlocs)[i]; + memset(&rloc, 0, sizeof(rloc)); + ip_address_set(&gid_address_ip(&rloc.address), &r->addr, + r->is_ip4 ? IP4 : IP6); + gid_address_ippref_len(&rloc.address) = r->is_ip4 ? 32: 128; + gid_address_type(&rloc.address) = GID_ADDR_IP_PREFIX; + rloc.priority = r->priority; + rloc.weight = r->weight; + vec_add1 (a->locators, rloc); + } + + a->action = mp->action; + a->is_add = mp->is_add; + + /* NOTE: the remote mapping is static, i.e., not authoritative and + * ttl is infinite. */ + a->authoritative = 0; + a->ttl = ~0; + + rv = vnet_lisp_add_del_adjacency (a); + + vec_free (a->locators); +send_reply: + REPLY_MACRO(VL_API_LISP_ADD_DEL_ADJACENCY_REPLY); } static void @@ -5152,21 +5273,15 @@ send_lisp_local_eid_table_details (mapping_t *mapit, lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); locator_set_t *ls = NULL; gid_address_t *gid = NULL; + u8 * mac = 0; 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); + mac = gid_address_mac(gid); rmp = vl_msg_api_alloc (sizeof (*rmp)); memset (rmp, 0, sizeof (*rmp)); @@ -5182,23 +5297,30 @@ send_lisp_local_eid_table_details (mapping_t *mapit, 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), + switch (gid_address_type (gid)) + { + case GID_ADDR_IP_PREFIX: + rmp->eid_prefix_len = ip_prefix_len(ip_prefix); + if (ip_prefix_version(ip_prefix) == IP4) + { + rmp->eid_type = 0; /* ipv4 type */ + clib_memcpy(rmp->eid, &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), + } + else + { + rmp->eid_type = 1; /* ipv6 type */ + clib_memcpy(rmp->eid, &ip_prefix_v6(ip_prefix), sizeof(ip_prefix_v6(ip_prefix))); - break; - - default: - ASSERT(0); - } - rmp->eid_prefix_len = ip_prefix_len(ip_prefix); + } + break; + case GID_ADDR_MAC: + rmp->eid_type = 2; /* l2 mac type */ + clib_memcpy(rmp->eid, mac, 6); + break; + default: + ASSERT(0); + } rmp->context = context; rmp->vni = clib_host_to_net_u32 (gid_address_vni (gid)); vl_msg_api_send_shmem (q, (u8 *)&rmp); @@ -5208,19 +5330,50 @@ static void vl_api_lisp_local_eid_table_dump_t_handler ( vl_api_lisp_local_eid_table_dump_t *mp) { + u32 mi; unix_shared_memory_queue_t * q = NULL; lisp_cp_main_t * lcm = vnet_lisp_cp_get_main(); mapping_t * mapit = NULL; + gid_address_t _eid, * eid = &_eid; q = vl_api_client_index_to_input_queue (mp->client_index); if (q == 0) { return; } - pool_foreach (mapit, lcm->mapping_pool, + if (mp->eid_set) { + memset (eid, 0, sizeof (*eid)); + gid_address_vni(eid) = ntohl(mp->vni); + switch (mp->eid_type) { + case 0: + gid_address_type(eid) = GID_ADDR_IP_PREFIX; + gid_address_ippref_len(eid) = mp->prefix_length; + gid_address_ip_version(eid) = IP4; + clib_memcpy (&gid_address_ippref(eid), mp->eid, 4); + break; + case 1: + gid_address_type(eid) = GID_ADDR_IP_PREFIX; + gid_address_ippref_len(eid) = mp->prefix_length; + gid_address_ip_version(eid) = IP6; + clib_memcpy (&gid_address_ippref(eid), mp->eid, 16); + break; + case 2: + gid_address_type(eid) = GID_ADDR_MAC; + clib_memcpy (gid_address_mac(eid), mp->eid, 6); + break; + } + mi = gid_dictionary_lookup (&lcm->mapping_index_by_gid, eid); + if ((u32)~0 == mi) + return; + + mapit = pool_elt_at_index (lcm->mapping_pool, mi); + send_lisp_local_eid_table_details(mapit, q, mp->context); + } else { + pool_foreach (mapit, lcm->mapping_pool, ({ send_lisp_local_eid_table_details(mapit, q, mp->context); })); + } } static void @@ -5593,11 +5746,17 @@ static void vl_api_ipsec_spd_add_del_entry_t_handler 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); - + if (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); + } else { + clib_memcpy(&p.raddr.start.ip4.data, mp->remote_address_start, 4); + clib_memcpy(&p.raddr.stop.ip4.data, mp->remote_address_stop, 4); + clib_memcpy(&p.laddr.start.ip4.data, mp->local_address_start, 4); + clib_memcpy(&p.laddr.stop.ip4.data, mp->local_address_stop, 4); + } p.protocol = mp->protocol; p.rport.start = ntohs(mp->remote_port_start); p.rport.stop = ntohs(mp->remote_port_stop); @@ -5674,8 +5833,13 @@ static void vl_api_ipsec_sad_add_del_entry_t_handler 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); + if (sa.is_tunnel_ip6) { + clib_memcpy(&sa.tunnel_src_addr, mp->tunnel_src_address, 16); + clib_memcpy(&sa.tunnel_dst_addr, mp->tunnel_dst_address, 16); + } else { + clib_memcpy(&sa.tunnel_src_addr.ip4.data, mp->tunnel_src_address, 4); + clib_memcpy(&sa.tunnel_dst_addr.ip4.data, mp->tunnel_dst_address, 4); + } rv = ipsec_add_del_sa(vm, &sa, mp->is_add); #else @@ -6855,6 +7019,106 @@ static void vl_api_classify_session_dump_t_handler (vl_api_classify_session_dump })); } +static void vl_api_ipfix_enable_t_handler (vl_api_ipfix_enable_t *mp) +{ + vlib_main_t *vm = vlib_get_main(); + flow_report_main_t * frm = &flow_report_main; + vl_api_ipfix_enable_reply_t *rmp; + ip4_address_t collector, src; + u16 collector_port = UDP_DST_PORT_ipfix; + u32 path_mtu; + u32 template_interval; + u32 fib_id; + u32 fib_index = ~0; + int rv = 0; + + memcpy(collector.data, mp->collector_address, sizeof(collector.data)); + collector_port = ntohs(mp->collector_port); + if (collector_port == (u16)~0) + collector_port = UDP_DST_PORT_ipfix; + memcpy(src.data, mp->src_address, sizeof(src.data)); + fib_id = ntohl(mp->vrf_id); + + ip4_main_t * im = &ip4_main; + uword * p = hash_get (im->fib_index_by_table_id, fib_id); + if (! p) { + rv = VNET_API_ERROR_NO_SUCH_FIB; + goto out; + } + fib_index = p[0]; + + path_mtu = ntohl(mp->path_mtu); + if (path_mtu == ~0) + path_mtu = 512; // RFC 7011 section 10.3.3. + template_interval = ntohl(mp->template_interval); + if (template_interval == ~0) + template_interval = 20; + + if (collector.as_u32 == 0) { + rv = VNET_API_ERROR_INVALID_VALUE; + goto out; + } + + if (src.as_u32 == 0) { + rv = VNET_API_ERROR_INVALID_VALUE; + goto out; + } + + if (path_mtu > 1450 /* vpp does not support fragmentation */) { + rv = VNET_API_ERROR_INVALID_VALUE; + goto out; + } + + if (path_mtu < 68) { + rv = VNET_API_ERROR_INVALID_VALUE; + goto out; + } + + /* Reset report streams if we are reconfiguring IP addresses */ + if (frm->ipfix_collector.as_u32 != collector.as_u32 || + frm->src_address.as_u32 != src.as_u32 || + frm->collector_port != collector_port) + vnet_flow_reports_reset(frm); + + frm->ipfix_collector.as_u32 = collector.as_u32; + frm->collector_port = collector_port; + frm->src_address.as_u32 = src.as_u32; + frm->fib_index = fib_index; + frm->path_mtu = path_mtu; + frm->template_interval = template_interval; + + /* Turn on the flow reporting process */ + vlib_process_signal_event (vm, flow_report_process_node.index, + 1, 0); + +out: + REPLY_MACRO(VL_API_IPFIX_ENABLE_REPLY); +} + +static void vl_api_ipfix_dump_t_handler (vl_api_ipfix_dump_t *mp) +{ + flow_report_main_t * frm = &flow_report_main; + unix_shared_memory_queue_t * q; + vl_api_ipfix_details_t *rmp; + + q = vl_api_client_index_to_input_queue (mp->client_index); + + rmp = vl_msg_api_alloc (sizeof (*rmp)); + memset (rmp, 0, sizeof (*rmp)); + rmp->_vl_msg_id = ntohs(VL_API_IPFIX_DETAILS); + rmp->context = mp->context; + memcpy(rmp->collector_address, frm->ipfix_collector.data, + sizeof(frm->ipfix_collector.data)); + rmp->collector_port = htons(frm->collector_port); + memcpy(rmp->src_address, frm->src_address.data, + sizeof(frm->src_address.data)); + rmp->fib_index = htonl(frm->fib_index); + rmp->path_mtu = htonl(frm->path_mtu); + rmp->template_interval = htonl(frm->template_interval); + + vl_msg_api_send_shmem (q, (u8 *)&rmp); +} + #define BOUNCE_HANDLER(nn) \ static void vl_api_##nn##_t_handler ( \ vl_api_##nn##_t *mp) \