void
eigrp_nbr_state_update (struct eigrp_neighbor *nbr)
{
switch (nbr->state)
{
case EIGRP_NEIGHBOR_DOWN:
{
/*Start Hold Down Timer for neighbor*/
// THREAD_OFF(nbr->t_holddown);
// THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired,
// nbr, nbr->v_holddown);
break;
}
case EIGRP_NEIGHBOR_PENDING:
{
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
break;
}
case EIGRP_NEIGHBOR_UP:
{
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
break;
}
}
}
int
oneway_received (struct thread *thread)
{
struct ospf6_neighbor *on;
struct ospf6_lsa *lsa;
on = (struct ospf6_neighbor *) THREAD_ARG (thread);
assert (on);
if (on->state < OSPF6_NEIGHBOR_TWOWAY)
return 0;
if (IS_OSPF6_DEBUG_NEIGHBOR (EVENT))
zlog_info ("Neighbor Event %s: *1Way-Received*", on->name);
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_INIT, on);
thread_add_event (master, neighbor_change, on->ospf6_if, 0);
ospf6_lsdb_remove_all (on->summary_list);
ospf6_lsdb_remove_all (on->request_list);
for (lsa = ospf6_lsdb_head (on->retrans_list); lsa;
lsa = ospf6_lsdb_next (lsa))
{
ospf6_decrement_retrans_count (lsa);
ospf6_lsdb_remove (lsa, on->retrans_list);
}
THREAD_OFF (on->thread_send_dbdesc);
THREAD_OFF (on->thread_send_lsreq);
THREAD_OFF (on->thread_send_lsupdate);
THREAD_OFF (on->thread_send_lsack);
return 0;
}
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);
}
/* Stop zebra client services. */
void
zclient_stop (struct zclient *zclient)
{
if (zclient_debug)
zlog_debug ("zclient stopped");
/* Stop threads. */
THREAD_OFF(zclient->t_read);
THREAD_OFF(zclient->t_connect);
THREAD_OFF(zclient->t_write);
/* Reset streams. */
stream_reset(zclient->ibuf);
stream_reset(zclient->obuf);
/* Empty the write buffer. */
buffer_reset(zclient->wb);
/* Close socket. */
if (zclient->sock >= 0)
{
close (zclient->sock);
zclient->sock = -1;
}
zclient->fail = 0;
}
static void sock_close(struct igmp_sock *igmp)
{
pim_igmp_other_querier_timer_off(igmp);
pim_igmp_general_query_off(igmp);
if (PIM_DEBUG_IGMP_TRACE) {
if (igmp->t_igmp_read) {
zlog_debug("Cancelling READ event on IGMP socket %s fd=%d on interface %s",
inet_ntoa(igmp->ifaddr), igmp->fd,
igmp->interface->name);
}
}
THREAD_OFF(igmp->t_igmp_read);
zassert(!igmp->t_igmp_read);
if (close(igmp->fd)) {
zlog_err("Failure closing IGMP socket %s fd=%d on interface %s: errno=%d: %s",
inet_ntoa(igmp->ifaddr), igmp->fd, igmp->interface->name,
errno, safe_strerror(errno));
}
if (PIM_DEBUG_IGMP_TRACE) {
zlog_debug("Deleted IGMP socket %s fd=%d on interface %s",
inet_ntoa(igmp->ifaddr), igmp->fd, igmp->interface->name);
}
}
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);
}
/* global 1second timer used for periodic processing */
static void pim_vxlan_work_timer_setup(bool start)
{
THREAD_OFF(vxlan_info.work_timer);
if (start)
thread_add_timer(router->master, pim_vxlan_work_timer_cb, NULL,
PIM_VXLAN_WORK_TIME, &vxlan_info.work_timer);
}
//receive and process hello high packet
void hello_on_high_packet_received(struct backbone_eth* eth, struct lsd_head *head)
{
struct hello_high *hello_high = (struct hello_high *)head;
struct hello_master* hello_master = eth->hello_master;
if (head->pktype != IC_MESSAGE_TYPE_HELLO_H)
return;
hello_high = (struct hello_high *)head;
THREAD_OFF(hello_master->dead_timer_high);
hello_master->dead_timer_high = thread_add_timer_high_resolution(master, dead_timer_high, eth, TMP_VAR * hello_master->h_dead_val);
if(hello_master->high_status == LSD_DISCONNETED)
{
hello_master->high_status = LSD_CONNECTED;
hello_master->neighbor.rt_id = hello_high->lsd_head.r_id;
hello_master->neighbor.if_id = hello_high->lsd_head.if_id;
printf("Link Connected---Neighbor[%d]:[%d]\n",hello_master->neighbor.rt_id,hello_master->neighbor.if_id);
char dst_addr[25],nexthop[25];
//if(eth->neighbour->ctrl_addr.s_addr!=0){
//inet_ntop(AF_INET,ð->neighbour->ctrl_addr,dst_addr,25);
//inet_ntop(AF_INET,ð->neighbour->nexthop_addr,nexthop,25);
//addStaticRoute(routerip, dst_addr,"255.255.255.255", nexthop);
//}
//eth->eth_state = ETH_UP;
struct event_handler_item* item;
for(item = detection_queue.next; item; item = item->next)
((hello_detection_handler)(item->handler))(eth, HIGH_PRIORITY_DETECTION, LSD_CONNECTED);
}
}
int exchange_done(struct thread * thread)
{
struct ospf6_neighbor *on;
on = (struct ospf6_neighbor *) THREAD_ARG (thread);
assert (on);
if (on->state != OSPF6_NEIGHBOR_EXCHANGE)
return 0;
if (IS_OSPF6_SIBLING_DEBUG_NEIGHBOR)
zlog_debug ("Neighbor Event %s: *ExchangeDone*", on->name);
THREAD_OFF (on->thread_send_dbdesc);
ospf6_lsdb_remove_all (on->dbdesc_list);
/* XXX
thread_add_timer (master, ospf6_neighbor_last_dbdesc_release, on,
on->ospf6_if->dead_interval);
*/
if (on->request_list->count == 0)
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_FULL, on);
else
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_LOADING, on);
return 0;
}
int bad_lsreq(struct thread * thread)
{
struct ospf6_neighbor * on;
struct ospf6_lsa * lsa;
on = (struct ospf6_neighbor *) THREAD_ARG(thread);
assert(on);
if(on->state < OSPF6_NEIGHBOR_EXCHANGE)
return 0;
if(IS_OSPF6_SIBLING_DEBUG_NEIGHBOR)
zlog_debug("Neighbor Event %s: *BadLSReq*", on->name);
ospf6_neighbor_state_change(OSPF6_NEIGHBOR_EXSTART, on);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MSBIT);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_MBIT);
SET_FLAG(on->dbdesc_bits, OSPF6_DBDESC_IBIT);
ospf6_lsdb_remove_all(on->summary_list);
ospf6_lsdb_remove_all(on->request_list);
for(lsa = ospf6_lsdb_head(on->retrans_list); lsa;
lsa = ospf6_lsdb_next(lsa))
{
ospf6_decrement_retrans_count(lsa);
ospf6_lsdb_remove(lsa, on->retrans_list);
}
THREAD_OFF(on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event(master, ospf6_dbdesc_send, on, 0);
return 0;
}
static int
zebra_server_send_message(struct zserv *client)
{
if (client->t_suicide)
return -1;
switch (buffer_write(client->wb, client->sock, STREAM_DATA(client->obuf),
stream_get_endp(client->obuf)))
{
case BUFFER_ERROR:
zlog_warn("%s: buffer_write failed to zserv client fd %d, closing",
__func__, client->sock);
/* Schedule a delayed close since many of the functions that call this
one do not check the return code. They do not allow for the
possibility that an I/O error may have caused the client to be
deleted. */
client->t_suicide = thread_add_event(zebrad.master, zserv_delayed_close,
client, 0);
return -1;
case BUFFER_EMPTY:
THREAD_OFF(client->t_write);
break;
case BUFFER_PENDING:
THREAD_WRITE_ON(zebrad.master, client->t_write,
zserv_flush_data, client, client->sock);
break;
}
return 0;
}
void
isis_circuit_down (struct isis_circuit *circuit)
{
/* Cancel all active threads -- FIXME: wrong place */
/* HT: Read thread if GNU_LINUX, TIMER thread otherwise. */
THREAD_OFF (circuit->t_read);
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
THREAD_TIMER_OFF (circuit->u.bc.t_send_lan_hello[0]);
THREAD_TIMER_OFF (circuit->u.bc.t_send_lan_hello[1]);
THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[0]);
THREAD_TIMER_OFF (circuit->u.bc.t_run_dr[1]);
}
else if (circuit->circ_type == CIRCUIT_T_P2P)
{
THREAD_TIMER_OFF (circuit->u.p2p.t_send_p2p_hello);
}
if (circuit->t_send_psnp[0]) {
THREAD_TIMER_OFF (circuit->t_send_psnp[0]);
}
if (circuit->t_send_psnp[1]) {
THREAD_TIMER_OFF (circuit->t_send_psnp[1]);
}
/* close the socket */
close (circuit->fd);
return;
}
int
twoway_received (struct thread *thread)
{
struct ospf6_neighbor *on;
on = (struct ospf6_neighbor *) THREAD_ARG (thread);
assert (on);
if (on->state > OSPF6_NEIGHBOR_INIT)
return 0;
if (IS_OSPF6_DEBUG_NEIGHBOR (EVENT))
zlog_info ("Neighbor Event %s: *2Way-Received*", on->name);
thread_add_event (master, neighbor_change, on->ospf6_if, 0);
if (! need_adjacency (on))
{
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_TWOWAY, on);
return 0;
}
ospf6_neighbor_state_change (OSPF6_NEIGHBOR_EXSTART, on);
SET_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MSBIT);
SET_FLAG (on->dbdesc_bits, OSPF6_DBDESC_MBIT);
SET_FLAG (on->dbdesc_bits, OSPF6_DBDESC_IBIT);
THREAD_OFF (on->thread_send_dbdesc);
on->thread_send_dbdesc =
thread_add_event (master, ospf6_dbdesc_send, on, 0);
return 0;
}
static void pim_msdp_peer_ka_timer_setup(struct pim_msdp_peer *mp, bool start)
{
THREAD_OFF(mp->ka_timer);
if (start) {
thread_add_timer(mp->pim->msdp.master,
pim_msdp_peer_ka_timer_cb, mp,
PIM_MSDP_PEER_KA_TIME, &mp->ka_timer);
}
}
static void pim_msdp_peer_hold_timer_setup(struct pim_msdp_peer *mp, bool start)
{
struct pim_instance *pim = mp->pim;
THREAD_OFF(mp->hold_timer);
if (start) {
thread_add_timer(pim->msdp.master, pim_msdp_peer_hold_timer_cb,
mp, PIM_MSDP_PEER_HOLD_TIME, &mp->hold_timer);
}
}
static void pim_msdp_sa_adv_timer_setup(struct pim_instance *pim, bool start)
{
THREAD_OFF(pim->msdp.sa_adv_timer);
if (start) {
thread_add_timer(pim->msdp.master, pim_msdp_sa_adv_timer_cb,
pim, PIM_MSDP_SA_ADVERTISMENT_TIME,
&pim->msdp.sa_adv_timer);
}
}
static void pim_msdp_sa_state_timer_setup(struct pim_msdp_sa *sa, bool start)
{
THREAD_OFF(sa->sa_state_timer);
if (start) {
thread_add_timer(sa->pim->msdp.master,
pim_msdp_sa_state_timer_cb, sa,
PIM_MSDP_SA_HOLD_TIME, &sa->sa_state_timer);
}
}
void
svz_tunnel_stop (struct tclient * tclient)
{
THREAD_OFF(tclient->t_read);
THREAD_OFF(tclient->t_connect);
THREAD_OFF(tclient->t_write);
stream_reset(tclient->ibuf);
stream_reset(tclient->obuf);
buffer_reset(tclient->wb);
if (tclient->sock >= 0)
{
close(tclient->sock);
tclient->sock = -1;
}
tclient->fail = 0;
}
void
ospf6_neighbor_delete (struct ospf6_neighbor *on)
{
struct ospf6_lsa *lsa;
ospf6_lsdb_remove_all (on->summary_list);
ospf6_lsdb_remove_all (on->request_list);
for (lsa = ospf6_lsdb_head (on->retrans_list); lsa;
lsa = ospf6_lsdb_next (lsa))
{
ospf6_decrement_retrans_count (lsa);
ospf6_lsdb_remove (lsa, on->retrans_list);
}
ospf6_lsdb_remove_all (on->dbdesc_list);
ospf6_lsdb_remove_all (on->lsreq_list);
ospf6_lsdb_remove_all (on->lsupdate_list);
ospf6_lsdb_remove_all (on->lsack_list);
ospf6_lsdb_delete (on->summary_list);
ospf6_lsdb_delete (on->request_list);
ospf6_lsdb_delete (on->retrans_list);
ospf6_lsdb_delete (on->dbdesc_list);
ospf6_lsdb_delete (on->lsreq_list);
ospf6_lsdb_delete (on->lsupdate_list);
ospf6_lsdb_delete (on->lsack_list);
#ifdef HAVE_KBFD
if (CHECK_FLAG (on->bfd_flag, OSPF6_NBR_BFD_ENABLE))
ospf6_bfd_peer_delete (on);
#endif /*HAVE_KBFD*/
THREAD_OFF (on->inactivity_timer);
THREAD_OFF (on->thread_send_dbdesc);
THREAD_OFF (on->thread_send_lsreq);
THREAD_OFF (on->thread_send_lsupdate);
THREAD_OFF (on->thread_send_lsack);
XFREE (MTYPE_OSPF6_NEIGHBOR, on);
}
void
ospf6_interface_disable (struct ospf6_interface *oi)
{
struct listnode *node, *nnode;
struct ospf6_neighbor *on;
SET_FLAG (oi->flag, OSPF6_INTERFACE_DISABLE);
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
ospf6_neighbor_delete (on);
list_delete_all_node (oi->neighbor_list);
ospf6_lsdb_remove_all (oi->lsdb);
ospf6_lsdb_remove_all (oi->lsupdate_list);
ospf6_lsdb_remove_all (oi->lsack_list);
THREAD_OFF (oi->thread_send_hello);
THREAD_OFF (oi->thread_send_lsupdate);
THREAD_OFF (oi->thread_send_lsack);
}
static void sock_close(struct interface *ifp)
{
struct pim_interface *pim_ifp = ifp->info;
if (PIM_DEBUG_PIM_TRACE) {
if (pim_ifp->t_pim_sock_read) {
zlog_debug("Cancelling READ event for PIM socket fd=%d on interface %s",
pim_ifp->pim_sock_fd,
ifp->name);
}
}
THREAD_OFF(pim_ifp->t_pim_sock_read);
if (PIM_DEBUG_PIM_TRACE) {
if (pim_ifp->t_pim_hello_timer) {
zlog_debug("Cancelling PIM hello timer for interface %s",
ifp->name);
}
}
THREAD_OFF(pim_ifp->t_pim_hello_timer);
if (PIM_DEBUG_PIM_TRACE) {
zlog_debug("Deleting PIM socket fd=%d on interface %s",
pim_ifp->pim_sock_fd, ifp->name);
}
if (close(pim_ifp->pim_sock_fd)) {
zlog_warn("Failure closing PIM socket fd=%d on interface %s: errno=%d: %s",
pim_ifp->pim_sock_fd, ifp->name,
errno, safe_strerror(errno));
}
pim_ifp->pim_sock_fd = -1;
pim_ifp->pim_sock_creation = 0;
zassert(pim_ifp->pim_sock_fd < 0);
zassert(!pim_ifp->t_pim_sock_read);
zassert(!pim_ifp->t_pim_hello_timer);
zassert(!pim_ifp->pim_sock_creation);
}
void hello_on_eth_state_changed(struct backbone_eth* eth)
{
if(!eth->hello_master)//insert init code.
eth->hello_master = malloc_z(struct hello_master);
struct hello_master* hello_master = eth->hello_master;
printf("hello state changed\n");
if(eth->_state == ETH_DOWN)
{
//THREAD_OFF(hello_master->dead_timer_high);
//THREAD_OFF(hello_master->dead_timer_low);
THREAD_OFF(hello_master->hello_timer_high);
THREAD_OFF(hello_master->hello_timer_low);
}
else if(eth->_state == ETH_UP)
{
//if(check_global_hello_config()==0)
//{
hello_master->h_hello_val = H_HELLO_VAL;
hello_master->l_hello_val = L_HELLO_VAL;
hello_master->h_dead_val = H_DEAD_VAL;
hello_master->l_dead_val = L_DEAD_VAL;
//}
//else
//{
// int ifid = global_config.if_id;
// if(ifid == -1)
// {
// update_timer_by_backbone(eth);
// }
// else if(global_config.if_id == eth->interface_id)
// {
// update_timer_by_backbone(eth);
// }
// }
hello_master->hello_timer_high = thread_add_event(master, hello_high_send, eth, 0);
hello_master->hello_timer_low = thread_add_event(master, hello_low_send, eth, 0);
}
}
void
ospf6_neighbor_delete(struct ospf6_neighbor * on)
{
struct ospf6_lsa * lsa;
ospf6_lsdb_remove_all(on->summary_list);
ospf6_lsdb_remove_all (on->request_list);
for (lsa = ospf6_lsdb_head (on->retrans_list); lsa;
lsa = ospf6_lsdb_next (lsa))
{
ospf6_decrement_retrans_count (lsa);
ospf6_lsdb_remove (lsa, on->retrans_list);
}
ospf6_lsdb_remove_all (on->dbdesc_list);
ospf6_lsdb_remove_all (on->lsreq_list);
ospf6_lsdb_remove_all (on->lsupdate_list);
ospf6_lsdb_remove_all (on->lsack_list);
ospf6_lsdb_delete (on->summary_list);
ospf6_lsdb_delete (on->request_list);
ospf6_lsdb_delete (on->retrans_list);
ospf6_lsdb_delete (on->dbdesc_list);
ospf6_lsdb_delete (on->lsreq_list);
ospf6_lsdb_delete (on->lsupdate_list);
ospf6_lsdb_delete (on->lsack_list);
THREAD_OFF (on->inactivity_timer);
THREAD_OFF (on->thread_send_dbdesc);
THREAD_OFF (on->thread_send_lsreq);
THREAD_OFF (on->thread_send_lsupdate);
THREAD_OFF (on->thread_send_lsack);
free(on);
on = NULL;
}
static void neighbor_timer_off(struct pim_neighbor *neigh)
{
if (PIM_DEBUG_PIM_TRACE) {
if (neigh->t_expire_timer) {
char src_str[100];
pim_inet4_dump("<src?>", neigh->source_addr, src_str, sizeof(src_str));
zlog_debug("%s: cancelling timer for neighbor %s on %s",
__PRETTY_FUNCTION__,
src_str, neigh->interface->name);
}
}
THREAD_OFF(neigh->t_expire_timer);
zassert(!neigh->t_expire_timer);
}
static void ospf6_disable(struct ospf6 *o)
{
struct listnode *node, *nnode;
struct ospf6_area *oa;
if (!CHECK_FLAG(o->flag, OSPF6_DISABLED)) {
SET_FLAG(o->flag, OSPF6_DISABLED);
for (ALL_LIST_ELEMENTS(o->area_list, node, nnode, oa))
ospf6_area_disable(oa);
/* XXX: This also changes persistent settings */
ospf6_asbr_redistribute_reset();
ospf6_lsdb_remove_all(o->lsdb);
ospf6_route_remove_all(o->route_table);
ospf6_route_remove_all(o->brouter_table);
THREAD_OFF(o->maxage_remover);
THREAD_OFF(o->t_spf_calc);
THREAD_OFF(o->t_ase_calc);
THREAD_OFF(o->t_distribute_update);
}
static void group_timer_off(struct igmp_group *group)
{
if (!group->t_group_timer)
return;
if (PIM_DEBUG_IGMP_TRACE) {
char group_str[100];
pim_inet4_dump("<group?>", group->group_addr, group_str, sizeof(group_str));
zlog_debug("Cancelling TIMER event for group %s on %s",
group_str, group->group_igmp_sock->interface->name);
}
THREAD_OFF(group->t_group_timer);
zassert(!group->t_group_timer);
}
/* Stop zebra client services. */
void
zclient_stop (struct zclient *zclient)
{
int i;
if (zclient_debug)
zlog_debug ("zclient stopped");
/* Stop threads. */
THREAD_OFF(zclient->t_read);
THREAD_OFF(zclient->t_connect);
THREAD_OFF(zclient->t_write);
/* Reset streams. */
stream_reset(zclient->ibuf);
stream_reset(zclient->obuf);
/* Empty the write buffer. */
buffer_reset(zclient->wb);
/* Close socket. */
if (zclient->sock >= 0)
{
close (zclient->sock);
zclient->sock = -1;
}
zclient->fail = 0;
for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
{
vrf_bitmap_free(zclient->redist[i]);
zclient->redist[i] = VRF_BITMAP_NULL;
}
vrf_bitmap_free(zclient->default_information);
zclient->default_information = VRF_BITMAP_NULL;
}
void
ospf6_interface_delete (struct ospf6_interface *oi)
{
struct listnode *node, *nnode;
struct ospf6_neighbor *on;
for (ALL_LIST_ELEMENTS (oi->neighbor_list, node, nnode, on))
ospf6_neighbor_delete (on);
list_delete (oi->neighbor_list);
THREAD_OFF (oi->thread_send_hello);
THREAD_OFF (oi->thread_send_lsupdate);
THREAD_OFF (oi->thread_send_lsack);
ospf6_lsdb_remove_all (oi->lsdb);
ospf6_lsdb_remove_all (oi->lsupdate_list);
ospf6_lsdb_remove_all (oi->lsack_list);
ospf6_lsdb_delete (oi->lsdb);
ospf6_lsdb_delete (oi->lsdb_self);
ospf6_lsdb_delete (oi->lsupdate_list);
ospf6_lsdb_delete (oi->lsack_list);
ospf6_route_table_delete (oi->route_connected);
/* cut link */
oi->interface->info = NULL;
/* plist_name */
if (oi->plist_name)
XFREE (MTYPE_PREFIX_LIST_STR, oi->plist_name);
XFREE (MTYPE_OSPF6_IF, oi);
}
void pim_upstream_delete(struct pim_upstream *up)
{
THREAD_OFF(up->t_join_timer);
upstream_channel_oil_detach(up);
/*
notice that listnode_delete() can't be moved
into pim_upstream_free() because the later is
called by list_delete_all_node()
*/
listnode_delete(qpim_upstream_list, up);
pim_upstream_free(up);
}
void pim_igmp_general_query_off(struct igmp_sock *igmp)
{
zassert(igmp);
if (PIM_DEBUG_IGMP_TRACE) {
if (igmp->t_igmp_query_timer) {
char ifaddr_str[100];
pim_inet4_dump("<ifaddr?>", igmp->ifaddr, ifaddr_str, sizeof(ifaddr_str));
zlog_debug("IGMP querier %s fd=%d cancelling query TIMER event on %s",
ifaddr_str, igmp->fd, igmp->interface->name);
}
}
THREAD_OFF(igmp->t_igmp_query_timer);
zassert(!igmp->t_igmp_query_timer);
}
