proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-04-29 10:32:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

*: ALLOC calls cannot fail

Browse Source 
There is no need to check for failure of a ALLOC call
as that any failure to do so will result in a assert
happening.  So we can safely remove all of this code.

Signed-off-by: Donald Sharp <sharpd@cumulusnetworks.com>
This commit is contained in:
Donald Sharp 2018-06-14 08:58:05 -04:00 committed by David Lamparter
parent 1408cdfc07
commit 0ce1ca805d
41 changed files with 84 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
bgpd/bgp_aspath.c
View File

@ -214,16 +214,11 @@ static struct assegment *assegment_append_asns(struct assegment *seg,
newas = XREALLOC(MTYPE_AS_SEG_DATA, seg->as, newas = XREALLOC(MTYPE_AS_SEG_DATA, seg->as,
ASSEGMENT_DATA_SIZE(seg->length + num, 1)); ASSEGMENT_DATA_SIZE(seg->length + num, 1));
if (newas) { seg->as = newas;
seg->as = newas; memcpy(seg->as + seg->length, asnos,
memcpy(seg->as + seg->length, asnos, ASSEGMENT_DATA_SIZE(num, 1));
ASSEGMENT_DATA_SIZE(num, 1)); seg->length += num;
seg->length += num; return seg;
return seg;
}
assegment_free_all(seg);
return NULL;
} }
static int int_cmp(const void *p1, const void *p2) static int int_cmp(const void *p1, const void *p2)

4
bgpd/bgp_labelpool.c
View File

@ -202,10 +202,6 @@ void bgp_lp_init(struct thread_master *master, struct labelpool *pool)
lp->requests = XCALLOC(MTYPE_BGP_LABEL_FIFO, sizeof(struct lp_fifo)); lp->requests = XCALLOC(MTYPE_BGP_LABEL_FIFO, sizeof(struct lp_fifo));
LABEL_FIFO_INIT(lp->requests); LABEL_FIFO_INIT(lp->requests);
lp->callback_q = work_queue_new(master, "label callbacks"); lp->callback_q = work_queue_new(master, "label callbacks");
if (!lp->callback_q) {
zlog_err("%s: Failed to allocate work queue", __func__);
exit(1);
}
lp->callback_q->spec.workfunc = lp_cbq_docallback; lp->callback_q->spec.workfunc = lp_cbq_docallback;
lp->callback_q->spec.del_item_data = lp_cbq_item_free; lp->callback_q->spec.del_item_data = lp_cbq_item_free;

14
bgpd/bgp_route.c
View File

