/* Lookup interface by IPv4 address. */
struct interface *
if_lookup_exact_address (struct in_addr src)
{
listnode node;
listnode cnode;
struct interface *ifp;
struct prefix *p;
struct connected *c;
for (node = listhead (iflist); node; nextnode (node))
{
ifp = getdata (node);
for (cnode = listhead (ifp->connected); cnode; nextnode (cnode))
{
c = getdata (cnode);
p = c->address;
if (p && p->family == AF_INET)
{
if (IPV4_ADDR_SAME (&p->u.prefix4, &src))
return ifp;
}
}
}
return NULL;
}
void
ospf6_area_show (struct vty *vty, struct ospf6_area *o6a)
{
listnode i;
struct ospf6_interface *o6i;
vty_out (vty, " Area %s%s", o6a->str, VTY_NEWLINE);
vty_out (vty, " Number of Area scoped LSAs is %u%s",
o6a->lsdb->count, VTY_NEWLINE);
ospf6_spf_statistics_show (vty, o6a->spf_tree);
vty_out (vty, " Interface attached to this area:");
for (i = listhead (o6a->if_list); i; nextnode (i))
{
o6i = (struct ospf6_interface *) getdata (i);
vty_out (vty, " %s", o6i->interface->name);
}
vty_out (vty, "%s", VTY_NEWLINE);
for (i = listhead (o6a->if_list); i; nextnode (i))
{
o6i = (struct ospf6_interface *) getdata (i);
if (listcount (o6i->neighbor_list) != 0)
ospf6_interface_statistics_show (vty, o6i);
}
}
void
ospf6_abr_examin_brouter (u_int32_t router_id)
{
struct ospf6_lsa *lsa;
struct ospf6_area *oa;
listnode node;
u_int16_t type;
type = htons (OSPF6_LSTYPE_INTER_ROUTER);
for (node = listhead (ospf6->area_list); node; nextnode (node))
{
oa = OSPF6_AREA (getdata (node));
for (lsa = ospf6_lsdb_type_router_head (type, router_id, oa->lsdb); lsa;
lsa = ospf6_lsdb_type_router_next (type, router_id, lsa))
ospf6_abr_examin_summary (lsa, oa);
}
type = htons (OSPF6_LSTYPE_INTER_PREFIX);
for (node = listhead (ospf6->area_list); node; nextnode (node))
{
oa = OSPF6_AREA (getdata (node));
for (lsa = ospf6_lsdb_type_router_head (type, router_id, oa->lsdb); lsa;
lsa = ospf6_lsdb_type_router_next (type, router_id, lsa))
ospf6_abr_examin_summary (lsa, oa);
}
}
/* Register zebra server interface information. Send current all
interface and address information. */
static void
zread_interface_add (struct zserv *client, u_short length)
{
struct listnode *ifnode;
struct listnode *cnode;
struct interface *ifp;
struct connected *c;
/* Interface information is needed. */
client->ifinfo = 1;
for (ifnode = listhead (iflist); ifnode; ifnode = nextnode (ifnode))
{
ifp = getdata (ifnode);
/* Skip pseudo interface. */
if (! CHECK_FLAG (ifp->status, ZEBRA_INTERFACE_ACTIVE))
continue;
zsend_interface_add (client, ifp);
for (cnode = listhead (ifp->connected); cnode; nextnode (cnode))
{
c = getdata (cnode);
if (CHECK_FLAG (c->conf, ZEBRA_IFC_REAL))
zsend_interface_address (ZEBRA_INTERFACE_ADDRESS_ADD, client,
ifp, c);
}
}
}
static int
bfd_ioctl_state_change (struct bfd_nl_peerinfo *peerinfo)
{
struct bfd_peer peer;
struct zserv *client;
struct listnode *node;
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_info ("rcvd peerinfo %s: state=%d, ifindex=%d",
sockunion_log ((union sockunion *) &peerinfo->dst),
peerinfo->state, peerinfo->ifindex);
memcpy (&peer.su, &peerinfo->dst.sa, sizeof (union sockunion));
peer.ifindex = peerinfo->ifindex;
if (peerinfo->state == BSM_Up)
{
for (node = listhead (client_list); node; nextnode (node))
if ((client = getdata (node)) != NULL)
zsend_bfd_peer_up (client, &peer);
}
else if (peerinfo->state == BSM_Down)
{
for (node = listhead (client_list); node; nextnode (node))
if ((client = getdata (node)) != NULL)
zsend_bfd_peer_down (client, &peer);
}
else
{
}
return 0;
}
void
isis_spftree_adj_del (struct isis_spftree *spftree, struct isis_adjacency *adj)
{
struct listnode *node;
if (!adj)
return;
for (node = listhead (spftree->tents); node; node = listnextnode (node))
isis_vertex_adj_del (listgetdata (node), adj);
for (node = listhead (spftree->paths); node; node = listnextnode (node))
isis_vertex_adj_del (listgetdata (node), adj);
return;
}
void
ospf_abr_remove_unapproved_summaries (struct ospf *ospf)
{
listnode node;
struct ospf_area *area;
struct route_node *rn;
struct ospf_lsa *lsa;
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_remove_unapproved_summaries(): Start");
for (node = listhead (ospf->areas); node; nextnode (node))
{
area = getdata (node);
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_remove_unapproved_summaries(): "
"looking at area %s", inet_ntoa (area->area_id));
LSDB_LOOP (SUMMARY_LSDB (area), rn, lsa)
if (ospf_lsa_is_self_originated (ospf, lsa))
if (!CHECK_FLAG (lsa->flags, OSPF_LSA_APPROVED))
ospf_lsa_flush_area (lsa, area);
LSDB_LOOP (ASBR_SUMMARY_LSDB (area), rn, lsa)
if (ospf_lsa_is_self_originated (ospf, lsa))
if (!CHECK_FLAG (lsa->flags, OSPF_LSA_APPROVED))
ospf_lsa_flush_area (lsa, area);
}
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_remove_unapproved_summaries(): Stop");
}
void
ospf_abr_prepare_aggregates (struct ospf *ospf)
{
listnode node;
struct route_node *rn;
struct ospf_area_range *range;
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_prepare_aggregates(): Start");
for (node = listhead (ospf->areas); node; nextnode (node))
{
struct ospf_area *area = getdata (node);
for (rn = route_top (area->ranges); rn; rn = route_next (rn))
if ((range = rn->info) != NULL)
{
range->cost = 0;
range->specifics = 0;
}
}
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_prepare_aggregates(): Stop");
}
void
ospf_abr_unapprove_summaries (struct ospf *ospf)
{
listnode node;
struct ospf_area *area;
struct route_node *rn;
struct ospf_lsa *lsa;
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_unapprove_summaries(): Start");
for (node = listhead (ospf->areas); node; nextnode (node))
{
area = getdata (node);
LSDB_LOOP (SUMMARY_LSDB (area), rn, lsa)
if (ospf_lsa_is_self_originated (ospf, lsa))
UNSET_FLAG (lsa->flags, OSPF_LSA_APPROVED);
LSDB_LOOP (ASBR_SUMMARY_LSDB (area), rn, lsa)
if (ospf_lsa_is_self_originated (ospf, lsa))
UNSET_FLAG (lsa->flags, OSPF_LSA_APPROVED);
}
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_unapprove_summaries(): Stop");
}
/* elect DR and BDR. Refer to RFC2319 section 9.4 */
struct ospf_neighbor *
ospf_dr_election_sub (struct list *routers)
{
struct listnode *node;
struct ospf_neighbor *nbr, *max = NULL;
/* Choose highest router priority.
In case of tie, choose highest Router ID. */
for (node = listhead (routers); node; nextnode (node))
{
nbr = getdata (node);
if (max == NULL)
max = nbr;
else
{
if (max->priority < nbr->priority)
max = nbr;
else if (max->priority == nbr->priority)
if (IPV4_ADDR_CMP (&max->router_id, &nbr->router_id) < 0)
max = nbr;
}
}
return max;
}
unsigned int
are_checksums_same (void)
{
int same = 0;
struct listnode * node, * nnode;
struct sisis_listener * listener;
struct sisis_listener * listener_swp = (struct sisis_listener *)listgetdata(listhead(sm->listen_sockets));
u_int16_t chsum_swp = listener_swp->chksum;
for(ALL_LIST_ELEMENTS (sm->listen_sockets, node, nnode, listener))
{
zlog_debug("checksum: %d\n", listener->chksum);
if(listener->chksum == chsum_swp)
{
same = 1;
chsum_swp = listener->chksum;
}
else
{
return 0;
}
}
return same;
}
/*
* check if interface with given address is configured and
* return it if yes.
*/
struct ospf_interface *
ospf_if_is_configured (struct ospf *ospf, struct in_addr *address)
{
listnode node;
struct ospf_interface *oi;
struct prefix *addr;
struct prefix query_addr;
for (node = listhead (ospf->oiflist); node; nextnode (node))
if ((oi = getdata (node)) != NULL && oi->type != OSPF_IFTYPE_VIRTUALLINK)
{
/* if (oi->type == OSPF_IFTYPE_POINTOPOINT)
addr = oi->connected->destination;
else
*/
addr = oi->address;
query_addr.family = AF_INET;
query_addr.u.prefix4 = *address;
query_addr.prefixlen = IPV4_ALLOWABLE_BITLEN_P2P;
if (oi->type == OSPF_IFTYPE_POINTOPOINT &&
prefix_match (addr, &query_addr))
return oi;
else if (IPV4_ADDR_SAME (address, &addr->u.prefix4))
return oi;
}
return NULL;
}
mpls_return_enum mpls_ifmgr_getnext_address(mpls_ifmgr_handle ifmgr_handle,
mpls_if_handle *handle, mpls_inet_addr *addr)
{
struct connected *ifc;
struct listnode *node;
int next = 0;
while ((*handle)) {
for (node = listhead((*handle)->connected); node; listnextnode(node)) {
ifc = listgetdata(node);
if (ifc->address->family == AF_INET &&
ifc->address->u.prefix4.s_addr != htonl(INADDR_LOOPBACK)) {
if (next) {
addr->type = MPLS_FAMILY_IPV4;
addr->u.ipv4 = ntohl(ifc->address->u.prefix4.s_addr);
return MPLS_SUCCESS;
} else if (addr->u.ipv4 == ntohl(ifc->address->u.prefix4.s_addr)) {
next = 1;
}
}
}
(*handle) = if_getnext(*handle);
next = 1;
}
return MPLS_END_OF_LIST;
}
void
ripng_interface_reset () {
struct listnode *node;
struct interface *ifp;
struct ripng_interface *ri;
for (node = listhead (iflist); node; nextnode (node))
{
ifp = getdata (node);
ri = ifp->info;
ri->enable_network = 0;
ri->enable_interface = 0;
ri->running = 0;
ri->split_horizon = RIPNG_NO_SPLIT_HORIZON;
ri->split_horizon_default = RIPNG_NO_SPLIT_HORIZON;
ri->list[RIPNG_FILTER_IN] = NULL;
ri->list[RIPNG_FILTER_OUT] = NULL;
ri->prefix[RIPNG_FILTER_IN] = NULL;
ri->prefix[RIPNG_FILTER_OUT] = NULL;
if (ri->t_wakeup)
{
thread_cancel (ri->t_wakeup);
ri->t_wakeup = NULL;
}
ri->passive = 0;
}
}
void
isis_adj_build_up_list (struct list *adjdb, struct list *list)
{
struct isis_adjacency *adj;
struct listnode *node;
if (!list)
{
zlog_warn ("isis_adj_build_up_list(): NULL list");
return;
}
for (node = listhead (adjdb); node; nextnode (node))
{
adj = getdata (node);
if (!adj)
{
zlog_warn ("isis_adj_build_up_list(): NULL adj");
return;
}
if (adj->adj_state == ISIS_ADJ_UP)
listnode_add (list, adj);
}
return;
}
/* Interface is up. */
void
if_up (struct interface *ifp)
{
struct listnode *node;
struct listnode *next;
struct connected *ifc;
struct prefix *p;
/* Notify the protocol daemons. */
zebra_interface_up_update (ifp);
/* Install connected routes to the kernel. */
if (ifp->connected)
{
for (node = listhead (ifp->connected); node; node = next)
{
next = node->next;
ifc = getdata (node);
p = ifc->address;
if (p->family == AF_INET)
connected_up_ipv4 (ifp, ifc);
#ifdef HAVE_IPV6
else if (p->family == AF_INET6)
connected_up_ipv6 (ifp, ifc);
#endif /* HAVE_IPV6 */
}
}
/* Examine all static routes. */
rib_update ();
}
int
kernel_bfd_delete_peer (struct bfd_peer *peer, char appid)
{
struct bfd_peer *tmp_peer;
struct listnode *node;
char *tmp_appid;
tmp_peer = bfd_peer_lookup (&peer->su, peer->ifindex, peer->type);
if (!tmp_peer)
return 0;
for (node = listhead (tmp_peer->appid_lst); node; nextnode (node))
{
tmp_appid = getdata (node);
if (*tmp_appid == appid)
break;
tmp_appid = NULL;
}
if (!tmp_appid)
return 0;
listnode_delete (tmp_peer->appid_lst, (void *) tmp_appid);
if (listcount (tmp_peer->appid_lst) == 0)
{
list_delete (tmp_peer->appid_lst);
listnode_delete (bfd_peer_list, tmp_peer);
bfd_ioctl_peer (BFD_DELPEER, tmp_peer);
XFREE (MTYPE_BFD_PEER, tmp_peer);
}
return 0;
}
/*
* When we recieve a NULL list, we will know its p2p
*/
void
isis_delete_adj (struct isis_adjacency *adj, struct list *adjdb)
{
struct isis_adjacency *adj2;
struct listnode *node;
if (adjdb)
{
for (node = listhead (adjdb); node; nextnode (node))
{
adj2 = getdata (node);
if (adj2 == adj)
break;
}
listnode_delete (adjdb, adj);
}
if (adj->ipv4_addrs)
list_delete (adj->ipv4_addrs);
#ifdef HAVE_IPV6
if (adj->ipv6_addrs)
list_delete (adj->ipv6_addrs);
#endif
if (adj)
{
XFREE (MTYPE_ISIS_ADJACENCY, adj);
}
else
{
zlog_warn ("tried to delete a non-existent adjacency");
}
return;
}
/* Interface goes down. We have to manage different behavior of based
OS. */
void
if_down (struct interface *ifp)
{
listnode node;
listnode next;
struct connected *ifc;
struct prefix *p;
/* Notify to the protocol daemons. */
zebra_interface_down_update (ifp);
/* Delete connected routes from the kernel. */
if (ifp->connected)
{
for (node = listhead (ifp->connected); node; node = next)
{
next = node->next;
ifc = getdata (node);
p = ifc->address;
if (p->family == AF_INET)
connected_down_ipv4 (ifp, ifc);
#ifdef HAVE_IPV6
else if (p->family == AF_INET6)
connected_down_ipv6 (ifp, ifc);
#endif /* HAVE_IPV6 */
}
}
/* Examine all static routes which direct to the interface. */
rib_update ();
}
static void
re_probe (ConnCacheEntry *e)
{
Listitem *item;
struct timeval tv;
assert (e->probe != NULL);
gettimeofday (&tv, NULL);
if (e->probe_le) {
listdel (connprobelist, e->probe_le);
e->probe_next = min(tv.tv_sec + (1 << e->ntries), e->probe_next);
} else
e->probe_next = tv.tv_sec + (1 << e->ntries);
if (e->ntries <= MAX_RETRIES)
++e->ntries;
for (item = listhead (connprobelist);
item;
item = listnext (connprobelist, item)) {
ConnCacheEntry *this = (ConnCacheEntry *)listdata (item);
if (e->probe_next < this->probe_next) {
e->probe_le = listaddbefore (connprobelist, item, e);
LWP_NoYieldSignal (connprobelist);
return;
}
}
e->probe_le = listaddtail (connprobelist, e);
LWP_NoYieldSignal (connprobelist);
}
void
ospf_vl_up_check (struct ospf_area *area, struct in_addr rid,
struct vertex *v)
{
struct ospf *ospf = area->ospf;
struct listnode *node;
struct ospf_vl_data *vl_data;
struct ospf_interface *oi;
if (IS_DEBUG_OSPF_EVENT)
{
zlog_debug ("ospf_vl_up_check(): Start");
zlog_debug ("ospf_vl_up_check(): Router ID is %s", inet_ntoa (rid));
zlog_debug ("ospf_vl_up_check(): Area is %s", inet_ntoa (area->area_id));
}
for (node = listhead (ospf->vlinks); node; nextnode (node))
{
if ((vl_data = getdata (node)) == NULL)
continue;
if (IS_DEBUG_OSPF_EVENT)
{
zlog_debug ("ospf_vl_up_check(): considering VL, name: %s",
vl_data->vl_oi->ifp->name);
zlog_debug ("ospf_vl_up_check(): VL area: %s, peer ID: %s",
inet_ntoa (vl_data->vl_area_id),
inet_ntoa (vl_data->vl_peer));
}
if (IPV4_ADDR_SAME (&vl_data->vl_peer, &rid) &&
IPV4_ADDR_SAME (&vl_data->vl_area_id, &area->area_id))
{
oi = vl_data->vl_oi;
SET_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED);
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("ospf_vl_up_check(): this VL matched");
if (oi->state == ISM_Down)
{
if (IS_DEBUG_OSPF_EVENT)
zlog_debug ("ospf_vl_up_check(): VL is down, waking it up");
SET_FLAG (oi->ifp->flags, IFF_UP);
OSPF_ISM_EVENT_EXECUTE(oi,ISM_InterfaceUp);
}
if (ospf_vl_set_params (vl_data, v))
{
if (IS_DEBUG_OSPF (ism, ISM_EVENTS))
zlog_debug ("ospf_vl_up_check: VL cost change,"
" scheduling router lsa refresh");
if(ospf->backbone)
ospf_router_lsa_timer_add (ospf->backbone);
else if (IS_DEBUG_OSPF (ism, ISM_EVENTS))
zlog_debug ("ospf_vl_up_check: VL cost change, no backbone!");
}
}
}
}
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;
}
void
ripng_connect_set (struct interface *ifp, int set)
{
struct listnode *nn;
struct connected *connected;
struct prefix_ipv6 address;
for (nn = listhead (ifp->connected); nn; nextnode (nn))
if ((connected = getdata (nn)) != NULL) {
struct prefix *p;
p = connected->address;
if (p->family != AF_INET6)
continue;
address.family = AF_INET6;
address.prefix = p->u.prefix6;
address.prefixlen = p->prefixlen;
apply_mask_ipv6 (&address);
if (set) {
/* Check once more wether this prefix is within a "network IF_OR_PREF" one */
if ((ripng_enable_if_lookup(connected->ifp->name) >= 0) ||
(ripng_enable_network_lookup2(connected) >= 0))
ripng_redistribute_add (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
&address, connected->ifp->ifindex, NULL);
} else {
ripng_redistribute_delete (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_INTERFACE,
&address, connected->ifp->ifindex);
if (ripng_redistribute_check (ZEBRA_ROUTE_CONNECT))
ripng_redistribute_add (ZEBRA_ROUTE_CONNECT, RIPNG_ROUTE_REDISTRIBUTE,
&address, connected->ifp->ifindex, NULL);
}
}
}
/* Check wether the interface has at least a connected prefix that
* is within the ripng_enable_network table. */
int
ripng_enable_network_lookup_if (struct interface *ifp)
{
struct listnode *listnode;
struct connected *connected;
struct prefix_ipv6 address;
for (listnode = listhead (ifp->connected); listnode; nextnode (listnode))
if ((connected = getdata (listnode)) != NULL)
{
struct prefix *p;
struct route_node *node;
p = connected->address;
if (p->family == AF_INET6)
{
address.family = AF_INET6;
address.prefix = p->u.prefix6;
address.prefixlen = IPV6_MAX_BITLEN;
node = route_node_match (ripng_enable_network,
(struct prefix *)&address);
if (node)
{
route_unlock_node (node);
return 1;
}
}
}
return -1;
}
void
isis_adj_print (struct isis_adjacency *adj)
{
struct isis_dynhn *dyn;
struct listnode *node;
struct in_addr *ipv4_addr;
#ifdef HAVE_IPV6
struct in6_addr *ipv6_addr;
u_char ip6[INET6_ADDRSTRLEN];
#endif /* HAVE_IPV6 */
if (!adj)
return;
dyn = dynhn_find_by_id (adj->sysid);
if (dyn)
zlog_debug ("%s", dyn->name.name);
zlog_debug ("SystemId %20s SNPA %s, level %d\nHolding Time %d",
adj->sysid ? sysid_print (adj->sysid) : "unknown",
snpa_print (adj->snpa), adj->level, adj->hold_time);
if (adj->ipv4_addrs && listcount (adj->ipv4_addrs) > 0)
{
zlog_debug ("IPv4 Addresses:");
for (node = listhead (adj->ipv4_addrs); node; nextnode (node))
{
ipv4_addr = getdata (node);
zlog_debug ("%s", inet_ntoa (*ipv4_addr));
}
}
#ifdef HAVE_IPV6
if (adj->ipv6_addrs && listcount (adj->ipv6_addrs) > 0)
{
zlog_debug ("IPv6 Addresses:");
for (node = listhead (adj->ipv6_addrs); node; nextnode (node))
{
ipv6_addr = getdata (node);
inet_ntop (AF_INET6, ipv6_addr, (char *)ip6, INET6_ADDRSTRLEN);
zlog_debug ("%s", ip6);
}
}
#endif /* HAVE_IPV6 */
zlog_debug ("Speaks: %s", nlpid2string (&adj->nlpids));
return;
}
int
VOLSER_AFSVolListVolumes(struct rx_call *call,
const int32_t partID,
const int32_t flags,
volEntries *resultEntries)
{
int ret = 0;
List *vollist;
Listitem *item;
volume_handle *vh;
struct dp_part *dp;
int numvol;
int i;
mlog_log(MDEBVOLDB, "VOLSER_AFSVolListVolumes");
ret = dp_create (partID, &dp);
if (ret)
goto out;
ret = vld_list_volumes(dp, &vollist);
if (ret)
goto free_part;
numvol = 0;
item = listhead(vollist);
while (item) {
numvol++;
item = listnext(vollist, item);
}
resultEntries->len = numvol;
resultEntries->val = calloc(sizeof(struct volintInfo) * resultEntries->len, 1);
i = 0;
while (!listemptyp(vollist)) {
vh = (volume_handle *) listdelhead(vollist);
assert(vh);
ret = vld_info_uptodatep (vh);
assert(ret == 0);
copy_volumeinfo(&resultEntries->val[i], vh, partID);
vld_free (vh);
i++;
}
free(vollist);
free_part:
dp_free (dp);
out:
VOLSER_EXIT;
return ret;
}
/* Send ECMP routes to zebra. */
static void
rip_zebra_ipv4_send (struct route_node *rp, u_char cmd)
{
static struct in_addr **nexthops = NULL;
static unsigned int nexthops_len = 0;
struct list *list = (struct list *)rp->info;
struct zapi_ipv4 api;
struct listnode *listnode = NULL;
struct rip_info *rinfo = NULL;
int count = 0;
if (vrf_bitmap_check (zclient->redist[ZEBRA_ROUTE_RIP], VRF_DEFAULT))
{
api.vrf_id = VRF_DEFAULT;
api.type = ZEBRA_ROUTE_RIP;
api.flags = 0;
api.message = 0;
api.safi = SAFI_UNICAST;
if (nexthops_len < listcount (list))
{
nexthops_len = listcount (list);
nexthops = XREALLOC (MTYPE_TMP, nexthops,
nexthops_len * sizeof (struct in_addr *));
}
SET_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP);
for (ALL_LIST_ELEMENTS_RO (list, listnode, rinfo))
{
nexthops[count++] = &rinfo->nexthop;
if (cmd == ZEBRA_IPV4_ROUTE_ADD)
SET_FLAG (rinfo->flags, RIP_RTF_FIB);
else
UNSET_FLAG (rinfo->flags, RIP_RTF_FIB);
}
api.nexthop = nexthops;
api.nexthop_num = count;
api.ifindex_num = 0;
rinfo = listgetdata (listhead (list));
SET_FLAG (api.message, ZAPI_MESSAGE_METRIC);
api.metric = rinfo->metric;
if (rinfo->distance && rinfo->distance != ZEBRA_RIP_DISTANCE_DEFAULT)
{
SET_FLAG (api.message, ZAPI_MESSAGE_DISTANCE);
api.distance = rinfo->distance;
}
zapi_ipv4_route (cmd, zclient,
(struct prefix_ipv4 *)&rp->p, &api);
rip_global_route_changes++;
}
void
ospf_vl_unapprove (struct ospf *ospf)
{
struct listnode *node;
struct ospf_vl_data *vl_data;
for (node = listhead (ospf->vlinks); node; nextnode (node))
if ((vl_data = getdata (node)) != NULL)
UNSET_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED);
}
void
ospf_vl_shut_unapproved (struct ospf *ospf)
{
struct listnode *node;
struct ospf_vl_data *vl_data;
for (node = listhead (ospf->vlinks); node; nextnode (node))
if ((vl_data = getdata (node)) != NULL)
if (!CHECK_FLAG (vl_data->flags, OSPF_VL_FLAG_APPROVED))
ospf_vl_shutdown (vl_data);
}
void
ospf_abr_announce_rtr (struct ospf *ospf,
struct prefix_ipv4 *p, struct ospf_route *or)
{
listnode node;
struct ospf_area *area;
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_announce_rtr(): Start");
for (node = listhead (ospf->areas); node; nextnode (node))
{
area = getdata (node);
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_announce_rtr(): looking at area %s",
inet_ntoa (area->area_id));
if (IPV4_ADDR_SAME (&or->u.std.area_id, &area->area_id))
continue;
if (ospf_abr_nexthops_belong_to_area (or, area))
continue;
if (area->external_routing != OSPF_AREA_DEFAULT)
{
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_announce_network(): "
"area %s doesn't support external routing",
inet_ntoa(area->area_id));
continue;
}
if (or->path_type == OSPF_PATH_INTER_AREA)
{
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_announce_rtr(): "
"this is inter-area route to %s", inet_ntoa (p->prefix));
if (!OSPF_IS_AREA_BACKBONE (area))
ospf_abr_announce_rtr_to_area (p, or->cost, area);
}
if (or->path_type == OSPF_PATH_INTRA_AREA)
{
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_announce_rtr(): "
"this is intra-area route to %s", inet_ntoa (p->prefix));
ospf_abr_announce_rtr_to_area (p, or->cost, area);
}
}
if (IS_DEBUG_OSPF_EVENT)
zlog_info ("ospf_abr_announce_rtr(): Stop");
}
