void
ospf6_asbr_external_lsa_remove (struct ospf6_lsa *lsa)
{
struct ospf6_lsa_as_external *external;
struct prefix dest;
char buf[64];
struct ospf6_route_req request;
if (IS_OSPF6_DUMP_ASBR)
zlog_info ("ASBR: Withdraw route of %s", lsa->str);
if (lsa->header->adv_router == ospf6->router_id)
{
if (IS_OSPF6_DUMP_ASBR)
zlog_info ("ASBR: Self-originated, ignore");
return;
}
external = OSPF6_LSA_HEADER_END (lsa->header);
memset (&dest, 0, sizeof (dest));
dest.family = AF_INET6;
dest.prefixlen = external->prefix.prefix_length;
memcpy (&dest.u.prefix6, (char *)(external + 1),
OSPF6_PREFIX_SPACE (dest.prefixlen));
prefix2str (&dest, buf, sizeof (buf));
if (IS_OSPF6_DUMP_ASBR)
zlog_info ("ASBR: route: %s", buf);
ospf6_route_lookup (&request, &dest, ospf6->route_table);
if (ospf6_route_end (&request))
{
zlog_info ("ASBR: route not found");
return;
}
while (request.path.origin.id != lsa->header->id ||
request.path.origin.adv_router != lsa->header->adv_router)
{
if (prefix_same (&request.route.prefix, &dest) != 1)
{
zlog_info ("ASBR: Can't find the entry matches the origin");
return;
}
ospf6_route_next (&request);
}
assert (request.path.origin.id == lsa->header->id);
assert (request.path.origin.adv_router == request.path.origin.adv_router);
while (request.path.origin.id == lsa->header->id &&
request.path.origin.adv_router == lsa->header->adv_router &&
prefix_same (&request.route.prefix, &dest) == 1)
{
ospf6_route_remove (&request, ospf6->route_table);
ospf6_route_next (&request);
}
}
struct ospf_interface *
ospf_if_lookup_by_prefix (struct ospf *ospf, struct prefix_ipv4 *p)
{
struct listnode *node;
struct ospf_interface *oi;
struct prefix ptmp;
/* Check each Interface. */
for (node = listhead (ospf->oiflist); node; nextnode (node))
{
if ((oi = getdata (node)) != NULL && oi->type != OSPF_IFTYPE_VIRTUALLINK)
{
if ((oi->type == OSPF_IFTYPE_POINTOPOINT) &&
CONNECTED_DEST_HOST(oi->connected))
{
prefix_copy (&ptmp, oi->connected->destination);
ptmp.prefixlen = IPV4_MAX_BITLEN;
}
else
prefix_copy (&ptmp, oi->address);
apply_mask (&ptmp);
if (prefix_same (&ptmp, (struct prefix *) p))
return oi;
}
}
return NULL;
}
mpls_bool mpls_policy_egress_check(mpls_instance_handle handle, mpls_fec * fec,
mpls_nexthop *nexthop)
{
struct ldp *ldp = handle;
int result = MPLS_BOOL_FALSE;
struct prefix p;
switch(ldp->egress) {
case LDP_EGRESS_ALL:
{
result = MPLS_BOOL_TRUE;
break;
}
case LDP_EGRESS_LSRID:
{
mpls_fec2zebra_prefix(fec,&p);
if (prefix_same(&router_id, &p)) {
result = MPLS_BOOL_TRUE;
}
break;
}
case LDP_EGRESS_CONNECTED:
{
if (nexthop->attached == MPLS_BOOL_TRUE) {
result = MPLS_BOOL_TRUE;
}
break;
}
default:
break;
}
return result;
}
static void check_lookup_result(struct list *list, va_list arglist)
{
char *prefix_str;
unsigned int prefix_count = 0;
printf("Searching results\n");
while ((prefix_str = va_arg(arglist, char *))) {
struct listnode *listnode;
struct bgp_node *bnode;
struct prefix p;
bool found = false;
prefix_count++;
printf("Searching for %s\n", prefix_str);
if (str2prefix(prefix_str, &p) <= 0)
assert(0);
for (ALL_LIST_ELEMENTS_RO(list, listnode, bnode)) {
if (prefix_same(&bnode->p, &p))
found = true;
}
assert(found);
}
printf("Checking for unexpected result items\n");
printf("Expecting %d found %d\n", prefix_count, listcount(list));
assert(prefix_count == listcount(list));
}
/* Check if two ifc's describe the same address in the same state */
static int
connected_same (struct connected *ifc1, struct connected *ifc2)
{
if (ifc1->ifp != ifc2->ifp)
return 0;
if (ifc1->destination)
if (!ifc2->destination)
return 0;
if (ifc2->destination)
if (!ifc1->destination)
return 0;
if (ifc1->destination && ifc2->destination)
if (!prefix_same (ifc1->destination, ifc2->destination))
return 0;
if (ifc1->flags != ifc2->flags)
return 0;
if (ifc1->conf != ifc2->conf)
return 0;
return 1;
}
void
router_id_del_address (struct connected *ifc)
{
struct connected *c;
struct list *l;
struct prefix after;
struct prefix before;
struct listnode *node;
struct zserv *client;
if (router_id_bad_address (ifc))
return;
router_id_get (&before);
if (!strncmp (ifc->ifp->name, "lo", 2)
|| !strncmp (ifc->ifp->name, "dummy", 5))
l = &rid_lo_sorted_list;
else
l = &rid_all_sorted_list;
if ((c = router_id_find_node (l, ifc)))
listnode_delete (l, c);
router_id_get (&after);
if (prefix_same (&before, &after))
return;
for (ALL_LIST_ELEMENTS_RO (zebrad.client_list, node, client))
zsend_router_id_update (client, &after);
}
void
router_id_add_address (struct connected *ifc)
{
struct list *l = NULL;
struct listnode *node;
struct prefix before;
struct prefix after;
struct zserv *client;
struct zebra_vrf *zvrf = vrf_info_get (ifc->ifp->vrf_id);
if (router_id_bad_address (ifc))
return;
router_id_get (&before, zvrf->vrf_id);
if (!strncmp (ifc->ifp->name, "lo", 2)
|| !strncmp (ifc->ifp->name, "dummy", 5))
l = zvrf->rid_lo_sorted_list;
else
l = zvrf->rid_all_sorted_list;
if (!router_id_find_node (l, ifc))
listnode_add_sort (l, ifc);
router_id_get (&after, zvrf->vrf_id);
if (prefix_same (&before, &after))
return;
for (ALL_LIST_ELEMENTS_RO (zebrad.client_list, node, client))
zsend_router_id_update (client, &after, zvrf->vrf_id);
}
/* If same interface address is already exist... */
struct connected *connected_check(struct interface *ifp, struct prefix *p)
{
struct connected *ifc;
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO(ifp->connected, node, ifc))
if (prefix_same(ifc->address, p))
return ifc;
return NULL;
}
static struct connected *
router_id_find_node (struct list *l, struct connected *ifc)
{
struct listnode *node;
struct connected *c;
for (ALL_LIST_ELEMENTS_RO (l, node, c))
if (prefix_same (ifc->address, c->address))
return c;
return NULL;
}
int if_address_add_v6(struct ctrl_client * ctrl_client, struct rfpbuf * buffer)
{
const struct rfp_ipv6_address * address = buffer->data;
struct interface * ifp = if_lookup_by_index(ctrl_client->if_list, address->ifindex);
struct connected * ifc;
struct prefix p;
memcpy(&p.u.prefix, &address->p, 16);
p.prefixlen = address->prefixlen;
p.family = AF_INET6;
ifc = connected_add_by_prefix(ifp, &p, NULL);
if(ifc == NULL)
return 1;
if(IS_OSPF6_SIBLING_DEBUG_MSG)
{
char prefix_str[INET6_ADDRSTRLEN+3]; // three extra chars for slash + two digits
if(prefix2str(ifc->address, prefix_str, INET6_ADDRSTRLEN) != 1)
{
zlog_debug("v6 addr: %s", prefix_str, ifc->address->prefixlen);
}
}
// check here for:
// 1. prefix matches
// 2. extract hostnum from host portion of address
// 3. if hostnum matches, this is the internal interface that should be recorded
char inter_target_str[INET6_ADDRSTRLEN+3]; // three extra chars for slash + two digits
struct prefix inter_target_p;
sprintf(inter_target_str, "2001:db8:beef:10::%x/64", ctrl_client->hostnum);
str2prefix(inter_target_str, &inter_target_p);
// link up the internal connected address with a pointer at ctrl_client
if(prefix_same(ifc->address, &inter_target_p))
{
ctrl_client->inter_con = ifc;
}
// since connected address is AF_INET6, needs to be updated
ospf6_interface_connected_route_update(ifc->ifp);
return 0;
}
struct sharp_nh_tracker *sharp_nh_tracker_get(struct prefix *p)
{
struct listnode *node;
struct sharp_nh_tracker *nht;
for (ALL_LIST_ELEMENTS_RO(sg.nhs, node, nht)) {
if (prefix_same(&nht->p, p))
break;
}
if (nht)
return nht;
nht = XCALLOC(MTYPE_NH_TRACKER, sizeof(*nht));
prefix_copy(&nht->p, p);
listnode_add(sg.nhs, nht);
return nht;
}
struct ospf_interface *ospf_if_lookup_by_prefix(struct ospf *ospf,
struct prefix_ipv4 *p)
{
struct listnode *node;
struct ospf_interface *oi;
/* Check each Interface. */
for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
if (oi->type != OSPF_IFTYPE_VIRTUALLINK) {
struct prefix ptmp;
prefix_copy(&ptmp, CONNECTED_PREFIX(oi->connected));
apply_mask(&ptmp);
if (prefix_same(&ptmp, (struct prefix *)p))
return oi;
}
}
return NULL;
}
void
isis_circuit_add_addr (struct isis_circuit *circuit,
struct connected *connected)
{
struct listnode *node;
struct prefix_ipv4 *ipv4;
u_char buf[BUFSIZ];
#ifdef HAVE_IPV6
struct prefix_ipv6 *ipv6;
#endif /* HAVE_IPV6 */
memset (&buf, 0, BUFSIZ);
if (connected->address->family == AF_INET)
{
u_int32_t addr = connected->address->u.prefix4.s_addr;
addr = ntohl (addr);
if (IPV4_NET0(addr) ||
IPV4_NET127(addr) ||
IN_CLASSD(addr) ||
IPV4_LINKLOCAL(addr))
return;
for (ALL_LIST_ELEMENTS_RO (circuit->ip_addrs, node, ipv4))
if (prefix_same ((struct prefix *) ipv4, connected->address))
return;
ipv4 = prefix_ipv4_new ();
ipv4->prefixlen = connected->address->prefixlen;
ipv4->prefix = connected->address->u.prefix4;
listnode_add (circuit->ip_addrs, ipv4);
/* Update MPLS TE Local IP address parameter */
set_circuitparams_local_ipaddr (circuit->mtc, ipv4->prefix);
if (circuit->area)
lsp_regenerate_schedule (circuit->area, circuit->is_type, 0);
#ifdef EXTREME_DEBUG
prefix2str (connected->address, buf, BUFSIZ);
zlog_debug ("Added IP address %s to circuit %d", buf,
circuit->circuit_id);
#endif /* EXTREME_DEBUG */
}
struct ospf_interface *
ospf_if_lookup_by_prefix (struct ospf *ospf, struct prefix_ipv4 *p)
{
listnode node;
struct ospf_interface *oi;
struct prefix ptmp;
/* Check each Interface. */
for (node = listhead (ospf->oiflist); node; nextnode (node))
{
if ((oi = getdata (node)) != NULL && oi->type != OSPF_IFTYPE_VIRTUALLINK)
{
prefix_copy (&ptmp, oi->address);
if (oi->type == OSPF_IFTYPE_POINTOPOINT)
ptmp.prefixlen = IPV4_ALLOWABLE_BITLEN_P2P;
apply_mask (&ptmp);
if (prefix_same (&ptmp, (struct prefix *) p))
return oi;
}
}
return NULL;
}
struct ospf6_lsa *
ospf6_lsdb_lookup_next (u_int16_t type, u_int32_t id, u_int32_t adv_router,
struct ospf6_lsdb *lsdb)
{
struct route_node *node;
struct route_node *matched = NULL;
struct prefix_ipv6 key;
struct prefix *p;
if (lsdb == NULL)
return NULL;
memset (&key, 0, sizeof (key));
ospf6_lsdb_set_key (&key, &type, sizeof (type));
ospf6_lsdb_set_key (&key, &adv_router, sizeof (adv_router));
ospf6_lsdb_set_key (&key, &id, sizeof (id));
p = (struct prefix *) &key;
{
char buf[64];
prefix2str (p, buf, sizeof (buf));
zlog_debug ("lsdb_lookup_next: key: %s", buf);
}
node = lsdb->table->top;
/* walk down tree. */
while (node && node->p.prefixlen <= p->prefixlen &&
prefix_match (&node->p, p))
{
matched = node;
node = node->link[prefix_bit(&p->u.prefix, node->p.prefixlen)];
}
if (matched)
node = matched;
else
node = lsdb->table->top;
route_lock_node (node);
/* skip to real existing entry */
while (node && node->info == NULL)
node = route_next (node);
if (! node)
return NULL;
if (prefix_same (&node->p, p))
{
struct route_node *prev = node;
struct ospf6_lsa *lsa_prev;
struct ospf6_lsa *lsa_next;
node = route_next (node);
while (node && node->info == NULL)
node = route_next (node);
lsa_prev = prev->info;
lsa_next = (node ? node->info : NULL);
assert (lsa_prev);
assert (lsa_prev->next == lsa_next);
if (lsa_next)
assert (lsa_next->prev == lsa_prev);
zlog_debug ("lsdb_lookup_next: assert OK with previous LSA");
}
if (! node)
return NULL;
route_unlock_node (node);
return (struct ospf6_lsa *) node->info;
}
