void
ospf_if_stream_unset (struct ospf_interface *oi)
{
struct ospf *ospf = oi->ospf;
if (oi->obuf)
{
ospf_fifo_free (oi->obuf);
oi->obuf = NULL;
if (oi->on_write_q)
{
listnode_delete (ospf->oi_write_q, oi);
if (list_isempty(ospf->oi_write_q))
OSPF_TIMER_OFF (ospf->t_write);
oi->on_write_q = 0;
}
}
if (oi->obuf_hello)
{
ospf_fifo_free (oi->obuf_hello);
oi->obuf_hello = NULL;
if (oi->on_write_q_hello)
{
listnode_delete (ospf->oi_write_q_hello, oi);
if (list_isempty(ospf->oi_write_q_hello))
OSPF_TIMER_OFF (ospf->t_write_hello);
oi->on_write_q_hello = 0;
}
}
}
static void
delete_marked_cache_groups()
{
cache_group* cache_group;
cache* cache;
struct listnode *cache_group_node, *cache_node;
struct listnode *next_node, *next_cache_node;
for (ALL_LIST_ELEMENTS(cache_group_list, cache_group_node, next_node,
cache_group))
{
for (ALL_LIST_ELEMENTS(cache_group->cache_config_list, cache_node,
next_cache_node, cache))
{
if (cache->delete_flag)
{
listnode_delete(cache_group->cache_config_list, cache);
delete_cache(cache);
}
}
if (listcount(cache_group->cache_config_list) == 0
|| cache_group->delete_flag)
{
listnode_delete(cache_group_list, cache_group);
delete_cache_group(cache_group);
}
}
}
void
ospf_if_free (struct ospf_interface *oi)
{
ospf_if_down (oi);
assert (oi->state == ISM_Down);
#ifdef HAVE_OPAQUE_LSA
ospf_opaque_type9_lsa_term (oi);
#endif /* HAVE_OPAQUE_LSA */
/* Free Pseudo Neighbour */
ospf_nbr_delete (oi->nbr_self);
route_table_finish (oi->nbrs);
route_table_finish (oi->ls_upd_queue);
/* Free any lists that should be freed */
list_free (oi->nbr_nbma);
list_free (oi->ls_ack);
list_free (oi->ls_ack_direct.ls_ack);
ospf_delete_from_if (oi->ifp, oi);
listnode_delete (oi->ospf->oiflist, oi);
listnode_delete (oi->area->oiflist, oi);
memset (oi, 0, sizeof (*oi));
XFREE (MTYPE_OSPF_IF, oi);
}
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;
}
/* withdraw a connected address */
static void
connected_withdraw (struct connected *ifc)
{
if (! ifc)
return;
/* Update interface address information to protocol daemon. */
if (CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
{
zebra_interface_address_delete_update (ifc->ifp, ifc);
if_subnet_delete (ifc->ifp, ifc);
if (ifc->address->family == AF_INET)
connected_down_ipv4 (ifc->ifp, ifc);
#ifdef HAVE_IPV6
else
connected_down_ipv6 (ifc->ifp, ifc);
#endif
UNSET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
}
if (!CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
{
/*
router_id_del_address(ifc);
listnode_delete (ifc->ifp->connected, ifc);
connected_free (ifc);*/
if(ifc->address->family == AF_INET)
{
router_id_del_address(ifc);
listnode_delete (ifc->ifp->connected, ifc);
connected_free (ifc);
}
else
{
if(!CHECK_FLAG(ifc->ipv6_config, RTMD_IPV6_ADDR_CONFIG))
{
router_id_del_address(ifc);
listnode_delete (ifc->ifp->connected, ifc);
connected_free (ifc);
}
else
{
zlog_debug("%s: line %d, Cannot delete IPv6 config addr .\n",__func__,__LINE__);
}
}
}
}
u_int32_t
eigrp_query_send_all (struct eigrp *eigrp)
{
struct eigrp_interface *iface;
struct listnode *node, *node2, *nnode2;
struct eigrp_neighbor *nbr;
struct eigrp_prefix_entry *pe;
u_int32_t counter;
if (eigrp == NULL)
{
zlog_debug("EIGRP Routing Process not enabled");
return 0;
}
counter=0;
for (ALL_LIST_ELEMENTS_RO(eigrp->eiflist, node, iface))
{
eigrp_send_query(iface);
counter++;
}
for (ALL_LIST_ELEMENTS(eigrp->topology_changes_internalIPV4, node2, nnode2, pe))
{
if(pe->req_action & EIGRP_FSM_NEED_QUERY)
{
pe->req_action &= ~EIGRP_FSM_NEED_QUERY;
listnode_delete(eigrp->topology_changes_internalIPV4, pe);
}
}
return counter;
}
void
ospf6_area_delete (struct ospf6_area *oa)
{
struct listnode *n, *nnode;
struct ospf6_interface *oi;
ospf6_route_table_delete (oa->range_table);
ospf6_route_table_delete (oa->summary_prefix);
ospf6_route_table_delete (oa->summary_router);
/* ospf6 interface list */
for (ALL_LIST_ELEMENTS (oa->if_list, n, nnode, oi))
{
ospf6_interface_delete (oi);
}
list_delete (oa->if_list);
ospf6_lsdb_delete (oa->lsdb);
ospf6_lsdb_delete (oa->lsdb_self);
ospf6_spf_table_finish (oa->spf_table);
ospf6_route_table_delete (oa->spf_table);
ospf6_route_table_delete (oa->route_table);
THREAD_OFF (oa->thread_spf_calculation);
THREAD_OFF (oa->thread_route_calculation);
listnode_delete (oa->ospf6->area_list, oa);
oa->ospf6 = NULL;
/* free area */
XFREE (MTYPE_OSPF6_AREA, oa);
}
static struct isis_vertex *
isis_spf_add_local (struct isis_spftree *spftree, enum vertextype vtype,
void *id, struct isis_adjacency *adj, u_int32_t cost,
int family)
{
struct isis_vertex *vertex;
vertex = isis_find_vertex (spftree->tents, id, vtype);
if (vertex)
{
/* C.2.5 c) */
if (vertex->d_N == cost)
{
if (adj)
listnode_add (vertex->Adj_N, adj);
/* d) */
if (listcount (vertex->Adj_N) > ISIS_MAX_PATH_SPLITS)
remove_excess_adjs (vertex->Adj_N);
}
/* f) */
else if (vertex->d_N > cost)
{
listnode_delete (spftree->tents, vertex);
goto add2tent;
}
/* e) do nothing */
return vertex;
}
add2tent:
return isis_spf_add2tent (spftree, vtype, id, adj, cost, 1, family);
}
static void igmp_group_delete(struct igmp_group *group)
{
struct listnode *src_node;
struct listnode *src_nextnode;
struct igmp_source *src;
if (PIM_DEBUG_IGMP_TRACE) {
char group_str[100];
pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
zlog_debug("Deleting IGMP group %s from socket %d interface %s",
group_str,
group->group_igmp_sock->fd,
group->group_igmp_sock->interface->name);
}
for (ALL_LIST_ELEMENTS(group->group_source_list, src_node, src_nextnode, src)) {
igmp_source_delete(src);
}
if (group->t_group_query_retransmit_timer) {
THREAD_OFF(group->t_group_query_retransmit_timer);
zassert(!group->t_group_query_retransmit_timer);
}
group_timer_off(group);
listnode_delete(group->group_igmp_sock->igmp_group_list, group);
igmp_group_free(group);
}
/* Close zebra client. */
static void
zebra_client_close (struct zserv *client)
{
/* Close file descriptor. */
if (client->sock)
{
close (client->sock);
client->sock = -1;
}
/* Free stream buffers. */
if (client->ibuf)
stream_free (client->ibuf);
if (client->obuf)
stream_free (client->obuf);
/* Release threads. */
if (client->t_read)
thread_cancel (client->t_read);
if (client->t_write)
thread_cancel (client->t_write);
/* Free client structure. */
listnode_delete (zebrad.client_list, client);
XFREE (0, client);
}
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);
}
/* communicate the withdrawal of a connected address */
static void connected_withdraw(struct connected *ifc)
{
if (!ifc)
return;
/* Update interface address information to protocol daemon. */
if (CHECK_FLAG(ifc->conf, ZEBRA_IFC_REAL)) {
zebra_interface_address_delete_update(ifc->ifp, ifc);
if (ifc->address->family == AF_INET)
if_subnet_delete(ifc->ifp, ifc);
if (ifc->address->family == AF_INET)
connected_down_ipv4(ifc->ifp, ifc);
#ifdef HAVE_IPV6
else
connected_down_ipv6(ifc->ifp, ifc);
#endif
UNSET_FLAG(ifc->conf, ZEBRA_IFC_REAL);
}
/* The address is not in the kernel anymore, so clear the flag */
UNSET_FLAG(ifc->conf, ZEBRA_IFC_QUEUED);
if (!CHECK_FLAG(ifc->conf, ZEBRA_IFC_CONFIGURED)) {
listnode_delete(ifc->ifp->connected, ifc);
connected_free(ifc);
}
}
/*
* 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;
}
static void key_delete(struct keychain *keychain, struct key *key)
{
listnode_delete(keychain->key, key);
XFREE(MTYPE_KEY, key->string);
key_free(key);
}
void
eigrp_update_send_all (struct eigrp *eigrp, struct eigrp_interface *exception)
{
struct eigrp_interface *iface;
struct listnode *node, *node2, *nnode2;
struct eigrp_prefix_entry *pe;
for (ALL_LIST_ELEMENTS_RO(eigrp->eiflist, node, iface))
{
if (iface != exception)
{
eigrp_update_send(iface);
}
}
for (ALL_LIST_ELEMENTS(eigrp->topology_changes_internalIPV4, node2, nnode2, pe))
{
if(pe->req_action & EIGRP_FSM_NEED_UPDATE)
{
pe->req_action &= ~EIGRP_FSM_NEED_UPDATE;
listnode_delete(eigrp->topology_changes_internalIPV4, pe);
zlog_debug("UPDATE COUNT: %d", eigrp->topology_changes_internalIPV4->count);
}
}
}
static void keychain_delete(struct keychain *keychain)
{
XFREE(MTYPE_KEYCHAIN, keychain->name);
list_delete(&keychain->key);
listnode_delete(keychain_list, keychain);
keychain_free(keychain);
}
static void
process_N (struct isis_spftree *spftree, enum vertextype vtype, void *id,
u_int16_t dist, u_int16_t depth, struct isis_adjacency *adj,
int family)
{
struct isis_vertex *vertex;
#ifdef EXTREME_DEBUG
u_char buff[255];
#endif
/* C.2.6 b) */
if (dist > MAX_PATH_METRIC)
return;
/* c) */
vertex = isis_find_vertex (spftree->paths, id, vtype);
if (vertex)
{
#ifdef EXTREME_DEBUG
zlog_debug ("ISIS-Spf: process_N %s %s dist %d already found from PATH",
vtype2string (vtype), vid2string (vertex, buff), dist);
#endif /* EXTREME_DEBUG */
assert (dist >= vertex->d_N);
return;
}
vertex = isis_find_vertex (spftree->tents, id, vtype);
/* d) */
if (vertex)
{
/* 1) */
#ifdef EXTREME_DEBUG
zlog_debug ("ISIS-Spf: process_N %s %s dist %d",
vtype2string (vtype), vid2string (vertex, buff), dist);
#endif /* EXTREME_DEBUG */
if (vertex->d_N == dist)
{
if (adj)
listnode_add (vertex->Adj_N, adj);
/* 2) */
if (listcount (vertex->Adj_N) > ISIS_MAX_PATH_SPLITS)
remove_excess_adjs (vertex->Adj_N);
/* 3) */
return;
}
else if (vertex->d_N < dist)
{
return;
/* 4) */
}
else
{
listnode_delete (spftree->tents, vertex);
}
}
isis_spf_add2tent (spftree, vtype, id, adj, dist, depth, family);
return;
}
static void
key_delete (struct keychain *keychain, struct key *key)
{
listnode_delete (keychain->key, key);
if (key->string)
free (key->string);
key_free (key);
}
/* Delete and free interface structure. */
void
if_delete (struct interface *ifp)
{
listnode_delete (iflist, ifp);
if_delete_retain(ifp);
XFREE (MTYPE_IF, ifp);
}
/* RIPng peer is timeout.
* Garbage collector.
**/
static int ripng_peer_timeout(struct thread *t)
{
struct ripng_peer *peer;
peer = THREAD_ARG(t);
listnode_delete(peer->ripng->peer_list, peer);
ripng_peer_free(peer);
return 0;
}
static void
keychain_delete (struct keychain *keychain)
{
if (keychain->name)
free (keychain->name);
list_delete (keychain->key);
listnode_delete (keychain_list, keychain);
keychain_free (keychain);
}
/* Delete and free interface structure. */
void if_delete(struct interface *ifp)
{
listnode_delete(iflist, ifp);
if_delete_retain(ifp);
list_free(ifp->connected);
XFREE(MTYPE_IF, ifp);
}
void
isis_adj_state_change (struct isis_adjacency *adj, enum isis_adj_state state,
const char *reason)
{
int old_state;
int level = adj->level;
struct isis_circuit *circuit;
old_state = adj->adj_state;
adj->adj_state = state;
circuit = adj->circuit;
if (isis->debugs & DEBUG_ADJ_PACKETS)
{
zlog_debug ("ISIS-Adj (%s): Adjacency state change %d->%d: %s",
circuit->area->area_tag,
old_state, state, reason ? reason : "unspecified");
}
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
if (state == ISIS_ADJ_UP)
circuit->upadjcount[level - 1]++;
if (state == ISIS_ADJ_DOWN)
{
listnode_delete (adj->circuit->u.bc.adjdb[level - 1], adj);
circuit->upadjcount[level - 1]--;
}
list_delete_all_node (circuit->u.bc.lan_neighs[level - 1]);
isis_adj_build_neigh_list (circuit->u.bc.adjdb[level - 1],
circuit->u.bc.lan_neighs[level - 1]);
}
else if (state == ISIS_ADJ_UP)
{ /* p2p interface */
if (adj->sys_type == ISIS_SYSTYPE_UNKNOWN)
send_hello (circuit, 1);
/* update counter & timers for debugging purposes */
adj->last_flap = time (NULL);
adj->flaps++;
/* 7.3.17 - going up on P2P -> send CSNP */
/* FIXME: yup, I know its wrong... but i will do it! (for now) */
send_csnp (circuit, 1);
send_csnp (circuit, 2);
}
else if (state == ISIS_ADJ_DOWN)
{ /* p2p interface */
adj->circuit->u.p2p.neighbor = NULL;
isis_delete_adj (adj, NULL);
}
return;
}
/* Restore an interface to its pre UP state
Used from ism_interface_down only */
void
ospf_if_cleanup (struct ospf_interface *oi)
{
struct route_node *rn;
struct listnode *node, *nnode;
struct ospf_neighbor *nbr;
struct ospf_nbr_nbma *nbr_nbma;
struct ospf_lsa *lsa;
/* oi->nbrs and oi->nbr_nbma should be deleted on InterfaceDown event */
/* delete all static neighbors attached to this interface */
for (ALL_LIST_ELEMENTS (oi->nbr_nbma, node, nnode, nbr_nbma))
{
OSPF_POLL_TIMER_OFF (nbr_nbma->t_poll);
if (nbr_nbma->nbr)
{
nbr_nbma->nbr->nbr_nbma = NULL;
nbr_nbma->nbr = NULL;
}
nbr_nbma->oi = NULL;
listnode_delete (oi->nbr_nbma, nbr_nbma);
}
/* send Neighbor event KillNbr to all associated neighbors. */
for (rn = route_top (oi->nbrs); rn; rn = route_next (rn))
if ((nbr = rn->info) != NULL)
if (nbr != oi->nbr_self)
OSPF_NSM_EVENT_EXECUTE (nbr, NSM_KillNbr);
/* Cleanup Link State Acknowlegdment list. */
for (ALL_LIST_ELEMENTS (oi->ls_ack, node, nnode, lsa))
ospf_lsa_unlock (&lsa); /* oi->ls_ack */
list_delete_all_node (oi->ls_ack);
oi->crypt_seqnum = 0;
/* Empty link state update queue */
ospf_ls_upd_queue_empty (oi);
/* Reset pseudo neighbor. */
ospf_nbr_delete (oi->nbr_self);
oi->nbr_self = ospf_nbr_new (oi);
ospf_nbr_add_self (oi);
ospf_lsa_unlock (&oi->network_lsa_self);
oi->network_lsa_self = NULL;
OSPF_TIMER_OFF (oi->t_network_lsa_self);
#ifdef HAVE_GRACEFUL_RESTART
THREAD_TIMER_OFF(oi->t_opaque_lsa_refresh);
oi->v_opaque_lsa_count = 0 ;
#endif
}
int pim_if_igmp_join_del(struct interface *ifp,
struct in_addr group_addr,
struct in_addr source_addr)
{
struct pim_interface *pim_ifp;
struct igmp_join *ij;
pim_ifp = ifp->info;
if (!pim_ifp) {
zlog_warn("%s: multicast not enabled on interface %s",
__PRETTY_FUNCTION__,
ifp->name);
return -1;
}
if (!pim_ifp->igmp_join_list) {
zlog_warn("%s: no IGMP join on interface %s",
__PRETTY_FUNCTION__,
ifp->name);
return -2;
}
ij = igmp_join_find(pim_ifp->igmp_join_list, group_addr, source_addr);
if (!ij) {
char group_str[100];
char source_str[100];
pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
zlog_warn("%s: could not find IGMP group %s source %s on interface %s",
__PRETTY_FUNCTION__,
group_str, source_str, ifp->name);
return -3;
}
if (close(ij->sock_fd)) {
int e = errno;
char group_str[100];
char source_str[100];
pim_inet4_dump("<grp?>", group_addr, group_str, sizeof(group_str));
pim_inet4_dump("<src?>", source_addr, source_str, sizeof(source_str));
zlog_warn("%s: failure closing sock_fd=%d for IGMP group %s source %s on interface %s: errno=%d: %s",
__PRETTY_FUNCTION__,
ij->sock_fd, group_str, source_str, ifp->name, e, safe_strerror(e));
/* warning only */
}
listnode_delete(pim_ifp->igmp_join_list, ij);
igmp_join_free(ij);
if (listcount(pim_ifp->igmp_join_list) < 1) {
list_delete(pim_ifp->igmp_join_list);
pim_ifp->igmp_join_list = 0;
}
return 0;
}
static void pim_channel_oil_delete(struct channel_oil *c_oil)
{
/*
notice that listnode_delete() can't be moved
into pim_channel_oil_free() because the later is
called by list_delete_all_node()
*/
listnode_delete(qpim_channel_oil_list, c_oil);
pim_channel_oil_free(c_oil);
}
/*
RFC 4601: 4.3.4. Maintaining Secondary Address Lists
All the advertised secondary addresses in received Hello messages
must be checked against those previously advertised by all other
PIM neighbors on that interface. If there is a conflict and the
same secondary address was previously advertised by another
neighbor, then only the most recently received mapping MUST be
maintained, and an error message SHOULD be logged to the
administrator in a rate-limited manner.
*/
static void delete_from_neigh_addr(struct interface *ifp,
struct list *addr_list,
struct in_addr neigh_addr)
{
struct listnode *addr_node;
struct prefix *addr;
struct pim_interface *pim_ifp;
pim_ifp = ifp->info;
zassert(pim_ifp);
zassert(addr_list);
/*
Scan secondary address list
*/
for (ALL_LIST_ELEMENTS_RO(addr_list, addr_node,
addr)) {
struct listnode *neigh_node;
struct pim_neighbor *neigh;
if (addr->family != AF_INET)
continue;
/*
Scan neighbors
*/
for (ALL_LIST_ELEMENTS_RO(pim_ifp->pim_neighbor_list, neigh_node,
neigh)) {
{
struct prefix *p = pim_neighbor_find_secondary(neigh, addr->u.prefix4);
if (p) {
char addr_str[100];
char this_neigh_str[100];
char other_neigh_str[100];
pim_inet4_dump("<addr?>", addr->u.prefix4, addr_str, sizeof(addr_str));
pim_inet4_dump("<neigh1?>", neigh_addr, this_neigh_str, sizeof(this_neigh_str));
pim_inet4_dump("<neigh2?>", neigh->source_addr, other_neigh_str, sizeof(other_neigh_str));
zlog_info("secondary addr %s recvd from neigh %s deleted from neigh %s on %s",
addr_str, this_neigh_str, other_neigh_str, ifp->name);
listnode_delete(neigh->prefix_list, p);
prefix_free(p);
}
}
} /* scan neighbors */
} /* scan addr list */
}
static void
isis_nexthop_delete (struct isis_nexthop *nexthop)
{
nexthop->lock--;
if (nexthop->lock == 0)
{
listnode_delete (isis->nexthops, nexthop);
XFREE (MTYPE_ISIS_NEXTHOP, nexthop);
}
return;
}
void ospf_vl_delete(struct ospf *ospf, struct ospf_vl_data *vl_data)
{
ospf_vl_shutdown(vl_data);
ospf_vl_if_delete(vl_data);
#ifdef HAVE_SNMP
ospf_snmp_vl_delete(vl_data);
#endif /* HAVE_SNMP */
listnode_delete(ospf->vlinks, vl_data);
ospf_vl_data_free(vl_data);
}
static void
isis_nexthop6_delete (struct isis_nexthop6 *nexthop6)
{
nexthop6->lock--;
if (nexthop6->lock == 0)
{
listnode_delete (isis->nexthops6, nexthop6);
XFREE (MTYPE_ISIS_NEXTHOP6, nexthop6);
}
return;
}
