if (suffix != NULL) {
len = strlen(keyname) + strlen(suffix) + 2;
keybuf = isc_mem_get(mctx, len);
- if (keybuf == NULL)
- fatal("failed to allocate memory for keyname");
snprintf(keybuf, len, "%s.%s", keyname, suffix);
keyname = (const char *) keybuf;
}
char *buf;
len = strlen(chrootdir) + strlen(keyfile) + 2;
buf = isc_mem_get(mctx, len);
- if (buf == NULL)
- fatal("isc_mem_get(%d) failed\n", len);
snprintf(buf, len, "%s%s%s", chrootdir,
(*keyfile != '/') ? "/" : "", keyfile);
do {
t = isc_mem_get(mctx, len);
- if (t == NULL)
- return (ISC_R_NOMEMORY);
isc_buffer_init(&target, t, len);
if (short_form) {
fatal("Use of IPv4 disabled by -6");
}
sa = isc_mem_get(mctx, sizeof(*sa));
- if (sa == NULL)
- return (ISC_R_NOMEMORY);
ISC_LINK_INIT(sa, link);
isc_sockaddr_fromin(sa, &in4, destport);
ISC_LIST_APPEND(servers, sa, link);
fatal("Use of IPv6 disabled by -4");
}
sa = isc_mem_get(mctx, sizeof(*sa));
- if (sa == NULL)
- return (ISC_R_NOMEMORY);
ISC_LINK_INIT(sa, link);
isc_sockaddr_fromin6(sa, &in6, destport);
ISC_LIST_APPEND(servers, sa, link);
cur->ai_family != AF_INET6)
continue;
sa = isc_mem_get(mctx, sizeof(*sa));
- if (sa == NULL) {
- result = ISC_R_NOMEMORY;
- break;
- }
memset(sa, 0, sizeof(*sa));
ISC_LINK_INIT(sa, link);
memmove(&sa->type, cur->ai_addr, cur->ai_addrlen);
struct in_addr localhost;
localhost.s_addr = htonl(INADDR_LOOPBACK);
sa = isc_mem_get(mctx, sizeof(*sa));
- if (sa == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
isc_sockaddr_fromin(sa, &localhost, destport);
ISC_LINK_INIT(sa, link);
if (use_ipv6) {
sa = isc_mem_get(mctx, sizeof(*sa));
- if (sa == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
isc_sockaddr_fromin6(sa, &in6addr_loopback, destport);
ISC_LINK_INIT(sa, link);
nkey = dns_rdataset_count(keyset);
keytable = isc_mem_get(mctx, sizeof(keyinfo_t) * nkey);
- if (keytable == NULL) {
- fatal("out of memory");
- }
for (result = dns_rdataset_first(keyset), i = 0;
result == ISC_R_SUCCESS;
int i;
algo = isc_mem_get(mctx, nkey);
- if (algo == NULL) {
- fatal("allocating RRSIG/DNSKEY match list: %s",
- isc_result_totext(ISC_R_NOMEMORY));
- }
memset(algo, 0, nkey);
for (result = dns_rdataset_first(sigset);
dns_rdata_t *rdata;
rdata = isc_mem_get(mctx, sizeof(*rdata));
- if (rdata == NULL) {
- fatal("allocating DS rdata: %s",
- isc_result_totext(ISC_R_NOMEMORY));
- }
dns_rdata_init(rdata);
return (rdata);
dns_rdatalist_t *dslist;
dslist = isc_mem_get(mctx, sizeof(*dslist));
- if (dslist == NULL) {
- fatal("allocating new DS list: %s",
- isc_result_totext(ISC_R_NOMEMORY));
- }
dns_rdatalist_init(dslist);
dslist->rdclass = rdclass;
n = dns_rdataset_count(dsset);
arrdata = isc_mem_get(mctx, n * sizeof(dns_rdata_t));
- if (arrdata == NULL) {
- fatal("allocating DS rdata array: %s",
- isc_result_totext(ISC_R_NOMEMORY));
- }
for (result = dns_rdataset_first(dsset), i = 0;
result == ISC_R_SUCCESS;
* Convert sorted arrdata to more accessible format
*/
ds = isc_mem_get(mctx, n * sizeof(dns_rdata_ds_t));
- if (ds == NULL) {
- fatal("allocating unpacked DS array: %s",
- isc_result_totext(ISC_R_NOMEMORY));
- }
for (i = 0; i < n; i++) {
result = dns_rdata_tostruct(&arrdata[i], &ds[i], NULL);
}
fname = isc_mem_get(mctx, sizeof(dns_fixedname_t));
- if (fname == NULL)
- fatal("out of memory");
name = dns_fixedname_initname(fname);
node = NULL;
found = false;
if (dsdir != NULL)
filenamelen += strlen(dsdir) + 1;
filename = isc_mem_get(mctx, filenamelen);
- if (filename == NULL)
- fatal("out of memory");
if (dsdir != NULL)
snprintf(filename, filenamelen, "%s/", dsdir);
else
} else {
tempfilelen = strlen(output) + 20;
tempfile = isc_mem_get(mctx, tempfilelen);
- if (tempfile == NULL)
- fatal("out of memory");
result = isc_file_mktemplate(output, tempfile, tempfilelen);
check_result(result, "isc_file_mktemplate");
fatal("failed to create task: %s", isc_result_totext(result));
tasks = isc_mem_get(mctx, ntasks * sizeof(isc_task_t *));
- if (tasks == NULL)
- fatal("out of memory");
for (i = 0; i < (int)ntasks; i++) {
tasks[i] = NULL;
result = isc_task_create(taskmgr, 0, &tasks[i]);
}
dscps = isc_mem_get(mctx, count * sizeof(isc_dscp_t));
- if (dscps == NULL)
- return (ISC_R_NOMEMORY);
}
addrs = isc_mem_get(mctx, count * sizeof(isc_sockaddr_t));
- if (addrs == NULL) {
- if (dscps != NULL)
- isc_mem_put(mctx, dscps, count * sizeof(isc_dscp_t));
- return (ISC_R_NOMEMORY);
- }
for (element = cfg_list_first(addrlist);
element != NULL;
newsize = newlen * sizeof(*lists);
oldsize = listcount * sizeof(*lists);
tmp = isc_mem_get(mctx, newsize);
- if (tmp == NULL)
- goto cleanup;
if (listcount != 0) {
memmove(tmp, lists, oldsize);
isc_mem_put(mctx, lists, oldsize);
newsize = newlen * sizeof(*stack);
oldsize = stackcount * sizeof(*stack);
tmp = isc_mem_get(mctx, newsize);
- if (tmp == NULL)
- goto cleanup;
if (stackcount != 0) {
memmove(tmp, stack, oldsize);
isc_mem_put(mctx, stack, oldsize);
newsize = newlen * sizeof(isc_sockaddr_t);
oldsize = addrcount * sizeof(isc_sockaddr_t);
tmp = isc_mem_get(mctx, newsize);
- if (tmp == NULL)
- goto cleanup;
if (addrcount != 0) {
memmove(tmp, addrs, oldsize);
isc_mem_put(mctx, addrs, oldsize);
newsize = newlen * sizeof(isc_dscp_t);
oldsize = dscpcount * sizeof(isc_dscp_t);
tmp = isc_mem_get(mctx, newsize);
- if (tmp == NULL)
- goto cleanup;
if (dscpcount != 0) {
memmove(tmp, dscps, oldsize);
isc_mem_put(mctx, dscps, oldsize);
newsize = newlen * sizeof(dns_name_t *);
oldsize = keycount * sizeof(dns_name_t *);
tmp = isc_mem_get(mctx, newsize);
- if (tmp == NULL)
- goto cleanup;
if (keycount != 0) {
memmove(tmp, keys, oldsize);
isc_mem_put(mctx, keys, oldsize);
if (!cfg_obj_isstring(key))
continue;
keys[i - 1] = isc_mem_get(mctx, sizeof(dns_name_t));
- if (keys[i - 1] == NULL)
- goto cleanup;
dns_name_init(keys[i - 1], NULL);
keystr = cfg_obj_asstring(key);
oldsize = addrcount * sizeof(isc_sockaddr_t);
if (i != 0) {
tmp = isc_mem_get(mctx, newsize);
- if (tmp == NULL)
- goto cleanup;
memmove(tmp, addrs, newsize);
} else
tmp = NULL;
oldsize = dscpcount * sizeof(isc_dscp_t);
if (i != 0) {
tmp = isc_mem_get(mctx, newsize);
- if (tmp == NULL)
- goto cleanup;
memmove(tmp, dscps, newsize);
} else
tmp = NULL;
oldsize = keycount * sizeof(dns_name_t *);
if (i != 0) {
tmp = isc_mem_get(mctx, newsize);
- if (tmp == NULL)
- goto cleanup;
memmove(tmp, keys, newsize);
} else
tmp = NULL;
ccregion.rstart = isc_buffer_base(&conn->ccmsg.buffer);
ccregion.rend = isc_buffer_used(&conn->ccmsg.buffer);
- secret.rstart = isc_mem_get(listener->mctx, key->secret.length);
- if (secret.rstart == NULL)
- goto cleanup;
+ secret.rstart = isc_mem_get(listener->mctx,
+ key->secret.length);
memmove(secret.rstart, key->secret.base, key->secret.length);
secret.rend = secret.rstart + key->secret.length;
algorithm = key->algorithm;
isc_result_t result;
conn = isc_mem_get(listener->mctx, sizeof(*conn));
- if (conn == NULL)
- return (ISC_R_NOMEMORY);
conn->sock = sock;
isccc_ccmsg_init(listener->mctx, sock, &conn->ccmsg);
if (newstr == NULL)
goto cleanup;
key = isc_mem_get(mctx, sizeof(*key));
- if (key == NULL)
- goto cleanup;
key->keyname = newstr;
key->algorithm = DST_ALG_UNKNOWN;
key->secret.base = NULL;
keyid->secret.length = isc_buffer_usedlength(&b);
keyid->secret.base = isc_mem_get(mctx,
keyid->secret.length);
- if (keyid->secret.base == NULL) {
- cfg_obj_log(keydef, named_g_lctx,
- ISC_LOG_WARNING,
- "couldn't register key '%s': "
- "out of memory", keyid->keyname);
- ISC_LIST_UNLINK(*keyids, keyid, link);
- free_controlkey(keyid, mctx);
- break;
- }
memmove(keyid->secret.base, isc_buffer_base(&b),
keyid->secret.length);
}
CHECK(cfg_map_get(config, "key", &key));
keyid = isc_mem_get(mctx, sizeof(*keyid));
- if (keyid == NULL)
- CHECK(ISC_R_NOMEMORY);
keyid->keyname = isc_mem_strdup(mctx,
cfg_obj_asstring(cfg_map_getname(key)));
keyid->secret.base = NULL;
}
keyid->secret.length = isc_buffer_usedlength(&b);
- keyid->secret.base = isc_mem_get(mctx,
- keyid->secret.length);
- if (keyid->secret.base == NULL) {
- cfg_obj_log(key, named_g_lctx, ISC_LOG_WARNING,
- "couldn't register key '%s': "
- "out of memory", keyid->keyname);
- CHECK(ISC_R_NOMEMORY);
- }
+ keyid->secret.base = isc_mem_get(mctx, keyid->secret.length);
memmove(keyid->secret.base, isc_buffer_base(&b),
keyid->secret.length);
ISC_LIST_APPEND(*keyids, keyid, link);
isc_result_t result = ISC_R_SUCCESS;
listener = isc_mem_get(mctx, sizeof(*listener));
- if (listener == NULL)
- result = ISC_R_NOMEMORY;
if (result == ISC_R_SUCCESS) {
listener->mctx = NULL;
if (ctx->cstr == NULL) {
ctx->cstr = isc_mem_get(ctx->mctx, 256);
- if (ctx->cstr == NULL) {
- ctx->result = ISC_R_NOMEMORY;
- return (false);
- }
ctx->cstr[0] = '\0';
ctx->cstr_size = 256;
}
new_cstr_size = ((cur_len + new_len)/256 + 1) * 256;
new_cstr = isc_mem_get(ctx->mctx, new_cstr_size);
- if (new_cstr == NULL) {
- ctx->result = ISC_R_NOMEMORY;
- return (false);
- }
memmove(new_cstr, ctx->cstr, cur_len);
isc_mem_put(ctx->mctx, ctx->cstr, ctx->cstr_size);
isc_mem_detach(&hmctx);
}
nsc = isc_mem_get(mctx, sizeof(*nsc));
- if (nsc == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
nsc->cache = NULL;
dns_cache_attach(cache, &nsc->cache);
nsc->primaryview = view;
{
const cfg_obj_t *forwarder = cfg_listelt_value(element);
fwd = isc_mem_get(view->mctx, sizeof(dns_forwarder_t));
- if (fwd == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
fwd->addr = *cfg_obj_assockaddr(forwarder);
if (isc_sockaddr_getport(&fwd->addr) == 0)
isc_sockaddr_setport(&fwd->addr, port);
view->name, namebuf);
tat = isc_mem_get(dotat_arg->view->mctx, sizeof(*tat));
- if (tat == NULL) {
- return;
- }
tat->mctx = NULL;
tat->task = NULL;
INSIST(server->session_keyalg == DST_ALG_UNKNOWN);
INSIST(server->session_keybits == 0);
- server->session_keyname = isc_mem_get(mctx, sizeof(dns_name_t));
- if (server->session_keyname == NULL)
- goto cleanup;
+ server->session_keyname = isc_mem_get(mctx,
+ sizeof(dns_name_t));
dns_name_init(server->session_keyname, NULL);
CHECK(dns_name_dup(keyname, mctx, server->session_keyname));
}
nzcfg = isc_mem_get(view->mctx, sizeof(*nzcfg));
- if (nzcfg == NULL) {
- dns_view_setnewzones(view, false, NULL, NULL, 0ULL);
- return (ISC_R_NOMEMORY);
- }
/*
* We attach the parser that was used for config as well
} else {
altsecret = isc_mem_get(server->sctx->mctx,
sizeof(*altsecret));
- if (altsecret == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
isc_buffer_init(&b, altsecret->secret,
sizeof(altsecret->secret));
result = isc_hex_decodestring(str, &b);
dns_view_t *view;
ns_zoneload_t *zl;
- zl = isc_mem_get(server->mctx, sizeof (*zl));
- if (zl == NULL)
- return (ISC_R_NOMEMORY);
+ zl = isc_mem_get(server->mctx, sizeof(*zl));
zl->server = server;
zl->reconfig = reconfig;
}
dispatch = isc_mem_get(server->mctx, sizeof(*dispatch));
- if (dispatch == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
dispatch->addr = *addr;
dispatch->dispatchgen = server->dispatchgen;
struct zonelistentry *zle;
zle = isc_mem_get(dctx->mctx, sizeof *zle);
- if (zle == NULL)
- return (ISC_R_NOMEMORY);
zle->zone = NULL;
dns_zone_attach(zone, &zle->zone);
ISC_LINK_INIT(zle, link);
return (ISC_R_SUCCESS);
vle = isc_mem_get(dctx->mctx, sizeof *vle);
- if (vle == NULL)
- return (ISC_R_NOMEMORY);
vle->view = NULL;
dns_view_attach(view, &vle->view);
ISC_LINK_INIT(vle, link);
return (ISC_R_UNEXPECTEDEND);
dctx = isc_mem_get(server->mctx, sizeof(*dctx));
- if (dctx == NULL)
- return (ISC_R_NOMEMORY);
dctx->mctx = server->mctx;
dctx->dumpcache = true;
/* Send cleanup event */
dz = isc_mem_get(named_g_mctx, sizeof(*dz));
- if (dz == NULL)
- CHECK(ISC_R_NOMEMORY);
dz->cleanup = cleanup;
dz->zone = NULL;
dns_acl_t *new_acl = NULL;
listener = isc_mem_get(server->mctx, sizeof(*listener));
- if (listener == NULL)
- return (ISC_R_NOMEMORY);
listener->httpdmgr = NULL;
listener->address = *addr;
name = dns_fixedname_initname(&fname);
RETERR(dns_name_fromtext(name, &b, dns_rootname, 0, NULL));
tctx->domain = isc_mem_get(mctx, sizeof(dns_name_t));
- if (tctx->domain == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
dns_name_init(tctx->domain, NULL);
RETERR(dns_name_dup(name, mctx, tctx->domain));
}
secretstr = cfg_obj_asstring(secretobj);
secretalloc = secretlen = strlen(secretstr) * 3 / 4;
secret = isc_mem_get(mctx, secretlen);
- if (secret == NULL) {
- ret = ISC_R_NOMEMORY;
- goto failure;
- }
isc_buffer_init(&secretbuf, secret, secretlen);
ret = isc_base64_decodestring(secretstr, &secretbuf);
if (ret != ISC_R_SUCCESS)
return (result);
cd = isc_mem_get(mctx, sizeof(*cd));
- if (cd == NULL) {
- isc_mem_destroy(&mctx);
- return (ISC_R_NOMEMORY);
- }
memset(cd, 0, sizeof(*cd));
cd->mctx = mctx;
isc_mem_create(0, 0, &mctx);
cd = isc_mem_get(mctx, sizeof(*cd));
- if (cd == NULL) {
- isc_mem_destroy(&mctx);
- return (ISC_R_NOMEMORY);
- }
memset(cd, 0, sizeof(*cd));
cd->mctx = mctx;
types = NULL;
else {
types = isc_mem_get(mctx, n * sizeof(dns_rdatatype_t));
- if (types == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
}
i = 0;
}
rdata = isc_mem_get(mctx, sizeof(*rdata) + region.length);
- if (rdata == NULL)
- return (ISC_R_NOMEMORY);
region.base = (unsigned char *)(rdata + 1);
memmove(region.base, &na.type, region.length);
dns_rdata_init(rdata);
/* Add to the list an apex NS with the ns name being the origin name */
dns_name_toregion(dns_zone_getorigin(zone), &sregion);
rdata = isc_mem_get(mctx, sizeof(*rdata) + sregion.length);
- if (rdata == NULL) {
- /*
- * Already allocated data will be freed in the caller, so
- * we can simply return here.
- */
- return (ISC_R_NOMEMORY);
- }
region.length = sregion.length;
region.base = (unsigned char *)(rdata + 1);
memmove(region.base, sregion.base, region.length);
dns_name_toregion(nsname, &sregion);
rdata = isc_mem_get(mctx, sizeof(*rdata) + sregion.length);
- if (rdata == NULL)
- return (ISC_R_NOMEMORY);
region.length = sregion.length;
region.base = (unsigned char *)(rdata + 1);
memmove(region.base, sregion.base, region.length);
/* We have reached the end of the string. */
*argcp = n;
*argvp = isc_mem_get(mctx, n * sizeof(char *));
- if (*argvp == NULL)
- return (ISC_R_NOMEMORY);
} else {
char *p = s;
while (*p != ' ' && *p != '\t' && *p != '\0')
RETERR(dns_zone_setfile(raw, filename,
masterformat, masterstyle));
signedname = isc_mem_get(mctx, signedlen);
- if (signedname == NULL)
- return (ISC_R_NOMEMORY);
(void)snprintf(signedname, signedlen, "%s" SIGNED, filename);
result = dns_zone_setfile(zone, signedname,
default_servers = !local_only;
ns_total = ns_alloc = (have_ipv4 ? 1 : 0) + (have_ipv6 ? 1 : 0);
- servers = isc_mem_get(gmctx, ns_alloc * sizeof(isc_sockaddr_t));
- if (servers == NULL)
- fatal("out of memory");
+ servers = isc_mem_get(gmctx,
+ ns_alloc * sizeof(isc_sockaddr_t));
if (have_ipv6) {
memset(&in6, 0, sizeof(in6));
}
ns_alloc = ns_total;
- servers = isc_mem_get(gmctx, ns_alloc * sizeof(isc_sockaddr_t));
- if (servers == NULL)
- fatal("out of memory");
+ servers = isc_mem_get(gmctx,
+ ns_alloc * sizeof(isc_sockaddr_t));
i = 0;
for (sa = ISC_LIST_HEAD(*nslist);
ns_alloc = MAX_SERVERADDRS;
ns_inuse = 0;
servers = isc_mem_get(gmctx, ns_alloc * sizeof(isc_sockaddr_t));
- if (servers == NULL)
- fatal("out of memory");
memset(servers, 0, ns_alloc * sizeof(isc_sockaddr_t));
ns_total = get_addresses(server, (in_port_t)port, servers, ns_alloc);
if (have_ipv6 && inet_pton(AF_INET6, local, &in6) == 1) {
if (localaddr6 == NULL)
- localaddr6 = isc_mem_get(gmctx, sizeof(isc_sockaddr_t));
- if (localaddr6 == NULL)
- fatal("out of memory");
+ localaddr6 = isc_mem_get(gmctx,
+ sizeof(isc_sockaddr_t));
isc_sockaddr_fromin6(localaddr6, &in6, (in_port_t)port);
} else if (have_ipv4 && inet_pton(AF_INET, local, &in4) == 1) {
if (localaddr4 == NULL)
- localaddr4 = isc_mem_get(gmctx, sizeof(isc_sockaddr_t));
- if (localaddr4 == NULL)
- fatal("out of memory");
+ localaddr4 = isc_mem_get(gmctx,
+ sizeof(isc_sockaddr_t));
isc_sockaddr_fromin(localaddr4, &in4, (in_port_t)port);
} else {
fprintf(stderr, "invalid address %s", local);
ddebug("Destroying request [%p]", request);
dns_request_destroy(&request);
reqinfo = isc_mem_get(gmctx, sizeof(nsu_requestinfo_t));
- if (reqinfo == NULL)
- fatal("out of memory");
reqinfo->msg = soaquery;
reqinfo->addr = addr;
dns_message_renderreset(soaquery);
master_alloc = MAX_SERVERADDRS;
size = master_alloc * sizeof(isc_sockaddr_t);
master_servers = isc_mem_get(gmctx, size);
- if (master_servers == NULL)
- fatal("out of memory");
memset(master_servers, 0, size);
master_total = get_addresses(serverstr, dnsport,
isc_sockaddr_t *srcaddr;
reqinfo = isc_mem_get(gmctx, sizeof(nsu_requestinfo_t));
- if (reqinfo == NULL)
- fatal("out of memory");
reqinfo->msg = msg;
reqinfo->addr = destaddr;
dns_name_format(master, namestr, sizeof(namestr));
if (kserver == NULL) {
kserver = isc_mem_get(gmctx, sizeof(isc_sockaddr_t));
- if (kserver == NULL)
- fatal("out of memory");
}
memmove(kserver, &master_servers[master_inuse],
debug("send_gssrequest");
reqinfo = isc_mem_get(gmctx, sizeof(nsu_gssinfo_t));
- if (reqinfo == NULL)
- fatal("out of memory");
reqinfo->msg = msg;
reqinfo->addr = destaddr;
reqinfo->context = context;
argslen += strlen(argv[i]) + 1;
args = isc_mem_get(rndc_mctx, argslen);
- if (args == NULL)
- DO("isc_mem_get", ISC_R_NOMEMORY);
p = args;
for (i = 0; i < argc; i++) {
unsigned int i;
dbi = isc_mem_get(mctx, sizeof(*dbi));
- if (dbi == NULL)
- return (ISC_R_NOMEMORY);
dbi->db = NULL;
dbi->version = NULL;
* name structure.
*/
name = isc_mem_get(mctx, sizeof(*name) + DNSNAMELEN);
- if (name == NULL) {
- printf("out of memory!\n");
- return (NULL);
- }
dns_name_init(name, NULL);
isc_buffer_init(&target, name + 1, DNSNAMELEN);
snprintf(buf, sizeof(buf), "\r\nReceived: %.*s\r\n\r\n",
(int)dev->n, (char *)region.base);
region.base = isc_mem_get(mctx, strlen(buf) + 1);
- if (region.base != NULL) {
+ {
region.length = strlen(buf) + 1;
strlcpy((char *)region.base, buf, region.length);
- } else
- region.length = 0;
+ }
isc_socket_send(sock, ®ion, task, my_send, event->ev_arg);
} else {
region = dev->region;
"GET / HTTP/1.1\r\nHost: www.flame.org\r\n"
"Connection: Close\r\n\r\n");
region.base = isc_mem_get(mctx, strlen(buf) + 1);
- if (region.base != NULL) {
+ {
region.length = strlen(buf) + 1;
strlcpy((char *)region.base, buf, region.length);
- } else {
- region.length = 0;
}
isc_socket_send(sock, ®ion, task, my_http_get, event->ev_arg);
do {
buf = isc_mem_get(mctx, len);
- if (buf == NULL) {
- result = ISC_R_NOMEMORY;
- break;
- }
isc_buffer_init(&b, buf, len);
result = dns_message_totext(msg, &dns_master_style_debug,
/* allocate and zero memory for driver structure */
db = isc_mem_get(named_g_mctx, sizeof(bdb_instance_t));
- if (db == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
- "Could not allocate memory for "
- "database instance object.");
- return (ISC_R_NOMEMORY);
- }
memset(db, 0, sizeof(bdb_instance_t));
/* attach to the memory context */
/* allocate and zero memory for driver structure */
db = isc_mem_get(named_g_mctx, sizeof(bdbhpt_instance_t));
- if (db == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
- "Could not allocate memory for "
- "database instance object.");
- return (ISC_R_NOMEMORY);
- }
memset(db, 0, sizeof(bdbhpt_instance_t));
/* attach to the memory context */
* dir list
*/
if (dir_list != NULL) {
- direntry =
- isc_mem_get(named_g_mctx,
- sizeof(dir_entry_t));
- if (direntry == NULL)
- return (ISC_R_NOMEMORY);
+ direntry = isc_mem_get(named_g_mctx,
+ sizeof(dir_entry_t));
strcpy(direntry->dirpath, tmp);
ISC_LINK_INIT(direntry, link);
ISC_LIST_APPEND(*dir_list, direntry,
/* allocate memory for list */
dir_list = isc_mem_get(named_g_mctx, sizeof(dlist_t));
- if (dir_list == NULL) {
- result = ISC_R_NOTFOUND;
- goto complete_allnds;
- }
/* initialize list */
ISC_LIST_INIT(*dir_list);
/* allocate memory for our config data */
cd = isc_mem_get(named_g_mctx, sizeof(config_data_t));
- if (cd == NULL)
- goto no_mem;
/* zero the memory */
memset(cd, 0, sizeof(config_data_t));
/* allocate memory for LDAP instance */
ldap_inst = isc_mem_get(named_g_mctx, sizeof(ldap_instance_t));
- if (ldap_inst == NULL)
- return (ISC_R_NOMEMORY);
memset(ldap_inst, 0, sizeof(ldap_instance_t));
/* store info needed to automatically re-connect. */
/* allocate memory for database connection list */
ldap_inst->db = isc_mem_get(named_g_mctx, sizeof(db_list_t));
- if (ldap_inst->db == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
/* initialize DB connection list */
ISC_LIST_INIT(*(ldap_inst->db));
/* allocate memory for odbc instance */
odbc_inst = isc_mem_get(named_g_mctx, sizeof(odbc_instance_t));
- if (odbc_inst == NULL)
- return (ISC_R_NOMEMORY);
memset(odbc_inst, 0, sizeof(odbc_instance_t));
/* parse connection string and get paramters. */
/* allocate memory for database connection list */
odbc_inst->db = isc_mem_get(named_g_mctx, sizeof(db_list_t));
- if (odbc_inst->db == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
/* initialize DB connection list */
/* allocate memory for database connection list */
dblist = isc_mem_get(named_g_mctx, sizeof(db_list_t));
- if (dblist == NULL)
- return (ISC_R_NOMEMORY);
/* initialize DB connection list */
ISC_LIST_INIT(*dblist);
/* allocate memory for query list */
tql = isc_mem_get(mctx, sizeof(query_list_t));
- /* couldn't allocate memory. Problem!! */
- if (tql == NULL)
- return (ISC_R_NOMEMORY);
/* initialize the query segment list */
ISC_LIST_INIT(*tql);
/* allocate memory for tseg */
tseg = isc_mem_get(mctx, sizeof(query_segment_t));
- if (tseg == NULL) { /* no memory, clean everything up. */
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
tseg->sql = NULL;
tseg->direct = false;
/* initialize the query segment link */
/* allocate and zero memory for driver structure */
db = isc_mem_get(mctx, sizeof(dbinstance_t));
- if (db == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
- DNS_LOGMODULE_DLZ, ISC_LOG_ERROR,
- "Could not allocate memory for "
- "database instance object.");
- return (ISC_R_NOMEMORY);
- }
memset(db, 0, sizeof(dbinstance_t));
db->dbconn = NULL;
db->client = NULL;
REQUIRE(foop != NULL && *foop == NULL);
foo = isc_mem_get(mctx, sizeof(isc_foo_t))
- if (foo == NULL)
- return (ISC_R_NOMEMORY);
/* Attach to memory context */
isc_mem_attach(mctx, &foo->mctx);
REQUIRE(foop != NULL && *foop == NULL);
foo = isc_mem_get(mctx, sizeof(isc_foo_t));
- if (foo == NULL)
- return (ISC_R_NOMEMORY);
ISC_LINK_INIT(foo, link);
newsize = newlen * sizeof(*stack);
oldsize = stackcount * sizeof(*stack);
newstack = isc_mem_get(mctx, newsize);
- if (newstack == NULL)
- goto cleanup;
if (stackcount != 0) {
void *ptr;
element = stack[--pushed];
goto resume;
}
- cleanup:
if (stack != NULL) {
void *ptr;
n = 1;
acl = isc_mem_get(mctx, sizeof(*acl));
- if (acl == NULL)
- return (ISC_R_NOMEMORY);
acl->mctx = NULL;
isc_mem_attach(mctx, &acl->mctx);
acl->magic = DNS_ACL_MAGIC;
acl->elements = isc_mem_get(mctx, n * sizeof(dns_aclelement_t));
- if (acl->elements == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
acl->alloc = n;
memset(acl->elements, 0, n * sizeof(dns_aclelement_t));
*target = acl;
return (ISC_R_SUCCESS);
-
- cleanup:
- dns_acl_detach(&acl);
- return (result);
}
/*
newmem = isc_mem_get(dest->mctx,
newalloc * sizeof(dns_aclelement_t));
- if (newmem == NULL)
- return (ISC_R_NOMEMORY);
/* Zero. */
memset(newmem, 0, newalloc * sizeof(dns_aclelement_t));
UNUSED(timermgr);
adb = isc_mem_get(mem, sizeof(dns_adb_t));
- if (adb == NULL)
- return (ISC_R_NOMEMORY);
/*
* Initialize things here that cannot fail, and especially things
if (addr->entry->cookie == NULL && cookie != NULL && len != 0U) {
addr->entry->cookie = isc_mem_get(adb->mctx, len);
- if (addr->entry->cookie != NULL)
- addr->entry->cookielen = (uint16_t)len;
+ addr->entry->cookielen = (uint16_t)len;
}
if (addr->entry->cookie != NULL)
isc_result_t
dns_badcache_init(isc_mem_t *mctx, unsigned int size, dns_badcache_t **bcp) {
- isc_result_t result;
dns_badcache_t *bc = NULL;
REQUIRE(bcp != NULL && *bcp == NULL);
REQUIRE(mctx != NULL);
bc = isc_mem_get(mctx, sizeof(dns_badcache_t));
- if (bc == NULL)
- return (ISC_R_NOMEMORY);
memset(bc, 0, sizeof(dns_badcache_t));
isc_mem_attach(mctx, &bc->mctx);
isc_mutex_init(&bc->lock);
bc->table = isc_mem_get(bc->mctx, sizeof(*bc->table) * size);
- if (bc->table == NULL) {
- result = ISC_R_NOMEMORY;
- goto destroy_lock;
- }
bc->size = bc->minsize = size;
memset(bc->table, 0, bc->size * sizeof(dns_bcentry_t *));
*bcp = bc;
return (ISC_R_SUCCESS);
-
- destroy_lock:
- isc_mutex_destroy(&bc->lock);
- isc_mem_putanddetach(&bc->mctx, bc, sizeof(dns_badcache_t));
- return (result);
}
void
newsize = (bc->size - 1) / 2;
newtable = isc_mem_get(bc->mctx, sizeof(dns_bcentry_t *) * newsize);
- if (newtable == NULL)
- return (ISC_R_NOMEMORY);
memset(newtable, 0, sizeof(dns_bcentry_t *) * newsize);
for (i = 0; bc->count > 0 && i < bc->size; i++) {
if (bad == NULL) {
isc_buffer_t buffer;
bad = isc_mem_get(bc->mctx, sizeof(*bad) + name->length);
- if (bad == NULL)
- goto cleanup;
bad->type = type;
bad->hashval = hashval;
bad->expire = *expire;
} else
bad->expire = *expire;
- cleanup:
UNLOCK(&bc->lock);
}
if (result != ISC_R_SUCCESS)
return (result);
name = isc_mem_get(byaddr->mctx, sizeof(*name));
- if (name == NULL) {
- dns_rdata_freestruct(&ptr);
- return (ISC_R_NOMEMORY);
- }
dns_name_init(name, NULL);
result = dns_name_dup(&ptr.ptr, byaddr->mctx, name);
dns_rdata_freestruct(&ptr);
isc_event_t *ievent;
byaddr = isc_mem_get(mctx, sizeof(*byaddr));
- if (byaddr == NULL)
- return (ISC_R_NOMEMORY);
byaddr->mctx = NULL;
isc_mem_attach(mctx, &byaddr->mctx);
byaddr->options = options;
byaddr->event = isc_mem_get(mctx, sizeof(*byaddr->event));
- if (byaddr->event == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_byaddr;
- }
ISC_EVENT_INIT(byaddr->event, sizeof(*byaddr->event), 0, NULL,
DNS_EVENT_BYADDRDONE, action, arg, byaddr,
bevent_destroy, mctx);
isc_task_detach(&byaddr->task);
- cleanup_byaddr:
isc_mem_putanddetach(&mctx, byaddr, sizeof(*byaddr));
return (result);
REQUIRE(cachename != NULL);
cache = isc_mem_get(cmctx, sizeof(*cache));
- if (cache == NULL)
- return (ISC_R_NOMEMORY);
cache->mctx = cache->hmctx = NULL;
isc_mem_attach(cmctx, &cache->mctx);
if (cache->db_argc != 0) {
cache->db_argv = isc_mem_get(cmctx,
cache->db_argc * sizeof(char *));
- if (cache->db_argv == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_dbtype;
- }
for (i = 0; i < cache->db_argc; i++)
cache->db_argv[i] = NULL;
if (cache->db_argv != NULL)
isc_mem_put(cmctx, cache->db_argv,
cache->db_argc * sizeof(char *));
-cleanup_dbtype:
isc_mem_free(cmctx, cache->db_type);
cleanup_filelock:
isc_mutex_destroy(&cache->filelock);
REQUIRE(nentryp != NULL && *nentryp == NULL);
nentry = isc_mem_get(mctx, sizeof(dns_catz_entry_t));
- if (nentry == NULL)
- return (ISC_R_NOMEMORY);
dns_name_init(&nentry->name, NULL);
if (domain != NULL) {
REQUIRE(zmm != NULL);
new_zones = isc_mem_get(mctx, sizeof(*new_zones));
- if (new_zones == NULL)
- return (ISC_R_NOMEMORY);
memset(new_zones, 0, sizeof(*new_zones));
isc_mutex_init(&new_zones->lock);
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
new_zone = isc_mem_get(catzs->mctx, sizeof(*new_zone));
- if (new_zone == NULL)
- return (ISC_R_NOMEMORY);
memset(new_zone, 0, sizeof(*new_zone));
/* rdatastr.length < DNS_NAME_MAXTEXT */
keyname = isc_mem_get(mctx, sizeof(dns_name_t));
- if (keyname == NULL)
- return (ISC_R_NOMEMORY);
dns_name_init(keyname, 0);
memmove(keycbuf, rdatastr.data, rdatastr.length);
keycbuf[rdatastr.length] = 0;
return (result);
}
- ipkl->labels[i] = isc_mem_get(mctx, sizeof(dns_name_t));
- if (ipkl->labels[i] == NULL) {
- if (keyname != NULL) {
- dns_name_free(keyname, mctx);
- isc_mem_put(mctx, keyname,
- sizeof(dns_name_t));
- }
- return (ISC_R_NOMEMORY);
- }
+ ipkl->labels[i] = isc_mem_get(mctx,
+ sizeof(dns_name_t));
dns_name_init(ipkl->labels[i], NULL);
result = dns_name_dup(name, mctx, ipkl->labels[i]);
if (result != ISC_R_SUCCESS) {
REQUIRE(clientp != NULL && *clientp == NULL);
client = isc_mem_get(mctx, sizeof(*client));
- if (client == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&client->lock);
REQUIRE(rdatasetp != NULL && *rdatasetp == NULL);
rdataset = isc_mem_get(mctx, sizeof(*rdataset));
- if (rdataset == NULL)
- return (ISC_R_NOMEMORY);
dns_rdataset_init(rdataset);
actx = client->actx;
resarg = isc_mem_get(client->mctx, sizeof(*resarg));
- if (resarg == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&resarg->lock);
actx = client->actx;
reqarg = isc_mem_get(client->mctx, sizeof(*reqarg));
- if (reqarg == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&reqarg->lock);
sa = isc_mem_get(uctx->client->mctx,
sizeof(*sa));
- if (sa == NULL) {
- /*
- * If we fail to get a sockaddr,
- we simply move forward with the
- * addresses we've got so far.
- */
- goto done;
- }
dns_rdata_init(&rdata);
switch (family) {
actx = client->actx;
uarg = isc_mem_get(client->mctx, sizeof(*uarg));
- if (uarg == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&uarg->lock);
*/
uctx = isc_mem_get(client->mctx, sizeof(*uctx));
- if (uctx == NULL) {
- dns_view_detach(&view);
- return (ISC_R_NOMEMORY);
- }
isc_mutex_init(&uctx->lock);
server != NULL;
server = ISC_LIST_NEXT(server, link)) {
sa = isc_mem_get(client->mctx, sizeof(*sa));
- if (sa == NULL)
- goto fail;
sa->type = server->type;
sa->length = server->length;
ISC_LINK_INIT(sa, link);
if (rdataset == NULL) {
updaterec = isc_mem_get(mctx, size);
- if (updaterec == NULL)
- return (ISC_R_NOMEMORY);
rdataset = &updaterec->rdataset;
rdatalist = &updaterec->rdatalist;
rdata = &updaterec->rdata;
dns_name_toregion(name, &r);
length = r.length;
tmp = isc_mem_get(cctx->mctx, length);
- if (tmp == NULL)
- return;
/*
* Copy name data to 'tmp' and make 'r' use 'tmp'.
*/
else {
node = isc_mem_get(cctx->mctx,
sizeof(dns_compressnode_t));
- if (node == NULL)
- break;
}
node->count = cctx->count++;
/*
}
imp = isc_mem_get(mctx, sizeof(dns_dbimplementation_t));
- if (imp == NULL) {
- RWUNLOCK(&implock, isc_rwlocktype_write);
- return (ISC_R_NOMEMORY);
- }
imp->name = name;
imp->create = create;
imp->mctx = NULL;
REQUIRE(fn != NULL);
listener = isc_mem_get(db->mctx, sizeof(dns_dbonupdatelistener_t));
- if (listener == NULL)
- return (ISC_R_NOMEMORY);
listener->onupdate = fn;
listener->onupdate_arg = fn_arg;
REQUIRE(mctx != NULL);
REQUIRE(dbtablep != NULL && *dbtablep == NULL);
- dbtable = (dns_dbtable_t *)isc_mem_get(mctx, sizeof(*dbtable));
- if (dbtable == NULL)
- return (ISC_R_NOMEMORY);
+ dbtable = isc_mem_get(mctx, sizeof(*dbtable));
dbtable->rbt = NULL;
result = dns_rbt_create(mctx, dbdetach, NULL, &dbtable->rbt);
if (length == 0)
return (ISC_R_SUCCESS);
v = isc_mem_get(diff->mctx, length * sizeof(dns_difftuple_t *));
- if (v == NULL)
- return (ISC_R_NOMEMORY);
for (i = 0; i < length; i++) {
p = ISC_LIST_HEAD(diff->tuples);
v[i] = p;
REQUIRE(DNS_DIFF_VALID(diff));
mem = isc_mem_get(diff->mctx, size);
- if (mem == NULL)
- return (ISC_R_NOMEMORY);
for (t = ISC_LIST_HEAD(diff->tuples); t != NULL;
t = ISC_LIST_NEXT(t, link))
isc_mem_put(diff->mctx, mem, size);
size += 1024;
mem = isc_mem_get(diff->mctx, size);
- if (mem == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
goto again;
}
REQUIRE(mgrp != NULL && *mgrp == NULL);
mgr = isc_mem_get(mctx, sizeof(dns_dispatchmgr_t));
- if (mgr == NULL)
- return (ISC_R_NOMEMORY);
mgr->mctx = NULL;
isc_mem_attach(mctx, &mgr->mctx);
v4ports = NULL;
if (nv4ports != 0) {
v4ports = isc_mem_get(mgr->mctx, sizeof(in_port_t) * nv4ports);
- if (v4ports == NULL)
- return (ISC_R_NOMEMORY);
}
v6ports = NULL;
if (nv6ports != 0) {
v6ports = isc_mem_get(mgr->mctx, sizeof(in_port_t) * nv6ports);
- if (v6ports == NULL) {
- if (v4ports != NULL) {
- isc_mem_put(mgr->mctx, v4ports,
- sizeof(in_port_t) *
- isc_portset_nports(v4portset));
- }
- return (ISC_R_NOMEMORY);
- }
}
p = 0;
REQUIRE(qidp != NULL && *qidp == NULL);
qid = isc_mem_get(mgr->mctx, sizeof(*qid));
- if (qid == NULL)
- return (ISC_R_NOMEMORY);
qid->qid_table = isc_mem_get(mgr->mctx,
buckets * sizeof(dns_displist_t));
- if (qid->qid_table == NULL) {
- isc_mem_put(mgr->mctx, qid, sizeof(*qid));
- return (ISC_R_NOMEMORY);
- }
qid->sock_table = NULL;
if (needsocktable) {
- qid->sock_table = isc_mem_get(mgr->mctx, buckets *
- sizeof(dispsocketlist_t));
- if (qid->sock_table == NULL) {
- isc_mem_put(mgr->mctx, qid->qid_table,
- buckets * sizeof(dns_displist_t));
- isc_mem_put(mgr->mctx, qid, sizeof(*qid));
- return (ISC_R_NOMEMORY);
- }
+ qid->sock_table = isc_mem_get(mgr->mctx,
+ buckets * sizeof(dispsocketlist_t));
}
isc_mutex_init(&qid->lock);
}
disp->port_table = isc_mem_get(mgr->mctx,
- sizeof(disp->port_table[0]) *
- DNS_DISPATCH_PORTTABLESIZE);
- if (disp->port_table == NULL) {
- goto deallocate_dispatch;
- }
+ sizeof(disp->port_table[0]) * DNS_DISPATCH_PORTTABLESIZE);
for (i = 0; i < DNS_DISPATCH_PORTTABLESIZE; i++) {
ISC_LIST_INIT(disp->port_table[i]);
}
mgr = source->mgr;
dset = isc_mem_get(mctx, sizeof(dns_dispatchset_t));
- if (dset == NULL)
- return (ISC_R_NOMEMORY);
memset(dset, 0, sizeof(*dset));
isc_mutex_init(&dset->lock);
dset->dispatches = isc_mem_get(mctx, sizeof(dns_dispatch_t *) * n);
- if (dset->dispatches == NULL) {
- result = ISC_R_NOMEMORY;
- goto fail_lock;
- }
isc_mem_attach(mctx, &dset->mctx);
dset->ndisp = n;
if (dset->mctx == mctx)
isc_mem_detach(&dset->mctx);
- fail_lock:
isc_mutex_destroy(&dset->lock);
isc_mem_put(mctx, dset, sizeof(dns_dispatchset_t));
return (result);
/* Allocate memory to hold the DLZ database driver */
db = isc_mem_get(mctx, sizeof(dns_dlzdb_t));
- if (db == NULL) {
- RWUNLOCK(&dlz_implock, isc_rwlocktype_read);
- return (ISC_R_NOMEMORY);
- }
/* Make sure memory region is set to all 0's */
memset(db, 0, sizeof(dns_dlzdb_t));
* we cannot.
*/
dlz_imp = isc_mem_get(mctx, sizeof(dns_dlzimplementation_t));
- if (dlz_imp == NULL) {
- RWUNLOCK(&dlz_implock, isc_rwlocktype_write);
- return (ISC_R_NOMEMORY);
- }
/* Make sure memory region is set to all 0's */
memset(dlz_imp, 0, sizeof(dns_dlzimplementation_t));
}
dns64 = isc_mem_get(mctx, sizeof(dns_dns64_t));
- if (dns64 == NULL)
- return (ISC_R_NOMEMORY);
memset(dns64->bits, 0, sizeof(dns64->bits));
memmove(dns64->bits, prefix->type.in6.s6_addr, prefixlen / 8);
if (suffix != NULL)
rpsdb_t *rpsdb;
rpsdb = isc_mem_get(mctx, sizeof(*rpsdb));
- if (rpsdb == NULL) {
- strlcpy(emsg->c, "no memory", sizeof(emsg->c));
- return (ISC_R_NOMEMORY);
- }
memset(rpsdb, 0, sizeof(*rpsdb));
if (!librpz->rsp_create(emsg, &rpsdb->rsp, NULL,
REQUIRE(node == &rpsdb->origin_node || node == &rpsdb->data_node);
rpsdb_iter = isc_mem_get(rpsdb->common.mctx, sizeof(*rpsdb_iter));
- if (rpsdb_iter == NULL)
- return (ISC_R_NOMEMORY);
memset(rpsdb_iter, 0, sizeof(*rpsdb_iter));
rpsdb_iter->common.magic = DNS_RDATASETITER_MAGIC;
n = dns_rdataset_count(set);
data = isc_mem_get(mctx, n * sizeof(dns_rdata_t));
- if (data == NULL)
- return (ISC_R_NOMEMORY);
dns_rdataset_init(&rdataset);
dns_rdataset_clone(set, &rdataset);
* they're not used in digest_sig().
*/
sig.signature = isc_mem_get(mctx, sig.siglen);
- if (sig.signature == NULL)
- return (ISC_R_NOMEMORY);
ret = isc_buffer_allocate(mctx, &databuf, sigsize + 256 + 18);
if (ret != ISC_R_SUCCESS)
RETERR(dst_key_sigsize(key, &sigsize));
sig.siglen = sigsize;
- sig.signature = (unsigned char *) isc_mem_get(mctx, sig.siglen);
- if (sig.signature == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
+ sig.signature = isc_mem_get(mctx, sig.siglen);
isc_buffer_init(&sigbuf, sig.signature, sig.siglen);
RETERR(dst_context_sign(ctx, &sigbuf));
REQUIRE(dkp != NULL && *dkp == NULL);
dk = isc_mem_get(mctx, sizeof(dns_dnsseckey_t));
- if (dk == NULL)
- return (ISC_R_NOMEMORY);
dk->key = *dstkey;
*dstkey = NULL;
REQUIRE(handlep != NULL && *handlep == NULL);
handle = isc_mem_get(mctx, sizeof(*handle));
- if (handle == NULL)
- CHECK(ISC_R_NOMEMORY);
handle->mode = mode;
handle->mctx = NULL;
REQUIRE(destp != NULL && *destp == NULL);
d = isc_mem_get(mctx, sizeof(*d));
- if (d == NULL)
- return (ISC_R_NOMEMORY);
memset(d, 0, sizeof(*d));
isc_mem_attach(mctx, &d->mctx);
return (DST_R_NULLKEY);
dctx = isc_mem_get(mctx, sizeof(dst_context_t));
- if (dctx == NULL)
- return (ISC_R_NOMEMORY);
memset(dctx, 0, sizeof(*dctx));
dst_key_attach(key, &dctx->key);
isc_mem_attach(mctx, &dctx->mctx);
if (dirname != NULL)
newfilenamelen += strlen(dirname) + 1;
newfilename = isc_mem_get(mctx, newfilenamelen);
- if (newfilename == NULL)
- return (ISC_R_NOMEMORY);
result = addsuffix(newfilename, newfilenamelen,
dirname, filename, ".key");
INSIST(result == ISC_R_SUCCESS);
if (dirname != NULL)
newfilenamelen += strlen(dirname) + 1;
newfilename = isc_mem_get(mctx, newfilenamelen);
- if (newfilename == NULL)
- RETERR(ISC_R_NOMEMORY);
result = addsuffix(newfilename, newfilenamelen,
dirname, filename, ".private");
INSIST(result == ISC_R_SUCCESS);
isc_result_t result;
int i;
- key = (dst_key_t *) isc_mem_get(mctx, sizeof(dst_key_t));
- if (key == NULL)
- return (NULL);
+ key = isc_mem_get(mctx, sizeof(dst_key_t));
memset(key, 0, sizeof(dst_key_t));
key->key_name = isc_mem_get(mctx, sizeof(dns_name_t));
- if (key->key_name == NULL) {
- isc_mem_put(mctx, key, sizeof(dst_key_t));
- return (NULL);
- }
dns_name_init(key->key_name, NULL);
result = dns_name_dup(name, mctx, key->key_name);
priv->elements[n].tag = tag;
- data = (unsigned char *) isc_mem_get(mctx, MAXFIELDSIZE);
- if (data == NULL)
- goto fail;
+ data = isc_mem_get(mctx, MAXFIELDSIZE);
isc_buffer_init(&b, data, MAXFIELDSIZE);
ret = isc_base64_tobuffer(lex, &b, -1);
(void **)&destroy_func));
imp = isc_mem_get(mctx, sizeof(dyndb_implementation_t));
- if (imp == NULL)
- CHECK(ISC_R_NOMEMORY);
imp->mctx = NULL;
isc_mem_attach(mctx, &imp->mctx);
(void **)&destroy_func));
imp = isc_mem_get(mctx, sizeof(dyndb_implementation_t));
- if (imp == NULL)
- CHECK(ISC_R_NOMEMORY);
imp->mctx = NULL;
isc_mem_attach(mctx, &imp->mctx);
REQUIRE(dctxp != NULL && *dctxp == NULL);
dctx = isc_mem_get(mctx, sizeof(*dctx));
- if (dctx == NULL)
- return (ISC_R_NOMEMORY);
memset(dctx, 0, sizeof(*dctx));
if (view != NULL)
mctx = ecdb->common.mctx;
node = isc_mem_get(mctx, sizeof(*node));
- if (node == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&node->lock);
mctx = ecdb->common.mctx;
iterator = isc_mem_get(mctx, sizeof(ecdb_rdatasetiter_t));
- if (iterator == NULL)
- return (ISC_R_NOMEMORY);
iterator->common.magic = DNS_RDATASETITER_MAGIC;
iterator->common.methods = &rdatasetiter_methods;
UNUSED(driverarg);
ecdb = isc_mem_get(mctx, sizeof(*ecdb));
- if (ecdb == NULL)
- return (ISC_R_NOMEMORY);
ecdb->common.attributes = DNS_DBATTR_CACHE;
ecdb->common.rdclass = rdclass;
REQUIRE(fwdtablep != NULL && *fwdtablep == NULL);
fwdtable = isc_mem_get(mctx, sizeof(dns_fwdtable_t));
- if (fwdtable == NULL)
- return (ISC_R_NOMEMORY);
fwdtable->table = NULL;
result = dns_rbt_create(mctx, auto_detach, fwdtable, &fwdtable->table);
REQUIRE(VALID_FWDTABLE(fwdtable));
forwarders = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarders_t));
- if (forwarders == NULL)
- return (ISC_R_NOMEMORY);
ISC_LIST_INIT(forwarders->fwdrs);
for (fwd = ISC_LIST_HEAD(*fwdrs);
fwd = ISC_LIST_NEXT(fwd, link))
{
nfwd = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarder_t));
- if (nfwd == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
*nfwd = *fwd;
ISC_LINK_INIT(nfwd, link);
ISC_LIST_APPEND(forwarders->fwdrs, nfwd, link);
REQUIRE(VALID_FWDTABLE(fwdtable));
forwarders = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarders_t));
- if (forwarders == NULL)
- return (ISC_R_NOMEMORY);
ISC_LIST_INIT(forwarders->fwdrs);
for (sa = ISC_LIST_HEAD(*addrs);
sa = ISC_LIST_NEXT(sa, link))
{
fwd = isc_mem_get(fwdtable->mctx, sizeof(dns_forwarder_t));
- if (fwd == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
fwd->addr = *sa;
fwd->dscp = -1;
ISC_LINK_INIT(fwd, link);
state = (geoip_state_t *) isc_thread_key_getspecific(state_key);
if (state == NULL) {
- state = (geoip_state_t *) isc_mem_get(state_mctx,
- sizeof(geoip_state_t));
+ state = isc_mem_get(state_mctx, sizeof(geoip_state_t));
memset(state, 0, sizeof(*state));
result = isc_thread_key_setspecific(state_key, state);
UNUSED(key);
ctx = isc_mem_get(dctx->mctx, sizeof(dst_gssapi_signverifyctx_t));
- if (ctx == NULL)
- return (ISC_R_NOMEMORY);
ctx->buffer = NULL;
result = isc_buffer_allocate(dctx->mctx, &ctx->buffer,
INITIAL_BUFFER_SIZE);
return (ISC_R_FAILURE);
len = ((gssbuffer.length + 2)/3) * 4;
buf = isc_mem_get(mctx, len);
- if (buf == NULL) {
- gss_release_buffer(&minor, &gssbuffer);
- return (ISC_R_NOMEMORY);
- }
isc_buffer_init(&b, buf, (unsigned int)len);
GBUFFER_TO_REGION(gssbuffer, r);
result = isc_base64_totext(&r, 0, "", &b);
}
hkey = isc_mem_get(key->mctx, sizeof(dst_hmac_key_t));
- if (hkey == NULL) {
- return (ISC_R_NOMEMORY);
- }
memset(hkey->key, 0, sizeof(hkey->key));
if (src->keys[i] != NULL) {
dst->keys[i] = isc_mem_get(mctx,
sizeof(dns_name_t));
- if (dst->keys[i] == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_keys;
- }
dns_name_init(dst->keys[i], NULL);
result = dns_name_dup(src->keys[i], mctx,
dst->keys[i]);
for (i = 0; i < src->count; i++) {
if (src->labels[i] != NULL) {
dst->labels[i] = isc_mem_get(mctx,
- sizeof(dns_name_t));
- if (dst->labels[i] == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_labels;
- }
+ sizeof(dns_name_t));
dns_name_init(dst->labels[i], NULL);
result = dns_name_dup(src->labels[i], mctx,
dst->labels[i]);
return (ISC_R_SUCCESS);
addrs = isc_mem_get(mctx, n * sizeof(isc_sockaddr_t));
- if (addrs == NULL)
- goto nomemory;
dscps = isc_mem_get(mctx, n * sizeof(isc_dscp_t));
- if (dscps == NULL)
- goto nomemory;
keys = isc_mem_get(mctx, n * sizeof(dns_name_t *));
- if (keys == NULL)
- goto nomemory;
labels = isc_mem_get(mctx, n * sizeof(dns_name_t *));
- if (labels == NULL)
- goto nomemory;
if (ipkl->addrs != NULL) {
memmove(addrs, ipkl->addrs,
ipkl->allocated = n;
return (ISC_R_SUCCESS);
-nomemory:
- if (addrs != NULL)
- isc_mem_put(mctx, addrs, n * sizeof(isc_sockaddr_t));
- if (dscps != NULL)
- isc_mem_put(mctx, dscps, n * sizeof(isc_dscp_t));
- if (keys != NULL)
- isc_mem_put(mctx, keys, n * sizeof(dns_name_t *));
- if (labels != NULL)
- isc_mem_put(mctx, labels, n * sizeof(dns_name_t *));
+ isc_mem_put(mctx, addrs, n * sizeof(isc_sockaddr_t));
+ isc_mem_put(mctx, dscps, n * sizeof(isc_dscp_t));
+ isc_mem_put(mctx, keys, n * sizeof(dns_name_t *));
+ isc_mem_put(mctx, labels, n * sizeof(dns_name_t *));
return (ISC_R_NOMEMORY);
}
dns_iptable_t *tab;
tab = isc_mem_get(mctx, sizeof(*tab));
- if (tab == NULL)
- return (ISC_R_NOMEMORY);
tab->mctx = NULL;
isc_mem_attach(mctx, &tab->mctx);
isc_refcount_init(&tab->refcount, 1);
index_size * sizeof(journal_rawpos_t);
mem = isc_mem_get(mctx, size);
- if (mem == NULL) {
- (void)isc_stdio_close(fp);
- (void)isc_file_remove(filename);
- return (ISC_R_NOMEMORY);
- }
memset(mem, 0, size);
memmove(mem, &rawheader, sizeof(rawheader));
INSIST(journalp != NULL && *journalp == NULL);
j = isc_mem_get(mctx, sizeof(*j));
- if (j == NULL)
- return (ISC_R_NOMEMORY);
j->mctx = NULL;
isc_mem_attach(mctx, &j->mctx);
rawbytes = j->header.index_size * sizeof(journal_rawpos_t);
j->rawindex = isc_mem_get(mctx, rawbytes);
- if (j->rawindex == NULL)
- FAIL(ISC_R_NOMEMORY);
CHECK(journal_read(j, j->rawindex, rawbytes));
- j->index = isc_mem_get(mctx, j->header.index_size *
- sizeof(journal_pos_t));
- if (j->index == NULL)
- FAIL(ISC_R_NOMEMORY);
+ j->index = isc_mem_get(mctx,
+ j->header.index_size * sizeof(journal_pos_t));
p = j->rawindex;
for (i = 0; i < j->header.index_size; i++) {
}
mem = isc_mem_get(j->mctx, size);
- if (mem == NULL)
- return (ISC_R_NOMEMORY);
isc_buffer_init(&buffer, mem, size);
if (copy_length < size)
size = copy_length;
buf = isc_mem_get(mctx, size);
- if (buf == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
CHECK(journal_seek(j1, best_guess.offset));
CHECK(journal_seek(j2, indexend));
REQUIRE(keytablep != NULL && *keytablep == NULL);
keytable = isc_mem_get(mctx, sizeof(*keytable));
- if (keytable == NULL) {
- return (ISC_R_NOMEMORY);
- }
keytable->table = NULL;
result = dns_rbt_create(mctx, free_keynode, mctx, &keytable->table);
REQUIRE(target != NULL && *target == NULL);
knode = isc_mem_get(mctx, sizeof(dns_keynode_t));
- if (knode == NULL)
- return (ISC_R_NOMEMORY);
knode->magic = KEYNODE_MAGIC;
knode->managed = false;
isc_result_t result;
name = isc_mem_get(lookup->mctx, sizeof(dns_name_t));
- if (name == NULL) {
- result = ISC_R_NOMEMORY;
- goto fail;
- }
dns_name_init(name, NULL);
result = dns_name_dup(dns_fixedname_name(&lookup->name),
lookup->mctx, name);
if (dns_rdataset_isassociated(&lookup->rdataset)) {
rdataset = isc_mem_get(lookup->mctx, sizeof(dns_rdataset_t));
- if (rdataset == NULL) {
- result = ISC_R_NOMEMORY;
- goto fail;
- }
dns_rdataset_init(rdataset);
dns_rdataset_clone(&lookup->rdataset, rdataset);
}
if (dns_rdataset_isassociated(&lookup->sigrdataset)) {
sigrdataset = isc_mem_get(lookup->mctx,
sizeof(dns_rdataset_t));
- if (sigrdataset == NULL) {
- result = ISC_R_NOMEMORY;
- goto fail;
- }
dns_rdataset_init(sigrdataset);
dns_rdataset_clone(&lookup->sigrdataset, sigrdataset);
}
isc_event_t *ievent;
lookup = isc_mem_get(mctx, sizeof(*lookup));
- if (lookup == NULL)
- return (ISC_R_NOMEMORY);
lookup->mctx = NULL;
isc_mem_attach(mctx, &lookup->mctx);
lookup->options = options;
int i;
ictx = isc_mem_get(mctx, sizeof(*ictx));
- if (ictx == NULL)
- return (ISC_R_NOMEMORY);
for (i = 0; i < NBUFS; i++) {
dns_fixedname_init(&ictx->fixed[i]);
(task != NULL && done != NULL));
lctx = isc_mem_get(mctx, sizeof(*lctx));
- if (lctx == NULL)
- return (ISC_R_NOMEMORY);
lctx->inc = NULL;
result = incctx_create(mctx, origin, &lctx->inc);
* the maximum individual RR data size.
*/
target_mem = isc_mem_get(mctx, target_size);
- if (target_mem == NULL) {
- result = ISC_R_NOMEMORY;
- goto log_and_cleanup;
- }
isc_buffer_init(&target, target_mem, target_size);
target_save = target;
* the maximum individual RR data size.
*/
target_mem = isc_mem_get(mctx, target_size);
- if (target_mem == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
isc_buffer_init(&target, target_mem, target_size);
name = dns_fixedname_initname(&fixed);
newlength = buffer->length * 2;
newmem = isc_mem_get(mctx, newlength);
- if (newmem == NULL)
- return (ISC_R_NOMEMORY);
isc_mem_put(mctx, buffer->base, buffer->length);
isc_buffer_init(buffer, newmem, newlength);
}
newlength = buffer->length * 2;
newmem = isc_mem_get(mctx, newlength);
- if (newmem == NULL)
- return (ISC_R_NOMEMORY);
isc_mem_put(mctx, buffer->base, buffer->length);
isc_buffer_init(buffer, newmem, newlength);
goto restart;
unsigned int options;
dctx = isc_mem_get(mctx, sizeof(*dctx));
- if (dctx == NULL)
- return (ISC_R_NOMEMORY);
dctx->mctx = NULL;
dctx->f = f;
uint32_t rawversion, now32;
bufmem = isc_mem_get(dctx->mctx, initial_buffer_length);
- if (bufmem == NULL)
- return (ISC_R_NOMEMORY);
isc_buffer_init(&buffer, bufmem, initial_buffer_length);
isc_time_t start;
bufmem = isc_mem_get(dctx->mctx, initial_buffer_length);
- if (bufmem == NULL)
- return (ISC_R_NOMEMORY);
isc_buffer_init(&buffer, bufmem, initial_buffer_length);
isc_stdtime_get(&now);
bufmem = isc_mem_get(mctx, initial_buffer_length);
- if (bufmem == NULL)
- return (ISC_R_NOMEMORY);
isc_buffer_init(&buffer, bufmem, initial_buffer_length);
REQUIRE(stylep != NULL && *stylep == NULL);
style = isc_mem_get(mctx, sizeof(*style));
- if (style == NULL)
- return (ISC_R_NOMEMORY);
style->flags = flags;
style->ttl_column = ttl_column;
length = sizeof(dns_msgblock_t) + (sizeof_type * count);
block = isc_mem_get(mctx, length);
- if (block == NULL)
- return (NULL);
block->count = count;
block->remaining = count;
|| intent == DNS_MESSAGE_INTENTRENDER);
m = isc_mem_get(mctx, sizeof(dns_message_t));
- if (m == NULL)
- return (ISC_R_NOMEMORY);
/*
* No allocations until further notice. Just initialize all lists
else {
msg->saved.length = isc_buffer_usedlength(&origsource);
msg->saved.base = isc_mem_get(msg->mctx, msg->saved.length);
- if (msg->saved.base == NULL)
- return (ISC_R_NOMEMORY);
memmove(msg->saved.base, isc_buffer_base(&origsource),
msg->saved.length);
msg->free_saved = 1;
do {
buf = isc_mem_get(mctx, len);
- if (buf == NULL)
- break;
isc_buffer_init(&buffer, buf, len);
result = dns_message_totext(message, style, 0, &buffer);
if (result == ISC_R_NOSPACE) {
MAKE_EMPTY(target);
target->ndata = isc_mem_get(mctx, source->length);
- if (target->ndata == NULL)
- return (ISC_R_NOMEMORY);
memmove(target->ndata, source->ndata, source->length);
MAKE_EMPTY(target);
target->ndata = isc_mem_get(mctx, source->length + source->labels);
- if (target->ndata == NULL)
- return (ISC_R_NOMEMORY);
memmove(target->ndata, source->ndata, source->length);
}
mem = isc_mem_get(thread_key_mctx, sizeof(*mem));
- if (mem == NULL)
- return (ISC_R_NOMEMORY);
*mem = proc;
if (isc_thread_key_setspecific(totext_filter_proc_key, mem) != 0) {
isc_mem_put(thread_key_mctx, mem, sizeof(*mem));
REQUIRE(ntatablep != NULL && *ntatablep == NULL);
ntatable = isc_mem_get(view->mctx, sizeof(*ntatable));
- if (ntatable == NULL)
- return (ISC_R_NOMEMORY);
ntatable->task = NULL;
result = isc_task_create(taskmgr, 0, &ntatable->task);
view = ntatable->view;
nta = isc_mem_get(view->mctx, sizeof(dns_nta_t));
- if (nta == NULL)
- return (ISC_R_NOMEMORY);
nta->ntatable = ntatable;
nta->expiry = 0;
memset(bufs, 0, sizeof(bufs));
for (i = 0; i < 4; i++) {
bufs[i] = isc_mem_get(key->mctx, BN_num_bytes(p));
- if (bufs[i] == NULL) {
- result = ISC_R_NOMEMORY;
- goto fail;
- }
}
i = 0;
priv.nelements = i;
result = dst__privstruct_writefile(key, &priv, directory);
- fail:
+
for (i = 0; i < 4; i++) {
if (bufs[i] == NULL)
break;
DST_RET (ISC_R_FAILURE);
buf = isc_mem_get(key->mctx, BN_num_bytes(privkey));
- if (buf == NULL)
- DST_RET (ISC_R_NOMEMORY);
priv.elements[0].tag = TAG_ECDSA_PRIVATEKEY;
priv.elements[0].length = BN_num_bytes(privkey);
if (key->key_alg == DST_ALG_ED25519) {
len = DNS_KEY_ED25519SIZE;
buf = isc_mem_get(key->mctx, len);
- if (buf == NULL)
- return (ISC_R_NOMEMORY);
priv.elements[0].tag = TAG_EDDSA_PRIVATEKEY;
priv.elements[0].length = len;
ret = priv_ed25519_from_ossl(pkey, buf);
} else {
len = DNS_KEY_ED448SIZE;
buf = isc_mem_get(key->mctx, len);
- if (buf == NULL)
- return (ISC_R_NOMEMORY);
priv.elements[0].tag = TAG_EDDSA_PRIVATEKEY;
priv.elements[0].length = len;
ret = priv_ed448_from_ossl(pkey, buf);
for (i = 0; i < 8; i++) {
bufs[i] = isc_mem_get(key->mctx, BN_num_bytes(n));
- if (bufs[i] == NULL) {
- result = ISC_R_NOMEMORY;
- goto fail;
- }
}
i = 0;
REQUIRE(orderp != NULL && *orderp == NULL);
order = isc_mem_get(mctx, sizeof(*order));
- if (order == NULL)
- return (ISC_R_NOMEMORY);
ISC_LIST_INIT(order->ents);
mode == DNS_RDATASETATTR_CYCLIC);
ent = isc_mem_get(order->mctx, sizeof(*ent));
- if (ent == NULL)
- return (ISC_R_NOMEMORY);
dns_fixedname_init(&ent->name);
RUNTIME_CHECK(dns_name_copy(name, dns_fixedname_name(&ent->name), NULL)
REQUIRE(list != NULL);
l = isc_mem_get(mem, sizeof(*l));
- if (l == NULL)
- return (ISC_R_NOMEMORY);
ISC_LIST_INIT(l->elements);
l->mem = mem;
REQUIRE(peerptr != NULL);
peer = isc_mem_get(mem, sizeof(*peer));
- if (peer == NULL)
- return (ISC_R_NOMEMORY);
peer->magic = DNS_PEER_MAGIC;
peer->address = *addr;
return (result);
name = isc_mem_get(peer->mem, sizeof(dns_name_t));
- if (name == NULL)
- return (ISC_R_NOMEMORY);
dns_name_init(name, NULL);
result = dns_name_dup(dns_fixedname_name(&fname), peer->mem, name);
}
if (transfer_source != NULL) {
peer->transfer_source = isc_mem_get(peer->mem,
- sizeof(*peer->transfer_source));
- if (peer->transfer_source == NULL)
- return (ISC_R_NOMEMORY);
+ sizeof(*peer->transfer_source));
*peer->transfer_source = *transfer_source;
}
}
if (notify_source != NULL) {
peer->notify_source = isc_mem_get(peer->mem,
- sizeof(*peer->notify_source));
- if (peer->notify_source == NULL)
- return (ISC_R_NOMEMORY);
+ sizeof(*peer->notify_source));
*peer->notify_source = *notify_source;
}
}
if (query_source != NULL) {
peer->query_source = isc_mem_get(peer->mem,
- sizeof(*peer->query_source));
- if (peer->query_source == NULL)
- return (ISC_R_NOMEMORY);
+ sizeof(*peer->query_source));
*peer->query_source = *query_source;
}
else
mech.mechanism = CKM_SHA384;
- pk11_ctx = (pk11_context_t *) isc_mem_get(dctx->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(dctx->mctx, sizeof(*pk11_ctx));
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
if (ec->ontoken && (dctx->use == DO_SIGN))
slotid = ec->slot;
INSIST(keyTemplate[5].type == attr->type);
keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[5].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[5].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[5].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[6].type == attr->type);
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[6].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[6].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[5].type == attr->type);
keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[5].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[5].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[5].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[6].type == attr->type);
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[6].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[6].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
#define SETCURVE() \
if (key->key_alg == DST_ALG_ECDSA256) { \
- attr->pValue = isc_mem_get(key->mctx, \
- sizeof(pk11_ecc_prime256v1)); \
- if (attr->pValue == NULL) \
- DST_RET(ISC_R_NOMEMORY); \
+ attr->pValue = isc_mem_get(key->mctx, sizeof(pk11_ecc_prime256v1)); \
+ \
memmove(attr->pValue, \
pk11_ecc_prime256v1, sizeof(pk11_ecc_prime256v1)); \
attr->ulValueLen = sizeof(pk11_ecc_prime256v1); \
} else { \
- attr->pValue = isc_mem_get(key->mctx, \
- sizeof(pk11_ecc_secp384r1)); \
- if (attr->pValue == NULL) \
- DST_RET(ISC_R_NOMEMORY); \
+ attr->pValue = isc_mem_get(key->mctx, sizeof(pk11_ecc_secp384r1)); \
+ \
memmove(attr->pValue, \
pk11_ecc_secp384r1, sizeof(pk11_ecc_secp384r1)); \
attr->ulValueLen = sizeof(pk11_ecc_secp384r1); \
UNUSED(unused);
UNUSED(callback);
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_ECDSA, true, false,
false, NULL, pk11_get_best_token(OP_ECDSA));
if (ret != ISC_R_SUCCESS)
goto err;
- ec = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*ec));
- if (ec == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec = isc_mem_get(key->mctx, sizeof(*ec));
memset(ec, 0, sizeof(*ec));
key->keydata.pkey = ec;
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 3);
- if (ec->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 3);
memset(ec->repr, 0, sizeof(*attr) * 3);
ec->attrcnt = 3;
(pk11_ctx->session, pub, attr, 1),
DST_R_CRYPTOFAILURE);
attr->pValue = isc_mem_get(key->mctx, attr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr->pValue, 0, attr->ulValueLen);
PK11_RET(pkcs_C_GetAttributeValue,
(pk11_ctx->session, pub, attr, 1),
(pk11_ctx->session, priv, attr, 1),
DST_R_CRYPTOFAILURE);
attr->pValue = isc_mem_get(key->mctx, attr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr->pValue, 0, attr->ulValueLen);
PK11_RET(pkcs_C_GetAttributeValue,
(pk11_ctx->session, priv, attr, 1),
if (r.length != len)
return (DST_R_INVALIDPUBLICKEY);
- ec = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*ec));
- if (ec == NULL)
- return (ISC_R_NOMEMORY);
+ ec = isc_mem_get(key->mctx, sizeof(*ec));
memset(ec, 0, sizeof(*ec));
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (ec->repr == NULL)
- goto nomemory;
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
ec->attrcnt = 2;
attr = ec->repr;
attr->type = CKA_EC_PARAMS;
if (key->key_alg == DST_ALG_ECDSA256) {
- attr->pValue =
- isc_mem_get(key->mctx, sizeof(pk11_ecc_prime256v1));
- if (attr->pValue == NULL)
- goto nomemory;
+ attr->pValue = isc_mem_get(key->mctx,
+ sizeof(pk11_ecc_prime256v1));
memmove(attr->pValue,
pk11_ecc_prime256v1, sizeof(pk11_ecc_prime256v1));
attr->ulValueLen = sizeof(pk11_ecc_prime256v1);
} else {
- attr->pValue =
- isc_mem_get(key->mctx, sizeof(pk11_ecc_secp384r1));
- if (attr->pValue == NULL)
- goto nomemory;
+ attr->pValue = isc_mem_get(key->mctx,
+ sizeof(pk11_ecc_secp384r1));
memmove(attr->pValue,
pk11_ecc_secp384r1, sizeof(pk11_ecc_secp384r1));
attr->ulValueLen = sizeof(pk11_ecc_secp384r1);
attr++;
attr->type = CKA_EC_POINT;
attr->pValue = isc_mem_get(key->mctx, len + 3);
- if (attr->pValue == NULL)
- goto nomemory;
((CK_BYTE_PTR) attr->pValue)[0] = TAG_OCTECT_STRING;
((CK_BYTE_PTR) attr->pValue)[1] = len + 1;
((CK_BYTE_PTR) attr->pValue)[2] = UNCOMPRESSED;
attr = pk11_attribute_bytype(ec, CKA_VALUE);
if (attr != NULL) {
buf = isc_mem_get(key->mctx, attr->ulValueLen);
- if (buf == NULL)
- return (ISC_R_NOMEMORY);
priv.elements[i].tag = TAG_ECDSA_PRIVATEKEY;
priv.elements[i].length = (unsigned short) attr->ulValueLen;
memmove(buf, attr->pValue, attr->ulValueLen);
ec->object = CK_INVALID_HANDLE;
ec->ontoken = true;
ec->reqlogon = true;
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (ec->repr == NULL)
- return (ISC_R_NOMEMORY);
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
memset(ec->repr, 0, sizeof(*attr) * 2);
ec->attrcnt = 2;
attr = ec->repr;
pubattr = pk11_attribute_bytype(pubec, CKA_EC_PARAMS);
INSIST(pubattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pubattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pubattr->pValue, pubattr->ulValueLen);
attr->ulValueLen = pubattr->ulValueLen;
attr++;
pubattr = pk11_attribute_bytype(pubec, CKA_EC_POINT);
INSIST(pubattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pubattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pubattr->pValue, pubattr->ulValueLen);
attr->ulValueLen = pubattr->ulValueLen;
if (ret != ISC_R_SUCCESS)
goto err;
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_ECDSA, true, false,
ec->reqlogon, NULL, ec->slot);
if (ret != ISC_R_SUCCESS)
break;
}
}
- ec = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*ec));
- if (ec == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec = isc_mem_get(key->mctx, sizeof(*ec));
memset(ec, 0, sizeof(*ec));
key->keydata.pkey = ec;
return (ret);
}
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 3);
- if (ec->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 3);
memset(ec->repr, 0, sizeof(*attr) * 3);
ec->attrcnt = 3;
pattr = pk11_attribute_bytype(pub->keydata.pkey, CKA_EC_PARAMS);
INSIST(pattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pattr->pValue, pattr->ulValueLen);
attr->ulValueLen = pattr->ulValueLen;
pattr = pk11_attribute_bytype(pub->keydata.pkey, CKA_EC_POINT);
INSIST(pattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pattr->pValue, pattr->ulValueLen);
attr->ulValueLen = pattr->ulValueLen;
attr++;
attr->type = CKA_VALUE;
attr->pValue = isc_mem_get(key->mctx, priv.elements[0].length);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, priv.elements[0].data, priv.elements[0].length);
attr->ulValueLen = priv.elements[0].length;
UNUSED(pin);
- ec = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*ec));
- if (ec == NULL)
- return (ISC_R_NOMEMORY);
+ ec = isc_mem_get(key->mctx, sizeof(*ec));
memset(ec, 0, sizeof(*ec));
ec->object = CK_INVALID_HANDLE;
ec->ontoken = true;
ec->reqlogon = true;
key->keydata.pkey = ec;
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (ec->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
memset(ec->repr, 0, sizeof(*attr) * 2);
ec->attrcnt = 2;
attr = ec->repr;
if (ret != ISC_R_SUCCESS)
goto err;
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_ECDSA, true, false,
ec->reqlogon, NULL, ec->slot);
if (ret != ISC_R_SUCCESS)
DST_R_CRYPTOFAILURE);
for (i = 0; i <= 1; i++) {
attr[i].pValue = isc_mem_get(key->mctx, attr[i].ulValueLen);
- if (attr[i].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr[i].pValue, 0, attr[i].ulValueLen);
}
PK11_RET(pkcs_C_GetAttributeValue,
else
siglen = DNS_SIG_ED448SIZE;
- pk11_ctx = (pk11_context_t *) isc_mem_get(dctx->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(dctx->mctx, sizeof(*pk11_ctx));
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
if (ec->ontoken && (dctx->use == DO_SIGN))
slotid = ec->slot;
INSIST(keyTemplate[5].type == attr->type);
keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[5].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[5].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[5].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[6].type == attr->type);
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[6].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[6].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
key->key_alg == DST_ALG_ED448);
REQUIRE(ec != NULL);
- pk11_ctx = (pk11_context_t *) isc_mem_get(dctx->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(dctx->mctx, sizeof(*pk11_ctx));
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
if (ec->ontoken && (dctx->use == DO_SIGN))
slotid = ec->slot;
INSIST(keyTemplate[5].type == attr->type);
keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[5].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[5].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[5].ulValueLen = attr->ulValueLen;
/* keyTemplate[6].type is CKA_VALUE */
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[6].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[6].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
#define SETCURVE() \
if (key->key_alg == DST_ALG_ED25519) { \
- attr->pValue = isc_mem_get(key->mctx, \
- sizeof(pk11_ecc_ed25519)); \
- if (attr->pValue == NULL) \
- DST_RET(ISC_R_NOMEMORY); \
+ attr->pValue = isc_mem_get(key->mctx, sizeof(pk11_ecc_ed25519)); \
+ \
memmove(attr->pValue, \
pk11_ecc_ed25519, sizeof(pk11_ecc_ed25519)); \
attr->ulValueLen = sizeof(pk11_ecc_ed25519); \
} else { \
- attr->pValue = isc_mem_get(key->mctx, \
- sizeof(pk11_ecc_ed448)); \
- if (attr->pValue == NULL) \
- DST_RET(ISC_R_NOMEMORY); \
+ attr->pValue = isc_mem_get(key->mctx, sizeof(pk11_ecc_ed448)); \
+ \
memmove(attr->pValue, \
pk11_ecc_ed448, sizeof(pk11_ecc_ed448)); \
attr->ulValueLen = sizeof(pk11_ecc_ed448); \
UNUSED(unused);
UNUSED(callback);
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_EC, true, false,
false, NULL, pk11_get_best_token(OP_EC));
if (ret != ISC_R_SUCCESS)
goto err;
- ec = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*ec));
- if (ec == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec = isc_mem_get(key->mctx, sizeof(*ec));
memset(ec, 0, sizeof(*ec));
key->keydata.pkey = ec;
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 3);
- if (ec->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 3);
memset(ec->repr, 0, sizeof(*attr) * 3);
ec->attrcnt = 3;
(pk11_ctx->session, pub, attr, 1),
DST_R_CRYPTOFAILURE);
attr->pValue = isc_mem_get(key->mctx, attr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr->pValue, 0, attr->ulValueLen);
PK11_RET(pkcs_C_GetAttributeValue,
(pk11_ctx->session, pub, attr, 1),
(pk11_ctx->session, priv, attr, 1),
DST_R_CRYPTOFAILURE);
attr->pValue = isc_mem_get(key->mctx, attr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr->pValue, 0, attr->ulValueLen);
PK11_RET(pkcs_C_GetAttributeValue,
(pk11_ctx->session, priv, attr, 1),
if (r.length != len)
return (DST_R_INVALIDPUBLICKEY);
- ec = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*ec));
- if (ec == NULL)
- return (ISC_R_NOMEMORY);
+ ec = isc_mem_get(key->mctx, sizeof(*ec));
memset(ec, 0, sizeof(*ec));
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (ec->repr == NULL)
- goto nomemory;
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
ec->attrcnt = 2;
attr = ec->repr;
attr->type = CKA_EC_PARAMS;
if (key->key_alg == DST_ALG_ED25519) {
- attr->pValue =
- isc_mem_get(key->mctx, sizeof(pk11_ecc_ed25519));
- if (attr->pValue == NULL)
- goto nomemory;
+ attr->pValue = isc_mem_get(key->mctx,
+ sizeof(pk11_ecc_ed25519));
memmove(attr->pValue,
pk11_ecc_ed25519, sizeof(pk11_ecc_ed25519));
attr->ulValueLen = sizeof(pk11_ecc_ed25519);
} else {
- attr->pValue =
- isc_mem_get(key->mctx, sizeof(pk11_ecc_ed448));
- if (attr->pValue == NULL)
- goto nomemory;
+ attr->pValue = isc_mem_get(key->mctx, sizeof(pk11_ecc_ed448));
memmove(attr->pValue,
pk11_ecc_ed448, sizeof(pk11_ecc_ed448));
attr->ulValueLen = sizeof(pk11_ecc_ed448);
attr++;
attr->type = CKA_EC_POINT;
attr->pValue = isc_mem_get(key->mctx, len);
- if (attr->pValue == NULL)
- goto nomemory;
memmove((CK_BYTE_PTR) attr->pValue, r.base, len);
attr->ulValueLen = len;
attr = pk11_attribute_bytype(ec, CKA_VALUE);
if (attr != NULL) {
buf = isc_mem_get(key->mctx, attr->ulValueLen);
- if (buf == NULL)
- return (ISC_R_NOMEMORY);
priv.elements[i].tag = TAG_EDDSA_PRIVATEKEY;
priv.elements[i].length = (unsigned short) attr->ulValueLen;
memmove(buf, attr->pValue, attr->ulValueLen);
ec->object = CK_INVALID_HANDLE;
ec->ontoken = true;
ec->reqlogon = true;
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (ec->repr == NULL)
- return (ISC_R_NOMEMORY);
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
memset(ec->repr, 0, sizeof(*attr) * 2);
ec->attrcnt = 2;
attr = ec->repr;
attr->type = CKA_EC_PARAMS;
pubattr = pk11_attribute_bytype(pubec, CKA_EC_PARAMS);
attr->pValue = isc_mem_get(key->mctx, pubattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pubattr->pValue, pubattr->ulValueLen);
attr->ulValueLen = pubattr->ulValueLen;
attr++;
attr->type = CKA_EC_POINT;
pubattr = pk11_attribute_bytype(pubec, CKA_EC_POINT);
attr->pValue = isc_mem_get(key->mctx, pubattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pubattr->pValue, pubattr->ulValueLen);
attr->ulValueLen = pubattr->ulValueLen;
if (ret != ISC_R_SUCCESS)
goto err;
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_EC, true, false,
ec->reqlogon, NULL, ec->slot);
if (ret != ISC_R_SUCCESS)
break;
}
}
- ec = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*ec));
- if (ec == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec = isc_mem_get(key->mctx, sizeof(*ec));
memset(ec, 0, sizeof(*ec));
key->keydata.pkey = ec;
return (ret);
}
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 3);
- if (ec->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 3);
memset(ec->repr, 0, sizeof(*attr) * 3);
ec->attrcnt = 3;
pattr = pk11_attribute_bytype(pub->keydata.pkey, CKA_EC_PARAMS);
INSIST(pattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pattr->pValue, pattr->ulValueLen);
attr->ulValueLen = pattr->ulValueLen;
pattr = pk11_attribute_bytype(pub->keydata.pkey, CKA_EC_POINT);
INSIST(pattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pattr->pValue, pattr->ulValueLen);
attr->ulValueLen = pattr->ulValueLen;
attr++;
attr->type = CKA_VALUE;
attr->pValue = isc_mem_get(key->mctx, priv.elements[0].length);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, priv.elements[0].data, priv.elements[0].length);
attr->ulValueLen = priv.elements[0].length;
UNUSED(pin);
- ec = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*ec));
- if (ec == NULL)
- return (ISC_R_NOMEMORY);
+ ec = isc_mem_get(key->mctx, sizeof(*ec));
memset(ec, 0, sizeof(*ec));
ec->object = CK_INVALID_HANDLE;
ec->ontoken = true;
ec->reqlogon = true;
key->keydata.pkey = ec;
- ec->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (ec->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ ec->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
memset(ec->repr, 0, sizeof(*attr) * 2);
ec->attrcnt = 2;
attr = ec->repr;
if (ret != ISC_R_SUCCESS)
goto err;
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_EC, true, false,
ec->reqlogon, NULL, ec->slot);
if (ret != ISC_R_SUCCESS)
DST_R_CRYPTOFAILURE);
for (i = 0; i <= 1; i++) {
attr[i].pValue = isc_mem_get(key->mctx, attr[i].ulValueLen);
- if (attr[i].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr[i].pValue, 0, attr[i].ulValueLen);
}
PK11_RET(pkcs_C_GetAttributeValue,
rsa = key->keydata.pkey;
- pk11_ctx = (pk11_context_t *) isc_mem_get(dctx->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(dctx->mctx, sizeof(*pk11_ctx));
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
if (rsa->ontoken)
slotid = rsa->slot;
INSIST(keyTemplate[6].type == attr->type);
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[6].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[6].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[7].type == attr->type);
keyTemplate[7].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[7].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[7].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[7].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[8].type == attr->type);
keyTemplate[8].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[8].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[8].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[8].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[9].type == attr->type);
keyTemplate[9].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[9].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[9].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[9].ulValueLen = attr->ulValueLen;
case CKA_PRIME_2:
INSIST(keyTemplate[10].type == attr->type);
keyTemplate[10].pValue = isc_mem_get(dctx->mctx,
- attr->ulValueLen);
- if (keyTemplate[10].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ attr->ulValueLen);
memmove(keyTemplate[10].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[10].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[11].type == attr->type);
keyTemplate[11].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[11].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[11].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[11].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[12].type == attr->type);
keyTemplate[12].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[12].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[12].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[12].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[13].type == attr->type);
keyTemplate[13].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[13].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[13].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[13].ulValueLen = attr->ulValueLen;
rsa = key->keydata.pkey;
- pk11_ctx = (pk11_context_t *) isc_mem_get(dctx->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(dctx->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_RSA, true, false,
rsa->reqlogon, NULL,
pk11_get_best_token(OP_RSA));
INSIST(keyTemplate[5].type == attr->type);
keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[5].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[5].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[5].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[6].type == attr->type);
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[6].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[6].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
ISC_UNREACHABLE();
}
- pk11_ctx = (pk11_context_t *) isc_mem_get(dctx->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(dctx->mctx, sizeof(*pk11_ctx));
memset(pk11_ctx, 0, sizeof(*pk11_ctx));
if (rsa->ontoken)
slotid = rsa->slot;
INSIST(keyTemplate[6].type == attr->type);
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[6].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[6].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[7].type == attr->type);
keyTemplate[7].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[7].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[7].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[7].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[8].type == attr->type);
keyTemplate[8].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[8].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[8].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[8].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[9].type == attr->type);
keyTemplate[9].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[9].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[9].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[9].ulValueLen = attr->ulValueLen;
case CKA_PRIME_2:
INSIST(keyTemplate[10].type == attr->type);
keyTemplate[10].pValue = isc_mem_get(dctx->mctx,
- attr->ulValueLen);
- if (keyTemplate[10].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ attr->ulValueLen);
memmove(keyTemplate[10].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[10].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[11].type == attr->type);
keyTemplate[11].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[11].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[11].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[11].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[12].type == attr->type);
keyTemplate[12].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[12].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[12].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[12].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[13].type == attr->type);
keyTemplate[13].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[13].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[13].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[13].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[5].type == attr->type);
keyTemplate[5].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[5].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[5].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[5].ulValueLen = attr->ulValueLen;
INSIST(keyTemplate[6].type == attr->type);
keyTemplate[6].pValue = isc_mem_get(dctx->mctx,
attr->ulValueLen);
- if (keyTemplate[6].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(keyTemplate[6].pValue, attr->pValue,
attr->ulValueLen);
keyTemplate[6].ulValueLen = attr->ulValueLen;
ISC_UNREACHABLE();
}
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- return (ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_RSA, true, false,
false, NULL, pk11_get_best_token(OP_RSA));
if (ret != ISC_R_SUCCESS)
&pub, &priv),
DST_R_CRYPTOFAILURE);
- rsa = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*rsa));
- if (rsa == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ rsa = isc_mem_get(key->mctx, sizeof(*rsa));
memset(rsa, 0, sizeof(*rsa));
key->keydata.pkey = rsa;
- rsa->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 8);
- if (rsa->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ rsa->repr = isc_mem_get(key->mctx, sizeof(*attr) * 8);
memset(rsa->repr, 0, sizeof(*attr) * 8);
rsa->attrcnt = 8;
DST_R_CRYPTOFAILURE);
for (i = 0; i <= 1; i++) {
attr[i].pValue = isc_mem_get(key->mctx, attr[i].ulValueLen);
- if (attr[i].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr[i].pValue, 0, attr[i].ulValueLen);
}
PK11_RET(pkcs_C_GetAttributeValue,
DST_R_CRYPTOFAILURE);
for (i = 0; i <= 5; i++) {
attr[i].pValue = isc_mem_get(key->mctx, attr[i].ulValueLen);
- if (attr[i].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr[i].pValue, 0, attr[i].ulValueLen);
}
PK11_RET(pkcs_C_GetAttributeValue,
return (ISC_R_SUCCESS);
length = r.length;
- rsa = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*rsa));
- if (rsa == NULL)
- return (ISC_R_NOMEMORY);
+ rsa = isc_mem_get(key->mctx, sizeof(*rsa));
memset(rsa, 0, sizeof(*rsa));
isc_buffer_forward(data, length);
- rsa->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (rsa->repr == NULL)
- goto nomemory;
+ rsa->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
memset(rsa->repr, 0, sizeof(*attr) * 2);
rsa->attrcnt = 2;
attr = rsa->repr;
attr[0].type = CKA_MODULUS;
attr[0].pValue = isc_mem_get(key->mctx, mod_bytes);
- if (attr[0].pValue == NULL)
- goto nomemory;
memmove(attr[0].pValue, modulus, mod_bytes);
attr[0].ulValueLen = (CK_ULONG) mod_bytes;
attr[1].type = CKA_PUBLIC_EXPONENT;
attr[1].pValue = isc_mem_get(key->mctx, e_bytes);
- if (attr[1].pValue == NULL)
- goto nomemory;
memmove(attr[1].pValue, exponent, e_bytes);
attr[1].ulValueLen = (CK_ULONG) e_bytes;
for (i = 0; i < 10; i++) {
bufs[i] = isc_mem_get(key->mctx, modulus->ulValueLen);
- if (bufs[i] == NULL) {
- result = ISC_R_NOMEMORY;
- goto fail;
- }
memset(bufs[i], 0, modulus->ulValueLen);
}
rsa->object = CK_INVALID_HANDLE;
rsa->ontoken = true;
rsa->reqlogon = true;
- rsa->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (rsa->repr == NULL)
- return (ISC_R_NOMEMORY);
+ rsa->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
memset(rsa->repr, 0, sizeof(*attr) * 2);
rsa->attrcnt = 2;
attr = rsa->repr;
pubattr = pk11_attribute_bytype(pubrsa, CKA_MODULUS);
INSIST(pubattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pubattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pubattr->pValue, pubattr->ulValueLen);
attr->ulValueLen = pubattr->ulValueLen;
attr++;
pubattr = pk11_attribute_bytype(pubrsa, CKA_PUBLIC_EXPONENT);
INSIST(pubattr != NULL);
attr->pValue = isc_mem_get(key->mctx, pubattr->ulValueLen);
- if (attr->pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(attr->pValue, pubattr->pValue, pubattr->ulValueLen);
attr->ulValueLen = pubattr->ulValueLen;
if (ret != ISC_R_SUCCESS)
goto err;
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_RSA, true, false,
rsa->reqlogon, NULL, rsa->slot);
if (ret != ISC_R_SUCCESS)
break;
}
}
- rsa = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*rsa));
- if (rsa == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ rsa = isc_mem_get(key->mctx, sizeof(*rsa));
memset(rsa, 0, sizeof(*rsa));
key->keydata.pkey = rsa;
return (ret);
}
- rsa->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 8);
- if (rsa->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ rsa->repr = isc_mem_get(key->mctx, sizeof(*attr) * 8);
memset(rsa->repr, 0, sizeof(*attr) * 8);
rsa->attrcnt = 8;
attr = rsa->repr;
continue;
default:
bn = isc_mem_get(key->mctx, priv.elements[i].length);
- if (bn == NULL)
- DST_RET(ISC_R_NOMEMORY);
memmove(bn, priv.elements[i].data,
priv.elements[i].length);
}
UNUSED(pin);
- rsa = (pk11_object_t *) isc_mem_get(key->mctx, sizeof(*rsa));
- if (rsa == NULL)
- return (ISC_R_NOMEMORY);
+ rsa = isc_mem_get(key->mctx, sizeof(*rsa));
memset(rsa, 0, sizeof(*rsa));
rsa->object = CK_INVALID_HANDLE;
rsa->ontoken = true;
rsa->reqlogon = true;
key->keydata.pkey = rsa;
- rsa->repr = (CK_ATTRIBUTE *) isc_mem_get(key->mctx, sizeof(*attr) * 2);
- if (rsa->repr == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ rsa->repr = isc_mem_get(key->mctx, sizeof(*attr) * 2);
memset(rsa->repr, 0, sizeof(*attr) * 2);
rsa->attrcnt = 2;
attr = rsa->repr;
if (ret != ISC_R_SUCCESS)
goto err;
- pk11_ctx = (pk11_context_t *) isc_mem_get(key->mctx,
- sizeof(*pk11_ctx));
- if (pk11_ctx == NULL)
- DST_RET(ISC_R_NOMEMORY);
+ pk11_ctx = isc_mem_get(key->mctx, sizeof(*pk11_ctx));
ret = pk11_get_session(pk11_ctx, OP_RSA, true, false,
rsa->reqlogon, NULL, rsa->slot);
if (ret != ISC_R_SUCCESS)
DST_R_CRYPTOFAILURE);
for (i = 0; i <= 1; i++) {
attr[i].pValue = isc_mem_get(key->mctx, attr[i].ulValueLen);
- if (attr[i].pValue == NULL)
- DST_RET(ISC_R_NOMEMORY);
memset(attr[i].pValue, 0, attr[i].ulValueLen);
}
PK11_RET(pkcs_C_GetAttributeValue,
REQUIRE(portlistp != NULL && *portlistp == NULL);
portlist = isc_mem_get(mctx, sizeof(*portlist));
- if (portlist == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&portlist->lock);
isc_refcount_init(&portlist->refcount, 1);
portlist->list = NULL;
unsigned int allocated;
allocated = portlist->allocated + DNS_PL_ALLOCATE;
el = isc_mem_get(portlist->mctx, sizeof(*el) * allocated);
- if (el == NULL) {
- result = ISC_R_NOMEMORY;
- goto unlock;
- }
if (portlist->list != NULL) {
memmove(el, portlist->list,
portlist->allocated * sizeof(*el));
REQUIRE(rbtp != NULL && *rbtp == NULL);
REQUIRE(deleter == NULL ? deleter_arg == NULL : 1);
- rbt = (dns_rbt_t *)isc_mem_get(mctx, sizeof(*rbt));
- if (rbt == NULL)
- return (ISC_R_NOMEMORY);
+ rbt = isc_mem_get(mctx, sizeof(*rbt));
rbt->mctx = NULL;
isc_mem_attach(mctx, &rbt->mctx);
* Allocate space for the node structure, the name, and the offsets.
*/
nodelen = sizeof(dns_rbtnode_t) + region.length + labels + 1;
- node = (dns_rbtnode_t *)isc_mem_get(mctx, nodelen);
- if (node == NULL)
- return (ISC_R_NOMEMORY);
+ node = isc_mem_get(mctx, nodelen);
memset(node, 0, nodelen);
node->is_root = 0;
bytes = (unsigned int)rbt->hashsize * sizeof(dns_rbtnode_t *);
rbt->hashtable = isc_mem_get(rbt->mctx, bytes);
- if (rbt->hashtable == NULL)
- return (ISC_R_NOMEMORY);
-
memset(rbt->hashtable, 0, bytes);
return (ISC_R_SUCCESS);
} while (newcount >= (rbt->hashsize * 3));
rbt->hashtable = isc_mem_get(rbt->mctx,
rbt->hashsize * sizeof(dns_rbtnode_t *));
- if (rbt->hashtable == NULL) {
- rbt->hashtable = oldtable;
- rbt->hashsize = oldsize;
- return;
- }
for (i = 0; i < rbt->hashsize; i++)
rbt->hashtable[i] = NULL;
size_t i;
version = isc_mem_get(mctx, sizeof(*version));
- if (version == NULL)
- return (NULL);
version->serial = serial;
isc_refcount_init(&version->references, references);
version->glue_table_size = RBTDB_GLUE_TABLE_INIT_SIZE;
version->glue_table_nodecount = 0U;
- version->glue_table = (rbtdb_glue_table_node_t **)
- isc_mem_get(mctx, (version->glue_table_size *
- sizeof(*version->glue_table)));
- if (version->glue_table == NULL) {
- isc_rwlock_destroy(&version->glue_rwlock);
- isc_refcount_destroy(&version->references);
- isc_mem_put(mctx, version, sizeof(*version));
- return (NULL);
- }
+ version->glue_table = isc_mem_get(mctx,
+ (version->glue_table_size * sizeof(*version->glue_table)));
version->writer = writer;
version->commit_ok = false;
rdatasetheader_t *h;
h = isc_mem_get(mctx, sizeof(*h));
- if (h == NULL)
- return (NULL);
#if TRACE_HEADER
if (IS_CACHE(rbtdb) && rbtdb->common.rdclass == dns_rdataclass_in)
REQUIRE(VALID_RBTDB(rbtdb));
rbtdbiter = isc_mem_get(rbtdb->common.mctx, sizeof(*rbtdbiter));
- if (rbtdbiter == NULL)
- return (ISC_R_NOMEMORY);
rbtdbiter->common.methods = &dbiterator_methods;
rbtdbiter->common.db = NULL;
REQUIRE(VALID_RBTDB(rbtdb));
iterator = isc_mem_get(rbtdb->common.mctx, sizeof(*iterator));
- if (iterator == NULL)
- return (ISC_R_NOMEMORY);
if ((db->attributes & DNS_DBATTR_CACHE) == 0) {
now = 0;
RUNTIME_CHECK(result == ISC_R_SUCCESS);
noqname = isc_mem_get(mctx, sizeof(*noqname));
- if (noqname == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
dns_name_init(&noqname->name, NULL);
noqname->neg = NULL;
noqname->negsig = NULL;
RUNTIME_CHECK(result == ISC_R_SUCCESS);
closest = isc_mem_get(mctx, sizeof(*closest));
- if (closest == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
dns_name_init(&closest->name, NULL);
closest->neg = NULL;
closest->negsig = NULL;
REQUIRE(VALID_RBTDB(rbtdb));
loadctx = isc_mem_get(rbtdb->common.mctx, sizeof(*loadctx));
- if (loadctx == NULL)
- return (ISC_R_NOMEMORY);
loadctx->rbtdb = rbtdb;
if (IS_CACHE(rbtdb))
UNUSED(driverarg);
rbtdb = isc_mem_get(mctx, sizeof(*rbtdb));
- if (rbtdb == NULL)
- return (ISC_R_NOMEMORY);
/*
* If argv[0] exists, it points to a memory context to use for heap
goto cleanup_tree_lock;
}
INSIST(rbtdb->node_lock_count < (1 << DNS_RBT_LOCKLENGTH));
- rbtdb->node_locks = isc_mem_get(mctx, rbtdb->node_lock_count *
- sizeof(rbtdb_nodelock_t));
- if (rbtdb->node_locks == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_tree_lock;
- }
+ rbtdb->node_locks = isc_mem_get(mctx,
+ rbtdb->node_lock_count * sizeof(rbtdb_nodelock_t));
rbtdb->cachestats = NULL;
rbtdb->gluecachestats = NULL;
result = dns_rdatasetstats_create(mctx, &rbtdb->rrsetstats);
if (result != ISC_R_SUCCESS)
goto cleanup_node_locks;
- rbtdb->rdatasets = isc_mem_get(mctx, rbtdb->node_lock_count *
- sizeof(rdatasetheaderlist_t));
- if (rbtdb->rdatasets == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_rrsetstats;
- }
+ rbtdb->rdatasets = isc_mem_get(mctx,
+ rbtdb->node_lock_count * sizeof(rdatasetheaderlist_t));
for (i = 0; i < (int)rbtdb->node_lock_count; i++)
ISC_LIST_INIT(rbtdb->rdatasets[i]);
} else
/*
* Create the heaps.
*/
- rbtdb->heaps = isc_mem_get(hmctx, rbtdb->node_lock_count *
- sizeof(isc_heap_t *));
- if (rbtdb->heaps == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_rdatasets;
- }
+ rbtdb->heaps = isc_mem_get(hmctx,
+ rbtdb->node_lock_count * sizeof(isc_heap_t *));
for (i = 0; i < (int)rbtdb->node_lock_count; i++)
rbtdb->heaps[i] = NULL;
sooner = IS_CACHE(rbtdb) ? ttl_sooner : resign_sooner;
/*
* Create deadnode lists.
*/
- rbtdb->deadnodes = isc_mem_get(mctx, rbtdb->node_lock_count *
- sizeof(rbtnodelist_t));
- if (rbtdb->deadnodes == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_heaps;
- }
+ rbtdb->deadnodes = isc_mem_get(mctx,
+ rbtdb->node_lock_count * sizeof(rbtnodelist_t));
for (i = 0; i < (int)rbtdb->node_lock_count; i++)
ISC_LIST_INIT(rbtdb->deadnodes[i]);
rbtdb->node_lock_count * sizeof(isc_heap_t *));
}
- cleanup_rdatasets:
if (rbtdb->rdatasets != NULL)
isc_mem_put(mctx, rbtdb->rdatasets, rbtdb->node_lock_count *
sizeof(rdatasetheaderlist_t));
- cleanup_rrsetstats:
if (rbtdb->rrsetstats != NULL)
dns_stats_detach(&rbtdb->rrsetstats);
} while (version->glue_table_nodecount >=
(version->glue_table_size * 3U));
- version->glue_table = (rbtdb_glue_table_node_t **)
- isc_mem_get(version->rbtdb->common.mctx,
- (version->glue_table_size *
- sizeof(*version->glue_table)));
+ version->glue_table = isc_mem_get(version->rbtdb->common.mctx,
+ (version->glue_table_size * sizeof(*version->glue_table)));
if (ISC_UNLIKELY(version->glue_table == NULL)) {
version->glue_table = oldtable;
version->glue_table_size = oldsize;
&rdataset_a, &sigrdataset_a);
if (result == DNS_R_GLUE) {
glue = isc_mem_get(ctx->rbtdb->common.mctx, sizeof(*glue));
- if (glue == NULL) {
- result = ISC_R_NOMEMORY;
- goto out;
- }
gluename = dns_fixedname_initname(&glue->fixedname);
dns_name_copy(name_a, gluename, NULL);
if (glue == NULL) {
glue = isc_mem_get(ctx->rbtdb->common.mctx,
sizeof(*glue));
- if (glue == NULL) {
- result = ISC_R_NOMEMORY;
- goto out;
- }
gluename = dns_fixedname_initname(&glue->fixedname);
dns_name_copy(name_aaaa, gluename, NULL);
result = ISC_R_SUCCESS;
-out:
if (dns_rdataset_isassociated(&rdataset_a))
rdataset_disassociate(&rdataset_a);
if (dns_rdataset_isassociated(&sigrdataset_a))
(void)dns_rdataset_additionaldata(rdataset, glue_nsdname_cb, &ctx);
cur = isc_mem_get(rbtdb->common.mctx, sizeof(*cur));
- if (cur == NULL) {
- result = ISC_R_NOMEMORY;
- goto out;
- }
/*
* XXXMUKS: it looks like the dns_dbversion is not destroyed
rbtversion->glue_table[idx] = cur;
rbtversion->glue_table_nodecount++;
- result = ISC_R_SUCCESS;
-
- out:
RWUNLOCK(&rbtversion->glue_rwlock, isc_rwlocktype_write);
- if (result == ISC_R_SUCCESS) {
- restarted = true;
- goto restart;
- }
+ restarted = true;
+ goto restart;
- return (result);
+ /* UNREACHABLE */
}
/*%
if (rdataset->type != 0)
return (ISC_R_FAILURE);
rawbuf = isc_mem_get(mctx, buflen);
- if (rawbuf == NULL)
- return (ISC_R_NOMEMORY);
region->base = rawbuf;
region->length = buflen;
rawbuf += reservelen;
*/
nalloc = nitems;
x = isc_mem_get(mctx, nalloc * sizeof(struct xrdata));
- if (x == NULL)
- return (ISC_R_NOMEMORY);
/*
* Save all of the rdata members into an array.
* data.
*/
rawbuf = isc_mem_get(mctx, buflen);
- if (rawbuf == NULL) {
- result = ISC_R_NOMEMORY;
- goto free_rdatas;
- }
#if DNS_RDATASET_FIXED
/* Allocate temporary offset table. */
offsettable = isc_mem_get(mctx, nalloc * sizeof(unsigned int));
- if (offsettable == NULL) {
- isc_mem_put(mctx, rawbuf, buflen);
- result = ISC_R_NOMEMORY;
- goto free_rdatas;
- }
memset(offsettable, 0, nalloc * sizeof(unsigned int));
#endif
* Copy the reserved area from the new slab.
*/
tstart = isc_mem_get(mctx, tlength);
- if (tstart == NULL)
- return (ISC_R_NOMEMORY);
memmove(tstart, nslab, reservelen);
tcurrent = tstart + reservelen;
#if DNS_RDATASET_FIXED
offsettable = isc_mem_get(mctx,
(ocount + oncount) * sizeof(unsigned int));
- if (offsettable == NULL) {
- isc_mem_put(mctx, tstart, tlength);
- return (ISC_R_NOMEMORY);
- }
memset(offsettable, 0, (ocount + oncount) * sizeof(unsigned int));
#endif
* Copy the reserved area from the mslab.
*/
tstart = isc_mem_get(mctx, tlength);
- if (tstart == NULL)
- return (ISC_R_NOMEMORY);
memmove(tstart, mslab, reservelen);
tcurrent = tstart + reservelen;
#if DNS_RDATASET_FIXED
offsetbase = tcurrent;
offsettable = isc_mem_get(mctx, mcount * sizeof(unsigned int));
- if (offsettable == NULL) {
- isc_mem_put(mctx, tstart, tlength);
- return (ISC_R_NOMEMORY);
- }
memset(offsettable, 0, mcount * sizeof(unsigned int));
#endif
}
requestmgr = isc_mem_get(mctx, sizeof(*requestmgr));
- if (requestmgr == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&requestmgr->lock);
dns_request_t *request;
request = isc_mem_get(mctx, sizeof(*request));
- if (request == NULL)
- return (ISC_R_NOMEMORY);
/*
* Zero structure.
isc_result_t result;
valarg = isc_mem_get(fctx->mctx, sizeof(*valarg));
- if (valarg == NULL)
- return (ISC_R_NOMEMORY);
valarg->fctx = fctx;
valarg->addrinfo = addrinfo;
if (counter == NULL) {
counter = isc_mem_get(dbucket->mctx, sizeof(fctxcount_t));
- if (counter == NULL)
- result = ISC_R_NOMEMORY;
- else {
+ {
ISC_LINK_INIT(counter, link);
counter->count = 1;
counter->logged = 0;
counter->allowed = 1;
counter->dropped = 0;
- counter->domain =
- dns_fixedname_initname(&counter->fdname);
+ counter->domain = dns_fixedname_initname(&counter->fdname);
dns_name_copy(&fctx->domain, counter->domain, NULL);
ISC_LIST_APPEND(dbucket->list, counter, link);
}
dns_message_reset(fctx->rmessage, DNS_MESSAGE_INTENTPARSE);
query = isc_mem_get(fctx->mctx, sizeof(*query));
- if (query == NULL) {
- result = ISC_R_NOMEMORY;
- goto stop_idle_timer;
- }
query->mctx = fctx->mctx;
query->options = options;
query->attributes = 0;
isc_mem_put(fctx->mctx, query, sizeof(*query));
}
- stop_idle_timer:
RUNTIME_CHECK(fctx_stopidletimer(fctx) == ISC_R_SUCCESS);
return (result);
return;
sa = isc_mem_get(fctx->mctx, sizeof(*sa));
- if (sa == NULL)
- return;
*sa = *address;
ISC_LIST_INITANDAPPEND(fctx->bad_edns, sa, link);
}
tried = isc_mem_get(fctx->mctx, sizeof(*tried));
- if (tried == NULL)
- return;
tried->addr = *address;
tried->count = 1;
}
tried = isc_mem_get(fctx->mctx, sizeof(*tried));
- if (tried == NULL)
- return;
tried->addr = *address;
tried->count = 1;
FCTXTRACE("add_bad");
sa = isc_mem_get(fctx->mctx, sizeof(*sa));
- if (sa == NULL)
- return;
*sa = *address;
ISC_LIST_INITANDAPPEND(fctx->bad, sa, link);
mctx = res->buckets[bucketnum].mctx;
fctx = isc_mem_get(mctx, sizeof(*fctx));
- if (fctx == NULL)
- return (ISC_R_NOMEMORY);
fctx->qc = NULL;
if (qc != NULL) {
/* Allocate buffer for storing hex version of the NSID */
buflen = (uint16_t)nsid_len * 2 + 1;
buf = isc_mem_get(mctx, buflen);
- if (buf == NULL)
- goto cleanup;
pbuf = isc_mem_get(mctx, nsid_len + 1);
- if (pbuf == NULL)
- goto cleanup;
/* Convert to hex */
p = buf;
isc_log_write(dns_lctx, DNS_LOGCATEGORY_NSID,
DNS_LOGMODULE_RESOLVER, level,
"received NSID %s (\"%s\") from %s", buf, pbuf, addrbuf);
- cleanup:
+
if (pbuf != NULL)
isc_mem_put(mctx, pbuf, nsid_len + 1);
if (buf != NULL)
REQUIRE(dispatchv4 != NULL || dispatchv6 != NULL);
res = isc_mem_get(view->mctx, sizeof(*res));
- if (res == NULL)
- return (ISC_R_NOMEMORY);
RTRACE("create");
res->mctx = view->mctx;
res->rdclass = view->rdclass;
isc_stats_set(view->resstats, ntasks,
dns_resstatscounter_buckets);
res->activebuckets = ntasks;
- res->buckets = isc_mem_get(view->mctx,
- ntasks * sizeof(fctxbucket_t));
- if (res->buckets == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_badcache;
- }
+ res->buckets = isc_mem_get(view->mctx, ntasks * sizeof(fctxbucket_t));
for (i = 0; i < ntasks; i++) {
isc_mutex_init(&res->buckets[i].lock);
res->dbuckets = isc_mem_get(view->mctx,
RES_DOMAIN_BUCKETS * sizeof(zonebucket_t));
- if (res->dbuckets == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_buckets;
- }
for (i = 0; i < RES_DOMAIN_BUCKETS; i++) {
ISC_LIST_INIT(res->dbuckets[i].list);
res->dbuckets[i].mctx = NULL;
isc_mem_put(view->mctx, res->buckets,
res->nbuckets * sizeof(fctxbucket_t));
- cleanup_badcache:
dns_badcache_destroy(&res->badcache);
cleanup_res:
*/
RTRACE("priming");
rdataset = isc_mem_get(res->mctx, sizeof(*rdataset));
- if (rdataset == NULL) {
- LOCK(&res->lock);
- INSIST(res->priming);
- INSIST(res->primefetch == NULL);
- res->priming = false;
- UNLOCK(&res->lock);
- return;
- }
dns_rdataset_init(rdataset);
LOCK(&res->primelock);
result = dns_resolver_createfetch(res, dns_rootname,
* XXXRTH use a mempool?
*/
fetch = isc_mem_get(res->mctx, sizeof(*fetch));
- if (fetch == NULL)
- return (ISC_R_NOMEMORY);
fetch->mctx = NULL;
isc_mem_attach(res->mctx, &fetch->mctx);
REQUIRE((alt == NULL) ^ (name == NULL));
a = isc_mem_get(resolver->mctx, sizeof(*a));
- if (a == NULL)
- return (ISC_R_NOMEMORY);
if (alt != NULL) {
a->isaddress = true;
a->_u.addr = *alt;
* into it if one exists.
*/
tmp = isc_mem_get(resolver->mctx, len);
- if (tmp == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
memset(tmp, 0, len);
if (algorithms != NULL)
memmove(tmp, algorithms, *algorithms);
* into it if one exists.
*/
tmp = isc_mem_get(resolver->mctx, len);
- if (tmp == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
memset(tmp, 0, len);
if (digests != NULL)
memmove(tmp, digests, *digests);
int i, words, wlen;
node = isc_mem_get(rpzs->mctx, sizeof(*node));
- if (node == NULL)
- return (NULL);
memset(node, 0, sizeof(*node));
if (child != NULL)
nm_data = nmnode->data;
if (nm_data == NULL) {
nm_data = isc_mem_get(rpzs->mctx, sizeof(*nm_data));
- if (nm_data == NULL)
- return (ISC_R_NOMEMORY);
*nm_data = *new_data;
nmnode->data = nm_data;
return (ISC_R_SUCCESS);
REQUIRE(rpzsp != NULL && *rpzsp == NULL);
zones = isc_mem_get(mctx, sizeof(*zones));
- if (zones == NULL)
- return (ISC_R_NOMEMORY);
memset(zones, 0, sizeof(*zones));
result = isc_rwlock_init(&zones->search_lock, 0, 0);
}
zone = isc_mem_get(rpzs->mctx, sizeof(*zone));
- if (zone == NULL) {
- return (ISC_R_NOMEMORY);
- }
memset(zone, 0, sizeof(*zone));
isc_refcount_init(&zone->refs, 1);
bsize = sizeof(dns_rrl_block_t) + (newsize-1)*sizeof(dns_rrl_entry_t);
b = isc_mem_get(rrl->mctx, bsize);
- if (b == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_FAIL,
- "isc_mem_get(%d) failed for RRL entries",
- bsize);
- return (ISC_R_NOMEMORY);
- }
memset(b, 0, bsize);
b->size = bsize;
hsize = sizeof(dns_rrl_hash_t) + (new_bins-1)*sizeof(hash->bins[0]);
hash = isc_mem_get(rrl->mctx, hsize);
- if (hash == NULL) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST, DNS_RRL_LOG_FAIL,
- "isc_mem_get(%d) failed for"
- " RRL hash table",
- hsize);
- return (ISC_R_NOMEMORY);
- }
memset(hash, 0, hsize);
hash->length = new_bins;
rrl->hash_gen ^= 1;
ISC_LIST_UNLINK(rrl->qname_free, qbuf, link);
} else if (rrl->num_qnames < DNS_RRL_QNAMES) {
qbuf = isc_mem_get(rrl->mctx, sizeof(*qbuf));
- if (qbuf != NULL) {
+ {
memset(qbuf, 0, sizeof(*qbuf));
ISC_LINK_INIT(qbuf, link);
qbuf->index = rrl->num_qnames;
rrl->qnames[rrl->num_qnames++] = qbuf;
- } else {
- isc_log_write(dns_lctx,
- DNS_LOGCATEGORY_RRL,
- DNS_LOGMODULE_REQUEST,
- DNS_RRL_LOG_FAIL,
- "isc_mem_get(%d)"
- " failed for RRL qname",
- (int)sizeof(*qbuf));
}
}
if (qbuf != NULL) {
*rrlp = NULL;
rrl = isc_mem_get(view->mctx, sizeof(*rrl));
- if (rrl == NULL)
- return (ISC_R_NOMEMORY);
memset(rrl, 0, sizeof(*rrl));
isc_mem_attach(view->mctx, &rrl->mctx);
isc_mutex_init(&rrl->lock);
DNS_SDBFLAG_DNS64)) == 0);
imp = isc_mem_get(mctx, sizeof(dns_sdbimplementation_t));
- if (imp == NULL)
- return (ISC_R_NOMEMORY);
imp->methods = methods;
imp->driverdata = driverdata;
imp->flags = flags;
if (rdatalist == NULL) {
rdatalist = isc_mem_get(mctx, sizeof(dns_rdatalist_t));
- if (rdatalist == NULL)
- return (ISC_R_NOMEMORY);
dns_rdatalist_init(rdatalist);
rdatalist->rdclass = lookup->sdb->common.rdclass;
rdatalist->type = typeval;
return (DNS_R_BADTTL);
rdata = isc_mem_get(mctx, sizeof(dns_rdata_t));
- if (rdata == NULL)
- return (ISC_R_NOMEMORY);
result = isc_buffer_allocate(mctx, &rdatabuf, rdlen);
if (result != ISC_R_SUCCESS)
if (size >= 65535)
size = 65535;
p = isc_mem_get(mctx, size);
- if (p == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
isc_buffer_init(&rb, p, size);
result = dns_rdata_fromtext(NULL,
lookup->sdb->common.rdclass,
if (result != ISC_R_SUCCESS)
return (result);
sdbnode->name = isc_mem_get(mctx, sizeof(dns_name_t));
- if (sdbnode->name == NULL) {
- destroynode(sdbnode);
- return (ISC_R_NOMEMORY);
- }
dns_name_init(sdbnode->name, NULL);
result = dns_name_dup(newname, mctx, sdbnode->name);
if (result != ISC_R_SUCCESS) {
dns_sdbnode_t *node;
node = isc_mem_get(sdb->common.mctx, sizeof(dns_sdbnode_t));
- if (node == NULL)
- return (ISC_R_NOMEMORY);
node->sdb = NULL;
attach((dns_db_t *)sdb, (dns_db_t **)&node->sdb);
return (ISC_R_NOTIMPLEMENTED);
sdbiter = isc_mem_get(sdb->common.mctx, sizeof(sdb_dbiterator_t));
- if (sdbiter == NULL)
- return (ISC_R_NOMEMORY);
sdbiter->common.methods = &dbiterator_methods;
sdbiter->common.db = NULL;
UNUSED(now);
iterator = isc_mem_get(db->mctx, sizeof(sdb_rdatasetiter_t));
- if (iterator == NULL)
- return (ISC_R_NOMEMORY);
iterator->common.magic = DNS_RDATASETITER_MAGIC;
iterator->common.methods = &rdatasetiter_methods;
return (ISC_R_NOTIMPLEMENTED);
sdb = isc_mem_get(mctx, sizeof(dns_sdb_t));
- if (sdb == NULL)
- return (ISC_R_NOMEMORY);
memset(sdb, 0, sizeof(dns_sdb_t));
dns_name_init(&sdb->common.origin, NULL);
dns_sdlznode_t *node;
node = isc_mem_get(sdlz->common.mctx, sizeof(dns_sdlznode_t));
- if (node == NULL)
- return (ISC_R_NOMEMORY);
node->sdlz = NULL;
attach((dns_db_t *)sdlz, (dns_db_t **)&node->sdlz);
isc_buffer_putuint8(&b, 0);
sdlziter = isc_mem_get(sdlz->common.mctx, sizeof(sdlz_dbiterator_t));
- if (sdlziter == NULL)
- return (ISC_R_NOMEMORY);
sdlziter->common.methods = &dbiterator_methods;
sdlziter->common.db = NULL;
UNUSED(now);
iterator = isc_mem_get(db->mctx, sizeof(sdlz_rdatasetiter_t));
- if (iterator == NULL)
- return (ISC_R_NOMEMORY);
iterator->common.magic = DNS_RDATASETITER_MAGIC;
iterator->common.methods = &rdatasetiter_methods;
/* allocate and zero memory for driver structure */
sdlzdb = isc_mem_get(mctx, sizeof(dns_sdlz_db_t));
- if (sdlzdb == NULL)
- return (ISC_R_NOMEMORY);
memset(sdlzdb, 0, sizeof(dns_sdlz_db_t));
/* initialize and set origin */
if (rdatalist == NULL) {
rdatalist = isc_mem_get(mctx, sizeof(dns_rdatalist_t));
- if (rdatalist == NULL)
- return (ISC_R_NOMEMORY);
dns_rdatalist_init(rdatalist);
rdatalist->rdclass = lookup->sdlz->common.rdclass;
rdatalist->type = typeval;
}
rdata = isc_mem_get(mctx, sizeof(dns_rdata_t));
- if (rdata == NULL)
- return (ISC_R_NOMEMORY);
dns_rdata_init(rdata);
if ((lookup->sdlz->dlzimp->flags & DNS_SDLZFLAG_RELATIVERDATA) != 0)
* we cannot.
*/
imp = isc_mem_get(mctx, sizeof(dns_sdlzimplementation_t));
- if (imp == NULL)
- return (ISC_R_NOMEMORY);
/* Make sure memory region is set to all 0's */
memset(imp, 0, sizeof(dns_sdlzimplementation_t));
mctx = table->mctx;
rule = isc_mem_get(mctx, sizeof(dns_ssurule_t));
- if (rule == NULL)
- return (ISC_R_NOMEMORY);
rule->identity = NULL;
rule->name = NULL;
rule->grant = grant;
rule->identity = isc_mem_get(mctx, sizeof(dns_name_t));
- if (rule->identity == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
dns_name_init(rule->identity, NULL);
result = dns_name_dup(identity, mctx, rule->identity);
if (result != ISC_R_SUCCESS)
goto failure;
rule->name = isc_mem_get(mctx, sizeof(dns_name_t));
- if (rule->name == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
dns_name_init(rule->name, NULL);
result = dns_name_dup(name, mctx, rule->name);
if (result != ISC_R_SUCCESS)
if (ntypes > 0) {
rule->types = isc_mem_get(mctx,
ntypes * sizeof(dns_rdatatype_t));
- if (rule->types == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
memmove(rule->types, types, ntypes * sizeof(dns_rdatatype_t));
} else
rule->types = NULL;
table->dlzdatabase = dlzdatabase;
rule = isc_mem_get(table->mctx, sizeof(dns_ssurule_t));
- if (rule == NULL) {
- dns_ssutable_detach(&table);
- return (ISC_R_NOMEMORY);
- }
rule->identity = NULL;
rule->name = NULL;
isc_result_t result;
stats = isc_mem_get(mctx, sizeof(*stats));
- if (stats == NULL)
- return (ISC_R_NOMEMORY);
stats->counters = NULL;
isc_refcount_init(&stats->references, 1);
CHECK(dst_context_adddata(tsigctx, &r));
CHECK(dst_key_sigsize(key->key, &sigsize));
- tsig.signature = (unsigned char *) isc_mem_get(dt_mctx, sigsize);
- if (tsig.signature == NULL) {
- CHECK(ISC_R_NOMEMORY);
- }
+ tsig.signature = isc_mem_get(dt_mctx, sigsize);
isc_buffer_init(&sigbuf, tsig.signature, sigsize);
CHECK(dst_context_sign(tsigctx, &sigbuf));
tsig.siglen = isc_buffer_usedlength(&sigbuf);
for (;;) {
output = isc_mem_get(msg->mctx, len);
- if (output == NULL)
- return;
isc_buffer_init(&outbuf, output, len);
result = dns_message_totext(msg, &dns_master_style_debug,
REQUIRE(tctxp != NULL && *tctxp == NULL);
tctx = isc_mem_get(mctx, sizeof(dns_tkeyctx_t));
- if (tctx == NULL)
- return (ISC_R_NOMEMORY);
tctx->mctx = NULL;
isc_mem_attach(mctx, &tctx->mctx);
tctx->dhkey = NULL;
isc_buffer_init(&secret, secretdata, sizeof(secretdata));
randomdata = isc_mem_get(tkeyout->mctx, TKEY_RANDOM_AMOUNT);
- if (randomdata == NULL)
- goto failure;
isc_nonce_buf(randomdata, TKEY_RANDOM_AMOUNT);
if (outtoken) {
tkeyout->key = isc_mem_get(tkeyout->mctx,
isc_buffer_usedlength(outtoken));
- if (tkeyout->key == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
tkeyout->keylen = isc_buffer_usedlength(outtoken);
memmove(tkeyout->key, isc_buffer_base(outtoken),
isc_buffer_usedlength(outtoken));
isc_buffer_free(&outtoken);
} else {
tkeyout->key = isc_mem_get(tkeyout->mctx, tkeyin->keylen);
- if (tkeyout->key == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
tkeyout->keylen = tkeyin->keylen;
memmove(tkeyout->key, tkeyin->key, tkeyin->keylen);
}
REQUIRE(tsecp != NULL && *tsecp == NULL);
tsec = isc_mem_get(mctx, sizeof(*tsec));
- if (tsec == NULL)
- return (ISC_R_NOMEMORY);
tsec->type = type;
tsec->mctx = mctx;
REQUIRE(mctx != NULL);
REQUIRE(key != NULL || ring != NULL);
- tkey = (dns_tsigkey_t *) isc_mem_get(mctx, sizeof(dns_tsigkey_t));
- if (tkey == NULL)
- return (ISC_R_NOMEMORY);
+ tkey = isc_mem_get(mctx, sizeof(dns_tsigkey_t));
dns_name_init(&tkey->name, NULL);
ret = dns_name_dup(name, mctx, &tkey->name);
goto cleanup_name;
}
tmpname = isc_mem_get(mctx, sizeof(dns_name_t));
- if (tmpname == NULL) {
- ret = ISC_R_NOMEMORY;
- goto cleanup_name;
- }
dns_name_init(tmpname, NULL);
ret = dns_name_dup(algorithm, mctx, tmpname);
if (ret != ISC_R_SUCCESS) {
if (creator != NULL) {
tkey->creator = isc_mem_get(mctx, sizeof(dns_name_t));
- if (tkey->creator == NULL) {
- ret = ISC_R_NOMEMORY;
- goto cleanup_algorithm;
- }
dns_name_init(tkey->creator, NULL);
ret = dns_name_dup(creator, mctx, tkey->creator);
if (ret != ISC_R_SUCCESS) {
ret = dst_key_sigsize(key->key, &sigsize);
if (ret != ISC_R_SUCCESS)
goto cleanup_context;
- tsig.signature = (unsigned char *) isc_mem_get(mctx, sigsize);
- if (tsig.signature == NULL) {
- ret = ISC_R_NOMEMORY;
- goto cleanup_context;
- }
+ tsig.signature = isc_mem_get(mctx, sigsize);
isc_buffer_init(&sigbuf, tsig.signature, sigsize);
ret = dst_context_sign(ctx, &sigbuf);
REQUIRE(*ringp == NULL);
ring = isc_mem_get(mctx, sizeof(dns_tsig_keyring_t));
- if (ring == NULL)
- return (ISC_R_NOMEMORY);
result = isc_rwlock_init(&ring->lock, 0, 0);
if (result != ISC_R_SUCCESS) {
state = &mystate;
} else {
state = isc_mem_get(diff->mctx, sizeof(*state));
- if (state == NULL)
- return (ISC_R_NOMEMORY);
}
dns_diff_init(diff->mctx, &state->diffnames);
if (val->siginfo == NULL) {
val->siginfo = isc_mem_get(val->view->mctx,
sizeof(*val->siginfo));
- if (val->siginfo == NULL)
- return (ISC_R_NOMEMORY);
}
result = dns_rdata_tostruct(&rdata, val->siginfo, NULL);
if (result != ISC_R_SUCCESS)
REQUIRE(validatorp != NULL && *validatorp == NULL);
val = isc_mem_get(view->mctx, sizeof(*val));
- if (val == NULL)
- return (ISC_R_NOMEMORY);
val->view = NULL;
dns_view_weakattach(view, &val->view);
REQUIRE(viewp != NULL && *viewp == NULL);
view = isc_mem_get(mctx, sizeof(*view));
- if (view == NULL)
- return (ISC_R_NOMEMORY);
view->nta_file = NULL;
view->mctx = NULL;
if (view->delonly == NULL) {
view->delonly = isc_mem_get(view->mctx,
- sizeof(dns_namelist_t) *
- DNS_VIEW_DELONLYHASH);
- if (view->delonly == NULL)
- return (ISC_R_NOMEMORY);
+ sizeof(dns_namelist_t) * DNS_VIEW_DELONLYHASH);
for (hash = 0; hash < DNS_VIEW_DELONLYHASH; hash++)
ISC_LIST_INIT(view->delonly[hash]);
}
if (item != NULL)
return (ISC_R_SUCCESS);
item = isc_mem_get(view->mctx, sizeof(*item));
- if (item == NULL)
- return (ISC_R_NOMEMORY);
dns_name_init(item, NULL);
result = dns_name_dup(name, view->mctx, item);
if (result == ISC_R_SUCCESS)
if (view->rootexclude == NULL) {
view->rootexclude = isc_mem_get(view->mctx,
- sizeof(dns_namelist_t) *
- DNS_VIEW_DELONLYHASH);
- if (view->rootexclude == NULL)
- return (ISC_R_NOMEMORY);
+ sizeof(dns_namelist_t) * DNS_VIEW_DELONLYHASH);
for (hash = 0; hash < DNS_VIEW_DELONLYHASH; hash++)
ISC_LIST_INIT(view->rootexclude[hash]);
}
if (item != NULL)
return (ISC_R_SUCCESS);
item = isc_mem_get(view->mctx, sizeof(*item));
- if (item == NULL)
- return (ISC_R_NOMEMORY);
dns_name_init(item, NULL);
result = dns_name_dup(name, view->mctx, item);
if (result == ISC_R_SUCCESS)
isc_result_t result;
xfr = isc_mem_get(mctx, sizeof(*xfr));
- if (xfr == NULL)
- return (ISC_R_NOMEMORY);
xfr->mctx = NULL;
isc_mem_attach(mctx, &xfr->mctx);
xfr->refcount = 0;
TIME_NOW(&now);
zone = isc_mem_get(mctx, sizeof(*zone));
- if (zone == NULL) {
- return (ISC_R_NOMEMORY);
- }
zone->mctx = NULL;
isc_mem_attach(mctx, &zone->mctx);
/* Set up a new database argument list. */
argv = isc_mem_get(zone->mctx, dbargc * sizeof(*argv));
- if (argv == NULL) {
- goto nomem;
- }
for (i = 0; i < dbargc; i++) {
argv[i] = NULL;
}
return (ISC_R_ALREADYRUNNING);
}
- asl = isc_mem_get(zone->mctx, sizeof (*asl));
- if (asl == NULL)
- CHECK(ISC_R_NOMEMORY);
+ asl = isc_mem_get(zone->mctx, sizeof(*asl));
asl->zone = NULL;
asl->flags = newonly ? DNS_ZONELOADFLAG_NOSTAT : 0;
return;
inc = isc_mem_get(zone->mctx, sizeof(dns_include_t));
- if (inc == NULL)
- return;
inc->name = isc_mem_strdup(zone->mctx, filename);
if (inc->name == NULL) {
isc_mem_put(zone->mctx, inc, sizeof(dns_include_t));
if (zone->zmgr != NULL && zone->db != NULL && zone->loadtask != NULL) {
load = isc_mem_get(zone->mctx, sizeof(*load));
- if (load == NULL)
- return (ISC_R_NOMEMORY);
load->mctx = NULL;
load->zone = NULL;
* separate zone_nsec3chain() calls.
*/
nsec3chain = isc_mem_get(zone->mctx, sizeof *nsec3chain);
- if (nsec3chain == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
nsec3chain->magic = 0;
nsec3chain->done = false;
REQUIRE(newnamesp != NULL && *newnamesp == NULL);
newaddrs = isc_mem_get(mctx, count * sizeof(*newaddrs));
- if (newaddrs == NULL)
- return (ISC_R_NOMEMORY);
memmove(newaddrs, addrs, count * sizeof(*newaddrs));
if (dscp != NULL) {
newdscp = isc_mem_get(mctx, count * sizeof(*newdscp));
- if (newdscp == NULL) {
- isc_mem_put(mctx, newaddrs, count * sizeof(*newaddrs));
- return (ISC_R_NOMEMORY);
- }
memmove(newdscp, dscp, count * sizeof(*newdscp));
} else
newdscp = NULL;
if (names != NULL) {
newnames = isc_mem_get(mctx, count * sizeof(*newnames));
- if (newnames == NULL) {
- if (newdscp != NULL)
- isc_mem_put(mctx, newdscp,
- count * sizeof(*newdscp));
- isc_mem_put(mctx, newaddrs, count * sizeof(*newaddrs));
- return (ISC_R_NOMEMORY);
- }
for (i = 0; i < count; i++)
newnames[i] = NULL;
for (i = 0; i < count; i++) {
if (names[i] != NULL) {
newnames[i] = isc_mem_get(mctx,
- sizeof(dns_name_t));
- if (newnames[i] == NULL)
- goto allocfail;
+ sizeof(dns_name_t));
dns_name_init(newnames[i], NULL);
result = dns_name_dup(names[i], mctx,
newnames[i]);
if (result != ISC_R_SUCCESS) {
- allocfail:
for (i = 0; i < count; i++)
if (newnames[i] != NULL)
dns_name_free(
* mastersok must contain count elements
*/
newok = isc_mem_get(zone->mctx, count * sizeof(*newok));
- if (newok == NULL) {
- result = ISC_R_NOMEMORY;
- isc_mem_put(zone->mctx, newaddrs, count * sizeof(*newaddrs));
- goto unlock;
- };
+ ;
for (i = 0; i < count; i++)
newok[i] = false;
}
kfetch = isc_mem_get(zone->mctx, sizeof(dns_keyfetch_t));
- if (kfetch == NULL) {
- fetch_err = true;
- goto failure;
- }
zone->refreshkeycount++;
kfetch->zone = zone;
REQUIRE(notifyp != NULL && *notifyp == NULL);
notify = isc_mem_get(mctx, sizeof(*notify));
- if (notify == NULL)
- return (ISC_R_NOMEMORY);
notify->mctx = NULL;
isc_mem_attach(mctx, ¬ify->mctx);
if (stub == NULL) {
stub = isc_mem_get(zone->mctx, sizeof(*stub));
- if (stub == NULL)
- goto cleanup;
stub->magic = STUB_MAGIC;
stub->mctx = zone->mctx;
stub->zone = NULL;
DNS_LOGMODULE_ZONE, ISC_LOG_DEBUG(3),
"looping through nsec3param data");
nsec3param = isc_mem_get(zone->mctx, sizeof(nsec3param_t));
- if (nsec3param == NULL)
- CHECK(ISC_R_NOMEMORY);
ISC_LINK_INIT(nsec3param, link);
/*
}
nsec3param = isc_mem_get(zone->mctx, sizeof(nsec3param_t));
- if (nsec3param == NULL)
- CHECK(ISC_R_NOMEMORY);
ISC_LINK_INIT(nsec3param, link);
/*
REQUIRE(callback != NULL);
forward = isc_mem_get(zone->mctx, sizeof(*forward));
- if (forward == NULL)
- return (ISC_R_NOMEMORY);
forward->request = NULL;
forward->zone = NULL;
isc_result_t result;
zmgr = isc_mem_get(mctx, sizeof(*zmgr));
- if (zmgr == NULL)
- return (ISC_R_NOMEMORY);
zmgr->mctx = NULL;
zmgr->refs = 1;
isc_mem_attach(mctx, &zmgr->mctx);
REQUIRE(iop != NULL && *iop == NULL);
io = isc_mem_get(zmgr->mctx, sizeof(*io));
- if (io == NULL)
- return (ISC_R_NOMEMORY);
io->event = isc_event_allocate(zmgr->mctx, task, DNS_EVENT_IOREADY,
action, arg, sizeof(*io->event));
buflen = strlen(path) + strlen(templat) + 2;
buf = isc_mem_get(zone->mctx, buflen);
- if (buf == NULL)
- return;
result = isc_file_template(path, templat, buf, buflen);
if (result != ISC_R_SUCCESS)
dns_db_t *db = NULL;
signing = isc_mem_get(zone->mctx, sizeof *signing);
- if (signing == NULL)
- return (ISC_R_NOMEMORY);
signing->magic = 0;
signing->db = NULL;
len = sizeof(*element) + nsec3->next_length * 2 + nsec3->salt_length;
element = isc_mem_get(vctx->mctx, len);
- if (element == NULL) {
- return (ISC_R_NOMEMORY);
- }
memset(element, 0, len);
element->hash = nsec3->hash;
element->salt_length = nsec3->salt_length;
REQUIRE(ztp != NULL && *ztp == NULL);
zt = isc_mem_get(mctx, sizeof(*zt));
- if (zt == NULL)
- return (ISC_R_NOMEMORY);
zt->table = NULL;
result = dns_rbt_create(mctx, auto_detach, zt, &zt->table);
REQUIRE(VALID_ZT(zt));
zt->loadparams = isc_mem_get(zt->mctx, sizeof(struct zt_load_params));
- if (zt->loadparams == NULL) {
- return (ISC_R_NOMEMORY);
- }
zt->loadparams->dl = doneloading;
zt->loadparams->newonly = newonly;
}
context = isc_mem_get(mctx, sizeof(*context));
- if (context == NULL) {
- ctxs_destroy(&mctx, &actx, &taskmgr, &socketmgr, &timermgr);
- return (ISC_R_NOMEMORY);
- }
context->mctx = mctx;
context->actx = actx;
return (result);
}
keyname = isc_mem_get(mctx, sizeof(*keyname));
- if (keyname == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
dns_name_init(keyname, NULL);
result = dns_name_dup(keyname_base, mctx, keyname);
if (result != ISC_R_SUCCESS) {
/* Add the key data to the list */
keyent = isc_mem_get(mctx, sizeof(*keyent));
- if (keyent == NULL) {
- dns_name_free(keyname, mctx);
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
keyent->keyname = keyname;
keyent->keydatabuf = keydatabuf;
REQUIRE(confp != NULL && *confp == NULL);
conf = isc_mem_get(mctx, sizeof(*conf));
- if (conf == NULL)
- return (ISC_R_NOMEMORY);
conf->mctx = mctx;
ISC_LIST_INIT(conf->trusted_keylist);
bool need_v6 = false;
state = isc_mem_get(mctx, sizeof(*state));
- if (state == NULL)
- return (ISC_R_NOMEMORY);
/* Construct base domain name */
namelen = strlen(domain);
state->trans4 = NULL;
if (need_v4) {
state->trans4 = isc_mem_get(mctx, sizeof(gai_restrans_t));
- if (state->trans4 == NULL) {
- isc_mem_put(mctx, state, sizeof(*state));
- return (ISC_R_NOMEMORY);
- }
state->trans4->error = 0;
state->trans4->xid = NULL;
state->trans4->resstate = state;
}
if (need_v6) {
state->trans6 = isc_mem_get(mctx, sizeof(gai_restrans_t));
- if (state->trans6 == NULL) {
- if (state->trans4 != NULL)
- isc_mem_put(mctx, state->trans4,
- sizeof(*state->trans4));
- isc_mem_put(mctx, state, sizeof(*state));
- return (ISC_R_NOMEMORY);
- }
state->trans6->error = 0;
state->trans6->xid = NULL;
state->trans6->resstate = state;
}
address = isc_mem_get(mctx, sizeof(*address));
- if (address == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
if (res->ai_addrlen > sizeof(address->type)) {
isc_mem_put(mctx, address, sizeof(*address));
result = ISC_R_RANGE;
irs_resconf_search_t *entry;
entry = isc_mem_get(conf->mctx, sizeof(*entry));
- if (entry == NULL)
- return (ISC_R_NOMEMORY);
entry->domain = domain;
ISC_LINK_INIT(entry, link);
REQUIRE(confp != NULL && *confp == NULL);
conf = isc_mem_get(mctx, sizeof(*conf));
- if (conf == NULL)
- return (ISC_R_NOMEMORY);
conf->mctx = mctx;
ISC_LIST_INIT(conf->nameservers);
REQUIRE(*dynbuffer == NULL);
dbuf = isc_mem_get(mctx, sizeof(isc_buffer_t));
- if (dbuf == NULL)
- return (ISC_R_NOMEMORY);
bdata = isc_mem_get(mctx, length);
- if (bdata == NULL) {
- isc_mem_put(mctx, dbuf, sizeof(isc_buffer_t));
- return (ISC_R_NOMEMORY);
- }
isc_buffer_init(dbuf, bdata, length);
dbuf->mctx = mctx;
* it doesn't remap pages, but does ordinary copy. So is
* isc_mem_reallocate(), which has additional issues.
*/
- bdata = isc_mem_get((*dynbuffer)->mctx, (unsigned int) len);
- if (bdata == NULL) {
- return (ISC_R_NOMEMORY);
- }
+ bdata = isc_mem_get((*dynbuffer)->mctx, (unsigned int)len);
memmove(bdata, (*dynbuffer)->base, (*dynbuffer)->length);
isc_mem_put((*dynbuffer)->mctx, (*dynbuffer)->base,
/* We have reached the end of the string. */
*argcp = n;
*argvp = isc_mem_get(mctx, n * sizeof(char *));
- if (*argvp == NULL)
- return (ISC_R_NOMEMORY);
} else {
char *p = s;
while (*p != ' ' && *p != '\t' && *p != '\0' && *p != '{') {
REQUIRE(counterp != NULL && *counterp == NULL);
counter = isc_mem_get(mctx, sizeof(*counter));
- if (counter == NULL)
- return (ISC_R_NOMEMORY);
counter->mctx = NULL;
isc_mem_attach(mctx, &counter->mctx);
REQUIRE(action != NULL);
event = isc_mem_get(mctx, size);
- if (event == NULL)
- return (NULL);
ISC_EVENT_INIT(event, size, 0, NULL, type, action, arg,
sender, destroy, mctx);
REQUIRE(action != NULL);
event = isc_mem_get(mctx, size);
- if (event == NULL)
- return (NULL);
/*
* Removing the const attribute from "arg" is the best of two
REQUIRE(compare != NULL);
heap = isc_mem_get(mctx, sizeof(*heap));
- if (heap == NULL)
- return (ISC_R_NOMEMORY);
heap->magic = HEAP_MAGIC;
heap->size = 0;
heap->mctx = NULL;
new_size = heap->size + heap->size_increment;
new_array = isc_mem_get(heap->mctx, new_size * sizeof(void *));
- if (new_array == NULL)
- return (false);
if (heap->array != NULL) {
memmove(new_array, heap->array, heap->size * sizeof(void *));
isc_mem_put(heap->mctx, heap->array,
REQUIRE(bits >= 1 && bits <= (sizeof(size_t)*8 - 1));
ht = isc_mem_get(mctx, sizeof(struct isc_ht));
- if (ht == NULL) {
- return (ISC_R_NOMEMORY);
- }
ht->mctx = NULL;
isc_mem_attach(mctx, &ht->mctx);
ht->mask = ((size_t)1<<bits)-1;
ht->count = 0;
- ht->table = isc_mem_get(ht->mctx, ht->size * sizeof(isc_ht_node_t*));
- if (ht->table == NULL) {
- isc_mem_putanddetach(&ht->mctx, ht, sizeof(struct isc_ht));
- return (ISC_R_NOMEMORY);
- }
+ ht->table = isc_mem_get(ht->mctx, ht->size * sizeof(isc_ht_node_t *));
for (i = 0; i < ht->size; i++) {
ht->table[i] = NULL;
}
node = isc_mem_get(ht->mctx, offsetof(isc_ht_node_t, key) + keysize);
- if (node == NULL)
- return (ISC_R_NOMEMORY);
memmove(node->key, key, keysize);
node->keysize = keysize;
REQUIRE(itp != NULL && *itp == NULL);
it = isc_mem_get(ht->mctx, sizeof(isc_ht_iter_t));
- if (it == NULL)
- return (ISC_R_NOMEMORY);
it->ht = ht;
it->i = 0;
REQUIRE(httpdmgrp != NULL && *httpdmgrp == NULL);
httpdmgr = isc_mem_get(mctx, sizeof(isc_httpdmgr_t));
- if (httpdmgr == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&httpdmgr->lock);
httpdmgr->mctx = NULL;
}
httpd = isc_mem_get(httpdmgr->mctx, sizeof(isc_httpd_t));
- if (httpd == NULL) {
- /* XXXMLG log failure */
- NOTICE("accept failed to allocate memory, goto requeue");
- isc_socket_detach(&nev->newsocket);
- goto requeue;
- }
httpd->mgr = httpdmgr;
ISC_LINK_INIT(httpd, link);
* Initialize the buffer for our headers.
*/
headerdata = isc_mem_get(httpdmgr->mctx, HTTP_SENDGROW);
- if (headerdata == NULL) {
- isc_mem_put(httpdmgr->mctx, httpd, sizeof(isc_httpd_t));
- isc_socket_detach(&nev->newsocket);
- goto requeue;
- }
isc_buffer_init(&httpd->headerbuffer, headerdata, HTTP_SENDGROW);
isc_buffer_initnull(&httpd->compbuffer);
}
newspace = isc_mem_get(httpd->mgr->mctx, size);
- if (newspace == NULL)
- return (ISC_R_NOMEMORY);
isc_buffer_reinit(&httpd->compbuffer, newspace, size);
if (r.base != NULL) {
return (ISC_R_NOSPACE);
newspace = isc_mem_get(httpd->mgr->mctx, newlen);
- if (newspace == NULL)
- return (ISC_R_NOMEMORY);
isc_buffer_reinit(&httpd->headerbuffer, newspace, newlen);
}
item = isc_mem_get(httpdmgr->mctx, sizeof(isc_httpdurl_t));
- if (item == NULL)
- return (ISC_R_NOMEMORY);
item->url = isc_mem_strdup(httpdmgr->mctx, url);
if (item->url == NULL) {
char *tmp;
tmp = isc_mem_get(lex->mctx, lex->max_token * 2 + 1);
- if (tmp == NULL)
- return (ISC_R_NOMEMORY);
memmove(tmp, lex->data, lex->max_token + 1);
*currp = tmp + (*currp - lex->data);
if (*prevp != NULL)
max_token = 1;
lex = isc_mem_get(mctx, sizeof(*lex));
- if (lex == NULL)
- return (ISC_R_NOMEMORY);
lex->data = isc_mem_get(mctx, max_token + 1);
- if (lex->data == NULL) {
- isc_mem_put(mctx, lex, sizeof(*lex));
- return (ISC_R_NOMEMORY);
- }
lex->mctx = mctx;
lex->max_token = max_token;
lex->comments = 0;
isc_result_t result;
source = isc_mem_get(lex->mctx, sizeof(*source));
- if (source == NULL)
- return (ISC_R_NOMEMORY);
source->result = ISC_R_SUCCESS;
source->is_file = is_file;
source->need_close = need_close;
lcfg = isc_mem_get(lctx->mctx, sizeof(*lcfg));
- if (lcfg != NULL) {
+ {
lcfg->lctx = lctx;
lcfg->channellists = NULL;
lcfg->channellist_count = 0;
lcfg->highest_level = level;
lcfg->tag = NULL;
lcfg->dynamic = false;
-
ISC_LIST_INIT(lcfg->channels);
-
- /*
- * Normally the magic number is the last thing set in the
- * structure, but isc_log_createchannel() needs a valid
- * config. If the channel creation fails, the lcfg is not
- * returned to the caller.
- */
lcfg->magic = LCFG_MAGIC;
-
- } else
- result = ISC_R_NOMEMORY;
+ }
/*
* Create the default channels:
mctx = lcfg->lctx->mctx;
channel = isc_mem_get(mctx, sizeof(*channel));
- if (channel == NULL)
- return (ISC_R_NOMEMORY);
channel->name = isc_mem_strdup(mctx, name);
if (channel->name == NULL) {
return (result);
new_item = isc_mem_get(lctx->mctx, sizeof(*new_item));
- if (new_item == NULL)
- return (ISC_R_NOMEMORY);
new_item->channel = channel;
new_item->module = module;
lists = isc_mem_get(lctx->mctx, bytes);
- if (lists == NULL)
- return (ISC_R_NOMEMORY);
-
memset(lists, 0, bytes);
if (lcfg->channellist_count != 0) {
size = sizeof(isc_logmessage_t) +
strlen(lctx->buffer) + 1;
message = isc_mem_get(lctx->mctx, size);
- if (message != NULL) {
- /*
- * Put the text immediately after
- * the struct. The strcpy is safe.
- */
+ {
message->text = (char *)(message + 1);
size -= sizeof(isc_logmessage_t);
strlcpy(message->text, lctx->buffer,
size);
-
TIME_NOW(&message->time);
-
ISC_LINK_INIT(message, link);
ISC_LIST_APPEND(lctx->messages,
message, link);
CK_BYTE cnt = obj->attrcnt;
obj->repr = isc_mem_get(mctx, (cnt + 1) * sizeof(*attr));
- if (obj->repr == NULL) {
- obj->repr = old;
- return (NULL);
- }
memset(obj->repr, 0, (cnt + 1) * sizeof(*attr));
memmove(obj->repr, old, cnt * sizeof(*attr));
attr = obj->repr + cnt;
attr->ulValueLen = (CK_ULONG) len;
attr->pValue = isc_mem_get(mctx, len);
- if (attr->pValue == NULL) {
- memset(obj->repr, 0, (cnt + 1) * sizeof(*attr));
- isc_mem_put(mctx, obj->repr, (cnt + 1) * sizeof(*attr));
- obj->repr = old;
- return (NULL);
- }
memset(attr->pValue, 0, len);
if (old != NULL) {
memset(old, 0, cnt * sizeof(*attr));
/* get values to work on */
len = strlen(label) + 1;
uri = isc_mem_get(mctx, len);
- if (uri == NULL)
- return (ISC_R_NOMEMORY);
memmove(uri, label, len);
/* get the URI scheme */
isc_pool_t *pool;
pool = isc_mem_get(mctx, sizeof(*pool));
- if (pool == NULL)
- return (ISC_R_NOMEMORY);
pool->count = count;
pool->free = NULL;
pool->init = NULL;
pool->mctx = NULL;
isc_mem_attach(mctx, &pool->mctx);
pool->pool = isc_mem_get(mctx, count * sizeof(void *));
- if (pool->pool == NULL) {
- isc_mem_put(mctx, pool, sizeof(*pool));
- return (ISC_R_NOMEMORY);
- }
memset(pool->pool, 0, count * sizeof(void *));
*poolp = pool;
REQUIRE(portsetp != NULL && *portsetp == NULL);
portset = isc_mem_get(mctx, sizeof(*portset));
- if (portset == NULL)
- return (ISC_R_NOMEMORY);
/* Make the set 'empty' by default */
memset(portset, 0, sizeof(*portset));
return (ISC_R_NOTIMPLEMENTED);
prefix = isc_mem_get(mctx, sizeof(isc_prefix_t));
- if (prefix == NULL)
- return (ISC_R_NOMEMORY);
if (family == AF_INET6) {
prefix->bitlen = (bitlen >= 0) ? bitlen : 128;
REQUIRE(target != NULL && *target == NULL);
radix = isc_mem_get(mctx, sizeof(isc_radix_tree_t));
- if (radix == NULL)
- return (ISC_R_NOMEMORY);
radix->mctx = NULL;
isc_mem_attach(mctx, &radix->mctx);
if (radix->head == NULL) {
node = isc_mem_get(radix->mctx, sizeof(isc_radix_node_t));
- if (node == NULL)
- return (ISC_R_NOMEMORY);
node->bit = bitlen;
for (i = 0; i < RADIX_FAMILIES; i++) {
node->node_num[i] = -1;
}
new_node = isc_mem_get(radix->mctx, sizeof(isc_radix_node_t));
- if (new_node == NULL)
- return (ISC_R_NOMEMORY);
if (node->bit != differ_bit && bitlen != differ_bit) {
glue = isc_mem_get(radix->mctx, sizeof(isc_radix_node_t));
- if (glue == NULL) {
- isc_mem_put(radix->mctx, new_node,
- sizeof(isc_radix_node_t));
- return (ISC_R_NOMEMORY);
- }
}
new_node->bit = bitlen;
new_node->prefix = NULL;
INSIST(ratelimiterp != NULL && *ratelimiterp == NULL);
rl = isc_mem_get(mctx, sizeof(*rl));
- if (rl == NULL)
- return ISC_R_NOMEMORY;
rl->mctx = mctx;
rl->refs = 1;
rl->task = task;
REQUIRE(symtabp != NULL && *symtabp == NULL);
REQUIRE(size > 0); /* Should be prime. */
- symtab = (isc_symtab_t *)isc_mem_get(mctx, sizeof(*symtab));
- if (symtab == NULL)
- return (ISC_R_NOMEMORY);
+ symtab = isc_mem_get(mctx, sizeof(*symtab));
symtab->mctx = NULL;
isc_mem_attach(mctx, &symtab->mctx);
- symtab->table = (eltlist_t *)isc_mem_get(mctx,
- size * sizeof(eltlist_t));
- if (symtab->table == NULL) {
- isc_mem_putanddetach(&symtab->mctx, symtab, sizeof(*symtab));
- return (ISC_R_NOMEMORY);
- }
+ symtab->table = isc_mem_get(mctx, size * sizeof(eltlist_t));
for (i = 0; i < size; i++)
INIT_LIST(symtab->table[i]);
symtab->size = size;
INSIST(newsize > 0U && newmax > 0U);
newtable = isc_mem_get(symtab->mctx, newsize * sizeof(eltlist_t));
- if (newtable == NULL)
- return;
for (i = 0; i < newsize; i++)
INIT_LIST(newtable[i]);
elt->value,
symtab->undefine_arg);
} else {
- elt = (elt_t *)isc_mem_get(symtab->mctx, sizeof(*elt));
- if (elt == NULL)
- return (ISC_R_NOMEMORY);
+ elt = isc_mem_get(symtab->mctx, sizeof(*elt));
ISC_LINK_INIT(elt, link);
symtab->count++;
}
REQUIRE(taskp != NULL && *taskp == NULL);
task = isc_mem_get(manager->mctx, sizeof(*task));
- if (task == NULL)
- return (ISC_R_NOMEMORY);
XTRACE("isc_task_create");
task->manager = manager;
manager->default_quantum = default_quantum;
INIT_LIST(manager->tasks);
atomic_store(&manager->tasks_count, 0);
- manager->queues = isc_mem_get(mctx, workers * sizeof(isc__taskqueue_t));
+ manager->queues = isc_mem_get(mctx,
+ workers * sizeof(isc__taskqueue_t));
RUNTIME_CHECK(manager->queues != NULL);
atomic_init(&manager->tasks_running, 0);
unsigned int i;
pool = isc_mem_get(mctx, sizeof(*pool));
- if (pool == NULL)
- return (ISC_R_NOMEMORY);
pool->mctx = NULL;
isc_mem_attach(mctx, &pool->mctx);
pool->quantum = quantum;
pool->tmgr = tmgr;
pool->tasks = isc_mem_get(mctx, ntasks * sizeof(isc_task_t *));
- if (pool->tasks == NULL) {
- isc_mem_putanddetach(&pool->mctx, pool, sizeof(*pool));
- return (ISC_R_NOMEMORY);
- }
for (i = 0; i < ntasks; i++)
pool->tasks[i] = NULL;
timer = isc_mem_get(manager->mctx, sizeof(*timer));
- if (timer == NULL)
- return (ISC_R_NOMEMORY);
timer->manager = manager;
isc_refcount_init(&timer->references, 1);
REQUIRE(managerp != NULL && *managerp == NULL);
manager = isc_mem_get(mctx, sizeof(*manager));
- if (manager == NULL)
- return (ISC_R_NOMEMORY);
manager->common.impmagic = TIMER_MANAGER_MAGIC;
manager->common.magic = ISCAPI_TIMERMGR_MAGIC;
REQUIRE(*iterp == NULL);
iter = isc_mem_get(mctx, sizeof(*iter));
- if (iter == NULL)
- return (ISC_R_NOMEMORY);
iter->mctx = mctx;
iter->buf = NULL;
thread->threadid < thread->manager->nthreads);
thread->fds = isc_mem_get(thread->manager->mctx,
- thread->manager->maxsocks *
- sizeof(isc__socket_t *));
+ thread->manager->maxsocks * sizeof(isc__socket_t *));
memset(thread->fds, 0,
thread->manager->maxsocks * sizeof(isc_socket_t *));
#elif defined(USE_EPOLL)
thread->nevents = ISC_SOCKET_MAXEVENTS;
thread->epoll_events = isc_mem_get(thread->manager->mctx,
- (thread->manager->maxsocks *
- sizeof(uint32_t)));
+ (thread->manager->maxsocks * sizeof(uint32_t)));
memset(thread->epoll_events, 0,
thread->manager->maxsocks * sizeof(uint32_t));
thread->events = isc_mem_get(thread->manager->mctx,
- sizeof(struct epoll_event) *
- thread->nevents);
+ sizeof(struct epoll_event) * thread->nevents);
thread->epoll_fd = epoll_create(thread->nevents);
if (thread->epoll_fd == -1) {
* it must have maxsocks entries (not nevents).
*/
thread->fdpollinfo = isc_mem_get(thread->manager->mctx,
- sizeof(pollinfo_t) *
- thread->manager->maxsocks);
+ sizeof(pollinfo_t) * thread->manager->maxsocks);
memset(thread->fdpollinfo, 0, sizeof(pollinfo_t) *
thread->manager->maxsocks);
thread->devpoll_fd = open("/dev/poll", O_RDWR);
/*
* Start up the select/poll thread.
*/
- manager->threads = isc_mem_get(mctx, sizeof(isc__socketthread_t)
- * manager->nthreads);
+ manager->threads = isc_mem_get(mctx,
+ sizeof(isc__socketthread_t) * manager->nthreads);
isc_mem_attach(mctx, &manager->mctx);
for (i=0; i < manager->nthreads; i++) {
REQUIRE(*iterp == NULL);
iter = isc_mem_get(mctx, sizeof(*iter));
- if (iter == NULL)
- return (ISC_R_NOMEMORY);
InitSockets();
for (;;) {
iter->buf4 = isc_mem_get(mctx, iter->buf4size);
- if (iter->buf4 == NULL) {
- result = ISC_R_NOMEMORY;
- goto alloc_failure;
- }
if (WSAIoctl(iter->socket, SIO_GET_INTERFACE_LIST,
0, 0, iter->buf4, iter->buf4size,
for (;;) {
iter->buf6 = isc_mem_get(mctx, iter->buf6size);
- if (iter->buf6 == NULL) {
- result = ISC_R_NOMEMORY;
- goto ioctl_failure;
- }
if (WSAIoctl(iter->socket, SIO_ADDRESS_LIST_QUERY,
0, 0, iter->buf6, iter->buf6size,
sock = isc_mem_get(manager->mctx, sizeof(*sock));
- if (sock == NULL)
- return (ISC_R_NOMEMORY);
-
sock->magic = 0;
isc_refcount_init(&sock->references, 0);
sock->recvbuf.consume_position = sock->recvbuf.base;
sock->recvbuf.remaining = 0;
sock->recvbuf.base = isc_mem_get(manager->mctx, sock->recvbuf.len); // max buffer size
- if (sock->recvbuf.base == NULL) {
- result = ISC_R_NOMEMORY;
- goto error;
- }
/*
* Initialize the lock.
return (ISC_R_NOTIMPLEMENTED);
manager = isc_mem_get(mctx, sizeof(*manager));
- if (manager == NULL)
- return (ISC_R_NOMEMORY);
InitSockets();
REQUIRE(ret != NULL && *ret == NULL);
actx = isc_mem_get(mctx, sizeof(*actx));
- if (actx == NULL)
- return (ISC_R_NOMEMORY);
isc_refcount_init(&actx->references, 1);
cfg_obj_t *obj = NULL;
CHECK(cfg_create_obj(pctx, &cfg_type_ustring, &obj));
obj->value.string.length = strlen("local");
- obj->value.string.base = isc_mem_get(pctx->mctx,
- obj->value.string.length + 1);
- if (obj->value.string.base == NULL) {
- isc_mem_put(pctx->mctx, obj, sizeof(*obj));
- return (ISC_R_NOMEMORY);
- }
+ obj->value.string.base = isc_mem_get(pctx->mctx,
+ obj->value.string.length + 1);
memmove(obj->value.string.base, "local", 5);
obj->value.string.base[5] = '\0';
*ret = obj;
CHECK(cfg_create_obj(pctx, type, &obj));
obj->value.tuple = isc_mem_get(pctx->mctx,
nfields * sizeof(cfg_obj_t *));
- if (obj->value.tuple == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
for (f = fields, i = 0; f->name != NULL; f++, i++)
obj->value.tuple[i] = NULL;
*ret = obj;
REQUIRE(ret != NULL && *ret == NULL);
pctx = isc_mem_get(mctx, sizeof(*pctx));
- if (pctx == NULL)
- return (ISC_R_NOMEMORY);
pctx->mctx = NULL;
isc_mem_attach(mctx, &pctx->mctx);
cfg_listelt_t *elt;
elt = isc_mem_get(pctx->mctx, sizeof(*elt));
- if (elt == NULL)
- return (ISC_R_NOMEMORY);
elt->obj = NULL;
ISC_LINK_INIT(elt, link);
*eltp = elt;
isc_lex_getlasttokentext(pctx->lexer, &pctx->token, &r);
obj->value.string.base = isc_mem_get(pctx->mctx, r.length + 1);
- if (obj->value.string.base == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup;
- }
obj->value.string.length = r.length;
memmove(obj->value.string.base, r.base, r.length);
obj->value.string.base[r.length] = '\0';
REQUIRE(ret != NULL && *ret == NULL);
obj = isc_mem_get(pctx->mctx, sizeof(cfg_obj_t));
- if (obj == NULL)
- return (ISC_R_NOMEMORY);
obj->type = type;
obj->file = current_file(pctx);
goto done;
}
client->tcpbuf = isc_mem_get(client->mctx, TCP_BUFFER_SIZE);
- if (client->tcpbuf == NULL) {
- result = ISC_R_NOMEMORY;
- goto done;
- }
data = client->tcpbuf;
if (tcpbuffer != NULL) {
isc_buffer_init(tcpbuffer, data, TCP_BUFFER_SIZE);
}
client->keytag = isc_mem_get(client->mctx, optlen);
- if (client->keytag != NULL) {
+ {
client->keytag_len = (uint16_t)optlen;
memmove(client->keytag, isc_buffer_current(buf), optlen);
}
return (result);
client = isc_mem_get(mctx, sizeof(*client));
- if (client == NULL) {
- isc_mem_detach(&mctx);
- return (ISC_R_NOMEMORY);
- }
client->mctx = mctx;
client->sctx = NULL;
}
client->recvbuf = isc_mem_get(client->mctx, RECV_BUFFER_SIZE);
- if (client->recvbuf == NULL) {
- result = ISC_R_NOMEMORY;
- goto cleanup_sendevent;
- }
client->recvevent = isc_socket_socketevent(client->mctx, client,
ISC_SOCKEVENT_RECVDONE,
cleanup_recvbuf:
isc_mem_put(client->mctx, client->recvbuf, RECV_BUFFER_SIZE);
- cleanup_sendevent:
isc_event_free((isc_event_t **)&client->sendevent);
client->magic = 0;
#endif
manager = isc_mem_get(mctx, sizeof(*manager));
- if (manager == NULL)
- return (ISC_R_NOMEMORY);
isc_mutex_init(&manager->lock);
isc_mutex_init(&manager->listlock);
do {
buf = isc_mem_get(client->mctx, len);
- if (buf == NULL)
- break;
isc_buffer_init(&buffer, buf, len);
result = dns_message_totext(client->message,
&dns_master_style_debug,
for (i = 0; i < n; i++) {
dbversion = isc_mem_get(client->mctx, sizeof(*dbversion));
- if (dbversion != NULL) {
+ {
dbversion->db = NULL;
dbversion->version = NULL;
ISC_LIST_INITANDAPPEND(client->query.freeversions,
- dbversion, link);
- } else {
- /*
- * We only return ISC_R_NOMEMORY if we couldn't
- * allocate anything.
- */
- if (i == 0) {
- return (ISC_R_NOMEMORY);
- } else {
- return (ISC_R_SUCCESS);
- }
+ dbversion, link);
}
}
REQUIRE(*mgrp == NULL);
mgr = isc_mem_get(mctx, sizeof(*mgr));
- if (mgr == NULL)
- return (ISC_R_NOMEMORY);
mgr->mctx = NULL;
isc_mem_attach(mctx, &mgr->mctx);
REQUIRE(NS_INTERFACEMGR_VALID(mgr));
ifp = isc_mem_get(mgr->mctx, sizeof(*ifp));
- if (ifp == NULL)
- return (ISC_R_NOMEMORY);
ifp->mgr = NULL;
ifp->generation = mgr->generation;
isc_sockaddr_t *old;
addr = isc_mem_get(mgr->mctx, sizeof(*addr));
- if (addr == NULL)
- return;
isc_sockaddr_fromnetaddr(addr, &interface->address, port);
ns_listenelt_t *elt = NULL;
REQUIRE(target != NULL && *target == NULL);
elt = isc_mem_get(mctx, sizeof(*elt));
- if (elt == NULL)
- return (ISC_R_NOMEMORY);
elt->mctx = mctx;
ISC_LINK_INIT(elt, link);
elt->port = port;
ns_listenlist_t *list = NULL;
REQUIRE(target != NULL && *target == NULL);
list = isc_mem_get(mctx, sizeof(*list));
- if (list == NULL)
- return (ISC_R_NOMEMORY);
list->mctx = mctx;
list->refcount = 1;
ISC_LIST_INIT(list->elts);
if (st == NULL) {
st = isc_mem_get(client->mctx, sizeof(*st));
- if (st == NULL)
- return (ISC_R_NOMEMORY);
st->state = 0;
st->rpsdb = NULL;
}
REQUIRE(sctxp != NULL && *sctxp == NULL);
sctx = isc_mem_get(mctx, sizeof(*sctx));
- if (sctx == NULL)
- return (ISC_R_NOMEMORY);
memset(sctx, 0, sizeof(*sctx));
INSIST(sp != NULL && *sp == NULL);
s = isc_mem_get(mctx, sizeof(*s));
- if (s == NULL)
- return (ISC_R_NOMEMORY);
s->common.mctx = NULL;
isc_mem_attach(mctx, &s->common.mctx);
s->common.methods = &ixfr_rrstream_methods;
INSIST(sp != NULL && *sp == NULL);
s = isc_mem_get(mctx, sizeof(*s));
- if (s == NULL)
- return (ISC_R_NOMEMORY);
s->common.mctx = NULL;
isc_mem_attach(mctx, &s->common.mctx);
s->common.methods = &axfr_rrstream_methods;
INSIST(sp != NULL && *sp == NULL);
s = isc_mem_get(mctx, sizeof(*s));
- if (s == NULL)
- return (ISC_R_NOMEMORY);
s->common.mctx = NULL;
isc_mem_attach(mctx, &s->common.mctx);
s->common.methods = &soa_rrstream_methods;
INSIST(sp != NULL && *sp == NULL);
s = isc_mem_get(mctx, sizeof(*s));
- if (s == NULL)
- return (ISC_R_NOMEMORY);
s->common.mctx = NULL;
isc_mem_attach(mctx, &s->common.mctx);
s->common.methods = &compound_rrstream_methods;
INSIST(xfrp != NULL && *xfrp == NULL);
xfr = isc_mem_get(mctx, sizeof(*xfr));
- if (xfr == NULL)
- return (ISC_R_NOMEMORY);
xfr->mctx = NULL;
isc_mem_attach(mctx, &xfr->mctx);
xfr->client = NULL;
*/
len = 65535;
mem = isc_mem_get(mctx, len);
- if (mem == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
isc_buffer_init(&xfr->buf, mem, len);
/*
*/
len = 2 + 65535;
mem = isc_mem_get(mctx, len);
- if (mem == NULL) {
- result = ISC_R_NOMEMORY;
- goto failure;
- }
isc_buffer_init(&xfr->txlenbuf, mem, 2);
isc_buffer_init(&xfr->txbuf, (char *) mem + 2, len - 2);
xfr->txmem = mem;
continue;
server = isc_mem_get(mctx, sizeof(*server));
- if (server == NULL) {
- fprintf(stderr, "resolve_nsaddress: "
- "mem_get failed");
- result = ISC_R_NOMEMORY;
- POST(result);
- goto cleanup;
- }
isc_sockaddr_fromin(&server->address,
&rdata_a.in_addr, 53);
ISC_LINK_INIT(server, link);
}
}
- cleanup:
dns_client_freeresanswer(client, &rev->answerlist);
dns_client_destroyrestrans(&trans->resid);
isc_event_free(&event);
continue;
pns = isc_mem_get(mctx, sizeof(*pns));
- if (pns == NULL) {
- fprintf(stderr,
- "resolve_ns: mem_get failed");
- result = ISC_R_NOMEMORY;
- POST(result);
- /*
- * XXX: should we continue with the
- * available servers anyway?
- */
- goto cleanup;
- }
pns->name =
dns_fixedname_initname(&pns->fixedname);
}
}
- cleanup:
dns_client_freeresanswer(client, &rev->answerlist);
dns_client_destroyrestrans(&trans->resid);
isc_event_free(&event);
parse_name(&cmdline, name);
rdata = isc_mem_get(mctx, sizeof(*rdata));
- if (rdata == NULL) {
- fprintf(stderr, "memory allocation for rdata failed\n");
- exit(1);
- }
dns_rdata_init(rdata);
/*
doneparsing:
rdatalist = isc_mem_get(mctx, sizeof(*rdatalist));
- if (rdatalist == NULL) {
- fprintf(stderr, "memory allocation for rdatalist failed\n");
- exit(1);
- }
dns_rdatalist_init(rdatalist);
rdatalist->type = rdatatype;
rdatalist->rdclass = rdataclass;
ISC_LIST_APPEND(usedrdatalists, rdatalist, link);
rdataset = isc_mem_get(mctx, sizeof(*rdataset));
- if (rdataset == NULL) {
- fprintf(stderr, "memory allocation for rdataset failed\n");
- exit(1);
- }
dns_rdataset_init(rdataset);
dns_rdatalist_tordataset(rdatalist, rdataset);
dns_rdataset_setownercase(rdataset, name);
rdatatype = dns_rdatatype_any;
rdata = isc_mem_get(mctx, sizeof(*rdata));
- if (rdata == NULL) {
- fprintf(stderr, "memory allocation for rdata failed\n");
- exit(1);
- }
dns_rdata_init(rdata);
if (isrrset && ispositive)
rdata->flags = DNS_RDATA_UPDATE;
rdatalist = isc_mem_get(mctx, sizeof(*rdatalist));
- if (rdatalist == NULL) {
- fprintf(stderr, "memory allocation for rdatalist failed\n");
- exit(1);
- }
dns_rdatalist_init(rdatalist);
rdatalist->type = rdatatype;
if (ispositive) {
ISC_LIST_APPEND(usedrdatalists, rdatalist, link);
rdataset = isc_mem_get(mctx, sizeof(*rdataset));
- if (rdataset == NULL) {
- fprintf(stderr, "memory allocation for rdataset failed\n");
- exit(1);
- }
dns_rdataset_init(rdataset);
dns_rdatalist_tordataset(rdatalist, rdataset);
dns_rdataset_setownercase(rdataset, name);
projects / thirdparty / bind9.git / commitdiff