@ -2459,16 +2459,10 @@ static void bgp_processq_del(struct work_queue *wq, void *data)
void bgp_process_queue_init(void) void bgp_process_queue_init(void)
{ {
if (!bm->process_main_queue) { if (!bm->process_main_queue)
bm->process_main_queue = bm->process_main_queue =
work_queue_new(bm->master, "process_main_queue"); work_queue_new(bm->master, "process_main_queue");
if (!bm->process_main_queue) {
zlog_err("%s: Failed to allocate work queue", __func__);
exit(1);
}
}
bm->process_main_queue->spec.workfunc = &bgp_process_wq; bm->process_main_queue->spec.workfunc = &bgp_process_wq;
bm->process_main_queue->spec.del_item_data = &bgp_processq_del; bm->process_main_queue->spec.del_item_data = &bgp_processq_del;
bm->process_main_queue->spec.max_retries = 0; bm->process_main_queue->spec.max_retries = 0;
@ -3838,11 +3832,7 @@ static void bgp_clear_node_queue_init(struct peer *peer)
snprintf(wname, sizeof(wname), "clear %s", peer->host); snprintf(wname, sizeof(wname), "clear %s", peer->host);
#undef CLEAR_QUEUE_NAME_LEN #undef CLEAR_QUEUE_NAME_LEN
if ((peer->clear_node_queue = work_queue_new(bm->master, wname)) peer->clear_node_queue = work_queue_new(bm->master, wname);
== NULL) {
zlog_err("%s: Failed to allocate work queue", __func__);
exit(1);
}
peer->clear_node_queue->spec.hold = 10; peer->clear_node_queue->spec.hold = 10;
peer->clear_node_queue->spec.workfunc = &bgp_clear_route_node; peer->clear_node_queue->spec.workfunc = &bgp_clear_route_node;
peer->clear_node_queue->spec.del_item_data = &bgp_clear_node_queue_del; peer->clear_node_queue->spec.del_item_data = &bgp_clear_node_queue_del;

41
isisd/dict.c
View File

@ -244,19 +244,18 @@ dict_t *dict_create(dictcount_t maxcount, dict_comp_t comp)
{ {
dict_t *new = XCALLOC(MTYPE_ISIS_DICT, sizeof(dict_t)); dict_t *new = XCALLOC(MTYPE_ISIS_DICT, sizeof(dict_t));
if (new) { new->compare = comp;
new->compare = comp; new->allocnode = dnode_alloc;
new->allocnode = dnode_alloc; new->freenode = dnode_free;
new->freenode = dnode_free; new->context = NULL;
new->context = NULL; new->nodecount = 0;
new->nodecount = 0; new->maxcount = maxcount;
new->maxcount = maxcount; new->nilnode.left = &new->nilnode;
new->nilnode.left = &new->nilnode; new->nilnode.right = &new->nilnode;
new->nilnode.right = &new->nilnode; new->nilnode.parent = &new->nilnode;
new->nilnode.parent = &new->nilnode; new->nilnode.color = dnode_black;
new->nilnode.color = dnode_black; new->dupes = 0;
new->dupes = 0;
}
return new; return new;
} }
@ -974,12 +973,12 @@ static void dnode_free(dnode_t *node, void *context)
dnode_t *dnode_create(void *data) dnode_t *dnode_create(void *data)
{ {
dnode_t *new = XCALLOC(MTYPE_ISIS_DICT_NODE, sizeof(dnode_t)); dnode_t *new = XCALLOC(MTYPE_ISIS_DICT_NODE, sizeof(dnode_t));
if (new) {
new->data = data; new->data = data;
new->parent = NULL; new->parent = NULL;
new->left = NULL; new->left = NULL;
new->right = NULL; new->right = NULL;
}
return new; return new;
} }
@ -1250,8 +1249,8 @@ static char *dupstring(char *str)
{ {
int sz = strlen(str) + 1; int sz = strlen(str) + 1;
char *new = XCALLOC(MTYPE_ISIS_TMP, sz); char *new = XCALLOC(MTYPE_ISIS_TMP, sz);
if (new)
memcpy(new, str, sz); memcpy(new, str, sz);
return new; return new;
} }

4
isisd/isis_circuit.c
View File

@ -73,10 +73,6 @@ struct isis_circuit *isis_circuit_new()
int i; int i;
circuit = XCALLOC(MTYPE_ISIS_CIRCUIT, sizeof(struct isis_circuit)); circuit = XCALLOC(MTYPE_ISIS_CIRCUIT, sizeof(struct isis_circuit));
if (circuit == NULL) {
zlog_err("Can't malloc isis circuit");
return NULL;
}
/* /*
* Default values * Default values

4
isisd/isis_spf.c
View File

@ -486,10 +486,6 @@ struct isis_spftree *isis_spftree_new(struct isis_area *area)
struct isis_spftree *tree; struct isis_spftree *tree;
tree = XCALLOC(MTYPE_ISIS_SPFTREE, sizeof(struct isis_spftree)); tree = XCALLOC(MTYPE_ISIS_SPFTREE, sizeof(struct isis_spftree));
if (tree == NULL) {
zlog_err("ISIS-Spf: isis_spftree_new Out of memory!");
return NULL;
}
isis_vertex_queue_init(&tree->tents, "IS-IS SPF tents", true); isis_vertex_queue_init(&tree->tents, "IS-IS SPF tents", true);
isis_vertex_queue_init(&tree->paths, "IS-IS SPF paths", false); isis_vertex_queue_init(&tree->paths, "IS-IS SPF paths", false);

3
isisd/isis_te.c
View File

@ -87,9 +87,6 @@ struct mpls_te_circuit *mpls_te_circuit_new()
mtc = XCALLOC(MTYPE_ISIS_MPLS_TE, sizeof(struct mpls_te_circuit)); mtc = XCALLOC(MTYPE_ISIS_MPLS_TE, sizeof(struct mpls_te_circuit));
if (mtc == NULL)
return NULL;
mtc->status = disable; mtc->status = disable;
mtc->type = STD_TE; mtc->type = STD_TE;
mtc->length = 0; mtc->length = 0;

6
lib/command.c
View File

@ -2409,11 +2409,7 @@ static int set_log_file(struct vty *vty, const char *fname, int loglevel)
return CMD_WARNING_CONFIG_FAILED; return CMD_WARNING_CONFIG_FAILED;
} }
if ((p = XMALLOC(MTYPE_TMP, strlen(cwd) + strlen(fname) + 2)) p = XMALLOC(MTYPE_TMP, strlen(cwd) + strlen(fname) + 2);
== NULL) {
zlog_err("config_log_file: Unable to alloc mem!");
return CMD_WARNING_CONFIG_FAILED;
}
sprintf(p, "%s/%s", cwd, fname); sprintf(p, "%s/%s", cwd, fname);
fullpath = p; fullpath = p;
} else } else

8
lib/workqueue.c
View File

@ -81,9 +81,6 @@ struct work_queue *work_queue_new(struct thread_master *m,
new = XCALLOC(MTYPE_WORK_QUEUE, sizeof(struct work_queue)); new = XCALLOC(MTYPE_WORK_QUEUE, sizeof(struct work_queue));
if (new == NULL)
return new;
new->name = XSTRDUP(MTYPE_WORK_QUEUE_NAME, queue_name); new->name = XSTRDUP(MTYPE_WORK_QUEUE_NAME, queue_name);
new->master = m; new->master = m;
SET_FLAG(new->flags, WQ_UNPLUGGED); SET_FLAG(new->flags, WQ_UNPLUGGED);
@ -152,10 +149,7 @@ void work_queue_add(struct work_queue *wq, void *data)
assert(wq); assert(wq);
if (!(item = work_queue_item_new(wq))) { item = work_queue_item_new(wq);
zlog_err("%s: unable to get new queue item", __func__);
return;
}
item->data = data; item->data = data;
work_queue_item_enqueue(wq, item); work_queue_item_enqueue(wq, item);

21
nhrpd/nhrp_cache.c
View File

@ -48,17 +48,16 @@ static void *nhrp_cache_alloc(void *data)
struct nhrp_cache *p, *key = data; struct nhrp_cache *p, *key = data;
p = XMALLOC(MTYPE_NHRP_CACHE, sizeof(struct nhrp_cache)); p = XMALLOC(MTYPE_NHRP_CACHE, sizeof(struct nhrp_cache));
if (p) {
*p = (struct nhrp_cache){ *p = (struct nhrp_cache){
.cur.type = NHRP_CACHE_INVALID, .cur.type = NHRP_CACHE_INVALID,
.new.type = NHRP_CACHE_INVALID, .new.type = NHRP_CACHE_INVALID,
.remote_addr = key->remote_addr, .remote_addr = key->remote_addr,
.ifp = key->ifp, .ifp = key->ifp,
.notifier_list = .notifier_list =
NOTIFIER_LIST_INITIALIZER(&p->notifier_list), NOTIFIER_LIST_INITIALIZER(&p->notifier_list),
}; };
nhrp_cache_counts[p->cur.type]++; nhrp_cache_counts[p->cur.type]++;
}
return p; return p;
} }

2
nhrpd/nhrp_interface.c
View File

@ -25,8 +25,6 @@ static int nhrp_if_new_hook(struct interface *ifp)
afi_t afi; afi_t afi;
nifp = XCALLOC(MTYPE_NHRP_IF, sizeof(struct nhrp_interface)); nifp = XCALLOC(MTYPE_NHRP_IF, sizeof(struct nhrp_interface));
if (!nifp)
return 0;
ifp->info = nifp; ifp->info = nifp;
nifp->ifp = ifp; nifp->ifp = ifp;

2
nhrpd/nhrp_nhs.c
View File

@ -324,8 +324,6 @@ int nhrp_nhs_add(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
} }
nhs = XMALLOC(MTYPE_NHRP_NHS, sizeof(struct nhrp_nhs)); nhs = XMALLOC(MTYPE_NHRP_NHS, sizeof(struct nhrp_nhs));
if (!nhs)
return NHRP_ERR_NO_MEMORY;
*nhs = (struct nhrp_nhs){ *nhs = (struct nhrp_nhs){
.afi = afi, .afi = afi,

24
nhrpd/nhrp_peer.c
View File

@ -165,18 +165,18 @@ static void *nhrp_peer_create(void *data)
struct nhrp_peer *p, *key = data; struct nhrp_peer *p, *key = data;
p = XMALLOC(MTYPE_NHRP_PEER, sizeof(*p)); p = XMALLOC(MTYPE_NHRP_PEER, sizeof(*p));
if (p) {
*p = (struct nhrp_peer){ *p = (struct nhrp_peer){
.ref = 0, .ref = 0,
.ifp = key->ifp, .ifp = key->ifp,
.vc = key->vc, .vc = key->vc,
.notifier_list = .notifier_list =
NOTIFIER_LIST_INITIALIZER(&p->notifier_list), NOTIFIER_LIST_INITIALIZER(&p->notifier_list),
}; };
nhrp_vc_notify_add(p->vc, &p->vc_notifier, nhrp_peer_vc_notify); nhrp_vc_notify_add(p->vc, &p->vc_notifier, nhrp_peer_vc_notify);
nhrp_interface_notify_add(p->ifp, &p->ifp_notifier, nhrp_interface_notify_add(p->ifp, &p->ifp_notifier,
nhrp_peer_ifp_notify); nhrp_peer_ifp_notify);
}
return p; return p;
} }

17
nhrpd/nhrp_vc.c
View File

@ -48,14 +48,13 @@ static void *nhrp_vc_alloc(void *data)
struct nhrp_vc *vc, *key = data; struct nhrp_vc *vc, *key = data;
vc = XMALLOC(MTYPE_NHRP_VC, sizeof(struct nhrp_vc)); vc = XMALLOC(MTYPE_NHRP_VC, sizeof(struct nhrp_vc));
if (vc) {
*vc = (struct nhrp_vc){ *vc = (struct nhrp_vc){
.local.nbma = key->local.nbma, .local.nbma = key->local.nbma,
.remote.nbma = key->remote.nbma, .remote.nbma = key->remote.nbma,
.notifier_list = .notifier_list =
NOTIFIER_LIST_INITIALIZER(&vc->notifier_list), NOTIFIER_LIST_INITIALIZER(&vc->notifier_list),
}; };
}
return vc; return vc;
} }
@ -118,8 +117,6 @@ int nhrp_vc_ipsec_updown(uint32_t child_id, struct nhrp_vc *vc)
return 0; return 0;
sa = XMALLOC(MTYPE_NHRP_VC, sizeof(struct child_sa)); sa = XMALLOC(MTYPE_NHRP_VC, sizeof(struct child_sa));
if (!sa)
return 0;
*sa = (struct child_sa){ *sa = (struct child_sa){
.id = child_id, .id = child_id,

2
nhrpd/zbuf.c
View File

@ -25,8 +25,6 @@ struct zbuf *zbuf_alloc(size_t size)
struct zbuf *zb; struct zbuf *zb;
zb = XMALLOC(MTYPE_ZBUF_DATA, sizeof(*zb) + size); zb = XMALLOC(MTYPE_ZBUF_DATA, sizeof(*zb) + size);
if (!zb)
return NULL;
zbuf_init(zb, zb + 1, size, 0); zbuf_init(zb, zb + 1, size, 0);
zb->allocated = 1; zb->allocated = 1;

6
ospf6d/ospf6_interface.c
View File

@ -180,12 +180,6 @@ struct ospf6_interface *ospf6_interface_create(struct interface *ifp)
oi = (struct ospf6_interface *)XCALLOC(MTYPE_OSPF6_IF, oi = (struct ospf6_interface *)XCALLOC(MTYPE_OSPF6_IF,
sizeof(struct ospf6_interface)); sizeof(struct ospf6_interface));
if (!oi) {
zlog_err("Can't malloc ospf6_interface for ifindex %d",
ifp->ifindex);
return (struct ospf6_interface *)NULL;
}
oi->area = (struct ospf6_area *)NULL; oi->area = (struct ospf6_area *)NULL;
oi->neighbor_list = list_new(); oi->neighbor_list = list_new();
oi->neighbor_list->cmp = ospf6_neighbor_cmp; oi->neighbor_list->cmp = ospf6_neighbor_cmp;

8
ospf6d/ospf6_message.c
View File

@ -1503,14 +1503,6 @@ int ospf6_iobuf_size(unsigned int size)
recvnew = XMALLOC(MTYPE_OSPF6_MESSAGE, size); recvnew = XMALLOC(MTYPE_OSPF6_MESSAGE, size);
sendnew = XMALLOC(MTYPE_OSPF6_MESSAGE, size); sendnew = XMALLOC(MTYPE_OSPF6_MESSAGE, size);
if (recvnew == NULL || sendnew == NULL) {
if (recvnew)
XFREE(MTYPE_OSPF6_MESSAGE, recvnew);
if (sendnew)
XFREE(MTYPE_OSPF6_MESSAGE, sendnew);
zlog_debug("Could not allocate I/O buffer of size %d.", size);
return iobuflen;
}
if (recvbuf) if (recvbuf)
XFREE(MTYPE_OSPF6_MESSAGE, recvbuf); XFREE(MTYPE_OSPF6_MESSAGE, recvbuf);

4
ospf6d/ospf6_neighbor.c
View File

@ -84,10 +84,6 @@ struct ospf6_neighbor *ospf6_neighbor_create(uint32_t router_id,
on = (struct ospf6_neighbor *)XMALLOC(MTYPE_OSPF6_NEIGHBOR, on = (struct ospf6_neighbor *)XMALLOC(MTYPE_OSPF6_NEIGHBOR,
sizeof(struct ospf6_neighbor)); sizeof(struct ospf6_neighbor));
if (on == NULL) {
zlog_warn("neighbor: malloc failed");
return NULL;
}
memset(on, 0, sizeof(struct ospf6_neighbor)); memset(on, 0, sizeof(struct ospf6_neighbor));
inet_ntop(AF_INET, &router_id, buf, sizeof(buf)); inet_ntop(AF_INET, &router_id, buf, sizeof(buf));

6
ospf6d/ospf6_spf.c
View File

@ -1012,16 +1012,10 @@ struct ospf6_lsa *ospf6_create_single_router_lsa(struct ospf6_area *area,
/* Allocate memory for this LSA */ /* Allocate memory for this LSA */
new_header = XMALLOC(MTYPE_OSPF6_LSA_HEADER, total_lsa_length); new_header = XMALLOC(MTYPE_OSPF6_LSA_HEADER, total_lsa_length);
if (!new_header)
return NULL;
/* LSA information structure */ /* LSA information structure */
lsa = (struct ospf6_lsa *)XCALLOC(MTYPE_OSPF6_LSA, lsa = (struct ospf6_lsa *)XCALLOC(MTYPE_OSPF6_LSA,
sizeof(struct ospf6_lsa)); sizeof(struct ospf6_lsa));
if (!lsa) {
free(new_header);
return NULL;
}
lsa->header = (struct ospf6_lsa_header *)new_header; lsa->header = (struct ospf6_lsa_header *)new_header;

10
ospfclient/ospf_apiclient.c
View File

@ -570,10 +570,7 @@ static void ospf_apiclient_handle_lsa_update(struct ospf_apiclient *oclient,
/* Extract LSA from message */ /* Extract LSA from message */
lsalen = ntohs(cn->data.length); lsalen = ntohs(cn->data.length);
lsa = XMALLOC(MTYPE_OSPF_APICLIENT, lsalen); lsa = XMALLOC(MTYPE_OSPF_APICLIENT, lsalen);
if (!lsa) {
fprintf(stderr, "LSA update: Cannot allocate memory for LSA\n");
return;
}
memcpy(lsa, &(cn->data), lsalen); memcpy(lsa, &(cn->data), lsalen);
/* Invoke registered update callback function */ /* Invoke registered update callback function */
@ -598,10 +595,7 @@ static void ospf_apiclient_handle_lsa_delete(struct ospf_apiclient *oclient,
/* Extract LSA from message */ /* Extract LSA from message */
lsalen = ntohs(cn->data.length); lsalen = ntohs(cn->data.length);
lsa = XMALLOC(MTYPE_OSPF_APICLIENT, lsalen); lsa = XMALLOC(MTYPE_OSPF_APICLIENT, lsalen);
if (!lsa) {
fprintf(stderr, "LSA delete: Cannot allocate memory for LSA\n");
return;
}
memcpy(lsa, &(cn->data), lsalen); memcpy(lsa, &(cn->data), lsalen);
/* Invoke registered update callback function */ /* Invoke registered update callback function */

12
ospfd/ospf_apiserver.c
View File

@ -1176,13 +1176,11 @@ int ospf_apiserver_handle_register_event(struct ospf_apiserver *apiserv,
apiserv->filter = apiserv->filter =
XMALLOC(MTYPE_OSPF_APISERVER_MSGFILTER, ntohs(msg->hdr.msglen)); XMALLOC(MTYPE_OSPF_APISERVER_MSGFILTER, ntohs(msg->hdr.msglen));
if (apiserv->filter) {
/* copy it over. */ /* copy it over. */
memcpy(apiserv->filter, &rmsg->filter, ntohs(msg->hdr.msglen)); memcpy(apiserv->filter, &rmsg->filter, ntohs(msg->hdr.msglen));
rc = OSPF_API_OK; rc = OSPF_API_OK;
} else {
rc = OSPF_API_NOMEMORY;
}
/* Send a reply back to client with return code */ /* Send a reply back to client with return code */
rc = ospf_apiserver_send_reply(apiserv, seqnum, rc); rc = ospf_apiserver_send_reply(apiserv, seqnum, rc);
return rc; return rc;

5
ospfd/ospf_ext.c
View File

@ -545,11 +545,6 @@ static int ospf_ext_link_new_if(struct interface *ifp)
} }
new = XCALLOC(MTYPE_OSPF_EXT_PARAMS, sizeof(struct ext_itf)); new = XCALLOC(MTYPE_OSPF_EXT_PARAMS, sizeof(struct ext_itf));
if (new == NULL) {
zlog_warn("EXT (%s): XCALLOC: %s", __func__,
safe_strerror(errno));
return rc;
}
/* initialize new information and link back the interface */ /* initialize new information and link back the interface */
new->ifp = ifp; new->ifp = ifp;

3
ospfd/ospf_interface.c
View File

@ -523,9 +523,6 @@ static struct ospf_if_params *ospf_new_if_params(void)
oip = XCALLOC(MTYPE_OSPF_IF_PARAMS, sizeof(struct ospf_if_params)); oip = XCALLOC(MTYPE_OSPF_IF_PARAMS, sizeof(struct ospf_if_params));
if (!oip)
return NULL;
UNSET_IF_PARAM(oip, output_cost_cmd); UNSET_IF_PARAM(oip, output_cost_cmd);
UNSET_IF_PARAM(oip, transmit_delay); UNSET_IF_PARAM(oip, transmit_delay);
UNSET_IF_PARAM(oip, retransmit_interval); UNSET_IF_PARAM(oip, retransmit_interval);

27
ospfd/ospf_lsa.c
View File

@ -2912,24 +2912,17 @@ void ospf_lsa_maxage(struct ospf *ospf, struct ospf_lsa *lsa)
lsa_prefix.prefixlen = sizeof(lsa_prefix.u.ptr) * CHAR_BIT; lsa_prefix.prefixlen = sizeof(lsa_prefix.u.ptr) * CHAR_BIT;
lsa_prefix.u.ptr = (uintptr_t)lsa; lsa_prefix.u.ptr = (uintptr_t)lsa;
if ((rn = route_node_get(ospf->maxage_lsa, rn = route_node_get(ospf->maxage_lsa, (struct prefix *)&lsa_prefix);
(struct prefix *)&lsa_prefix)) if (rn->info != NULL) {
!= NULL) { if (IS_DEBUG_OSPF(lsa, LSA_FLOODING))
if (rn->info != NULL) { zlog_debug(
if (IS_DEBUG_OSPF(lsa, LSA_FLOODING)) "LSA[%s]: found LSA (%p) in table for LSA %p %d",
zlog_debug( dump_lsa_key(lsa), rn->info,
"LSA[%s]: found LSA (%p) in table for LSA %p %d", (void *)lsa, lsa_prefix.prefixlen);
dump_lsa_key(lsa), rn->info, route_unlock_node(rn);
(void *)lsa, lsa_prefix.prefixlen);
route_unlock_node(rn);
} else {
rn->info = ospf_lsa_lock(lsa);
SET_FLAG(lsa->flags, OSPF_LSA_IN_MAXAGE);
}
} else { } else {
zlog_err("Unable to allocate memory for maxage lsa %s\n", rn->info = ospf_lsa_lock(lsa);
dump_lsa_key(lsa)); SET_FLAG(lsa->flags, OSPF_LSA_IN_MAXAGE);
assert(0);
} }
if (IS_DEBUG_OSPF(lsa, LSA_FLOODING)) if (IS_DEBUG_OSPF(lsa, LSA_FLOODING))

29
ospfd/ospf_opaque.c
View File

@ -399,13 +399,8 @@ int ospf_register_opaque_functab(
} }
} }
if ((new = XCALLOC(MTYPE_OSPF_OPAQUE_FUNCTAB, new = XCALLOC(MTYPE_OSPF_OPAQUE_FUNCTAB,
sizeof(struct ospf_opaque_functab))) sizeof(struct ospf_opaque_functab));
== NULL) {
zlog_warn("ospf_register_opaque_functab: XMALLOC: %s",
safe_strerror(errno));
goto out;
}
new->opaque_type = opaque_type; new->opaque_type = opaque_type;
new->oipt = NULL; new->oipt = NULL;
@ -554,13 +549,8 @@ register_opaque_info_per_type(struct ospf_opaque_functab *functab,
struct ospf *top; struct ospf *top;
struct opaque_info_per_type *oipt; struct opaque_info_per_type *oipt;
if ((oipt = XCALLOC(MTYPE_OPAQUE_INFO_PER_TYPE, oipt = XCALLOC(MTYPE_OPAQUE_INFO_PER_TYPE,
sizeof(struct opaque_info_per_type))) sizeof(struct opaque_info_per_type));
== NULL) {
zlog_warn("register_opaque_info_per_type: XMALLOC: %s",
safe_strerror(errno));
goto out;
}
switch (new->data->type) { switch (new->data->type) {
case OSPF_OPAQUE_LINK_LSA: case OSPF_OPAQUE_LINK_LSA:
@ -711,13 +701,9 @@ register_opaque_info_per_id(struct opaque_info_per_type *oipt,
{ {
struct opaque_info_per_id *oipi; struct opaque_info_per_id *oipi;
if ((oipi = XCALLOC(MTYPE_OPAQUE_INFO_PER_ID, oipi = XCALLOC(MTYPE_OPAQUE_INFO_PER_ID,
sizeof(struct opaque_info_per_id))) sizeof(struct opaque_info_per_id));
== NULL) {
zlog_warn("register_opaque_info_per_id: XMALLOC: %s",
safe_strerror(errno));
goto out;
}
oipi->opaque_id = GET_OPAQUE_ID(ntohl(new->data->id.s_addr)); oipi->opaque_id = GET_OPAQUE_ID(ntohl(new->data->id.s_addr));
oipi->t_opaque_lsa_self = NULL; oipi->t_opaque_lsa_self = NULL;
oipi->opqctl_type = oipt; oipi->opqctl_type = oipt;
@ -725,7 +711,6 @@ register_opaque_info_per_id(struct opaque_info_per_type *oipt,
listnode_add(oipt->id_list, oipi); listnode_add(oipt->id_list, oipi);
out:
return oipi; return oipi;
} }

3
ospfd/ospf_spf.c
View File

@ -154,9 +154,6 @@ static struct vertex_parent *vertex_parent_new(struct vertex *v, int backlink,
new = XMALLOC(MTYPE_OSPF_VERTEX_PARENT, sizeof(struct vertex_parent)); new = XMALLOC(MTYPE_OSPF_VERTEX_PARENT, sizeof(struct vertex_parent));
if (new == NULL)
return NULL;
new->parent = v; new->parent = v;
new->backlink = backlink; new->backlink = backlink;
new->nexthop = hop; new->nexthop = hop;

12
ospfd/ospf_sr.c
View File

@ -128,12 +128,6 @@ static struct sr_node *sr_node_new(struct in_addr *rid)
/* Allocate Segment Routing node memory */ /* Allocate Segment Routing node memory */
new = XCALLOC(MTYPE_OSPF_SR_PARAMS, sizeof(struct sr_node)); new = XCALLOC(MTYPE_OSPF_SR_PARAMS, sizeof(struct sr_node));
/* Sanity Check */
if (new == NULL) {
zlog_err("SR (%s): Abort! can't create new SR node", __func__);
return NULL;
}
/* Default Algorithm, SRGB and MSD */ /* Default Algorithm, SRGB and MSD */
for (int i = 0; i < ALGORITHM_COUNT; i++) for (int i = 0; i < ALGORITHM_COUNT; i++)
new->algo[i] = SR_ALGORITHM_UNSET; new->algo[i] = SR_ALGORITHM_UNSET;
@ -735,9 +729,6 @@ static struct sr_link *get_ext_link_sid(struct tlv_header *tlvh)
srl = XCALLOC(MTYPE_OSPF_SR_PARAMS, sizeof(struct sr_link)); srl = XCALLOC(MTYPE_OSPF_SR_PARAMS, sizeof(struct sr_link));
if (srl == NULL)
return NULL;
/* Initialize TLV browsing */ /* Initialize TLV browsing */
length = ntohs(tlvh->length) - EXT_TLV_LINK_SIZE; length = ntohs(tlvh->length) - EXT_TLV_LINK_SIZE;
sub_tlvh = (struct tlv_header *)((char *)(tlvh) + TLV_HDR_SIZE sub_tlvh = (struct tlv_header *)((char *)(tlvh) + TLV_HDR_SIZE
@ -820,9 +811,6 @@ static struct sr_prefix *get_ext_prefix_sid(struct tlv_header *tlvh)
srp = XCALLOC(MTYPE_OSPF_SR_PARAMS, sizeof(struct sr_prefix)); srp = XCALLOC(MTYPE_OSPF_SR_PARAMS, sizeof(struct sr_prefix));
if (srp == NULL)
return NULL;
/* Initialize TLV browsing */ /* Initialize TLV browsing */
length = ntohs(tlvh->length) - EXT_TLV_PREFIX_SIZE; length = ntohs(tlvh->length) - EXT_TLV_PREFIX_SIZE;
sub_tlvh = (struct tlv_header *)((char *)(tlvh) + TLV_HDR_SIZE sub_tlvh = (struct tlv_header *)((char *)(tlvh) + TLV_HDR_SIZE

5
ospfd/ospf_te.c
View File

@ -857,11 +857,6 @@ static int ospf_mpls_te_new_if(struct interface *ifp)
} }
new = XCALLOC(MTYPE_OSPF_MPLS_TE, sizeof(struct mpls_te_link)); new = XCALLOC(MTYPE_OSPF_MPLS_TE, sizeof(struct mpls_te_link));
if (new == NULL) {
zlog_warn("ospf_mpls_te_new_if: XMALLOC: %s",
safe_strerror(errno));
return rc;
}
new->instance = get_mpls_te_instance_value(); new->instance = get_mpls_te_instance_value();
new->ifp = ifp; new->ifp = ifp;

6
pbrd/pbr_zebra.c
View File

@ -54,12 +54,6 @@ struct pbr_interface *pbr_if_new(struct interface *ifp)
pbr_ifp = XCALLOC(MTYPE_PBR_INTERFACE, sizeof(*pbr_ifp)); pbr_ifp = XCALLOC(MTYPE_PBR_INTERFACE, sizeof(*pbr_ifp));
if (!pbr_ifp) {
zlog_err("%s: PBR XCALLOC(%zu) failure", __PRETTY_FUNCTION__,
sizeof(*pbr_ifp));
return 0;
}
ifp->info = pbr_ifp; ifp->info = pbr_ifp;
return pbr_ifp; return pbr_ifp;
} }

1
pimd/pim_br.c
View File

@ -64,7 +64,6 @@ void pim_br_set_pmbr(struct prefix_sg *sg, struct in_addr br)
if (!pim_br) { if (!pim_br) {
pim_br = XCALLOC(MTYPE_PIM_BR, sizeof(*pim_br)); pim_br = XCALLOC(MTYPE_PIM_BR, sizeof(*pim_br));
pim_br->sg = *sg; pim_br->sg = *sg;
listnode_add(pim_br_list, pim_br); listnode_add(pim_br_list, pim_br);

5
pimd/pim_cmd.c
View File

@ -5106,11 +5106,6 @@ static int pim_rp_cmd_worker(struct pim_instance *pim, struct vty *vty,
result = pim_rp_new(pim, rp, group, plist); result = pim_rp_new(pim, rp, group, plist);
if (result == PIM_MALLOC_FAIL) {
vty_out(vty, "%% Out of memory\n");
return CMD_WARNING_CONFIG_FAILED;
}
if (result == PIM_GROUP_BAD_ADDRESS) { if (result == PIM_GROUP_BAD_ADDRESS) {
vty_out(vty, "%% Bad group address specified: %s\n", group); vty_out(vty, "%% Bad group address specified: %s\n", group);
return CMD_WARNING_CONFIG_FAILED; return CMD_WARNING_CONFIG_FAILED;

31
pimd/pim_igmpv3.c
View File

@ -486,9 +486,6 @@ static struct igmp_source *add_source_by_addr(struct igmp_sock *igmp,
} }
src = source_new(group, src_addr); src = source_new(group, src_addr);
if (!src) {
return 0;
}
return src; return src;
} }
@ -579,10 +576,6 @@ static void isex_excl(struct igmp_group *group, int num_sources,
/* E.4: if not found, create source with timer=GMI: /* E.4: if not found, create source with timer=GMI:
* (A-X-Y) */ * (A-X-Y) */
source = source_new(group, *src_addr); source = source_new(group, *src_addr);
if (!source) {
/* ugh, internal malloc failure, skip source */
continue;
}
zassert(!source->t_source_timer); /* timer == 0 */ zassert(!source->t_source_timer); /* timer == 0 */
igmp_source_reset_gmi(group->group_igmp_sock, group, igmp_source_reset_gmi(group->group_igmp_sock, group,
source); source);
@ -637,10 +630,6 @@ static void isex_incl(struct igmp_group *group, int num_sources,
/* I.4: if not found, create source with timer=0 (B-A) /* I.4: if not found, create source with timer=0 (B-A)
*/ */
source = source_new(group, *src_addr); source = source_new(group, *src_addr);
if (!source) {
/* ugh, internal malloc failure, skip source */
continue;
}
zassert(!source->t_source_timer); /* (B-A) timer=0 */ zassert(!source->t_source_timer); /* (B-A) timer=0 */
} }
@ -720,10 +709,6 @@ static void toin_incl(struct igmp_group *group, int num_sources,
} else { } else {
/* If not found, create new source */ /* If not found, create new source */
source = source_new(group, *src_addr); source = source_new(group, *src_addr);
if (!source) {
/* ugh, internal malloc failure, skip source */
continue;
}
} }
/* (B)=GMI */ /* (B)=GMI */
@ -765,10 +750,6 @@ static void toin_excl(struct igmp_group *group, int num_sources,
} else { } else {
/* If not found, create new source */ /* If not found, create new source */
source = source_new(group, *src_addr); source = source_new(group, *src_addr);
if (!source) {
/* ugh, internal malloc failure, skip source */
continue;
}
} }
/* (A)=GMI */ /* (A)=GMI */
@ -854,10 +835,6 @@ static void toex_incl(struct igmp_group *group, int num_sources,
/* If source not found, create source with timer=0: /* If source not found, create source with timer=0:
* (B-A)=0 */ * (B-A)=0 */
source = source_new(group, *src_addr); source = source_new(group, *src_addr);
if (!source) {
/* ugh, internal malloc failure, skip source */
continue;
}
zassert(!source->t_source_timer); /* (B-A) timer=0 */ zassert(!source->t_source_timer); /* (B-A) timer=0 */
} }
@ -917,10 +894,6 @@ static void toex_excl(struct igmp_group *group, int num_sources,
* (A-X-Y)=Group Timer */ * (A-X-Y)=Group Timer */
long group_timer_msec; long group_timer_msec;
source = source_new(group, *src_addr); source = source_new(group, *src_addr);
if (!source) {
/* ugh, internal malloc failure, skip source */
continue;
}
zassert(!source->t_source_timer); /* timer == 0 */ zassert(!source->t_source_timer); /* timer == 0 */
group_timer_msec = igmp_group_timer_remain_msec(group); group_timer_msec = igmp_group_timer_remain_msec(group);
@ -1431,10 +1404,6 @@ static void block_excl(struct igmp_group *group, int num_sources,
* (A-X-Y)=Group Timer */ * (A-X-Y)=Group Timer */
long group_timer_msec; long group_timer_msec;
source = source_new(group, *src_addr); source = source_new(group, *src_addr);
if (!source) {
/* ugh, internal malloc failure, skip source */
continue;
}
zassert(!source->t_source_timer); /* timer == 0 */ zassert(!source->t_source_timer); /* timer == 0 */
group_timer_msec = igmp_group_timer_remain_msec(group); group_timer_msec = igmp_group_timer_remain_msec(group);

17
pimd/pim_rp.c
View File

@ -102,19 +102,10 @@ void pim_rp_init(struct pim_instance *pim)
struct route_node *rn; struct route_node *rn;
pim->rp_list = list_new(); pim->rp_list = list_new();
if (!pim->rp_list) {
zlog_err("Unable to alloc rp_list");
return;
}
pim->rp_list->del = (void (*)(void *))pim_rp_info_free; pim->rp_list->del = (void (*)(void *))pim_rp_info_free;
pim->rp_list->cmp = pim_rp_list_cmp; pim->rp_list->cmp = pim_rp_list_cmp;
pim->rp_table = route_table_init(); pim->rp_table = route_table_init();
if (!pim->rp_table) {
zlog_err("Unable to alloc rp_table");
list_delete_and_null(&pim->rp_list);
return;
}
rp_info = XCALLOC(MTYPE_PIM_RP, sizeof(*rp_info)); rp_info = XCALLOC(MTYPE_PIM_RP, sizeof(*rp_info));
@ -133,14 +124,6 @@ void pim_rp_init(struct pim_instance *pim)
listnode_add(pim->rp_list, rp_info); listnode_add(pim->rp_list, rp_info);
rn = route_node_get(pim->rp_table, &rp_info->group); 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_and_null(&pim->rp_list);
route_table_finish(pim->rp_table);
XFREE(MTYPE_PIM_RP, rp_info);
return;
}
rn->info = rp_info; rn->info = rp_info;
if (PIM_DEBUG_TRACE) if (PIM_DEBUG_TRACE)
zlog_debug( zlog_debug(

1
pimd/pimd.h
View File

@ -117,7 +117,6 @@
/* PIM error codes */ /* PIM error codes */
#define PIM_SUCCESS 0 #define PIM_SUCCESS 0
#define PIM_MALLOC_FAIL -1
#define PIM_GROUP_BAD_ADDRESS -2 #define PIM_GROUP_BAD_ADDRESS -2
#define PIM_GROUP_OVERLAP -3 #define PIM_GROUP_OVERLAP -3
#define PIM_GROUP_PFXLIST_OVERLAP -4 #define PIM_GROUP_PFXLIST_OVERLAP -4

8
ripd/ripd.c
View File

@ -2802,15 +2802,9 @@ DEFUN_NOSH (router_rip,
"Enable a routing process\n" "Enable a routing process\n"
"Routing Information Protocol (RIP)\n") "Routing Information Protocol (RIP)\n")
{ {
int ret;
/* If rip is not enabled before. */ /* If rip is not enabled before. */
if (!rip) { if (!rip) {
ret = rip_create(); rip_create();
if (ret < 0) {
zlog_info("Can't create RIP");
return CMD_WARNING_CONFIG_FAILED;
}
} }
VTY_PUSH_CONTEXT(RIP_NODE, rip); VTY_PUSH_CONTEXT(RIP_NODE, rip);

6
zebra/if_ioctl_solaris.c
View File

@ -100,11 +100,7 @@ calculate_lifc_len: /* must hold privileges to enter here */
if (needed > lastneeded || needed < lastneeded / 2) { if (needed > lastneeded || needed < lastneeded / 2) {
if (buf != NULL) if (buf != NULL)
XFREE(MTYPE_TMP, buf); XFREE(MTYPE_TMP, buf);
if ((buf = XMALLOC(MTYPE_TMP, needed)) == NULL) { buf = XMALLOC(MTYPE_TMP, needed);
zlog_warn("interface_list_ioctl: malloc failed");
close(sock);
return -1;
}
} }
lastneeded = needed; lastneeded = needed;

2
zebra/label_manager.c
View File

@ -384,8 +384,6 @@ struct label_manager_chunk *assign_label_chunk(uint8_t proto,
} }
/* otherwise create a new one */ /* otherwise create a new one */
lmc = XCALLOC(MTYPE_LM_CHUNK, sizeof(struct label_manager_chunk)); lmc = XCALLOC(MTYPE_LM_CHUNK, sizeof(struct label_manager_chunk));
if (!lmc)
return NULL;
if (list_isempty(lbl_mgr.lc_list)) if (list_isempty(lbl_mgr.lc_list))
lmc->start = MPLS_LABEL_UNRESERVED_MIN; lmc->start = MPLS_LABEL_UNRESERVED_MIN;

4
zebra/zebra_mpls.c
View File

@ -550,8 +550,6 @@ static zebra_fec_t *fec_add(struct route_table *table, struct prefix *p,
if (!fec) { if (!fec) {
fec = XCALLOC(MTYPE_FEC, sizeof(zebra_fec_t)); fec = XCALLOC(MTYPE_FEC, sizeof(zebra_fec_t));
if (!fec)
return NULL;
rn->info = fec; rn->info = fec;
fec->rn = rn; fec->rn = rn;
@ -1181,8 +1179,6 @@ static zebra_nhlfe_t *nhlfe_add(zebra_lsp_t *lsp, enum lsp_types_t lsp_type,
return NULL; return NULL;
nhlfe = XCALLOC(MTYPE_NHLFE, sizeof(zebra_nhlfe_t)); nhlfe = XCALLOC(MTYPE_NHLFE, sizeof(zebra_nhlfe_t));
if (!nhlfe)
return NULL;
nhlfe->lsp = lsp; nhlfe->lsp = lsp;
nhlfe->type = lsp_type; nhlfe->type = lsp_type;

1
zebra/zebra_rib.c
View File

@ -1965,7 +1965,6 @@ static struct meta_queue *meta_queue_new(void)
unsigned i; unsigned i;
new = XCALLOC(MTYPE_WORK_QUEUE, sizeof(struct meta_queue)); new = XCALLOC(MTYPE_WORK_QUEUE, sizeof(struct meta_queue));
assert(new);
for (i = 0; i < MQ_SIZE; i++) { for (i = 0; i < MQ_SIZE; i++) {
new->subq[i] = list_new(); new->subq[i] = list_new();

3
zebra/zebra_routemap.c
View File

@ -1098,9 +1098,6 @@ static void *route_match_address_prefix_len_compile(const char *arg)
prefix_len = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t)); prefix_len = XMALLOC(MTYPE_ROUTE_MAP_COMPILED, sizeof(uint32_t));
if (!prefix_len)
return prefix_len;
*prefix_len = tmpval; *prefix_len = tmpval;
return prefix_len; return prefix_len;
} }

4
zebra/zebra_vxlan.c
View File

@ -2985,10 +2985,6 @@ static zebra_vtep_t *zvni_vtep_add(zebra_vni_t *zvni, struct in_addr *vtep_ip)
zebra_vtep_t *zvtep; zebra_vtep_t *zvtep;
zvtep = XCALLOC(MTYPE_ZVNI_VTEP, sizeof(zebra_vtep_t)); zvtep = XCALLOC(MTYPE_ZVNI_VTEP, sizeof(zebra_vtep_t));
if (!zvtep) {
zlog_err("Failed to alloc VTEP entry, VNI %u", zvni->vni);
return NULL;
}
zvtep->vtep_ip = *vtep_ip; zvtep->vtep_ip = *vtep_ip;