}
hash_release(bgp_def->vrf_import_rt_hash, irt);
- list_delete_and_null(&irt->vrfs);
+ list_delete(&irt->vrfs);
XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT, irt);
}
static void import_rt_free(struct bgp *bgp, struct irt_node *irt)
{
hash_release(bgp->import_rt_hash, irt);
- list_delete_and_null(&irt->vnis);
+ list_delete(&irt->vnis);
XFREE(MTYPE_BGP_EVPN_IMPORT_RT, irt);
}
bgpevpn_unlink_from_l3vni(vpn);
bgp_table_unlock(vpn->route_table);
bgp_evpn_unmap_vni_from_its_rts(bgp, vpn);
- list_delete_and_null(&vpn->import_rtl);
- list_delete_and_null(&vpn->export_rtl);
+ list_delete(&vpn->import_rtl);
+ list_delete(&vpn->export_rtl);
bf_release_index(bm->rd_idspace, vpn->rd_id);
hash_release(bgp->vnihash, vpn);
QOBJ_UNREG(vpn);
*/
void bgp_evpn_es_free(struct bgp *bgp, struct evpnes *es)
{
- list_delete_and_null(&es->vtep_list);
+ list_delete(&es->vtep_list);
bgp_table_unlock(es->route_table);
bf_release_index(bm->rd_idspace, es->rd_id);
hash_release(bgp->esihash, es);
hash_free(bgp->esihash);
bgp->esihash = NULL;
- list_delete_and_null(&bgp->vrf_import_rtl);
- list_delete_and_null(&bgp->vrf_export_rtl);
- list_delete_and_null(&bgp->l2vnis);
+ list_delete(&bgp->vrf_import_rtl);
+ list_delete(&bgp->vrf_export_rtl);
+ list_delete(&bgp->l2vnis);
}
/*
for (ALL_LIST_ELEMENTS_RO(vnilist, ln, data))
write_vni_config(vty, data);
- list_delete_and_null(&vnilist);
+ list_delete(&vnilist);
}
if (bgp->advertise_all_vni)
if (list_began)
vty_out(vty, ")");
vty_out(vty, "\n");
- list_delete_and_null(&list_bpm);
+ list_delete(&list_bpm);
} else
vty_out(vty, "\tnot installed in PBR\n");
}
skiplist_free(lp->inuse);
lp->inuse = NULL;
- list_delete_and_null(&lp->chunks);
+ list_delete(&lp->chunks);
while ((lf = LABEL_FIFO_HEAD(lp->requests))) {
bgp_zebra_destroy();
bf_free(bm->rd_idspace);
- list_delete_and_null(&bm->bgp);
+ list_delete(&bm->bgp);
memset(bm, 0, sizeof(*bm));
frr_fini();
{
struct bgp_addr *addr = data;
- list_delete_and_null(&addr->ifp_name_list);
+ list_delete(&addr->ifp_name_list);
XFREE(MTYPE_BGP_ADDR, addr);
}
if (addr->ifp_name_list->count == 0) {
hash_release(bgp->address_hash, addr);
- list_delete_and_null(&addr->ifp_name_list);
+ list_delete(&addr->ifp_name_list);
XFREE(MTYPE_BGP_ADDR, addr);
}
}
bgp_unlock(e->bgp_orig);
if ((*extra)->bgp_fs_pbr)
- list_delete_and_null(&((*extra)->bgp_fs_pbr));
+ list_delete(&((*extra)->bgp_fs_pbr));
XFREE(MTYPE_BGP_ROUTE_EXTRA, *extra);
*extra = NULL;
revalidate_bgp_node(bgp_node, afi,
safi);
- list_delete_and_null(&matches);
+ list_delete(&matches);
}
}
}
static int bgp_rpki_fini(void)
{
stop();
- list_delete_and_null(&cache_list);
+ list_delete(&cache_list);
close(rpki_sync_socket_rtr);
close(rpki_sync_socket_bgpd);
listnode_delete(bgp->redist[afi][type], red);
XFREE(MTYPE_BGP_REDIST, red);
if (!bgp->redist[afi][type]->count)
- list_delete_and_null(&bgp->redist[afi][type]);
+ list_delete(&bgp->redist[afi][type]);
}
}
peer_delete(other);
}
}
- list_delete_and_null(&group->peer);
+ list_delete(&group->peer);
for (afi = AFI_IP; afi < AFI_MAX; afi++) {
for (ALL_LIST_ELEMENTS(group->listen_range[afi], node, nnode,
prefix)) {
prefix_free(prefix);
}
- list_delete_and_null(&group->listen_range[afi]);
+ list_delete(&group->listen_range[afi]);
}
XFREE(MTYPE_PEER_GROUP_HOST, group->name);
QOBJ_UNREG(bgp);
- list_delete_and_null(&bgp->group);
- list_delete_and_null(&bgp->peer);
+ list_delete(&bgp->group);
+ list_delete(&bgp->peer);
if (bgp->peerhash) {
hash_free(bgp->peerhash);
vpn_policy_direction_t dir;
if (bgp->vpn_policy[afi].import_vrf)
- list_delete_and_null(&bgp->vpn_policy[afi].import_vrf);
+ list_delete(&bgp->vpn_policy[afi].import_vrf);
if (bgp->vpn_policy[afi].export_vrf)
- list_delete_and_null(&bgp->vpn_policy[afi].export_vrf);
+ list_delete(&bgp->vpn_policy[afi].export_vrf);
dir = BGP_VPN_POLICY_DIR_FROMVPN;
if (bgp->vpn_policy[afi].rtlist[dir])
bgp_close();
if (bm->listen_sockets)
- list_delete_and_null(&bm->listen_sockets);
+ list_delete(&bm->listen_sockets);
for (ALL_LIST_ELEMENTS(bm->bgp, mnode, mnnode, bgp))
for (ALL_LIST_ELEMENTS(bgp->peer, node, nnode, peer))
listnode_delete(rfg->nves, rfd);
listnode_add(orphaned_nves, rfd);
}
- list_delete_and_null(&rfg->nves);
+ list_delete(&rfg->nves);
}
/* delete it */
if (vty)
vty_out(vty, "\n");
}
- list_delete_and_null(&orphaned_nves);
+ list_delete(&orphaned_nves);
}
}
if (rfg->rt_export_list)
ecommunity_free(&rfg->rt_export_list);
if (rfg->labels)
- list_delete_and_null(&rfg->labels);
+ list_delete(&rfg->labels);
if (rfg->rfp_cfg)
XFREE(MTYPE_RFAPI_RFP_GROUP_CFG, rfg->rfp_cfg);
listnode_delete(bgp->rfapi_cfg->l2_groups, rfg);
bgp_rfapi_delete_named_nve_group(NULL, bgp, NULL, RFAPI_GROUP_CFG_MAX);
bgp_rfapi_delete_named_l2_group(NULL, bgp, NULL);
if (h->l2_groups != NULL)
- list_delete_and_null(&h->l2_groups);
- list_delete_and_null(&h->nve_groups_sequential);
- list_delete_and_null(&h->rfg_export_direct_bgp_l);
- list_delete_and_null(&h->rfg_export_zebra_l);
+ list_delete(&h->l2_groups);
+ list_delete(&h->nve_groups_sequential);
+ list_delete(&h->rfg_export_direct_bgp_l);
+ list_delete(&h->rfg_export_zebra_l);
if (h->default_rt_export_list)
ecommunity_free(&h->default_rt_export_list);
if (h->default_rt_import_list)
* Delete local_nexthops list
*/
if (bi->extra && bi->extra->vnc.export.local_nexthops) {
- list_delete_and_null(
+ list_delete(
&bi->extra->vnc.export.local_nexthops);
}
*/
if (pn->info) {
if (pn->info != (void *)1) {
- list_delete_and_null(
+ list_delete(
(struct list *
*)(&pn->info));
}
}
delete_list->del = (void (*)(void *))rfapi_info_free;
- list_delete_and_null(&delete_list);
+ list_delete(&delete_list);
}
RFAPI_RIB_CHECK_COUNTS(0, 0);
agg_unlock_node(pn);
}
if (lPendCost) {
- list_delete_and_null(&lPendCost);
+ list_delete(&lPendCost);
pn->info = NULL;
agg_unlock_node(pn);
}
*/
if (pn->info) {
if (pn->info != (void *)1) {
- list_delete_and_null((struct list **)(&pn->info));
+ list_delete((struct list **)(&pn->info));
}
pn->info = NULL;
agg_unlock_node(pn); /* linklist or 1 deleted */
}
list_delete_all_node(adb_delete_list);
}
- list_delete_and_null(&adb_delete_list);
+ list_delete(&adb_delete_list);
}
if (nve_list) {
vnc_direct_bgp_unexport_table(
afi, it->imported_vpn[afi], nve_list);
- list_delete_and_null(&nve_list);
+ list_delete(&nve_list);
}
}
}
skiplist_delete(it->monitor_exterior_orphans,
an_bi_exterior, NULL);
}
- list_delete_and_null(&list_adopted);
+ list_delete(&list_adopted);
}
}
nve_list_to_nh_array(rn->p.family, nves, &nexthop_count,
&nh_ary, &nhp_ary);
- list_delete_and_null(&nves);
+ list_delete(&nves);
if (nexthop_count)
vnc_zebra_route_msg(&rn->p, nexthop_count, nhp_ary,
vnc_zlog_debug_verbose("%s: family: %d, nve count: %d",
__func__, family, nexthop_count);
- list_delete_and_null(&nves);
+ list_delete(&nves);
if (nexthop_count) {
/*
tn->serno);
if (successors)
- list_delete_and_null(&successors);
+ list_delete(&successors);
}
void show_ip_eigrp_nexthop_entry(struct vty *vty, struct eigrp *eigrp,
// neighbors left
}
- list_delete_and_null(&successors);
+ list_delete(&successors);
return 1;
}
// neighbors left
}
- list_delete_and_null(&successors);
+ list_delete(&successors);
return 1;
}
ne = listnode_head(successors);
eigrp_send_reply(ne->adv_router, prefix);
- list_delete_and_null(&successors);
+ list_delete(&successors);
}
prefix->state = EIGRP_FSM_STATE_PASSIVE;
msg);
- list_delete_and_null(&successors);
+ list_delete(&successors);
return 1;
}
ne = listnode_head(successors);
eigrp_send_reply(ne->adv_router, prefix);
- list_delete_and_null(&successors);
+ list_delete(&successors);
}
prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
listnode_add(eigrp->topology_changes_internalIPV4, prefix);
// neighbors left
}
- list_delete_and_null(&successors);
+ list_delete(&successors);
return 1;
}
msg->prefix->state = EIGRP_FSM_STATE_ACTIVE_2;
msg->prefix->distance = ne->distance;
- list_delete_and_null(&successors);
+ list_delete(&successors);
return 1;
}
if (!ei)
return 0;
- list_delete_and_null(&ei->nbrs);
+ list_delete(&ei->nbrs);
eigrp = ei->eigrp;
listnode_delete(eigrp->eiflist, ei);
eigrp_if_down(ei);
- list_delete_and_null(&ei->nbrs);
+ list_delete(&ei->nbrs);
listnode_delete(ei->eigrp->eiflist, ei);
}
eigrp_zebra_route_add(node->destination, l);
}
- list_delete_and_null(&l);
+ list_delete(&l);
}
/*
for (ALL_LIST_ELEMENTS(pe->entries, node, nnode, ne))
eigrp_nexthop_entry_delete(pe, ne);
- list_delete_and_null(&pe->entries);
- list_delete_and_null(&pe->rij);
+ list_delete(&pe->entries);
+ list_delete(&pe->rij);
eigrp_zebra_route_delete(pe->destination);
prefix_free(pe->destination);
* If we have no successors return NULL
*/
if (!successors->count) {
- list_delete_and_null(&successors);
+ list_delete(&successors);
successors = NULL;
}
for (ALL_LIST_ELEMENTS_RO(successors, node, entry))
entry->flags |= EIGRP_NEXTHOP_ENTRY_INTABLE_FLAG;
- list_delete_and_null(&successors);
+ list_delete(&successors);
} else {
eigrp_zebra_route_delete(prefix->destination);
for (ALL_LIST_ELEMENTS_RO(prefix->entries, node, entry))
eigrp_update_send_all(eigrp, ei);
if (nbr_prefixes)
- list_delete_and_null(&nbr_prefixes);
+ list_delete(&nbr_prefixes);
}
/*send EIGRP Update packet*/
THREAD_OFF(eigrp->t_read);
close(eigrp->fd);
- list_delete_and_null(&eigrp->eiflist);
- list_delete_and_null(&eigrp->oi_write_q);
+ list_delete(&eigrp->eiflist);
+ list_delete(&eigrp->oi_write_q);
eigrp_topology_free(eigrp->topology_table);
eigrp_nbr_delete(eigrp->neighbor_self);
- list_delete_and_null(&eigrp->topology_changes_externalIPV4);
- list_delete_and_null(&eigrp->topology_changes_internalIPV4);
+ list_delete(&eigrp->topology_changes_externalIPV4);
+ list_delete(&eigrp->topology_changes_internalIPV4);
listnode_delete(eigrp_om->eigrp, eigrp);
if (circuit->ip_addrs) {
assert(listcount(circuit->ip_addrs) == 0);
- list_delete_and_null(&circuit->ip_addrs);
+ list_delete(&circuit->ip_addrs);
}
if (circuit->ipv6_link) {
assert(listcount(circuit->ipv6_link) == 0);
- list_delete_and_null(&circuit->ipv6_link);
+ list_delete(&circuit->ipv6_link);
}
if (circuit->ipv6_non_link) {
assert(listcount(circuit->ipv6_non_link) == 0);
- list_delete_and_null(&circuit->ipv6_non_link);
+ list_delete(&circuit->ipv6_non_link);
}
circuit->circ_type = CIRCUIT_T_UNKNOWN;
if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
/* destroy neighbour lists */
if (circuit->u.bc.lan_neighs[0]) {
- list_delete_and_null(&circuit->u.bc.lan_neighs[0]);
+ list_delete(&circuit->u.bc.lan_neighs[0]);
circuit->u.bc.lan_neighs[0] = NULL;
}
if (circuit->u.bc.lan_neighs[1]) {
- list_delete_and_null(&circuit->u.bc.lan_neighs[1]);
+ list_delete(&circuit->u.bc.lan_neighs[1]);
circuit->u.bc.lan_neighs[1] = NULL;
}
/* destroy adjacency databases */
if (circuit->u.bc.adjdb[0]) {
circuit->u.bc.adjdb[0]->del = isis_delete_adj;
- list_delete_and_null(&circuit->u.bc.adjdb[0]);
+ list_delete(&circuit->u.bc.adjdb[0]);
circuit->u.bc.adjdb[0] = NULL;
}
if (circuit->u.bc.adjdb[1]) {
circuit->u.bc.adjdb[1]->del = isis_delete_adj;
- list_delete_and_null(&circuit->u.bc.adjdb[1]);
+ list_delete(&circuit->u.bc.adjdb[1]);
circuit->u.bc.adjdb[1] = NULL;
}
if (circuit->u.bc.is_dr[0]) {
if (!adjdb) {
zlog_warn("isis_dr_elect() adjdb == NULL");
- list_delete_and_null(&list);
+ list_delete(&list);
return ISIS_WARNING;
}
isis_adj_build_up_list(adjdb, list);
*/
if (circuit->u.bc.is_dr[level - 1])
retval = isis_dr_resign(circuit, level);
- list_delete_and_null(&list);
+ list_delete(&list);
return retval;
}
if (circuit->u.bc.is_dr[level - 1])
retval = isis_dr_resign(circuit, level);
}
- list_delete_and_null(&list);
+ list_delete(&list);
return retval;
}
circuit->lsp_regenerate_pending[idx] = 0;
circuit->u.bc.run_dr_elect[idx] = 0;
if (circuit->u.bc.lan_neighs[idx] != NULL)
- list_delete_and_null(&circuit->u.bc.lan_neighs[idx]);
+ list_delete(&circuit->u.bc.lan_neighs[idx]);
}
return;
lsp_clear_data(lsp);
if (LSP_FRAGMENT(lsp->hdr.lsp_id) == 0 && lsp->lspu.frags) {
- list_delete_and_null(&lsp->lspu.frags);
+ list_delete(&lsp->lspu.frags);
lsp->lspu.frags = NULL;
}
frag->tlvs = tlvs;
}
- list_delete_and_null(&fragments);
+ list_delete(&fragments);
lsp_debug("ISIS (%s): LSP construction is complete. Serializing...",
area->area_tag);
return;
LSP_PSEUDO_ID(ne_id));
}
}
- list_delete_and_null(&adj_list);
+ list_delete(&adj_list);
return;
}
void area_mt_finish(struct isis_area *area)
{
- list_delete_and_null(&area->mt_settings);
+ list_delete(&area->mt_settings);
}
struct isis_area_mt_setting *area_get_mt_setting(struct isis_area *area,
void circuit_mt_finish(struct isis_circuit *circuit)
{
- list_delete_and_null(&circuit->mt_settings);
+ list_delete(&circuit->mt_settings);
}
struct isis_circuit_mt_setting *
}
/* lets free it */
- list_delete_and_null(&lsp_list);
+ list_delete(&lsp_list);
}
if (fabricd_initial_sync_is_complete(circuit->area) && resync_needed)
if (route_info->nexthops) {
route_info->nexthops->del =
(void (*)(void *))isis_nexthop_delete;
- list_delete_and_null(&route_info->nexthops);
+ list_delete(&route_info->nexthops);
}
if (route_info->nexthops6) {
route_info->nexthops6->del =
(void (*)(void *))isis_nexthop6_delete;
- list_delete_and_null(&route_info->nexthops6);
+ list_delete(&route_info->nexthops6);
}
XFREE(MTYPE_ISIS_ROUTE_INFO, route_info);
adjdb = circuit->u.bc.adjdb[spftree->level - 1];
isis_adj_build_up_list(adjdb, adj_list);
if (listcount(adj_list) == 0) {
- list_delete_and_null(&adj_list);
+ list_delete(&adj_list);
if (isis->debugs & DEBUG_SPF_EVENTS)
zlog_debug(
"ISIS-Spf: no L%d adjacencies on circuit %s",
"isis_spf_preload_tent unknow adj type");
}
}
- list_delete_and_null(&adj_list);
+ list_delete(&adj_list);
/*
* Add the pseudonode
*/
__attribute__((__unused__))
static void isis_vertex_del(struct isis_vertex *vertex)
{
- list_delete_and_null(&vertex->Adj_N);
- list_delete_and_null(&vertex->parents);
+ list_delete(&vertex->Adj_N);
+ list_delete(&vertex->parents);
if (vertex->firsthops) {
hash_clean(vertex->firsthops, NULL);
hash_free(vertex->firsthops);
skiplist_free(queue->l.slist);
queue->l.slist = NULL;
} else
- list_delete_and_null(&queue->l.list);
+ list_delete(&queue->l.list);
}
__attribute__((__unused__))
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO(rv, node, fragment_tlvs))
isis_free_tlvs(fragment_tlvs);
- list_delete_and_null(&rv);
+ list_delete(&rv);
}
stream_free(dummy_stream);
circuit->ipv6_router = 0;
isis_csm_state_change(ISIS_DISABLE, circuit, area);
}
- list_delete_and_null(&area->circuit_list);
+ list_delete(&area->circuit_list);
}
if (area->lspdb[0] != NULL) {
}
vector comps = completions_to_vec(completions);
- list_delete_and_null(&completions);
+ list_delete(&completions);
// set status code appropriately
switch (vector_active(comps)) {
// if matcher error, return corresponding CMD_ERR
if (MATCHER_ERROR(status)) {
if (argv_list)
- list_delete_and_null(&argv_list);
+ list_delete(&argv_list);
switch (status) {
case MATCHER_INCOMPLETE:
return CMD_ERR_INCOMPLETE;
ret = matched_element->func(matched_element, vty, argc, argv);
// delete list and cmd_token's in it
- list_delete_and_null(&argv_list);
+ list_delete(&argv_list);
XFREE(MTYPE_TMP, argv);
return ret;
if (host.config)
XFREE(MTYPE_HOST, host.config);
- list_delete_and_null(&varhandlers);
+ list_delete(&varhandlers);
qobj_finish();
}
status = MATCHER_INCOMPLETE;
// cleanup
- list_delete_and_null(&next);
+ list_delete(&next);
return status;
}
unsigned int idx;
for (idx = 0; idx < vector_active(vline) && next->count > 0; idx++) {
- list_delete_and_null(¤t);
+ list_delete(¤t);
current = next;
next = list_new();
next->del = stack_del;
}
}
- list_delete_and_null(¤t);
- list_delete_and_null(&next);
+ list_delete(¤t);
+ list_delete(&next);
return mrv;
}
list_delete_node(list, tail);
// delete the rest of the list as usual
- list_delete_and_null(&list);
+ list_delete(&list);
}
/*---------- token level matching functions ----------*/
json_object_free(top);
}
- list_delete_and_null(&errlist);
+ list_delete(&errlist);
}
DEFUN_NOSH(show_error_code,
{
pthread_mutex_lock(&frr_pthread_list_mtx);
{
- list_delete_and_null(&frr_pthread_list);
+ list_delete(&frr_pthread_list);
}
pthread_mutex_unlock(&frr_pthread_list_mtx);
}
vty_out(vty, "%% No match\n");
// free resources
- list_delete_and_null(&completions);
+ list_delete(&completions);
cmd_free_strvec(command);
XFREE(MTYPE_TMP, cmdstr);
vty_out(vty, "func: %p\n", element->func);
- list_delete_and_null(&argvv);
+ list_delete(&argvv);
} else {
assert(MATCHER_ERROR(result));
switch (result) {
}
prev = cur;
}
- list_delete_and_null(&commands);
+ list_delete(&commands);
vty_out(vty, "\n");
} while (scan && scannode < LINK_PARAMS_NODE);
if (_hashes) {
listnode_delete(_hashes, hash);
if (_hashes->count == 0) {
- list_delete_and_null(&_hashes);
+ list_delete(&_hashes);
}
}
}
if_delete_retain(ifp);
- list_delete_and_null(&ifp->connected);
- list_delete_and_null(&ifp->nbr_connected);
+ list_delete(&ifp->connected);
+ list_delete(&ifp->nbr_connected);
if_link_params_free(ifp);
if (keychain->name)
XFREE(MTYPE_KEYCHAIN, keychain->name);
- list_delete_and_null(&keychain->key);
+ list_delete(&keychain->key);
listnode_delete(keychain_list, keychain);
keychain_free(keychain);
}
list->count = 0;
}
-void list_delete_and_null(struct list **list)
+void list_delete(struct list **list)
{
assert(*list);
list_delete_all_node(*list);
* pointer to list pointer; this will be set to NULL after the list has been
* deleted
*/
-extern void list_delete_and_null(struct list **plist);
+extern void list_delete(struct list **plist);
/*
* Delete all nodes from a list without deleting the list itself.
RB_REMOVE(nhgc_entry_head, &nhgc_entries, nhgc);
- list_delete_and_null(&nhgc->nhg_list);
+ list_delete(&nhgc->nhg_list);
XFREE(MTYPE_TMP, nhgc);
}
for (ALL_LIST_ELEMENTS_RO(maplist, ln, map))
vty_show_route_map_entry(vty, map);
- list_delete_and_null(&maplist);
+ list_delete(&maplist);
}
return CMD_SUCCESS;
}
{
listnode_delete(masters, m);
if (masters->count == 0) {
- list_delete_and_null(&masters);
+ list_delete(&masters);
}
}
pthread_mutex_unlock(&masters_mtx);
pthread_cond_destroy(&m->cancel_cond);
close(m->io_pipe[0]);
close(m->io_pipe[1]);
- list_delete_and_null(&m->cancel_req);
+ list_delete(&m->cancel_req);
m->cancel_req = NULL;
hash_clean(m->cpu_record, cpu_record_hash_free);
int i;
for (i = 0; i < wheel->slots; i++) {
- list_delete_and_null(&wheel->wheel_slot_lists[i]);
+ list_delete(&wheel->wheel_slot_lists[i]);
}
THREAD_OFF(wheel->timer);
XFREE(MTYPE_REDIST_INST, id);
if (!red->instances->count) {
red->enabled = 0;
- list_delete_and_null(&red->instances);
+ list_delete(&red->instances);
}
}
for (ALL_LIST_ELEMENTS_RO(oa->if_list, n, oi))
oi->area = NULL;
- list_delete_and_null(&oa->if_list);
+ list_delete(&oa->if_list);
ospf6_lsdb_delete(oa->lsdb);
ospf6_lsdb_delete(oa->lsdb_self);
for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on))
ospf6_neighbor_delete(on);
- list_delete_and_null(&oi->neighbor_list);
+ list_delete(&oi->neighbor_list);
THREAD_OFF(oi->thread_send_hello);
THREAD_OFF(oi->thread_send_lsupdate);
void ospf6_path_free(struct ospf6_path *op)
{
if (op->nh_list)
- list_delete_and_null(&op->nh_list);
+ list_delete(&op->nh_list);
XFREE(MTYPE_OSPF6_PATH, op);
}
{
if (route) {
if (route->nh_list)
- list_delete_and_null(&route->nh_list);
+ list_delete(&route->nh_list);
if (route->paths)
- list_delete_and_null(&route->paths);
+ list_delete(&route->paths);
XFREE(MTYPE_OSPF6_ROUTE, route);
}
}
static void ospf6_vertex_delete(struct ospf6_vertex *v)
{
- list_delete_and_null(&v->nh_list);
- list_delete_and_null(&v->child_list);
+ list_delete(&v->nh_list);
+ list_delete(&v->child_list);
XFREE(MTYPE_OSPF6_VERTEX, v);
}
ospf6_area_delete(oa);
- list_delete_and_null(&o->area_list);
+ list_delete(&o->area_list);
ospf6_lsdb_delete(o->lsdb);
ospf6_lsdb_delete(o->lsdb_self);
/* Free client list itself */
if (apiserver_list)
- list_delete_and_null(&apiserver_list);
+ list_delete(&apiserver_list);
/* Free wildcard list */
/* XXX */
/* If none is found -- look through all. */
if (listcount(chosen) == 0) {
- list_delete_and_null(&chosen);
+ list_delete(&chosen);
chosen = rn->info;
}
}
if (chosen != rn->info)
- list_delete_and_null(&chosen);
+ list_delete(&chosen);
return best;
}
if ((lst = rn->info) != NULL) {
for (ALL_LIST_ELEMENTS(lst, node, nnode, lsa))
ospf_lsa_unlock(&lsa); /* external_lsas lst */
- list_delete_and_null(&lst);
+ list_delete(&lst);
}
route_table_finish(rt);
ospf_delete_opaque_functab(OSPF_OPAQUE_AREA_LSA,
OPAQUE_TYPE_EXTENDED_LINK_LSA);
- list_delete_and_null(&OspfEXT.iflist);
+ list_delete(&OspfEXT.iflist);
OspfEXT.scope = 0;
OspfEXT.enabled = false;
route_table_finish(oi->ls_upd_queue);
/* Free any lists that should be freed */
- list_delete_and_null(&oi->nbr_nbma);
+ list_delete(&oi->nbr_nbma);
- list_delete_and_null(&oi->ls_ack);
- list_delete_and_null(&oi->ls_ack_direct.ls_ack);
+ list_delete(&oi->ls_ack);
+ list_delete(&oi->ls_ack_direct.ls_ack);
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("%s: ospf interface %s vrf %s id %u deleted",
void ospf_del_if_params(struct ospf_if_params *oip)
{
- list_delete_and_null(&oip->auth_crypt);
+ list_delete(&oip->auth_crypt);
bfd_info_free(&(oip->bfd_info));
XFREE(MTYPE_OSPF_IF_PARAMS, oip);
}
else
DR(oi).s_addr = 0;
- list_delete_and_null(&dr_list);
+ list_delete(&dr_list);
return dr;
}
else
BDR(oi).s_addr = 0;
- list_delete_and_null(&bdr_list);
- list_delete_and_null(&no_dr_list);
+ list_delete(&bdr_list);
+ list_delete(&no_dr_list);
return bdr;
}
zlog_debug("DR-Election[2nd]: DR %s", inet_ntoa(DR(oi)));
}
- list_delete_and_null(&el_list);
+ list_delete(&el_list);
/* if DR or BDR changes, cause AdjOK? neighbor event. */
if (!IPV4_ADDR_SAME(&old_dr, &DR(oi))
ospf->lsa_refresh_queue.qs[lsa->refresh_list];
listnode_delete(refresh_list, lsa);
if (!listcount(refresh_list)) {
- list_delete_and_null(&refresh_list);
+ list_delete(&refresh_list);
ospf->lsa_refresh_queue.qs[lsa->refresh_list] = NULL;
}
ospf_lsa_unlock(&lsa); /* lsa_refresh_queue */
lsa->refresh_list = -1;
listnode_add(lsa_to_refresh, lsa);
}
- list_delete_and_null(&refresh_list);
+ list_delete(&refresh_list);
}
}
&lsa); /* lsa_refresh_queue & temp for lsa_to_refresh*/
}
- list_delete_and_null(&lsa_to_refresh);
+ list_delete(&lsa_to_refresh);
if (IS_DEBUG_OSPF(lsa, LSA_REFRESH))
zlog_debug("LSA[Refresh]: ospf_lsa_refresh_walker(): end");
int ospf_opaque_type9_lsa_init(struct ospf_interface *oi)
{
if (oi->opaque_lsa_self != NULL)
- list_delete_and_null(&oi->opaque_lsa_self);
+ list_delete(&oi->opaque_lsa_self);
oi->opaque_lsa_self = list_new();
oi->opaque_lsa_self->del = free_opaque_info_per_type;
{
OSPF_TIMER_OFF(oi->t_opaque_lsa_self);
if (oi->opaque_lsa_self != NULL)
- list_delete_and_null(&oi->opaque_lsa_self);
+ list_delete(&oi->opaque_lsa_self);
oi->opaque_lsa_self = NULL;
return;
}
int ospf_opaque_type10_lsa_init(struct ospf_area *area)
{
if (area->opaque_lsa_self != NULL)
- list_delete_and_null(&area->opaque_lsa_self);
+ list_delete(&area->opaque_lsa_self);
area->opaque_lsa_self = list_new();
area->opaque_lsa_self->del = free_opaque_info_per_type;
OSPF_TIMER_OFF(area->t_opaque_lsa_self);
if (area->opaque_lsa_self != NULL)
- list_delete_and_null(&area->opaque_lsa_self);
+ list_delete(&area->opaque_lsa_self);
return;
}
int ospf_opaque_type11_lsa_init(struct ospf *top)
{
if (top->opaque_lsa_self != NULL)
- list_delete_and_null(&top->opaque_lsa_self);
+ list_delete(&top->opaque_lsa_self);
top->opaque_lsa_self = list_new();
top->opaque_lsa_self->del = free_opaque_info_per_type;
OSPF_TIMER_OFF(top->t_opaque_lsa_self);
if (top->opaque_lsa_self != NULL)
- list_delete_and_null(&top->opaque_lsa_self);
+ list_delete(&top->opaque_lsa_self);
return;
}
struct list *funclist;
funclist = ospf_opaque_wildcard_funclist;
- list_delete_and_null(&funclist);
+ list_delete(&funclist);
funclist = ospf_opaque_type9_funclist;
- list_delete_and_null(&funclist);
+ list_delete(&funclist);
funclist = ospf_opaque_type10_funclist;
- list_delete_and_null(&funclist);
+ list_delete(&funclist);
funclist = ospf_opaque_type11_funclist;
- list_delete_and_null(&funclist);
+ list_delete(&funclist);
return;
}
}
OSPF_TIMER_OFF(oipt->t_opaque_lsa_self);
- list_delete_and_null(&oipt->id_list);
+ list_delete(&oipt->id_list);
XFREE(MTYPE_OPAQUE_INFO_PER_TYPE, oipt);
return;
}
if (listcount(update) > 0)
ospf_ls_upd_send(nbr, update, OSPF_SEND_PACKET_DIRECT,
0);
- list_delete_and_null(&update);
+ list_delete(&update);
}
/* Set LS Update retransmission timer. */
/* Verify LSA type. */
if (ls_type < OSPF_MIN_LSA || ls_type >= OSPF_MAX_LSA) {
OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_BadLSReq);
- list_delete_and_null(&ls_upd);
+ list_delete(&ls_upd);
return;
}
adv_router);
if (find == NULL) {
OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_BadLSReq);
- list_delete_and_null(&ls_upd);
+ list_delete(&ls_upd);
return;
}
ospf_ls_upd_send(nbr, ls_upd, OSPF_SEND_PACKET_INDIRECT,
0);
- list_delete_and_null(&ls_upd);
+ list_delete(&ls_upd);
} else
- list_delete_and_null(&ls_upd);
+ list_delete(&ls_upd);
}
/* Get the list of LSAs from Link State Update packet.
for (ALL_LIST_ELEMENTS(lsas, node, nnode, lsa))
ospf_lsa_discard(lsa);
- list_delete_and_null(&lsas);
+ list_delete(&lsas);
}
/* OSPF Link State Update message read -- RFC2328 Section 13. */
#undef DISCARD_LSA
assert(listcount(lsas) == 0);
- list_delete_and_null(&lsas);
+ list_delete(&lsas);
}
/* OSPF Link State Acknowledgment message read -- RFC2328 Section 13.7. */
else
ospf_ls_upd_send(nbr, update, flag, 0);
- list_delete_and_null(&update);
+ list_delete(&update);
}
/* Determine size for packet. Must be at least big enough to accomodate next
/* list might not be empty. */
if (listcount(update) == 0) {
- list_delete_and_null((struct list **)&rn->info);
+ list_delete((struct list **)&rn->info);
route_unlock_node(rn);
} else
again = 1;
void ospf_router_info_term(void)
{
- list_delete_and_null(&OspfRI.pce_info.pce_domain);
- list_delete_and_null(&OspfRI.pce_info.pce_neighbor);
+ list_delete(&OspfRI.pce_info.pce_domain);
+ list_delete(&OspfRI.pce_info.pce_neighbor);
OspfRI.enabled = false;
void ospf_route_free(struct ospf_route * or)
{
if (or->paths)
- list_delete_and_null(& or->paths);
+ list_delete(& or->paths);
XFREE(MTYPE_OSPF_ROUTE, or);
}
zlog_debug("Pruning router node %s",
inet_ntoa(rn->p.u.prefix4));
- list_delete_and_null(&paths);
+ list_delete(&paths);
rn->info = NULL;
route_unlock_node(rn);
}
// assert (listcount (v->parents) == 0);
if (v->children)
- list_delete_and_null(&v->children);
+ list_delete(&v->children);
if (v->parents)
- list_delete_and_null(&v->parents);
+ list_delete(&v->parents);
v->lsa = NULL;
for (ALL_LIST_ELEMENTS(or_list, node, nnode, or))
ospf_route_free(or);
- list_delete_and_null(&or_list);
+ list_delete(&or_list);
/* Unlock the node. */
rn->info = NULL;
return;
/* Clean Extended Link */
- list_delete_and_null(&srn->ext_link);
+ list_delete(&srn->ext_link);
/* Clean Prefix List */
- list_delete_and_null(&srn->ext_prefix);
+ list_delete(&srn->ext_prefix);
XFREE(MTYPE_OSPF_SR_PARAMS, srn);
}
/*
* Remove all SR Nodes from the Hash table. Prefix and Link SID will
- * be remove though list_delete_and_null() call. See sr_node_del()
+ * be remove though list_delete() call. See sr_node_del()
*/
hash_clean(OspfSR.neighbors, (void *)sr_node_del);
}
void ospf_mpls_te_term(void)
{
- list_delete_and_null(&OspfMplsTE.iflist);
+ list_delete(&OspfMplsTE.iflist);
ospf_delete_opaque_functab(OSPF_OPAQUE_AREA_LSA,
OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA);
listnode_delete(ospf->external[type], ext);
if (!ospf->external[type]->count)
- list_delete_and_null(&ospf->external[type]);
+ list_delete(&ospf->external[type]);
XFREE(MTYPE_OSPF_EXTERNAL, ext);
}
if (red) {
listnode_delete(ospf->redist[type], red);
if (!ospf->redist[type]->count) {
- list_delete_and_null(&ospf->redist[type]);
+ list_delete(&ospf->redist[type]);
}
ospf_routemap_unset(red);
XFREE(MTYPE_OSPF_REDISTRIBUTE, red);
for (ALL_LIST_ELEMENTS(ospf->vlinks, node, nnode, vl_data))
ospf_vl_delete(ospf, vl_data);
- list_delete_and_null(&ospf->vlinks);
+ list_delete(&ospf->vlinks);
/* Remove any ospf interface config params */
FOR_ALL_INTERFACES (vrf, ifp) {
/* Reset interface. */
for (ALL_LIST_ELEMENTS(ospf->oiflist, node, nnode, oi))
ospf_if_free(oi);
- list_delete_and_null(&ospf->oiflist);
+ list_delete(&ospf->oiflist);
/* De-Register VRF */
ospf_zebra_vrf_deregister(ospf);
ospf_ase_external_lsas_finish(ospf->external_lsas);
}
- list_delete_and_null(&ospf->areas);
- list_delete_and_null(&ospf->oi_write_q);
+ list_delete(&ospf->areas);
+ list_delete(&ospf->oi_write_q);
for (i = ZEBRA_ROUTE_SYSTEM; i <= ZEBRA_ROUTE_MAX; i++) {
struct list *ext_list;
ospf_lsa_unlock(&area->router_lsa_self);
route_table_finish(area->ranges);
- list_delete_and_null(&area->oiflist);
+ list_delete(&area->oiflist);
if (EXPORT_NAME(area))
free(EXPORT_NAME(area));
if ((lst = (struct list *)rn->info)) {
for (ALL_LIST_ELEMENTS(lst, node, nnode, lsa))
ospf_lsa_unlock(&lsa); /* oi->ls_upd_queue */
- list_delete_and_null(&lst);
+ list_delete(&lst);
rn->info = NULL;
}
#define FREE_ADDR_LIST \
if (hello_option_addr_list) { \
- list_delete_and_null(&hello_option_addr_list); \
+ list_delete(&hello_option_addr_list); \
}
#define FREE_ADDR_LIST_THEN_RETURN(code) \
pim_if_del_vif(ifp);
- list_delete_and_null(&pim_ifp->igmp_socket_list);
- list_delete_and_null(&pim_ifp->pim_neighbor_list);
- list_delete_and_null(&pim_ifp->upstream_switch_list);
- list_delete_and_null(&pim_ifp->sec_addr_list);
+ list_delete(&pim_ifp->igmp_socket_list);
+ list_delete(&pim_ifp->pim_neighbor_list);
+ list_delete(&pim_ifp->upstream_switch_list);
+ list_delete(&pim_ifp->sec_addr_list);
if (pim_ifp->boundary_oil_plist)
XFREE(MTYPE_PIM_INTERFACE, pim_ifp->boundary_oil_plist);
listnode_delete(pim_ifp->igmp_join_list, ij);
igmp_join_free(ij);
if (listcount(pim_ifp->igmp_join_list) < 1) {
- list_delete_and_null(&pim_ifp->igmp_join_list);
+ list_delete(&pim_ifp->igmp_join_list);
pim_ifp->igmp_join_list = 0;
}
pim_ifchannel_remove_children(ch);
if (ch->sources)
- list_delete_and_null(&ch->sources);
+ list_delete(&ch->sources);
listnode_delete(ch->upstream->ifchannels, ch);
static void igmp_group_free(struct igmp_group *group)
{
- list_delete_and_null(&group->group_source_list);
+ list_delete(&group->group_source_list);
XFREE(MTYPE_PIM_IGMP_GROUP, group);
}
zassert(igmp->igmp_group_list);
zassert(!listcount(igmp->igmp_group_list));
- list_delete_and_null(&igmp->igmp_group_list);
+ list_delete(&igmp->igmp_group_list);
hash_free(igmp->igmp_group_hash);
XFREE(MTYPE_PIM_IGMP_SOCKET, igmp);
}
if (pim->static_routes)
- list_delete_and_null(&pim->static_routes);
+ list_delete(&pim->static_routes);
pim_upstream_terminate(pim);
void pim_jp_agg_group_list_free(struct pim_jp_agg_group *jag)
{
- list_delete_and_null(&jag->sources);
+ list_delete(&jag->sources);
XFREE(MTYPE_PIM_JP_AGG_GROUP, jag);
}
js->up = NULL;
XFREE(MTYPE_PIM_JP_AGG_SOURCE, js);
}
- list_delete_and_null(&jag->sources);
+ list_delete(&jag->sources);
listnode_delete(group, jag);
XFREE(MTYPE_PIM_JP_AGG_GROUP, jag);
}
}
if (jag->sources->count == 0) {
- list_delete_and_null(&jag->sources);
+ list_delete(&jag->sources);
listnode_delete(group, jag);
XFREE(MTYPE_PIM_JP_AGG_GROUP, jag);
}
XFREE(MTYPE_PIM_MSDP_MG_NAME, mg->mesh_group_name);
if (mg->mbr_list)
- list_delete_and_null(&mg->mbr_list);
+ list_delete(&mg->mbr_list);
XFREE(MTYPE_PIM_MSDP_MG, pim->msdp.mg);
}
}
if (pim->msdp.peer_list) {
- list_delete_and_null(&pim->msdp.peer_list);
+ list_delete(&pim->msdp.peer_list);
}
if (pim->msdp.sa_hash) {
}
if (pim->msdp.sa_list) {
- list_delete_and_null(&pim->msdp.sa_list);
+ list_delete(&pim->msdp.sa_list);
}
if (pim->msdp.work_obuf)
}
#endif
- list_delete_and_null(&neigh->prefix_list);
+ list_delete(&neigh->prefix_list);
}
}
delete_prefix_list(neigh);
- list_delete_and_null(&neigh->upstream_jp_agg);
+ list_delete(&neigh->upstream_jp_agg);
THREAD_OFF(neigh->jp_timer);
if (neigh->bfd_info)
pim_sendmsg_zebra_rnh(pim, zclient, pnc,
ZEBRA_NEXTHOP_UNREGISTER);
- list_delete_and_null(&pnc->rp_list);
+ list_delete(&pnc->rp_list);
hash_free(pnc->upstream_hash);
hash_release(pim->rpf_hash, pnc);
void pim_oil_terminate(struct pim_instance *pim)
{
if (pim->channel_oil_list)
- list_delete_and_null(&pim->channel_oil_list);
+ list_delete(&pim->channel_oil_list);
if (pim->channel_oil_hash)
hash_free(pim->channel_oil_hash);
{
struct pim_nexthop_cache *pnc = (struct pim_nexthop_cache *)data;
- list_delete_and_null(&pnc->rp_list);
+ list_delete(&pnc->rp_list);
hash_clean(pnc->upstream_hash, NULL);
hash_free(pnc->upstream_hash);
if (!str2prefix("224.0.0.0/4", &rp_info->group)) {
flog_err(EC_LIB_DEVELOPMENT,
"Unable to convert 224.0.0.0/4 to prefix");
- list_delete_and_null(&pim->rp_list);
+ list_delete(&pim->rp_list);
route_table_finish(pim->rp_table);
XFREE(MTYPE_PIM_RP, rp_info);
return;
void pim_rp_free(struct pim_instance *pim)
{
if (pim->rp_list)
- list_delete_and_null(&pim->rp_list);
+ list_delete(&pim->rp_list);
}
/*
void pim_ssmpingd_destroy(struct pim_instance *pim)
{
if (pim->ssmpingd_list)
- list_delete_and_null(&pim->ssmpingd_list);
+ list_delete(&pim->ssmpingd_list);
}
static struct ssmpingd_sock *ssmpingd_find(struct pim_instance *pim,
#define FREE_ADDR_LIST(hello_option_addr_list) \
{ \
if (hello_option_addr_list) { \
- list_delete_and_null(&hello_option_addr_list); \
+ list_delete(&hello_option_addr_list); \
hello_option_addr_list = 0; \
} \
}
if (child)
child->parent = NULL;
}
- list_delete_and_null(&up->sources);
+ list_delete(&up->sources);
}
/*
for (ALL_LIST_ELEMENTS(up->ifchannels, node, nnode, ch))
pim_ifchannel_delete(ch);
- list_delete_and_null(&up->ifchannels);
+ list_delete(&up->ifchannels);
pim_upstream_remove_children(pim, up);
if (up->sources)
- list_delete_and_null(&up->sources);
+ list_delete(&up->sources);
if (up->parent && up->parent->sources)
listnode_delete(up->parent->sources, up);
pim_upstream_remove_children(pim, up);
if (up->sources)
- list_delete_and_null(&up->sources);
+ list_delete(&up->sources);
- list_delete_and_null(&up->ifchannels);
+ list_delete(&up->ifchannels);
hash_release(pim->upstream_hash, up);
XFREE(MTYPE_PIM_UPSTREAM, up);
pim_upstream_del(pim, up, __PRETTY_FUNCTION__);
}
- list_delete_and_null(&pim->upstream_list);
+ list_delete(&pim->upstream_list);
}
if (pim->upstream_hash)
void rip_offset_clean()
{
- list_delete_and_null(&rip_offset_list_master);
+ list_delete(&rip_offset_list_master);
rip_offset_list_master = list_new();
rip_offset_list_master->cmp = (int (*)(void *, void *))offset_list_cmp;
/* Unlock route_node. */
listnode_delete(rp->info, rinfo);
if (list_isempty((struct list *)rp->info)) {
- list_delete_and_null((struct list **)&rp->info);
+ list_delete((struct list **)&rp->info);
route_unlock_node(rp);
}
RIP_TIMER_OFF(rinfo->t_garbage_collect);
rip_info_free(rinfo);
}
- list_delete_and_null(&list);
+ list_delete(&list);
rp->info = NULL;
route_unlock_node(rp);
}
void ripng_rte_free(struct list *ripng_rte_list)
{
- list_delete_and_null(&ripng_rte_list);
+ list_delete(&ripng_rte_list);
}
/* Delete RTE */
void ripng_offset_clean(void)
{
- list_delete_and_null(&ripng_offset_list_master);
+ list_delete(&ripng_offset_list_master);
ripng_offset_list_master = list_new();
ripng_offset_list_master->cmp =
/* Unlock route_node. */
listnode_delete(rp->info, rinfo);
if (list_isempty((struct list *)rp->info)) {
- list_delete_and_null((struct list **)&rp->info);
+ list_delete((struct list **)&rp->info);
agg_unlock_node(rp);
}
}
if (list_isempty(list)) {
- list_delete_and_null(&list);
+ list_delete(&list);
rp->info = NULL;
agg_unlock_node(rp);
}
rinfo->t_garbage_collect);
ripng_info_free(rinfo);
}
- list_delete_and_null(&list);
+ list_delete(&list);
rp->info = NULL;
agg_unlock_node(rp);
}
check_lookup_result(list, arglist);
- list_delete_and_null(&list);
+ list_delete(&list);
va_end(arglist);
test->vty = NULL;
}
if (test->log)
- list_delete_and_null(&test->log);
+ list_delete(&test->log);
if (test->desc)
XFREE(MTYPE_TMP, test->desc);
if (test->error)
bgp_zebra_destroy();
bf_free(bm->rd_idspace);
- list_delete_and_null(&bm->bgp);
+ list_delete(&bm->bgp);
memset(bm, 0, sizeof(*bm));
vty_terminate();
XFREE(MTYPE_TMP, pa);
}
- list_delete_and_null(&pa_list);
+ list_delete(&pa_list);
bgp_shutdown();
return 0;
sbuf_push(&fragment_format, 0, "%s", isis_format_tlvs(tlvs));
isis_free_tlvs(tlvs);
}
- list_delete_and_null(&fragments);
+ list_delete(&fragments);
stream_free(s);
char *fragment_content = sortlines((char *)sbuf_buf(&fragment_format));
static void config_del(struct config *config)
{
- list_delete_and_null(&config->line);
+ list_delete(&config->line);
if (config->name)
XFREE(MTYPE_VTYSH_CONFIG_LINE, config->name);
XFREE(MTYPE_VTYSH_CONFIG, config);
for (i = 0; i < vector_active(configvec); i++)
if ((master = vector_slot(configvec, i)) != NULL) {
- list_delete_and_null(&master);
+ list_delete(&master);
vector_slot(configvec, i) = NULL;
}
list_delete_all_node(config_top);
struct route_node *node)
{
if (node->info)
- list_delete_and_null((struct list **)&node->info);
+ list_delete((struct list **)&node->info);
route_node_destroy(delegate, table, node);
}
struct rtadvconf *rtadv;
rtadv = &zebra_if->rtadv;
- list_delete_and_null(&rtadv->AdvPrefixList);
+ list_delete(&rtadv->AdvPrefixList);
#endif /* HAVE_RTADV */
THREAD_OFF(zebra_if->speed_update);
}
/* Otherwise, free list and route node. */
- list_delete_and_null(&addr_list);
+ list_delete(&addr_list);
rn->info = NULL;
route_unlock_node(rn);
}
/* Free chain list and respective route node. */
- list_delete_and_null(&addr_list);
+ list_delete(&addr_list);
rn->info = NULL;
route_unlock_node(rn);
} else if (cp.family == AF_INET6) {
irdp_advert_off(ifp);
- list_delete_and_null(&irdp->AdvPrefList);
+ list_delete(&irdp->AdvPrefList);
irdp->flags = 0;
}
void label_manager_close()
{
- list_delete_and_null(&lbl_mgr.lc_list);
+ list_delete(&lbl_mgr.lc_list);
stream_free(obuf);
}
prefix_list_reset();
route_map_finish();
- list_delete_and_null(&zebrad.client_list);
+ list_delete(&zebrad.client_list);
work_queue_free_and_null(&zebrad.ribq);
meta_queue_free(zebrad.mq);
{
if (ns_id != NS_DEFAULT)
return;
- list_delete_and_null(&tbl_mgr.lc_list);
+ list_delete(&tbl_mgr.lc_list);
}
*/
static int fec_del(zebra_fec_t *fec)
{
- list_delete_and_null(&fec->client_list);
+ list_delete(&fec->client_list);
fec->rn->info = NULL;
route_unlock_node(fec->rn);
XFREE(MTYPE_FEC, fec);
vty_out(vty, "\n");
}
- list_delete_and_null(&lsp_list);
+ list_delete(&lsp_list);
}
/*
}
}
- list_delete_and_null(&slsp_list);
+ list_delete(&slsp_list);
return (zvrf->slsp_table->count ? 1 : 0);
}
unsigned i;
for (i = 0; i < MQ_SIZE; i++)
- list_delete_and_null(&mq->subq[i]);
+ list_delete(&mq->subq[i]);
XFREE(MTYPE_WORK_QUEUE, mq);
}
void zebra_free_rnh(struct rnh *rnh)
{
rnh->flags |= ZEBRA_NHT_DELETED;
- list_delete_and_null(&rnh->client_list);
- list_delete_and_null(&rnh->zebra_pseudowire_list);
+ list_delete(&rnh->client_list);
+ list_delete(&rnh->zebra_pseudowire_list);
free_state(rnh->vrf_id, rnh->state, rnh->node);
XFREE(MTYPE_RNH, rnh);
}
{
zebra_mac_t *tmp_mac;
- list_delete_and_null(&mac->neigh_list);
+ list_delete(&mac->neigh_list);
/* Free the VNI hash entry and allocated memory. */
tmp_mac = hash_release(zvni->mac_table, mac);
assert(zns);
/* free the list of l2vnis */
- list_delete_and_null(&zl3vni->l2vnis);
+ list_delete(&zl3vni->l2vnis);
zl3vni->l2vnis = NULL;
/* Free the rmac table */