/* delete dp fwd entry */
u32 sw_if_index;
a->is_add = 0;
- a->rmt_loc = fe->dst_loc;
- a->lcl_loc = fe->src_loc;
+ a->locator_pairs = fe->locator_pairs;
a->vni = gid_address_vni(&a->rmt_eid);
gid_address_copy(&a->rmt_eid, &fe->deid);
/* delete entry in fwd table */
hash_unset(lcm->fwd_entry_by_mapping_index, dst_map_index);
+ vec_free(fe->locator_pairs);
pool_put(lcm->fwd_entry_pool, fe);
}
*/
static u32
get_locator_pair (lisp_cp_main_t* lcm, mapping_t * lcl_map, mapping_t * rmt_map,
- ip_address_t * lcl_loc, ip_address_t * rmt_loc)
+ locator_pair_t ** locator_pairs)
{
u32 i, minp = ~0, limitp = 0, li, check_index = 0, done = 0, esi;
locator_set_t * rmt_ls, * lcl_ls;
ip_address_t _lcl, * lcl = &_lcl;
locator_t * l, * rmt = 0;
uword * checked = 0;
+ locator_pair_t pair;
rmt_ls = pool_elt_at_index(lcm->locator_set_pool, rmt_map->locator_set_index);
lcl_ls = pool_elt_at_index(lcm->locator_set_pool, lcl_map->locator_set_index);
gid_address_ip_version(&rmt->address), lcl))
continue;
- ip_address_copy(rmt_loc, &gid_address_ip(&rmt->address));
- ip_address_copy(lcl_loc, lcl);
+ memset(&pair, 0, sizeof(pair));
+ ip_address_copy(&pair.rmt_loc, &gid_address_ip(&rmt->address));
+ ip_address_copy(&pair.lcl_loc, lcl);
+ vec_add1(locator_pairs[0], pair);
done = 2;
}
}
}
/* find best locator pair that 1) verifies LISP policy 2) are connected */
- if (0 == get_locator_pair (lcm, src_map, dst_map, &a->lcl_loc, &a->rmt_loc))
+ if (0 == get_locator_pair (lcm, src_map, dst_map, &a->locator_pairs))
{
/* negative entry */
a->is_negative = 1;
/* add tunnel to fwd entry table XXX check return value from DP insertion */
pool_get (lcm->fwd_entry_pool, fe);
- fe->dst_loc = a->rmt_loc;
- fe->src_loc = a->lcl_loc;
+ fe->locator_pairs = a->locator_pairs;
gid_address_copy (&fe->deid, &a->rmt_eid);
hash_set (lcm->fwd_entry_by_mapping_index, dst_map_index,
fe - lcm->fwd_entry_pool);
is_add = 0;
else if (unformat (line_input, "add"))
;
- else if (unformat (line_input, "%U", unformat_gid_address, &eid))
+ else if (unformat (line_input, "eid %U", unformat_gid_address, &eid))
eid_set = 1;
else if (unformat (line_input, "vni %u", &vni))
{
curr_rloc->weight = w;
}
else if (unformat (line_input, "rloc %U", unformat_ip_address,
- &rloc.address))
+ &gid_address_ip(&rloc.address)))
{
vec_add1 (rlocs, rloc);
curr_rloc = &rlocs[vec_len (rlocs) - 1];
if (!del_all)
{
-
-
if (is_add && (~0 == action)
&& 0 == vec_len (rlocs))
{
/* fill in the key's remote eid */
if (!is_l2)
- ip_prefix_copy (&key.rmt_ippref, &gid_address_ippref(&a->rmt_eid));
+ ip_prefix_copy (&key.rmt.ippref, &gid_address_ippref(&a->rmt_eid));
else
- mac_copy (&key.rmt_mac, &gid_address_mac(&a->rmt_eid));
+ mac_copy (&key.rmt.mac, &gid_address_mac(&a->rmt_eid));
-
- ip_address_copy(&key.rmt_loc, &a->rmt_loc);
key.vni = clib_host_to_net_u32 (a->vni);
p = mhash_get (&lgm->lisp_gpe_tunnel_by_key, &key);
foreach_copy_field;
#undef _
- ip_address_copy(&t->src, &a->lcl_loc);
- ip_address_copy(&t->dst, &a->rmt_loc);
+ /* TODO multihoming */
+ if (!a->is_negative)
+ {
+ ip_address_copy (&t->src, &a->locator_pairs[0].lcl_loc);
+ ip_address_copy (&t->dst, &a->locator_pairs[0].rmt_loc);
+ }
/* if vni is non-default */
if (a->vni)
/* next proto */
if (!is_l2)
- t->next_protocol = ip_prefix_version(&key.rmt_ippref) == IP4 ?
+ t->next_protocol = ip_prefix_version(&key.rmt.ippref) == IP4 ?
LISP_GPE_NEXT_PROTO_IP4 : LISP_GPE_NEXT_PROTO_IP6;
else
t->next_protocol = LISP_GPE_NEXT_PROTO_ETHERNET;
}
static int
-add_del_negative_ip_fwd_entry (lisp_gpe_main_t * lgm,
- vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
-{
- ip_adjacency_t adj;
- ip_prefix_t * dpref = &gid_address_ippref(&a->rmt_eid);
- ip_prefix_t * spref = &gid_address_ippref(&a->lcl_eid);
-
- /* setup adjacency for eid */
- memset (&adj, 0, sizeof(adj));
- adj.n_adj = 1;
-
- /* fill in 'legal' data to avoid issues */
- adj.lookup_next_index = (ip_prefix_version(dpref) == IP4) ?
- lgm->ip4_lookup_next_lgpe_ip4_lookup :
- lgm->ip6_lookup_next_lgpe_ip6_lookup;
-
- adj.rewrite_header.sw_if_index = ~0;
- adj.rewrite_header.next_index = ~0;
-
- switch (a->action)
- {
- case LISP_NO_ACTION:
- /* TODO update timers? */
- case LISP_FORWARD_NATIVE:
- /* TODO check if route/next-hop for eid exists in fib and add
- * more specific for the eid with the next-hop found */
- case LISP_SEND_MAP_REQUEST:
- /* insert tunnel that always sends map-request */
- adj.explicit_fib_index = (ip_prefix_version(dpref) == IP4) ?
- LGPE_IP4_LOOKUP_NEXT_LISP_CP_LOOKUP:
- LGPE_IP6_LOOKUP_NEXT_LISP_CP_LOOKUP;
- /* add/delete route for prefix */
- return ip_sd_fib_add_del_route (lgm, dpref, spref, a->table_id, &adj,
- a->is_add);
- case LISP_DROP:
- /* for drop fwd entries, just add route, no need to add encap tunnel */
- adj.explicit_fib_index = (ip_prefix_version(dpref) == IP4 ?
- LGPE_IP4_LOOKUP_NEXT_DROP : LGPE_IP6_LOOKUP_NEXT_DROP);
-
- /* add/delete route for prefix */
- return ip_sd_fib_add_del_route (lgm, dpref, spref, a->table_id, &adj,
- a->is_add);
- default:
- return -1;
- }
-}
-
-static int
-add_del_ip_fwd_entry (lisp_gpe_main_t * lgm,
- vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
+build_ip_adjacency (lisp_gpe_main_t * lgm, ip_adjacency_t * adj, u32 table_id,
+ u32 vni, u32 tun_index, u8 is_negative, u8 action,
+ u8 ip_ver)
{
- ip_adjacency_t adj, * adjp;
- u32 adj_index, rv, tun_index = ~0;
- ip_prefix_t * dpref, * spref;
uword * lookup_next_index, * lgpe_sw_if_index, * lnip;
- u8 ip_ver;
-
- /* treat negative fwd entries separately */
- if (a->is_negative)
- return add_del_negative_ip_fwd_entry (lgm, a);
-
- /* add/del tunnel to tunnels pool and prepares rewrite */
- rv = add_del_ip_tunnel (a, 0 /* is_l2 */, &tun_index);
- if (rv)
- return rv;
-
- dpref = &gid_address_ippref(&a->rmt_eid);
- spref = &gid_address_ippref(&a->lcl_eid);
- ip_ver = ip_prefix_version(dpref);
-
- /* setup adjacency for eid */
- memset (&adj, 0, sizeof(adj));
- adj.n_adj = 1;
+ memset(adj, 0, sizeof(adj[0]));
+ adj->n_adj = 1;
/* fill in lookup_next_index with a 'legal' value to avoid problems */
- adj.lookup_next_index = (ip_ver == IP4) ?
+ adj->lookup_next_index = (ip_ver == IP4) ?
lgm->ip4_lookup_next_lgpe_ip4_lookup :
lgm->ip6_lookup_next_lgpe_ip6_lookup;
- if (a->is_add)
+ /* positive mapping */
+ if (!is_negative)
{
/* send packets that hit this adj to lisp-gpe interface output node in
* requested vrf. */
lnip = (ip_ver == IP4) ?
lgm->lgpe_ip4_lookup_next_index_by_table_id :
lgm->lgpe_ip6_lookup_next_index_by_table_id;
- lookup_next_index = hash_get(lnip, a->table_id);
- lgpe_sw_if_index = hash_get(lgm->l3_ifaces.sw_if_index_by_vni, a->vni);
+ lookup_next_index = hash_get(lnip, table_id);
+ lgpe_sw_if_index = hash_get(lgm->l3_ifaces.sw_if_index_by_vni, vni);
/* the assumption is that the interface must've been created before
* programming the dp */
/* hijack explicit fib index to store lisp interface node index and
* if_address_index for the tunnel index */
- adj.explicit_fib_index = lookup_next_index[0];
- adj.if_address_index = tun_index;
- adj.rewrite_header.sw_if_index = lgpe_sw_if_index[0];
+ adj->explicit_fib_index = lookup_next_index[0];
+ adj->if_address_index = tun_index;
+ adj->rewrite_header.sw_if_index = lgpe_sw_if_index[0];
+ }
+ /* negative mapping */
+ else
+ {
+ adj->rewrite_header.sw_if_index = ~0;
+ adj->rewrite_header.next_index = ~0;
+
+ switch (action)
+ {
+ case LISP_NO_ACTION:
+ /* TODO update timers? */
+ case LISP_FORWARD_NATIVE:
+ /* TODO check if route/next-hop for eid exists in fib and add
+ * more specific for the eid with the next-hop found */
+ case LISP_SEND_MAP_REQUEST:
+ /* insert tunnel that always sends map-request */
+ adj->explicit_fib_index = (ip_ver == IP4) ?
+ LGPE_IP4_LOOKUP_NEXT_LISP_CP_LOOKUP:
+ LGPE_IP6_LOOKUP_NEXT_LISP_CP_LOOKUP;
+ break;
+ case LISP_DROP:
+ /* for drop fwd entries, just add route, no need to add encap tunnel */
+ adj->explicit_fib_index = (ip_ver == IP4 ?
+ LGPE_IP4_LOOKUP_NEXT_DROP : LGPE_IP6_LOOKUP_NEXT_DROP);
+ break;
+ default:
+ return -1;
+ }
+ }
+ return 0;
+}
+
+static int
+add_del_ip_fwd_entry (lisp_gpe_main_t * lgm,
+ vnet_lisp_gpe_add_del_fwd_entry_args_t * a)
+{
+ ip_adjacency_t adj, * adjp;
+ u32 rv, tun_index = ~0;
+ ip_prefix_t * rmt_pref, * lcl_pref;
+ u8 ip_ver;
+
+ rmt_pref = &gid_address_ippref(&a->rmt_eid);
+ lcl_pref = &gid_address_ippref(&a->lcl_eid);
+ ip_ver = ip_prefix_version(rmt_pref);
+
+ /* add/del tunnel to tunnels pool and prepares rewrite */
+ if (!a->is_negative)
+ {
+ rv = add_del_ip_tunnel (a, 0 /* is_l2 */, &tun_index);
+ if (rv)
+ {
+ clib_warning ("failed to build tunnel!");
+ return rv;
+ }
}
- /* add/delete route for prefix */
- rv = ip_sd_fib_add_del_route (lgm, dpref, spref, a->table_id, &adj,
+ /* setup adjacency for eid */
+ rv = build_ip_adjacency (lgm, &adj, a->table_id, a->vni, tun_index,
+ a->is_negative, a->action, ip_ver);
+
+ /* add/delete route for eid */
+ rv |= ip_sd_fib_add_del_route (lgm, rmt_pref, lcl_pref, a->table_id, &adj,
a->is_add);
+ if (rv)
+ {
+ clib_warning ("failed to insert route for tunnel!");
+ return rv;
+ }
+
/* check that everything worked */
if (CLIB_DEBUG && a->is_add)
{
- adj_index = ip_sd_fib_get_route (lgm, dpref, spref, a->table_id);
+ u32 adj_index;
+ adj_index = ip_sd_fib_get_route (lgm, rmt_pref, lcl_pref, a->table_id);
ASSERT(adj_index != 0);
adjp = ip_get_adjacency ((ip_ver == IP4) ? lgm->lm4 : lgm->lm6,
{
unformat_input_t _line_input, * line_input = &_line_input;
u8 is_add = 1;
- ip_address_t lloc, rloc, *llocs = 0, *rlocs = 0;
+ ip_address_t lloc, rloc;
clib_error_t * error = 0;
gid_address_t _reid, * reid = &_reid, _leid, * leid = &_leid;
u8 reid_set = 0, leid_set = 0, is_negative = 0, vrf_set = 0, vni_set = 0;
- u32 vni, vrf, action = ~0;
+ u32 vni, vrf, action = ~0, p, w;
+ locator_pair_t pair, * pairs = 0;
int rv;
/* Get a line of input. */
{
is_negative = 1;
}
- else if (unformat (line_input, "lloc %U rloc %U",
+ else if (unformat (line_input, "loc-pair %U %U p %d w %d",
unformat_ip_address, &lloc,
- unformat_ip_address, &rloc))
+ unformat_ip_address, &rloc, &p, &w))
{
- /* TODO: support p and w */
- vec_add1 (llocs, lloc);
- vec_add1 (rlocs, rloc);
+ pair.lcl_loc = lloc;
+ pair.rmt_loc = rloc;
+ pair.priority = p;
+ pair.weight = w;
+ vec_add1(pairs, pair);
}
else
{
}
else
{
- if (vec_len (llocs) == 0)
+ if (vec_len (pairs) == 0)
{
error = clib_error_return (0, "expected ip4/ip6 locators.");
goto done;
}
-
- if (vec_len (llocs) != 1)
- {
- error = clib_error_return (0, "multihoming not supported for now!");
- goto done;
- }
}
a->table_id = vrf;
gid_address_copy(&a->lcl_eid, leid);
gid_address_copy(&a->rmt_eid, reid);
-
- if (!is_negative)
- {
- a->lcl_loc = llocs[0];
- a->rmt_loc = rlocs[0];
- }
+ a->locator_pairs = pairs;
rv = vnet_lisp_gpe_add_del_fwd_entry (a, 0);
if (0 != rv)
}
done:
- vec_free(llocs);
- vec_free(rlocs);
+ vec_free(pairs);
return error;
}
vec_add1(tunnels, tunnel[0]);
}));
- vec_foreach(tunnel, tunnels) {
+ vec_foreach(tunnel, tunnels)
+ {
memset(at, 0, sizeof(at[0]));
at->is_add = 0;
- gid_address_type(&at->rmt_eid) = GID_ADDR_IP_PREFIX;
- ip_prefix_copy(&gid_address_ippref(&at->rmt_eid), &tunnel->rmt_ippref);
- ip_address_copy(&at->rmt_loc, &tunnel->rmt_loc);
+ if (tunnel->rmt.type == GID_ADDR_IP_PREFIX)
+ {
+ gid_address_type(&at->rmt_eid) = GID_ADDR_IP_PREFIX;
+ ip_prefix_copy(&gid_address_ippref(&at->rmt_eid), &tunnel->rmt.ippref);
+ }
+ else
+ {
+ gid_address_type(&at->rmt_eid) = GID_ADDR_MAC;
+ mac_copy(&gid_address_mac(&at->rmt_eid), &tunnel->rmt.mac);
+ }
vnet_lisp_gpe_add_del_fwd_entry (at, 0);
}
vec_free(tunnels);
u8 addr[16]; /**< IPv4/IPv6 address */
}) rloc_t;
+static locator_pair_t *
+unformat_lisp_loc_pairs (void * lcl_locs, void * rmt_locs, u32 rloc_num)
+{
+ u32 i;
+ locator_pair_t * pairs = 0, pair;
+ rloc_t * r;
+
+ for (i = 0; i < rloc_num; i++) {
+ /* local locator */
+ r = &((rloc_t *) lcl_locs)[i];
+ memset(&pair.lcl_loc, 0, sizeof(pair.lcl_loc));
+ ip_address_set(&pair.lcl_loc, &r->addr, r->is_ip4 ? IP4 : IP6);
+
+ /* remote locators */
+ r = &((rloc_t *) rmt_locs)[i];
+ memset(&pair.rmt_loc, 0, sizeof(pair.rmt_loc));
+ ip_address_set(&pair.rmt_loc, &r->addr, r->is_ip4 ? IP4 : IP6);
+
+ pair.priority = r->priority;
+ pair.weight = r->weight;
+
+ vec_add1 (pairs, pair);
+ }
+ return pairs;
+}
+
static locator_t *
-unformat_lisp_locs (void * data, u32 rloc_num)
+unformat_lisp_locs (void * rmt_locs, u32 rloc_num)
{
u32 i;
- locator_t rloc, * rlocs = 0;
+ locator_t * locs = 0, loc;
+ rloc_t * r;
for (i = 0; i < rloc_num; i++) {
- rloc_t * r = &((rloc_t *) data)[i];
- memset(&rloc, 0, sizeof(rloc));
- gid_address_ip_set (&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);
+ /* remote locators */
+ r = &((rloc_t *) rmt_locs)[i];
+ memset(&loc, 0, sizeof(loc));
+ gid_address_ip_set(&loc.address, &r->addr, r->is_ip4 ? IP4 : IP6);
+
+ loc.priority = r->priority;
+ loc.weight = r->weight;
+
+ vec_add1 (locs, loc);
}
- return rlocs;
+ return locs;
}
static void
vl_api_lisp_gpe_add_del_fwd_entry_t *mp)
{
vl_api_lisp_gpe_add_del_fwd_entry_reply_t *rmp;
- int rv = 0;
vnet_lisp_gpe_add_del_fwd_entry_args_t _a, * a = &_a;
- locator_t * lcl_locs = 0, * rmt_locs = 0;
+ locator_pair_t * pairs = 0;
+ int rv = 0;
memset (a, 0, sizeof(a[0]));
rv |= unformat_lisp_eid_api (&a->lcl_eid, mp->vni, mp->eid_type,
mp->lcl_eid, mp->lcl_len);
- lcl_locs = unformat_lisp_locs (mp->lcl_locs, mp->loc_num);
- rmt_locs = unformat_lisp_locs (mp->rmt_locs, mp->loc_num);
+ pairs = unformat_lisp_loc_pairs (mp->lcl_locs, mp->rmt_locs, mp->loc_num);
- if (rv || 0 == lcl_locs || 0 == lcl_locs)
+ if (rv || 0 == pairs)
goto send_reply;
a->is_add = mp->is_add;
- a->lcl_loc = gid_address_ip(&lcl_locs[0].address); /* TODO support more */
- a->rmt_loc = gid_address_ip(&rmt_locs[0].address);
+ a->locator_pairs = pairs;
a->dp_table = mp->dp_table;
a->vni = mp->vni;
+ a->action = mp->action;
rv = vnet_lisp_gpe_add_del_fwd_entry (a, 0);
-
+ vec_free(pairs);
send_reply:
REPLY_MACRO(VL_API_LISP_GPE_ADD_DEL_FWD_ENTRY_REPLY);
}
Code Review / vpp.git / commitdiff