{
bgp_table_unlock(vpn->route_table);
bgp_evpn_unmap_vni_from_its_rts(bgp, vpn);
- list_delete(vpn->import_rtl);
- list_delete(vpn->export_rtl);
- vpn->import_rtl = NULL;
- vpn->export_rtl = NULL;
+ list_delete_and_null(&vpn->import_rtl);
+ list_delete_and_null(&vpn->export_rtl);
bf_release_index(bgp->rd_idspace, vpn->rd_id);
hash_release(bgp->vnihash, vpn);
QOBJ_UNREG(vpn);
#endif
bgp_zebra_destroy();
- list_delete(bm->bgp);
+ list_delete_and_null(&bm->bgp);
memset(bm, 0, sizeof(*bm));
frr_fini();
peer_delete(other);
}
}
- list_delete(group->peer);
+ list_delete_and_null(&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(group->listen_range[afi]);
+ list_delete_and_null(&group->listen_range[afi]);
}
XFREE(MTYPE_PEER_GROUP_HOST, group->name);
QOBJ_UNREG(bgp);
- list_delete(bgp->group);
- list_delete(bgp->peer);
+ list_delete_and_null(&bgp->group);
+ list_delete_and_null(&bgp->peer);
if (bgp->peerhash) {
hash_free(bgp->peerhash);
listnode_delete(rfg->nves, rfd);
listnode_add(orphaned_nves, rfd);
}
- list_delete(rfg->nves);
- rfg->nves = NULL;
+ list_delete_and_null(&rfg->nves);
}
/* delete it */
if (vty)
vty_out(vty, "\n");
}
- list_delete(orphaned_nves);
+ list_delete_and_null(&orphaned_nves);
}
}
if (rfg->rt_export_list)
ecommunity_free(&rfg->rt_export_list);
if (rfg->labels)
- list_delete(rfg->labels);
+ list_delete_and_null(&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(h->l2_groups);
- list_delete(h->nve_groups_sequential);
- list_delete(h->rfg_export_direct_bgp_l);
- list_delete(h->rfg_export_zebra_l);
+ 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);
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(bi->extra->vnc.export.local_nexthops);
+ list_delete_and_null(
+ &bi->extra->vnc.export.local_nexthops);
}
bgp_aggregate_decrement(bgp, p, bi, afi, safi);
*/
if (pn->info) {
if (pn->info != (void *)1) {
- list_delete(
- (struct list
- *)(pn->info));
+ list_delete_and_null(
+ (struct list **)(&pn->info));
}
pn->info = NULL;
- route_unlock_node(
- pn); /* linklist or 1 deleted */
+ /* linklist or 1 deleted */
+ route_unlock_node(pn);
}
}
}
}
delete_list->del = (void (*)(void *))rfapi_info_free;
- list_delete(delete_list);
+ list_delete_and_null(&delete_list);
}
RFAPI_RIB_CHECK_COUNTS(0, 0);
route_unlock_node(pn);
}
if (lPendCost) {
- list_delete(lPendCost);
+ list_delete_and_null(&lPendCost);
pn->info = NULL;
route_unlock_node(pn);
}
*/
if (pn->info) {
if (pn->info != (void *)1) {
- list_delete((struct list *)(pn->info));
+ list_delete_and_null((struct list **)(&pn->info));
}
pn->info = NULL;
route_unlock_node(pn); /* linklist or 1 deleted */
}
list_delete_all_node(adb_delete_list);
}
- list_delete(adb_delete_list);
+ list_delete_and_null(&adb_delete_list);
}
skiplist_delete(it->monitor_exterior_orphans,
bi_exterior, NULL);
}
- list_delete(list_adopted);
+ list_delete_and_null(&list_adopted);
}
}
nve_list_to_nh_array(rn->p.family, nves, &nexthop_count,
&nh_ary, &nhp_ary);
- list_delete(nves);
+ list_delete_and_null(&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(nves);
+ list_delete_and_null(&nves);
if (nexthop_count) {
/*
tn->serno);
if (successors)
- list_delete(successors);
+ list_delete_and_null(&successors);
}
void show_ip_eigrp_nexthop_entry(struct vty *vty, struct eigrp *eigrp,
// neighbors left
}
- list_delete(successors);
+ list_delete_and_null(&successors);
return 1;
}
// neighbors left
}
- list_delete(successors);
+ list_delete_and_null(&successors);
return 1;
}
ne = listnode_head(successors);
eigrp_send_reply(ne->adv_router,
prefix);
- list_delete(successors);
+ list_delete_and_null(&successors);
}
prefix->state = EIGRP_FSM_STATE_PASSIVE;
msg);
- list_delete(successors);
+ list_delete_and_null(&successors);
return 1;
}
eigrp_send_reply(ne->adv_router,
prefix);
- list_delete(successors);
+ list_delete_and_null(&successors);
}
prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
listnode_add(eigrp->topology_changes_internalIPV4, prefix);
// neighbors left
}
- list_delete(successors);
+ list_delete_and_null(&successors);
return 1;
}
msg->prefix->state = EIGRP_FSM_STATE_ACTIVE_2;
msg->prefix->distance = ne->distance;
- list_delete(successors);
+ list_delete_and_null(&successors);
return 1;
}
if (!ei)
return 0;
- list_delete(ei->nbrs);
+ list_delete_and_null(&ei->nbrs);
eigrp = ei->eigrp;
listnode_delete(eigrp->eiflist, ei);
eigrp_if_down(ei);
- list_delete(ei->nbrs);
+ list_delete_and_null(&ei->nbrs);
listnode_delete(ei->eigrp->eiflist, ei);
}
eigrp_zebra_route_add(node->destination, l);
}
- list_delete(l);
+ list_delete_and_null(&l);
}
/*
* If we have no successors return NULL
*/
if (!successors->count) {
- list_delete(successors);
+ list_delete_and_null(&successors);
successors = NULL;
}
for (ALL_LIST_ELEMENTS_RO(successors, node, entry))
entry->flags |= EIGRP_NEXTHOP_ENTRY_INTABLE_FLAG;
- list_delete(successors);
+ list_delete_and_null(&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(nbr_prefixes);
+ list_delete_and_null(&nbr_prefixes);
}
/*send EIGRP Update packet*/
THREAD_OFF(eigrp->t_read);
close(eigrp->fd);
- list_delete(eigrp->eiflist);
- list_delete(eigrp->oi_write_q);
- list_delete(eigrp->topology_changes_externalIPV4);
- list_delete(eigrp->topology_changes_internalIPV4);
+ list_delete_and_null(&eigrp->eiflist);
+ list_delete_and_null(&eigrp->oi_write_q);
+ list_delete_and_null(&eigrp->topology_changes_externalIPV4);
+ list_delete_and_null(&eigrp->topology_changes_internalIPV4);
eigrp_topology_cleanup(eigrp->topology_table);
eigrp_topology_free(eigrp->topology_table);
if (circuit->ip_addrs) {
assert(listcount(circuit->ip_addrs) == 0);
- list_delete(circuit->ip_addrs);
+ list_delete_and_null(&circuit->ip_addrs);
circuit->ip_addrs = NULL;
}
if (circuit->ipv6_link) {
assert(listcount(circuit->ipv6_link) == 0);
- list_delete(circuit->ipv6_link);
+ list_delete_and_null(&circuit->ipv6_link);
circuit->ipv6_link = NULL;
}
if (circuit->ipv6_non_link) {
assert(listcount(circuit->ipv6_non_link) == 0);
- list_delete(circuit->ipv6_non_link);
+ list_delete_and_null(&circuit->ipv6_non_link);
circuit->ipv6_non_link = NULL;
}
if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
/* destroy neighbour lists */
if (circuit->u.bc.lan_neighs[0]) {
- list_delete(circuit->u.bc.lan_neighs[0]);
+ list_delete_and_null(&circuit->u.bc.lan_neighs[0]);
circuit->u.bc.lan_neighs[0] = NULL;
}
if (circuit->u.bc.lan_neighs[1]) {
- list_delete(circuit->u.bc.lan_neighs[1]);
+ list_delete_and_null(&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(circuit->u.bc.adjdb[0]);
+ list_delete_and_null(&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(circuit->u.bc.adjdb[1]);
+ list_delete_and_null(&circuit->u.bc.adjdb[1]);
circuit->u.bc.adjdb[1] = NULL;
}
if (circuit->u.bc.is_dr[0]) {
THREAD_OFF(circuit->t_read);
if (circuit->lsp_queue) {
- list_delete(circuit->lsp_queue);
- circuit->lsp_queue = NULL;
+ list_delete_and_null(&circuit->lsp_queue);
}
if (circuit->lsp_hash) {
if (!adjdb) {
zlog_warn("isis_dr_elect() adjdb == NULL");
- list_delete(list);
+ list_delete_and_null(&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(list);
+ list_delete_and_null(&list);
return retval;
}
if (circuit->u.bc.is_dr[level - 1])
retval = isis_dr_resign(circuit, level);
}
- list_delete(list);
+ list_delete_and_null(&list);
return retval;
}
THREAD_TIMER_OFF(circuit->u.bc.t_refresh_pseudo_lsp[idx]);
circuit->lsp_regenerate_pending[idx] = 0;
circuit->u.bc.run_dr_elect[idx] = 0;
- if (circuit->u.bc.lan_neighs[idx] != NULL) {
- list_delete(circuit->u.bc.lan_neighs[idx]);
- circuit->u.bc.lan_neighs[idx] = NULL;
- }
+ if (circuit->u.bc.lan_neighs[idx] != NULL)
+ list_delete_and_null(&circuit->u.bc.lan_neighs[idx]);
}
return;
lsp_clear_data(lsp);
if (LSP_FRAGMENT(lsp->hdr.lsp_id) == 0 && lsp->lspu.frags) {
- list_delete(lsp->lspu.frags);
+ list_delete_and_null(&lsp->lspu.frags);
lsp->lspu.frags = NULL;
}
frag->tlvs = tlvs;
}
- list_delete(fragments);
+ list_delete_and_null(&fragments);
lsp_debug("ISIS (%s): LSP construction is complete. Serializing...",
area->area_tag);
return;
LSP_PSEUDO_ID(ne_id));
}
}
- list_delete(adj_list);
+ list_delete_and_null(&adj_list);
return;
}
}
}
- list_delete(lsp_list);
+ list_delete_and_null(&lsp_list);
return ISIS_OK;
}
void area_mt_finish(struct isis_area *area)
{
- list_delete(area->mt_settings);
- area->mt_settings = NULL;
+ list_delete_and_null(&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(circuit->mt_settings);
- circuit->mt_settings = NULL;
+ list_delete_and_null(&circuit->mt_settings);
}
struct isis_circuit_mt_setting *
for (ALL_LIST_ELEMENTS_RO(lsp_list, node, lsp))
ISIS_SET_FLAG(lsp->SRMflags, circuit);
/* lets free it */
- list_delete(lsp_list);
+ list_delete_and_null(&lsp_list);
}
retval = ISIS_OK;
if (route_info->nexthops) {
route_info->nexthops->del =
(void (*)(void *))isis_nexthop_delete;
- list_delete(route_info->nexthops);
+ list_delete_and_null(&route_info->nexthops);
}
if (route_info->nexthops6) {
route_info->nexthops6->del =
(void (*)(void *))isis_nexthop6_delete;
- list_delete(route_info->nexthops6);
+ list_delete_and_null(&route_info->nexthops6);
}
XFREE(MTYPE_ISIS_ROUTE_INFO, route_info);
if (queue->insert_counter) {
skiplist_free(queue->l.slist);
queue->l.slist = NULL;
- } else {
- list_delete(queue->l.list);
- queue->l.list = NULL;
- }
+ } else
+ list_delete_and_null(&queue->l.list);
}
static unsigned int isis_vertex_queue_count(struct isis_vertex_queue *queue)
static void isis_vertex_del(struct isis_vertex *vertex)
{
- list_delete(vertex->Adj_N);
- vertex->Adj_N = NULL;
- list_delete(vertex->parents);
- vertex->parents = NULL;
+ list_delete_and_null(&vertex->Adj_N);
+ list_delete_and_null(&vertex->parents);
memset(vertex, 0, sizeof(struct isis_vertex));
XFREE(MTYPE_ISIS_VERTEX, vertex);
adjdb = circuit->u.bc.adjdb[spftree->level - 1];
isis_adj_build_up_list(adjdb, adj_list);
if (listcount(adj_list) == 0) {
- list_delete(adj_list);
+ list_delete_and_null(&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(adj_list);
+ list_delete_and_null(&adj_list);
/*
* Add the pseudonode
*/
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO(rv, node, fragment_tlvs))
isis_free_tlvs(fragment_tlvs);
- list_delete(rv);
- rv = NULL;
+ list_delete_and_null(&rv);
}
stream_free(dummy_stream);
circuit->ipv6_router = 0;
isis_csm_state_change(ISIS_DISABLE, circuit, area);
}
- list_delete(area->circuit_list);
- area->circuit_list = NULL;
+ list_delete_and_null(&area->circuit_list);
}
if (area->lspdb[0] != NULL) {
}
vector comps = completions_to_vec(completions);
- list_delete(completions);
+ list_delete_and_null(&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(argv_list);
+ list_delete_and_null(&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(argv_list);
+ list_delete_and_null(&argv_list);
XFREE(MTYPE_TMP, argv);
return ret;
if (host.config)
XFREE(MTYPE_HOST, host.config);
- list_delete(varhandlers);
+ list_delete_and_null(&varhandlers);
qobj_finish();
}
status = MATCHER_INCOMPLETE;
// cleanup
- list_delete(next);
+ list_delete_and_null(&next);
return status;
}
unsigned int idx;
for (idx = 0; idx < vector_active(vline) && next->count > 0; idx++) {
- list_delete(current);
+ list_delete_and_null(¤t);
current = next;
next = list_new();
next->del = stack_del;
}
}
- list_delete(current);
- list_delete(next);
+ list_delete_and_null(¤t);
+ list_delete_and_null(&next);
return mrv;
}
list_delete_node(list, tail);
// delete the rest of the list as usual
- list_delete(list);
+ list_delete_and_null(&list);
}
/*---------- token level matching functions ----------*/
vty_out(vty, "%% No match\n");
// free resources
- list_delete(completions);
+ list_delete_and_null(&completions);
cmd_free_strvec(command);
XFREE(MTYPE_TMP, cmdstr);
vty_out(vty, "func: %p\n", element->func);
- list_delete(argvv);
+ list_delete_and_null(&argvv);
} else {
assert(MATCHER_ERROR(result));
switch (result) {
}
prev = cur;
}
- list_delete(commands);
+ list_delete_and_null(&commands);
vty_out(vty, "\n");
} while (scan && scannode < LINK_PARAMS_NODE);
if (_hashes) {
listnode_delete(_hashes, hash);
if (_hashes->count == 0) {
- list_delete(_hashes);
- _hashes = NULL;
+ list_delete_and_null(&_hashes);
}
}
}
if_delete(ifp);
}
- list_delete(*intf_list);
- *intf_list = NULL;
+ list_delete_and_null(intf_list);
}
const char *if_link_type_str(enum zebra_link_type llt)
if (keychain->name)
XFREE(MTYPE_KEYCHAIN, keychain->name);
- list_delete(keychain->key);
+ list_delete_and_null(&keychain->key);
listnode_delete(keychain_list, keychain);
keychain_free(keychain);
}
assert(list);
for (node = list->head; node; node = next) {
next = node->next;
- if (list->del)
+ if (*list->del)
(*list->del)(node->data);
listnode_free(node);
}
}
/* Delete all listnode then free list itself. */
-void list_delete(struct list *list)
+void list_delete_and_null(struct list **list)
{
- assert(list);
- list_delete_all_node(list);
- list_free(list);
+ assert(*list);
+ list_delete_all_node(*list);
+ list_free(*list);
+ *list = NULL;
+}
+
+void list_delete_original(struct list *list)
+{
+ list_delete_and_null(&list);
}
/* Lookup the node which has given data. */
extern struct listnode *listnode_lookup(struct list *, void *);
extern void *listnode_head(struct list *);
-extern void list_delete(struct list *);
+/*
+ * The usage of list_delete is being transitioned to pass in
+ * the double pointer to remove use after free's.
+ * In Oct of 2018, rename list_delete_and_null to list_delete
+ * and remove list_delete_original and the list_delete #define
+ */
+#if CONFDATE > 20181001
+CPP_NOTICE("list_delete without double pointer is deprecated, please fixup")
+#endif
+extern void list_delete_and_null(struct list **);
+extern void list_delete_original(struct list *);
+#define list_delete(X) list_delete_original((X)) \
+ CPP_WARN("Please transition to using list_delete_and_null")
+
extern void list_delete_all_node(struct list *);
/* For ospfd and ospf6d. */
pthread_cond_destroy(&m->cancel_cond);
close(m->io_pipe[0]);
close(m->io_pipe[1]);
- list_delete(m->cancel_req);
+ list_delete_and_null(&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(wheel->wheel_slot_lists[i]);
+ list_delete_and_null(&wheel->wheel_slot_lists[i]);
}
THREAD_OFF(wheel->timer);
for (ALL_LIST_ELEMENTS_RO(oa->if_list, n, oi))
oi->area = NULL;
- list_delete(oa->if_list);
+ list_delete_and_null(&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(oi->neighbor_list);
+ list_delete_and_null(&oi->neighbor_list);
THREAD_OFF(oi->thread_send_hello);
THREAD_OFF(oi->thread_send_lsupdate);
{
if (route) {
if (route->nh_list)
- list_delete(route->nh_list);
+ list_delete_and_null(&route->nh_list);
XFREE(MTYPE_OSPF6_ROUTE, route);
}
}
static void ospf6_vertex_delete(struct ospf6_vertex *v)
{
- list_delete(v->nh_list);
- list_delete(v->child_list);
+ list_delete_and_null(&v->nh_list);
+ list_delete_and_null(&v->child_list);
XFREE(MTYPE_OSPF6_VERTEX, v);
}
ospf6_area_delete(oa);
- list_delete(o->area_list);
+ list_delete_and_null(&o->area_list);
ospf6_lsdb_delete(o->lsdb);
ospf6_lsdb_delete(o->lsdb_self);
/* Free client list itself */
if (apiserver_list)
- list_delete(apiserver_list);
+ list_delete_and_null(&apiserver_list);
/* Free wildcard list */
/* XXX */
}
if (chosen != rn->info)
- list_delete(chosen);
+ list_delete_and_null(&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(lst);
+ list_delete_and_null(&lst);
}
route_table_finish(rt);
void ospf_del_if_params(struct ospf_if_params *oip)
{
- list_delete(oip->auth_crypt);
+ list_delete_and_null(&oip->auth_crypt);
bfd_info_free(&(oip->bfd_info));
XFREE(MTYPE_OSPF_IF_PARAMS, oip);
}
else
DR(oi).s_addr = 0;
- list_delete(dr_list);
+ list_delete_and_null(&dr_list);
return dr;
}
else
BDR(oi).s_addr = 0;
- list_delete(bdr_list);
- list_delete(no_dr_list);
+ list_delete_and_null(&bdr_list);
+ list_delete_and_null(&no_dr_list);
return bdr;
}
zlog_debug("DR-Election[2nd]: DR %s", inet_ntoa(DR(oi)));
}
- list_delete(el_list);
+ list_delete_and_null(&el_list);
/* if DR or BDR changes, cause AdjOK? neighbor event. */
if (!IPV4_ADDR_SAME(&old_dr, &DR(oi))
&lsa); /* lsa_refresh_queue & temp for lsa_to_refresh*/
}
- list_delete(lsa_to_refresh);
+ list_delete_and_null(&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(oi->opaque_lsa_self);
+ list_delete_and_null(&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(oi->opaque_lsa_self);
+ list_delete_and_null(&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(area->opaque_lsa_self);
+ list_delete_and_null(&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(area->opaque_lsa_self);
- area->opaque_lsa_self = NULL;
+ list_delete_and_null(&area->opaque_lsa_self);
return;
}
int ospf_opaque_type11_lsa_init(struct ospf *top)
{
if (top->opaque_lsa_self != NULL)
- list_delete(top->opaque_lsa_self);
+ list_delete_and_null(&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(top->opaque_lsa_self);
- top->opaque_lsa_self = NULL;
+ list_delete_and_null(&top->opaque_lsa_self);
return;
}
struct list *funclist;
funclist = ospf_opaque_wildcard_funclist;
- list_delete(funclist);
+ list_delete_and_null(&funclist);
funclist = ospf_opaque_type9_funclist;
- list_delete(funclist);
+ list_delete_and_null(&funclist);
funclist = ospf_opaque_type10_funclist;
- list_delete(funclist);
+ list_delete_and_null(&funclist);
funclist = ospf_opaque_type11_funclist;
- list_delete(funclist);
+ list_delete_and_null(&funclist);
return;
}
}
OSPF_TIMER_OFF(oipt->t_opaque_lsa_self);
- list_delete(oipt->id_list);
+ list_delete_and_null(&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);
- list_delete(update);
+ list_delete_and_null(&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(ls_upd);
+ list_delete_and_null(&ls_upd);
return;
}
adv_router);
if (find == NULL) {
OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_BadLSReq);
- list_delete(ls_upd);
+ list_delete_and_null(&ls_upd);
return;
}
ospf_ls_upd_send(nbr, ls_upd,
OSPF_SEND_PACKET_INDIRECT);
- list_delete(ls_upd);
+ list_delete_and_null(&ls_upd);
} else
list_free(ls_upd);
}
for (ALL_LIST_ELEMENTS(lsas, node, nnode, lsa))
ospf_lsa_discard(lsa);
- list_delete(lsas);
+ list_delete_and_null(&lsas);
}
/* OSPF Link State Update message read -- RFC2328 Section 13. */
#undef DISCARD_LSA
assert(listcount(lsas) == 0);
- list_delete(lsas);
+ list_delete_and_null(&lsas);
}
/* OSPF Link State Acknowledgment message read -- RFC2328 Section 13.7. */
listnode_add(update, lsa);
ospf_ls_upd_send(nbr, update, flag);
- list_delete(update);
+ list_delete_and_null(&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(rn->info);
- rn->info = NULL;
+ list_delete_and_null((struct list **)&rn->info);
route_unlock_node(rn);
} else
again = 1;
void ospf_router_info_term(void)
{
- list_delete(OspfRI.pce_info.pce_domain);
- list_delete(OspfRI.pce_info.pce_neighbor);
+ list_delete_and_null(&OspfRI.pce_info.pce_domain);
+ list_delete_and_null(&OspfRI.pce_info.pce_neighbor);
- OspfRI.pce_info.pce_domain = NULL;
- OspfRI.pce_info.pce_neighbor = NULL;
OspfRI.enabled = false;
ospf_router_info_unregister();
void ospf_route_free(struct ospf_route * or)
{
if (or->paths)
- list_delete(or->paths);
+ list_delete_and_null(&or->paths);
XFREE(MTYPE_OSPF_ROUTE, or);
}
zlog_debug("Pruning router node %s",
inet_ntoa(rn->p.u.prefix4));
- list_delete(paths);
+ list_delete_and_null(&paths);
rn->info = NULL;
route_unlock_node(rn);
}
// assert (listcount (v->parents) == 0);
if (v->children)
- list_delete(v->children);
- v->children = NULL;
+ list_delete_and_null(&v->children);
if (v->parents)
- list_delete(v->parents);
- v->parents = NULL;
+ list_delete_and_null(&v->parents);
v->lsa = NULL;
for (ALL_LIST_ELEMENTS(or_list, node, nnode, or))
ospf_route_free(or);
- list_delete(or_list);
+ list_delete_and_null(&or_list);
/* Unlock the node. */
rn->info = NULL;
void ospf_mpls_te_term(void)
{
- list_delete(OspfMplsTE.iflist);
- OspfMplsTE.iflist = NULL;
+ list_delete_and_null(&OspfMplsTE.iflist);
ospf_delete_opaque_functab(OSPF_OPAQUE_AREA_LSA,
OPAQUE_TYPE_TRAFFIC_ENGINEERING_LSA);
for (ALL_LIST_ELEMENTS(ospf->vlinks, node, nnode, vl_data))
ospf_vl_delete(ospf, vl_data);
- list_delete(ospf->vlinks);
+ list_delete_and_null(&ospf->vlinks);
/* Remove any ospf interface config params */
for (ALL_LIST_ELEMENTS_RO(vrf_iflist(ospf->vrf_id), node, ifp)) {
ospf_ase_external_lsas_finish(ospf->external_lsas);
}
- list_delete(ospf->areas);
- list_delete(ospf->oi_write_q);
- list_delete(ospf->oiflist);
+ list_delete_and_null(&ospf->areas);
+ list_delete_and_null(&ospf->oi_write_q);
+ list_delete_and_null(&ospf->oiflist);
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(area->oiflist);
+ list_delete_and_null(&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(lst);
+ list_delete_and_null(&lst);
rn->info = NULL;
}
}
}
-#define FREE_ADDR_LIST \
- if (hello_option_addr_list) { \
- list_delete(hello_option_addr_list); \
+#define FREE_ADDR_LIST \
+ if (hello_option_addr_list) { \
+ list_delete_and_null(&hello_option_addr_list); \
}
#define FREE_ADDR_LIST_THEN_RETURN(code) \
struct pim_ifchannel *ch;
if (pim_ifp->igmp_join_list)
- list_delete(pim_ifp->igmp_join_list);
+ list_delete_and_null(&pim_ifp->igmp_join_list);
if (pim_ifp->igmp_socket_list)
- list_delete(pim_ifp->igmp_socket_list);
+ list_delete_and_null(&pim_ifp->igmp_socket_list);
if (pim_ifp->pim_neighbor_list)
- list_delete(pim_ifp->pim_neighbor_list);
+ list_delete_and_null(&pim_ifp->pim_neighbor_list);
if (pim_ifp->upstream_switch_list)
- list_delete(pim_ifp->upstream_switch_list);
+ list_delete_and_null(&pim_ifp->upstream_switch_list);
if (pim_ifp->sec_addr_list)
- list_delete(pim_ifp->sec_addr_list);
+ list_delete_and_null(&pim_ifp->sec_addr_list);
while ((ch = RB_ROOT(pim_ifchannel_rb,
&pim_ifp->ifchannel_rb)) != NULL)
pim_if_del_vif(ifp);
- 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);
+ 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);
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(pim_ifp->igmp_join_list);
+ list_delete_and_null(&pim_ifp->igmp_join_list);
pim_ifp->igmp_join_list = 0;
}
pim_ifchannel_remove_children(ch);
if (ch->sources)
- list_delete(ch->sources);
+ list_delete_and_null(&ch->sources);
listnode_delete(ch->upstream->ifchannels, ch);
pim_ifchannel_remove_children(ch);
if (ch->sources)
- list_delete(ch->sources);
+ list_delete_and_null(&ch->sources);
THREAD_OFF(ch->t_ifjoin_expiry_timer);
THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
static void igmp_group_free(struct igmp_group *group)
{
- list_delete(group->group_source_list);
+ list_delete_and_null(&group->group_source_list);
XFREE(MTYPE_PIM_IGMP_GROUP, group);
}
zassert(igmp->igmp_group_list);
zassert(!listcount(igmp->igmp_group_list));
- list_delete(igmp->igmp_group_list);
+ list_delete_and_null(&igmp->igmp_group_list);
hash_free(igmp->igmp_group_hash);
XFREE(MTYPE_PIM_IGMP_SOCKET, igmp);
}
if (pim->static_routes)
- list_delete(pim->static_routes);
+ list_delete_and_null(&pim->static_routes);
pim_rp_free(pim);
void pim_jp_agg_group_list_free(struct pim_jp_agg_group *jag)
{
- list_delete(jag->sources);
+ list_delete_and_null(&jag->sources);
XFREE(MTYPE_PIM_JP_AGG_GROUP, jag);
}
js->up = NULL;
XFREE(MTYPE_PIM_JP_AGG_SOURCE, js);
}
- list_delete(jag->sources);
- jag->sources = NULL;
+ list_delete_and_null(&jag->sources);
listnode_delete(group, jag);
XFREE(MTYPE_PIM_JP_AGG_GROUP, jag);
}
}
if (jag->sources->count == 0) {
- list_delete(jag->sources);
- jag->sources = NULL;
+ list_delete_and_null(&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(mg->mbr_list);
+ list_delete_and_null(&mg->mbr_list);
XFREE(MTYPE_PIM_MSDP_MG, mg);
pim->msdp.mg = NULL;
}
if (pim->msdp.peer_list) {
- list_delete(pim->msdp.peer_list);
- pim->msdp.peer_list = NULL;
+ list_delete_and_null(&pim->msdp.peer_list);
}
if (pim->msdp.sa_hash) {
}
if (pim->msdp.sa_list) {
- list_delete(pim->msdp.sa_list);
- pim->msdp.sa_list = NULL;
+ list_delete_and_null(&pim->msdp.sa_list);
}
}
}
#endif
- list_delete(neigh->prefix_list);
- neigh->prefix_list = 0;
+ list_delete_and_null(&neigh->prefix_list);
}
}
delete_prefix_list(neigh);
- list_delete(neigh->upstream_jp_agg);
+ list_delete_and_null(&neigh->upstream_jp_agg);
THREAD_OFF(neigh->jp_timer);
XFREE(MTYPE_PIM_NEIGHBOR, neigh);
pim_sendmsg_zebra_rnh(pim, zclient, pnc,
ZEBRA_NEXTHOP_UNREGISTER);
- list_delete(pnc->rp_list);
+ list_delete_and_null(&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(pim->channel_oil_list);
- pim->channel_oil_list = NULL;
+ list_delete_and_null(&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(pnc->rp_list);
- pnc->rp_list = NULL;
+ list_delete_and_null(&pnc->rp_list);
hash_clean(pnc->upstream_hash, NULL);
hash_free(pnc->upstream_hash);
pim->rp_table = route_table_init();
if (!pim->rp_table) {
zlog_err("Unable to alloc rp_table");
- list_delete(pim->rp_list);
+ list_delete_and_null(&pim->rp_list);
return;
}
if (!rp_info) {
zlog_err("Unable to alloc rp_info");
route_table_finish(pim->rp_table);
- list_delete(pim->rp_list);
+ list_delete_and_null(&pim->rp_list);
return;
}
if (!str2prefix("224.0.0.0/4", &rp_info->group)) {
zlog_err("Unable to convert 224.0.0.0/4 to prefix");
- list_delete(pim->rp_list);
+ list_delete_and_null(&pim->rp_list);
route_table_finish(pim->rp_table);
XFREE(MTYPE_PIM_RP, rp_info);
return;
rn = route_node_get(pim->rp_table, &rp_info->group);
if (!rn) {
zlog_err("Failure to get route node for pim->rp_table");
- list_delete(pim->rp_list);
+ list_delete_and_null(&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(pim->rp_list);
- pim->rp_list = NULL;
+ list_delete_and_null(&pim->rp_list);
}
/*
void pim_ssmpingd_destroy(struct pim_instance *pim)
{
- if (pim->ssmpingd_list) {
- list_delete(pim->ssmpingd_list);
- pim->ssmpingd_list = 0;
- }
+ if (pim->ssmpingd_list)
+ list_delete_and_null(&pim->ssmpingd_list);
}
static struct ssmpingd_sock *ssmpingd_find(struct pim_instance *pim,
return addr - buf;
}
-#define FREE_ADDR_LIST(hello_option_addr_list) \
- { \
- if (hello_option_addr_list) { \
- list_delete(hello_option_addr_list); \
- hello_option_addr_list = 0; \
- } \
+#define FREE_ADDR_LIST(hello_option_addr_list) \
+ { \
+ if (hello_option_addr_list) { \
+ list_delete_and_null(&hello_option_addr_list); \
+ hello_option_addr_list = 0; \
+ } \
}
int pim_tlv_parse_addr_list(const char *ifname, struct in_addr src_addr,
if (child)
child->parent = NULL;
}
- list_delete(up->sources);
- up->sources = NULL;
+ list_delete_and_null(&up->sources);
}
/*
pim_upstream_remove_children(pim, up);
if (up->sources)
- list_delete(up->sources);
- up->sources = NULL;
+ list_delete_and_null(&up->sources);
+
pim_mroute_del(up->channel_oil, __PRETTY_FUNCTION__);
upstream_channel_oil_detach(up);
- list_delete(up->ifchannels);
- up->ifchannels = NULL;
+ list_delete_and_null(&up->ifchannels);
/*
notice that listnode_delete() can't be moved
pim_upstream_remove_children(pim, up);
if (up->sources)
- list_delete(up->sources);
+ list_delete_and_null(&up->sources);
- list_delete(up->ifchannels);
+ list_delete_and_null(&up->ifchannels);
hash_release(pim->upstream_hash, up);
XFREE(MTYPE_PIM_UPSTREAM, up);
void pim_upstream_terminate(struct pim_instance *pim)
{
if (pim->upstream_list)
- list_delete(pim->upstream_list);
- pim->upstream_list = NULL;
+ list_delete_and_null(&pim->upstream_list);
if (pim->upstream_hash)
hash_free(pim->upstream_hash);
void rip_offset_clean()
{
- list_delete(rip_offset_list_master);
+ list_delete_and_null(&rip_offset_list_master);
rip_offset_list_master = list_new();
rip_offset_list_master->cmp = (int (*)(void *, void *))offset_list_cmp;
RIP_TIMER_OFF(rinfo->t_garbage_collect);
rip_info_free(rinfo);
}
- list_delete(list);
+ list_delete_and_null(&list);
rp->info = NULL;
route_unlock_node(rp);
}
void ripng_rte_free(struct list *ripng_rte_list)
{
- list_delete(ripng_rte_list);
+ list_delete_and_null(&ripng_rte_list);
}
/* Delete RTE */
void ripng_offset_clean(void)
{
- list_delete(ripng_offset_list_master);
+ list_delete_and_null(&ripng_offset_list_master);
ripng_offset_list_master = list_new();
ripng_offset_list_master->cmp =
rinfo->t_garbage_collect);
ripng_info_free(rinfo);
}
- list_delete(list);
+ list_delete_and_null(&list);
rp->info = NULL;
route_unlock_node(rp);
}
sbuf_push(&fragment_format, 0, "%s", isis_format_tlvs(tlvs));
isis_free_tlvs(tlvs);
}
- list_delete(fragments);
+ list_delete_and_null(&fragments);
stream_free(s);
char *fragment_content = sortlines((char *)sbuf_buf(&fragment_format));
static void config_del(struct config *config)
{
- list_delete(config->line);
+ list_delete_and_null(&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(master);
+ list_delete_and_null(&master);
vector_slot(configvec, i) = NULL;
}
list_delete_all_node(config_top);
struct route_node *node)
{
if (node->info)
- list_delete(node->info);
+ list_delete_and_null((struct list **)&node->info);
route_node_destroy(delegate, table, node);
}
}
/* Free chain list and respective route node. */
- list_delete(addr_list);
+ list_delete_and_null(&addr_list);
rn->info = NULL;
route_unlock_node(rn);
} else if (cp.family == AF_INET6) {
irdp_advert_off(ifp);
- list_delete(irdp->AdvPrefList);
- irdp->AdvPrefList = NULL;
+ list_delete_and_null(&irdp->AdvPrefList);
irdp->flags = 0;
}
void label_manager_close()
{
- list_delete(lbl_mgr.lc_list);
+ list_delete_and_null(&lbl_mgr.lc_list);
}
prefix_list_reset();
route_map_finish();
- list_delete(zebrad.client_list);
+ list_delete_and_null(&zebrad.client_list);
work_queue_free(zebrad.ribq);
if (zebrad.lsp_process_q)
work_queue_free(zebrad.lsp_process_q);
vty_out(vty, "\n");
}
- list_delete(lsp_list);
+ list_delete_and_null(&lsp_list);
}
/*
}
}
- list_delete(slsp_list);
+ list_delete_and_null(&slsp_list);
return (zvrf->slsp_table->count ? 1 : 0);
}
unsigned i;
for (i = 0; i < MQ_SIZE; i++)
- list_delete(mq->subq[i]);
+ list_delete_and_null(&mq->subq[i]);
XFREE(MTYPE_WORK_QUEUE, mq);
}
{
zebra_mac_t *tmp_mac;
- list_delete(mac->neigh_list);
+ list_delete_and_null(&mac->neigh_list);
/* Free the VNI hash entry and allocated memory. */
tmp_mac = hash_release(zvni->mac_table, mac);
projects / mirror_frr.git / commitdiff