No mem checks, pt 1

bin/check/check-tool.c

@@ -129,9 +129,7 @@ add(char *key, int value) {
 	isc_symvalue_t symvalue;
 
 	if (sym_mctx == NULL) {
-		result = isc_mem_create(0, 0, &sym_mctx);
-		if (result != ISC_R_SUCCESS)
-			return;
+		isc_mem_create(0, 0, &sym_mctx);
 	}
 
 	if (symtab == NULL) {

bin/check/named-checkconf.c

@@ -569,7 +569,7 @@ main(int argc, char **argv) {
 	}
 	isc_commandline_reset = true;
 
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
 
 	while ((c = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != EOF) {
 		switch (c) {

bin/check/named-checkzone.c

@@ -517,7 +517,7 @@ main(int argc, char **argv) {
 	InitSockets();
 #endif
 
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
 	if (!quiet)
 		RUNTIME_CHECK(setup_logging(mctx, errout, &lctx)
 			      == ISC_R_SUCCESS);

bin/confgen/ddns-confgen.c

@@ -207,7 +207,7 @@ main(int argc, char **argv) {
 	/* Use canonical algorithm name */
 	algname = alg_totext(alg);
 
-	DO("create memory context", isc_mem_create(0, 0, &mctx));
+	isc_mem_create(0, 0, &mctx);
 
 	if (keyname == NULL) {
 		const char *suffix = NULL;

bin/confgen/rndc-confgen.c

@@ -211,7 +211,7 @@ main(int argc, char **argv) {
 		keysize = alg_bits(alg);
 	algname = alg_totext(alg);
 
-	DO("create memory context", isc_mem_create(0, 0, &mctx));
+	isc_mem_create(0, 0, &mctx);
 	isc_buffer_init(&key_txtbuffer, &key_txtsecret, sizeof(key_txtsecret));
 
 	generate_key(mctx, alg, keysize, &key_txtbuffer);

bin/delv/delv.c

@@ -1585,14 +1585,12 @@ main(int argc, char *argv[]) {
 	if (result != ISC_R_SUCCESS)
 		fatal("dns_lib_init failed: %d", result);
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS)
-		fatal("failed to create mctx");
+	isc_mem_create(0, 0, &mctx);
 
 	CHECK(isc_appctx_create(mctx, &actx));
 	CHECK(isc_taskmgr_createinctx(mctx, actx, 1, 0, &taskmgr));
 	CHECK(isc_socketmgr_createinctx(mctx, actx, &socketmgr));
-	CHECK(isc_timermgr_createinctx(mctx, actx, &timermgr));
+	isc_timermgr_createinctx(mctx, actx, &timermgr);
 
 	parse_args(argc, argv);
 

bin/dig/dig.c

@@ -520,8 +520,7 @@ printmessage(dig_query_t *query, dns_message_t *msg, bool headers) {
 	if (!query->lookup->comments)
 		flags |= DNS_MESSAGETEXTFLAG_NOCOMMENTS;
 
-	result = isc_buffer_allocate(mctx, &buf, len);
-	check_result(result, "isc_buffer_allocate");
+	isc_buffer_allocate(mctx, &buf, len);
 
 	if (query->lookup->comments && !short_form) {
 		if (query->lookup->cmdline[0] != 0)
@@ -597,11 +596,8 @@ repopulate_buffer:
 buftoosmall:
 			len += OUTPUTBUF;
 			isc_buffer_free(&buf);
-			result = isc_buffer_allocate(mctx, &buf, len);
-			if (result == ISC_R_SUCCESS)
-				goto repopulate_buffer;
-			else
-				goto cleanup;
+			isc_buffer_allocate(mctx, &buf, len);
+			goto repopulate_buffer;
 		}
 		check_result(result,
 		     "dns_message_pseudosectiontotext");

bin/dig/dighost.c

@@ -862,8 +862,7 @@ setup_text_key(void) {
 	unsigned char *secretstore;
 
 	debug("setup_text_key()");
-	result = isc_buffer_allocate(mctx, &namebuf, MXNAME);
-	check_result(result, "isc_buffer_allocate");
+	isc_buffer_allocate(mctx, &namebuf, MXNAME);
 	dns_name_init(&keyname, NULL);
 	check_result(result, "dns_name_init");
 	isc_buffer_putstr(namebuf, keynametext);
@@ -1328,8 +1327,7 @@ setup_libs(void) {
 	if (!have_ipv6 && !have_ipv4)
 		fatal("can't find either v4 or v6 networking");
 
-	result = isc_mem_create(0, 0, &mctx);
-	check_result(result, "isc_mem_create");
+	isc_mem_create(0, 0, &mctx);
 	isc_mem_setname(mctx, "dig", NULL);
 
 	result = isc_log_create(mctx, &lctx, &logconfig);
@@ -1351,8 +1349,7 @@ setup_libs(void) {
 	check_result(result, "isc_task_create");
 	isc_task_setname(global_task, "dig", NULL);
 
-	result = isc_timermgr_create(mctx, &timermgr);
-	check_result(result, "isc_timermgr_create");
+	isc_timermgr_create(mctx, &timermgr);
 
 	result = isc_socketmgr_create(mctx, &socketmgr);
 	check_result(result, "isc_socketmgr_create");
@@ -1361,8 +1358,7 @@ setup_libs(void) {
 	check_result(result, "dst_lib_init");
 	is_dst_up = true;
 
-	result = isc_mempool_create(mctx, COMMSIZE, &commctx);
-	check_result(result, "isc_mempool_create");
+	isc_mempool_create(mctx, COMMSIZE, &commctx);
 	isc_mempool_setname(commctx, "COMMPOOL");
 	/*
 	 * 6 and 2 set as reasonable parameters for 3 or 4 nameserver
@@ -1371,8 +1367,7 @@ setup_libs(void) {
 	isc_mempool_setfreemax(commctx, 6);
 	isc_mempool_setfillcount(commctx, 2);
 
-	result = isc_mutex_init(&lookup_lock);
-	check_result(result, "isc_mutex_init");
+	isc_mutex_init(&lookup_lock);
 }
 
 typedef struct dig_ednsoptname {
@@ -2018,9 +2013,8 @@ setup_lookup(dig_lookup_t *lookup) {
 
 	debug("setup_lookup(%p)", lookup);
 
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER,
+	dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER,
 				    &lookup->sendmsg);
-	check_result(result, "dns_message_create");
 
 	if (lookup->new_search) {
 		debug("resetting lookup counter.");
@@ -2256,8 +2250,7 @@ setup_lookup(dig_lookup_t *lookup) {
 	if (lookup->sendspace == NULL)
 		fatal("memory allocation failure");
 
-	result = dns_compress_init(&cctx, -1, mctx);
-	check_result(result, "dns_compress_init");
+	dns_compress_init(&cctx, -1, mctx);
 
 	debug("starting to render the message");
 	isc_buffer_init(&lookup->renderbuf, lookup->sendspace, COMMSIZE);
@@ -3611,8 +3604,7 @@ recv_done(isc_task_t *task, isc_event_t *event) {
 	if (!match)
 		goto udp_mismatch;
 
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &msg);
-	check_result(result, "dns_message_create");
+	dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &msg);
 
 	if (tsigkey != NULL) {
 		if (l->querysig == NULL) {

bin/dig/host.c

@@ -201,8 +201,7 @@ say_message(dns_name_t *name, const char *msg, dns_rdata_t *rdata,
 
 	dns_name_format(name, namestr, sizeof(namestr));
  retry:
-	result = isc_buffer_allocate(mctx, &b, bufsize);
-	check_result(result, "isc_buffer_allocate");
+	isc_buffer_allocate(mctx, &b, bufsize);
 	result = dns_rdata_totext(rdata, NULL, b);
 	if (result == ISC_R_NOSPACE) {
 		isc_buffer_free(&b);

bin/dig/nslookup.c

@@ -223,9 +223,7 @@ printrdata(dns_rdata_t *rdata) {
 		printf("rdata_%d = ", rdata->type);
 
 	while (!done) {
-		result = isc_buffer_allocate(mctx, &b, size);
-		if (result != ISC_R_SUCCESS)
-			check_result(result, "isc_buffer_allocate");
+		isc_buffer_allocate(mctx, &b, size);
 		result = dns_rdata_totext(rdata, NULL, b);
 		if (result == ISC_R_SUCCESS) {
 			printf("%.*s\n", (int)isc_buffer_usedlength(b),

bin/dnssec/dnssec-cds.c

@@ -383,8 +383,7 @@ formatset(dns_rdataset_t *rdataset) {
 					mctx);
 	check_result(result, "dns_master_stylecreate2 failed");
 
-	result = isc_buffer_allocate(mctx, &buf, MAX_CDS_RDATA_TEXT_SIZE);
-	check_result(result, "printing DS records");
+	isc_buffer_allocate(mctx, &buf, MAX_CDS_RDATA_TEXT_SIZE);
 	result = dns_master_rdatasettotext(name, rdataset, style, buf);
 
 	if ((result == ISC_R_SUCCESS) && isc_buffer_availablelength(buf) < 1) {
@@ -896,8 +895,7 @@ make_new_ds_set(ds_maker_func_t *ds_from_rdata,
 		result = dns_rdatalist_tordataset(dslist, &new_ds_set);
 		check_result(result, "dns_rdatalist_tordataset(dslist)");
 
-		result = isc_buffer_allocate(mctx, &new_ds_buf, size);
-		check_result(result, "building new DS records");
+		isc_buffer_allocate(mctx, &new_ds_buf, size);
 
 		for (result = dns_rdataset_first(rdset);
 		     result == ISC_R_SUCCESS;
@@ -1144,10 +1142,7 @@ main(int argc, char *argv[]) {
 	int ch;
 	char *endp;
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS) {
-		fatal("out of memory");
-	}
+	isc_mem_create(0, 0, &mctx);
 
 #if USE_PKCS11
 	pk11_result_register();

bin/dnssec/dnssec-dsfromkey.c

@@ -368,7 +368,7 @@ main(int argc, char **argv) {
 	if (argc == 1)
 		usage();
 
-	result = isc_mem_create(0, 0, &mctx);
+	isc_mem_create(0, 0, &mctx);
 	if (result != ISC_R_SUCCESS)
 		fatal("out of memory");
 

bin/dnssec/dnssec-importkey.c

@@ -307,9 +307,7 @@ main(int argc, char **argv) {
 	if (argc == 1)
 		usage();
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS)
-		fatal("out of memory");
+	isc_mem_create(0, 0, &mctx);
 
 #if USE_PKCS11
 	pk11_result_register();

bin/dnssec/dnssec-keyfromlabel.c

@@ -166,7 +166,7 @@ main(int argc, char **argv) {
 	if (argc == 1)
 		usage();
 
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
 
 #if USE_PKCS11
 	pk11_result_register();

bin/dnssec/dnssec-keygen.c

@@ -274,7 +274,7 @@ main(int argc, char **argv) {
 	}
 	isc_commandline_reset = true;
 
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
 
 	isc_stdtime_get(&now);
 

bin/dnssec/dnssec-revoke.c

@@ -91,9 +91,7 @@ main(int argc, char **argv) {
 	if (argc == 1)
 		usage();
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS)
-		fatal("Out of memory");
+	isc_mem_create(0, 0, &mctx);
 
 #if HAVE_PKCS11
 	pk11_result_register();

bin/dnssec/dnssec-settime.c

@@ -170,9 +170,7 @@ main(int argc, char **argv) {
 	if (argc == 1)
 		usage();
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS)
-		fatal("Out of memory");
+	isc_mem_create(0, 0, &mctx);
 
 	setup_logging(mctx, &log);
 

bin/dnssec/dnssec-signzone.c

@@ -232,8 +232,7 @@ dumpnode(dns_name_t *name, dns_dbnode_t *node) {
 
 	dns_rdataset_init(&rds);
 
-	result = isc_buffer_allocate(mctx, &buffer, bufsize);
-	check_result(result, "isc_buffer_allocate");
+	isc_buffer_allocate(mctx, &buffer, bufsize);
 
 	for (result = dns_rdatasetiter_first(iter);
 	     result == ISC_R_SUCCESS;
@@ -258,8 +257,7 @@ dumpnode(dns_name_t *name, dns_dbnode_t *node) {
 
 			bufsize <<= 1;
 			isc_buffer_free(&buffer);
-			result = isc_buffer_allocate(mctx, &buffer, bufsize);
-			check_result(result, "isc_buffer_allocate");
+			isc_buffer_allocate(mctx, &buffer, bufsize);
 		}
 		check_result(result, "dns_master_rdatasettotext");
 
@@ -3277,9 +3275,7 @@ main(int argc, char *argv[]) {
 
 	check_result(isc_app_start(), "isc_app_start");
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS)
-		fatal("out of memory");
+	isc_mem_create(0, 0, &mctx);
 
 #if USE_PKCS11
 	pk11_result_register();
@@ -3710,10 +3706,7 @@ main(int argc, char *argv[]) {
 	 * of keys rather early.
 	 */
 	ISC_LIST_INIT(keylist);
-	result = isc_rwlock_init(&keylist_lock, 0, 0);
-	if (result != ISC_R_SUCCESS)
-		fatal("could not initialize keylist_lock: %s",
-		      isc_result_totext(result));
+	isc_rwlock_init(&keylist_lock, 0, 0);
 
 	/*
 	 * Fill keylist with:
@@ -3875,9 +3868,9 @@ main(int argc, char *argv[]) {
 			      isc_result_totext(result));
 	}
 
-	RUNTIME_CHECK(isc_mutex_init(&namelock) == ISC_R_SUCCESS);
+	isc_mutex_init(&namelock);
 	if (printstats)
-		RUNTIME_CHECK(isc_mutex_init(&statslock) == ISC_R_SUCCESS);
+		isc_mutex_init(&statslock);
 
 	presign();
 	TIME_NOW(&sign_start);

bin/dnssec/dnssec-verify.c

@@ -201,9 +201,7 @@ main(int argc, char *argv[]) {
 	isc_commandline_reset = true;
 	check_result(isc_app_start(), "isc_app_start");
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS)
-		fatal("out of memory");
+	isc_mem_create(0, 0, &mctx);
 
 #if USE_PKCS11
 	pk11_result_register();

bin/named/config.c

@@ -802,10 +802,8 @@ named_config_getipandkeylist(const cfg_obj_t *config, const cfg_obj_t *list,
 					   dns_rootname, 0, NULL);
 		if (result != ISC_R_SUCCESS)
 			goto cleanup;
-		result = dns_name_dup(dns_fixedname_name(&fname), mctx,
+		dns_name_dup(dns_fixedname_name(&fname), mctx,
 				      keys[i - 1]);
-		if (result != ISC_R_SUCCESS)
-			goto cleanup;
 	}
 	if (pushed != 0) {
 		pushed--;

bin/named/control.c

@@ -100,15 +100,11 @@ named_control_docommand(isccc_sexpr_t *message, bool readonly,
 		return (result);
 	}
 
-	result = isc_lex_create(named_g_mctx, strlen(cmdline), &lex);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_lex_create(named_g_mctx, strlen(cmdline), &lex);
 
 	isc_buffer_init(&src, cmdline, strlen(cmdline));
 	isc_buffer_add(&src, strlen(cmdline));
-	result = isc_lex_openbuffer(lex, &src);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_lex_openbuffer(lex, &src);
 
 	result = getcommand(lex, &command);
 	if (result != ISC_R_SUCCESS)

bin/named/controlconf.c

@@ -448,9 +448,7 @@ control_recvmessage(isc_task_t *task, isc_event_t *event) {
 		goto cleanup_request;
 	}
 
-	result = isc_buffer_allocate(listener->mctx, &text, 2 * 2048);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_request;
+	isc_buffer_allocate(listener->mctx, &text, 2 * 2048);
 
 	/*
 	 * Establish nonce.
@@ -496,10 +494,8 @@ control_recvmessage(isc_task_t *task, isc_event_t *event) {
 		goto cleanup_response;
 
 	if (conn->buffer == NULL) {
-		result = isc_buffer_allocate(listener->mctx,
+		isc_buffer_allocate(listener->mctx,
 					     &conn->buffer, 2 * 2048);
-		if (result != ISC_R_SUCCESS)
-			goto cleanup_response;
 	}
 
 	isc_buffer_clear(conn->buffer);
@@ -1061,7 +1057,8 @@ update_listener(named_controls_t *cp, controllistener_t **listenerp,
 					    aclconfctx, listener->mctx, 0,
 					    &new_acl);
 	} else {
-		result = dns_acl_any(listener->mctx, &new_acl);
+		dns_acl_any(listener->mctx, &new_acl);
+		result = ISC_R_SUCCESS;
 	}
 
 	if (control != NULL) {
@@ -1158,7 +1155,8 @@ add_listener(named_controls_t *cp, controllistener_t **listenerp,
 						    aclconfctx, mctx, 0,
 						    &new_acl);
 		} else {
-			result = dns_acl_any(mctx, &new_acl);
+			dns_acl_any(mctx, &new_acl);
+			result = ISC_R_SUCCESS;
 		}
 	}
 

bin/named/main.c

@@ -815,14 +815,7 @@ create_managers(void) {
 		return (ISC_R_UNEXPECTED);
 	}
 
-	result = isc_timermgr_create(named_g_mctx, &named_g_timermgr);
-	if (result != ISC_R_SUCCESS) {
-		UNEXPECTED_ERROR(__FILE__, __LINE__,
-				 "isc_timermgr_create() failed: %s",
-				 isc_result_totext(result));
-		return (ISC_R_UNEXPECTED);
-	}
-
+	isc_timermgr_create(named_g_mctx, &named_g_timermgr);
 	result = isc_socketmgr_create2(named_g_mctx, &named_g_socketmgr,
 				       maxsocks);
 	if (result != ISC_R_SUCCESS) {
@@ -831,7 +824,7 @@ create_managers(void) {
 				 isc_result_totext(result));
 		return (ISC_R_UNEXPECTED);
 	}
-	isc__socketmgr_maxudp(named_g_socketmgr, maxudp);
+	isc_socketmgr_maxudp(named_g_socketmgr, maxudp);
 	result = isc_socketmgr_getmaxsockets(named_g_socketmgr, &socks);
 	if (result == ISC_R_SUCCESS) {
 		isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
@@ -1387,10 +1380,7 @@ main(int argc, char *argv[]) {
 						named_g_chrootdir);
 	}
 
-	result = isc_mem_create(0, 0, &named_g_mctx);
-	if (result != ISC_R_SUCCESS)
-		named_main_earlyfatal("isc_mem_create() failed: %s",
-				   isc_result_totext(result));
+	isc_mem_create(0, 0, &named_g_mctx);
 	isc_mem_setname(named_g_mctx, "main", NULL);
 
 	setup();

bin/named/server.c

@@ -656,9 +656,7 @@ configure_view_nametable(const cfg_obj_t *vconfig, const cfg_obj_t *config,
 			return (ISC_R_SUCCESS);
 	}
 
-	result = dns_rbt_create(mctx, NULL, NULL, rbtp);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dns_rbt_create(mctx, NULL, NULL, rbtp);
 
 	name = dns_fixedname_initname(&fixed);
 	for (element = cfg_list_first(obj);
@@ -966,13 +964,7 @@ configure_view_dnsseckeys(dns_view_t *view, const cfg_obj_t *vconfig,
 	maps[i++] = named_g_defaults;
 	maps[i] = NULL;
 
-	result = dns_view_initsecroots(view, mctx);
-	if (result != ISC_R_SUCCESS) {
-		isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
-			      NAMED_LOGMODULE_SERVER, ISC_LOG_ERROR,
-			      "couldn't create keytable");
-		return (ISC_R_UNEXPECTED);
-	}
+	dns_view_initsecroots(view, mctx);
 
 	result = dns_view_initntatable(view, named_g_taskmgr, named_g_timermgr);
 	if (result != ISC_R_SUCCESS) {
@@ -1677,10 +1669,8 @@ setquerystats(dns_zone_t *zone, isc_mem_t *mctx, dns_zonestat_level_t level) {
 
 	zoneqrystats = NULL;
 	if (level == dns_zonestat_full) {
-		result = isc_stats_create(mctx, &zoneqrystats,
+		isc_stats_create(mctx, &zoneqrystats,
 					  ns_statscounter_max);
-		if (result != ISC_R_SUCCESS)
-			return (result);
 	}
 	dns_zone_setrequeststats(zone, zoneqrystats);
 	if (zoneqrystats != NULL)
@@ -2836,13 +2826,7 @@ configure_catz_zone(dns_view_t *view, const cfg_obj_t *config,
 		 * We have to walk through all the member zones and attach
 		 * them to current view
 		 */
-		result = dns_catz_get_iterator(zone, &it);
-		if (result != ISC_R_SUCCESS) {
-			cfg_obj_log(catz_obj, named_g_lctx,
-				    DNS_CATZ_ERROR_LEVEL,
-				    "catz: unable to create iterator");
-			goto cleanup;
-		}
+		dns_catz_get_iterator(zone, &it);
 
 		for (result = isc_ht_iter_first(it);
 		     result == ISC_R_SUCCESS;
@@ -2938,9 +2922,9 @@ configure_catz(dns_view_t *view, const cfg_obj_t *config,
 	if (zone_element == NULL)
 		return (ISC_R_SUCCESS);
 
-	CHECK(dns_catz_new_zones(&view->catzs, &ns_catz_zonemodmethods,
+	dns_catz_new_zones(&view->catzs, &ns_catz_zonemodmethods,
 				 view->mctx, named_g_taskmgr,
-				 named_g_timermgr));
+				 named_g_timermgr);
 
 	result = dns_viewlist_find(&named_g_server->viewlist, view->name,
 				   view->rdclass, &pview);
@@ -3017,9 +3001,7 @@ configure_rrl(dns_view_t *view, const cfg_obj_t *config, const cfg_obj_t *map) {
 		if (min_entries < 1)
 			min_entries = 1;
 	}
-	result = dns_rrl_init(&rrl, view, min_entries);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dns_rrl_init(&rrl, view, min_entries);
 
 	i = ISC_MAX(20000, min_entries);
 	obj = NULL;
@@ -3603,24 +3585,18 @@ configure_dnstap(const cfg_obj_t **maps, dns_view_t *view) {
 }
 #endif /* HAVE_DNSTAP */
 
-static isc_result_t
+static void
 create_mapped_acl(void) {
-	isc_result_t result;
 	dns_acl_t *acl = NULL;
 	struct in6_addr in6 = IN6ADDR_V4MAPPED_INIT;
 	isc_netaddr_t addr;
 
 	isc_netaddr_fromin6(&addr, &in6);
 
-	result = dns_acl_create(named_g_mctx, 1, &acl);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dns_acl_create(named_g_mctx, 1, &acl);
 
-	result = dns_iptable_addprefix(acl->iptable, &addr, 96, true);
-	if (result == ISC_R_SUCCESS)
-		dns_acl_attach(acl, &named_g_mapped);
+	dns_iptable_addprefix(acl->iptable, &addr, 96, true);
 	dns_acl_detach(&acl);
-	return (result);
 }
 
 /*
@@ -4021,9 +3997,7 @@ configure_view(dns_view_t *view, dns_viewlist_t *viewlist,
 					goto cleanup;
 			} else {
 				if (named_g_mapped == NULL) {
-					result = create_mapped_acl();
-					if (result != ISC_R_SUCCESS)
-						goto cleanup;
+					create_mapped_acl();
 				}
 				dns_acl_attach(named_g_mapped, &excluded);
 			}
@@ -4202,9 +4176,9 @@ configure_view(dns_view_t *view, dns_viewlist_t *viewlist,
 			 * cache, for the main cache memory and the heap
 			 * memory.
 			 */
-			CHECK(isc_mem_create(0, 0, &cmctx));
+			isc_mem_create(0, 0, &cmctx);
 			isc_mem_setname(cmctx, "cache", NULL);
-			CHECK(isc_mem_create(0, 0, &hmctx));
+			isc_mem_create(0, 0, &hmctx);
 			isc_mem_setname(hmctx, "cache_heap", NULL);
 			CHECK(dns_cache_create(cmctx, hmctx, named_g_taskmgr,
 					       named_g_timermgr, view->rdclass,
@@ -4270,20 +4244,20 @@ configure_view(dns_view_t *view, dns_viewlist_t *viewlist,
 	}
 
 	if (resstats == NULL) {
-		CHECK(isc_stats_create(mctx, &resstats,
-				       dns_resstatscounter_max));
+		isc_stats_create(mctx, &resstats,
+				       dns_resstatscounter_max);
 	}
 	dns_view_setresstats(view, resstats);
 	if (resquerystats == NULL)
-		CHECK(dns_rdatatypestats_create(mctx, &resquerystats));
+		dns_rdatatypestats_create(mctx, &resquerystats);
 	dns_view_setresquerystats(view, resquerystats);
 
 	ndisp = 4 * ISC_MIN(named_g_udpdisp, MAX_UDP_DISPATCH);
-	CHECK(dns_view_createresolver(view, named_g_taskmgr, RESOLVER_NTASKS,
+	dns_view_createresolver(view, named_g_taskmgr, RESOLVER_NTASKS,
 				      ndisp, named_g_socketmgr,
 				      named_g_timermgr, resopts,
 				      named_g_dispatchmgr,
-				      dispatch4, dispatch6));
+				      dispatch4, dispatch6);
 
 	if (dscp4 == -1)
 		dscp4 = named_g_dscp;
@@ -4838,10 +4812,10 @@ configure_view(dns_view_t *view, dns_viewlist_t *viewlist,
 		 * been set at the options/view level, set them to none.
 		 */
 		if (view->cacheacl == NULL) {
-			CHECK(dns_acl_none(mctx, &view->cacheacl));
+			dns_acl_none(mctx, &view->cacheacl);
 		}
 		if (view->cacheonacl == NULL) {
-			CHECK(dns_acl_none(mctx, &view->cacheonacl));
+			dns_acl_none(mctx, &view->cacheonacl);
 		}
 	}
 
@@ -5196,7 +5170,7 @@ configure_view(dns_view_t *view, dns_viewlist_t *viewlist,
 			CHECK(dns_name_fromstring(name,
 						  cfg_obj_asstring(exclude),
 						  0, NULL));
-			CHECK(dns_view_excludedelegationonly(view, name));
+			dns_view_excludedelegationonly(view, name);
 		}
 	} else
 		dns_view_setrootdelonly(view, false);
@@ -5958,7 +5932,7 @@ configure_zone(const cfg_obj_t *config, const cfg_obj_t *zconfig,
 			tresult = cfg_map_get(zoptions, "delegation-only",
 					      &only);
 			if (tresult == ISC_R_SUCCESS && cfg_obj_asboolean(only))
-				CHECK(dns_view_adddelegationonly(view, origin));
+				dns_view_adddelegationonly(view, origin);
 		} else {
 			isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,
 				      NAMED_LOGMODULE_SERVER, ISC_LOG_WARNING,
@@ -5989,7 +5963,7 @@ configure_zone(const cfg_obj_t *config, const cfg_obj_t *zconfig,
 		only = NULL;
 		tresult = cfg_map_get(zoptions, "delegation-only", &only);
 		if (tresult == ISC_R_SUCCESS && cfg_obj_asboolean(only))
-			CHECK(dns_view_adddelegationonly(view, origin));
+			dns_view_adddelegationonly(view, origin);
 		goto cleanup;
 	}
 
@@ -5997,7 +5971,8 @@ configure_zone(const cfg_obj_t *config, const cfg_obj_t *zconfig,
 	 * "delegation-only zones" aren't zones either.
 	 */
 	if (strcasecmp(ztypestr, "delegation-only") == 0) {
-		result = dns_view_adddelegationonly(view, origin);
+		dns_view_adddelegationonly(view, origin);
+		result = ISC_R_SUCCESS;
 		goto cleanup;
 	}
 
@@ -6152,7 +6127,7 @@ configure_zone(const cfg_obj_t *config, const cfg_obj_t *zconfig,
 	if (cfg_map_get(zoptions, "delegation-only", &only) == ISC_R_SUCCESS)
 	{
 		if (cfg_obj_asboolean(only))
-			CHECK(dns_view_adddelegationonly(view, origin));
+			dns_view_adddelegationonly(view, origin);
 	}
 
 	/*
@@ -6283,7 +6258,7 @@ add_keydata_zone(dns_view_t *view, const char *directory, isc_mem_t *mctx) {
 
 	CHECK(dns_zonemgr_managezone(named_g_server->zonemgr, zone));
 
-	CHECK(dns_acl_none(mctx, &none));
+	dns_acl_none(mctx, &none);
 	dns_zone_setqueryacl(zone, none);
 	dns_zone_setqueryonacl(zone, none);
 	dns_acl_detach(&none);
@@ -6392,14 +6367,10 @@ add_listenelt(isc_mem_t *mctx, ns_listenlist_t *list, isc_sockaddr_t *addr,
 	    (wcardport_ok || isc_sockaddr_getport(addr) != 0)) {
 		isc_netaddr_fromin6(&netaddr, &addr->type.sin6.sin6_addr);
 
-		result = dns_acl_create(mctx, 0, &src_acl);
-		if (result != ISC_R_SUCCESS)
-			return (result);
+		dns_acl_create(mctx, 0, &src_acl);
 
-		result = dns_iptable_addprefix(src_acl->iptable, &netaddr,
+		dns_iptable_addprefix(src_acl->iptable, &netaddr,
 					       128, true);
-		if (result != ISC_R_SUCCESS)
-			goto clean;
 
 		result = ns_listenelt_create(mctx, isc_sockaddr_getport(addr),
 					     dscp, src_acl, &lelt);
@@ -7173,7 +7144,7 @@ configure_session_key(const cfg_obj_t **maps, named_server_t *server,
 		if (server->session_keyname == NULL)
 			goto cleanup;
 		dns_name_init(server->session_keyname, NULL);
-		CHECK(dns_name_dup(keyname, mctx, server->session_keyname));
+		dns_name_dup(keyname, mctx, server->session_keyname);
 
 		server->session_keyfile = isc_mem_strdup(mctx, keyfile);
 		if (server->session_keyfile == NULL)
@@ -8098,7 +8069,7 @@ load_configuration(const char *filename, named_server_t *server,
 			      "less than 128 UDP sockets available after "
 			      "applying 'reserved-sockets' and 'maxsockets'");
 	}
-	isc__socketmgr_setreserved(named_g_socketmgr, reserved);
+	isc_socketmgr_setreserved(named_g_socketmgr, reserved);
 
 #ifdef HAVE_GEOIP
 	/*
@@ -8241,10 +8212,8 @@ load_configuration(const char *filename, named_server_t *server,
 	/*
 	 * Configure sets of UDP query source ports.
 	 */
-	CHECKM(isc_portset_create(named_g_mctx, &v4portset),
-	       "creating UDP port set");
-	CHECKM(isc_portset_create(named_g_mctx, &v6portset),
-	       "creating UDP port set");
+	isc_portset_create(named_g_mctx, &v4portset);
+	isc_portset_create(named_g_mctx, &v6portset);
 
 	usev4ports = NULL;
 	usev6ports = NULL;
@@ -9305,8 +9274,7 @@ run_server(isc_task_t *task, isc_event_t *event) {
 
 	isc_event_free(&event);
 
-	CHECKFATAL(dns_dispatchmgr_create(named_g_mctx, &named_g_dispatchmgr),
-		   "creating dispatch manager");
+	dns_dispatchmgr_create(named_g_mctx, &named_g_dispatchmgr);
 
 	dns_dispatchmgr_setstats(named_g_dispatchmgr, server->resolverstats);
 
@@ -9537,8 +9505,7 @@ named_server_create(isc_mem_t *mctx, named_server_t **serverp) {
 				     &server->in_roothints),
 		   "setting up root hints");
 
-	CHECKFATAL(isc_mutex_init(&server->reload_event_lock),
-		   "initializing reload event lock");
+	isc_mutex_init(&server->reload_event_lock);
 	server->reload_event =
 		isc_event_allocate(named_g_mctx, server,
 				   NAMED_EVENT_RELOAD,
@@ -9629,18 +9596,15 @@ named_server_create(isc_mem_t *mctx, named_server_t **serverp) {
 	server->zonestats = NULL;
 	server->resolverstats = NULL;
 	server->sockstats = NULL;
-	CHECKFATAL(isc_stats_create(server->mctx, &server->sockstats,
-				    isc_sockstatscounter_max),
-		   "isc_stats_create");
+	isc_stats_create(server->mctx, &server->sockstats,
+				    isc_sockstatscounter_max);
 	isc_socketmgr_setstats(named_g_socketmgr, server->sockstats);
 
-	CHECKFATAL(isc_stats_create(named_g_mctx, &server->zonestats,
-				    dns_zonestatscounter_max),
-		   "dns_stats_create (zone)");
+	isc_stats_create(named_g_mctx, &server->zonestats,
+				    dns_zonestatscounter_max);
 
-	CHECKFATAL(isc_stats_create(named_g_mctx, &server->resolverstats,
-				    dns_resstatscounter_max),
-		   "dns_stats_create (resolver)");
+	isc_stats_create(named_g_mctx, &server->resolverstats,
+				    dns_resstatscounter_max);
 
 	server->flushonshutdown = false;
 

bin/named/statschannel.c

@@ -3235,7 +3235,7 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
 	     isc_sockaddr_t *addr, cfg_aclconfctx_t *aclconfctx,
 	     const char *socktext)
 {
-	isc_result_t result;
+	isc_result_t result = ISC_R_SUCCESS;
 	named_statschannel_t *listener;
 	isc_task_t *task = NULL;
 	isc_socket_t *sock = NULL;
@@ -3243,8 +3243,6 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
 	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;
@@ -3252,11 +3250,7 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
 	listener->mctx = NULL;
 	ISC_LINK_INIT(listener, link);
 
-	result = isc_mutex_init(&listener->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(server->mctx, listener, sizeof(*listener));
-		return (ISC_R_FAILURE);
-	}
+	isc_mutex_init(&listener->lock);
 
 	isc_mem_attach(server->mctx, &listener->mctx);
 
@@ -3266,7 +3260,7 @@ add_listener(named_server_t *server, named_statschannel_t **listenerp,
 					    aclconfctx, listener->mctx, 0,
 					    &new_acl);
 	} else
-		result = dns_acl_any(listener->mctx, &new_acl);
+		dns_acl_any(listener->mctx, &new_acl);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
 	dns_acl_attach(new_acl, &listener->acl);
@@ -3394,7 +3388,7 @@ update_listener(named_server_t *server, named_statschannel_t **listenerp,
 					    aclconfctx, listener->mctx, 0,
 					    &new_acl);
 	} else
-		result = dns_acl_any(listener->mctx, &new_acl);
+		dns_acl_any(listener->mctx, &new_acl);
 
 	if (result == ISC_R_SUCCESS) {
 		LOCK(&listener->lock);

bin/named/tkeyconf.c

@@ -91,7 +91,7 @@ named_tkeyctx_fromconfig(const cfg_obj_t *options, isc_mem_t *mctx,
 			goto failure;
 		}
 		dns_name_init(tctx->domain, NULL);
-		RETERR(dns_name_dup(name, mctx, tctx->domain));
+		dns_name_dup(name, mctx, tctx->domain);
 	}
 
 	obj = NULL;

bin/named/tsigconf.c

@@ -155,9 +155,7 @@ named_tsigkeyring_fromconfig(const cfg_obj_t *config, const cfg_obj_t *vconfig,
 		maps[i++] = cfg_tuple_get(vconfig, "options");
 	maps[i] = NULL;
 
-	result = dns_tsigkeyring_create(mctx, &ring);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dns_tsigkeyring_create(mctx, &ring);
 
 	for (i = 0; ; i++) {
 		if (maps[i] == NULL)

bin/named/unix/dlz_dlopen_driver.c

@@ -226,35 +226,20 @@ dlopen_dlz_create(const char *dlzname, unsigned int argc, char *argv[],
 		return (ISC_R_FAILURE);
 	}
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	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;
 
 	cd->dl_path = isc_mem_strdup(cd->mctx, argv[1]);
-	if (cd->dl_path == NULL) {
-		result = ISC_R_NOMEMORY;
-		goto failed;
-	}
 
 	cd->dlzname = isc_mem_strdup(cd->mctx, dlzname);
-	if (cd->dlzname == NULL) {
-		result = ISC_R_NOMEMORY;
-		goto failed;
-	}
 
 	/* Initialize the lock */
-	result = isc_mutex_init(&cd->lock);
-	if (result != ISC_R_SUCCESS)
-		goto failed;
+	isc_mutex_init(&cd->lock);
 
 	/* Open the library */
 	dlopen_flags = RTLD_NOW|RTLD_GLOBAL;

bin/named/zoneconf.c

@@ -207,9 +207,7 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
 		updatepolicy = NULL;
 	}
 
-	result = dns_ssutable_create(mctx, &table);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dns_ssutable_create(mctx, &table);
 
 	for (element = cfg_list_first(updatepolicy);
 	     element != NULL;
@@ -320,16 +318,13 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
 		}
 		INSIST(i == n);
 
-		result = dns_ssutable_addrule(table, grant,
+		dns_ssutable_addrule(table, grant,
 					      dns_fixedname_name(&fident),
 					      mtype,
 					      dns_fixedname_name(&fname),
 					      n, types);
 		if (types != NULL)
 			isc_mem_put(mctx, types, n * sizeof(dns_rdatatype_t));
-		if (result != ISC_R_SUCCESS) {
-			goto cleanup;
-		}
 	}
 
 	/*
@@ -350,14 +345,11 @@ configure_zone_ssutable(const cfg_obj_t *zconfig, dns_zone_t *zone,
 			goto cleanup;
 		}
 
-		result = dns_ssutable_addrule(table, true,
+		dns_ssutable_addrule(table, true,
 					      named_g_server->session_keyname,
 					      dns_ssumatchtype_local,
 					      dns_zone_getorigin(zone),
 					      1, &any);
-
-		if (result != ISC_R_SUCCESS)
-			goto cleanup;
 	}
 
 	result = ISC_R_SUCCESS;
@@ -1144,10 +1136,10 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
 	zoneqrystats  = NULL;
 	rcvquerystats = NULL;
 	if (statlevel == dns_zonestat_full) {
-		RETERR(isc_stats_create(mctx, &zoneqrystats,
-					ns_statscounter_max));
-		RETERR(dns_rdatatypestats_create(mctx,
-					&rcvquerystats));
+		isc_stats_create(mctx, &zoneqrystats,
+					ns_statscounter_max);
+		dns_rdatatypestats_create(mctx,
+					&rcvquerystats);
 	}
 	dns_zone_setrequeststats(zone,  zoneqrystats);
 	dns_zone_setrcvquerystats(zone, rcvquerystats);
@@ -1744,7 +1736,7 @@ named_zone_configure(const cfg_obj_t *config, const cfg_obj_t *vconfig,
 						  &obj);
 				if (obj == NULL) {
 					dns_acl_t *none;
-					RETERR(dns_acl_none(mctx, &none));
+					dns_acl_none(mctx, &none);
 					dns_zone_setxfracl(zone, none);
 					dns_acl_detach(&none);
 				}
@@ -1880,9 +1872,7 @@ named_zone_configure_writeable_dlz(dns_dlzdb_t *dlzdatabase,
 	TIME_NOW(&now);
 
 	dns_zone_settype(zone, dns_zone_dlz);
-	result = dns_sdlz_setdb(dlzdatabase, rdclass, name, &db);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dns_sdlz_setdb(dlzdatabase, rdclass, name, &db);
 	result = dns_zone_dlzpostload(zone, db);
 	dns_db_detach(&db);
 	return (result);

bin/nsupdate/nsupdate.c

@@ -354,9 +354,8 @@ reset_system(void) {
 	if (updatemsg != NULL)
 		dns_message_reset(updatemsg, DNS_MESSAGE_INTENTRENDER);
 	else {
-		result = dns_message_create(gmctx, DNS_MESSAGE_INTENTRENDER,
+		dns_message_create(gmctx, DNS_MESSAGE_INTENTRENDER,
 					    &updatemsg);
-		check_result(result, "dns_message_create");
 	}
 	updatemsg->opcode = dns_opcode_update;
 	if (usegsstsig) {
@@ -876,14 +875,12 @@ setup_system(void) {
 
 	irs_resconf_destroy(&resconf);
 
-	result = dns_dispatchmgr_create(gmctx, &dispatchmgr);
-	check_result(result, "dns_dispatchmgr_create");
+	dns_dispatchmgr_create(gmctx, &dispatchmgr);
 
 	result = isc_socketmgr_create(gmctx, &socketmgr);
 	check_result(result, "dns_socketmgr_create");
 
-	result = isc_timermgr_create(gmctx, &timermgr);
-	check_result(result, "dns_timermgr_create");
+	isc_timermgr_create(gmctx, &timermgr);
 
 	result = isc_taskmgr_create(gmctx, 1, 0, &taskmgr);
 	check_result(result, "isc_taskmgr_create");
@@ -925,10 +922,9 @@ setup_system(void) {
 		check_result(result, "dns_dispatch_getudp (v4)");
 	}
 
-	result = dns_requestmgr_create(gmctx, timermgr,
+	dns_requestmgr_create(gmctx, timermgr,
 				       socketmgr, taskmgr, dispatchmgr,
 				       dispatchv4, dispatchv6, &requestmgr);
-	check_result(result, "dns_requestmgr_create");
 
 	if (keystr != NULL)
 		setup_keystr();
@@ -1215,8 +1211,7 @@ parse_name(char **cmdlinep, dns_message_t *msg, dns_name_t **namep) {
 
 	result = dns_message_gettempname(msg, namep);
 	check_result(result, "dns_message_gettempname");
-	result = isc_buffer_allocate(gmctx, &namebuf, DNS_NAME_MAXWIRE);
-	check_result(result, "isc_buffer_allocate");
+	isc_buffer_allocate(gmctx, &namebuf, DNS_NAME_MAXWIRE);
 	dns_name_init(*namep, NULL);
 	dns_name_setbuffer(*namep, namebuf);
 	dns_message_takebuffer(msg, &namebuf);
@@ -1255,22 +1250,18 @@ parse_rdata(char **cmdlinep, dns_rdataclass_t rdataclass,
 
 	if (*cmdline != 0) {
 		dns_rdatacallbacks_init(&callbacks);
-		result = isc_lex_create(gmctx, strlen(cmdline), &lex);
-		check_result(result, "isc_lex_create");
+		isc_lex_create(gmctx, strlen(cmdline), &lex);
 		isc_buffer_init(&source, cmdline, strlen(cmdline));
 		isc_buffer_add(&source, strlen(cmdline));
-		result = isc_lex_openbuffer(lex, &source);
-		check_result(result, "isc_lex_openbuffer");
-		result = isc_buffer_allocate(gmctx, &buf, MAXWIRE);
-		check_result(result, "isc_buffer_allocate");
+		isc_lex_openbuffer(lex, &source);
+		isc_buffer_allocate(gmctx, &buf, MAXWIRE);
 		result = dns_rdata_fromtext(NULL, rdataclass, rdatatype, lex,
 					    dns_rootname, 0, gmctx, buf,
 					    &callbacks);
 		isc_lex_destroy(&lex);
 		if (result == ISC_R_SUCCESS) {
 			isc_buffer_usedregion(buf, &r);
-			result = isc_buffer_allocate(gmctx, &newbuf, r.length);
-			check_result(result, "isc_buffer_allocate");
+			isc_buffer_allocate(gmctx, &newbuf, r.length);
 			isc_buffer_putmem(newbuf, r.base, r.length);
 			isc_buffer_usedregion(newbuf, &r);
 			dns_rdata_fromregion(rdata, rdataclass, rdatatype, &r);
@@ -2026,8 +2017,7 @@ show_message(FILE *stream, dns_message_t *msg, const char *description) {
 		}
 		if (buf != NULL)
 			isc_buffer_free(&buf);
-		result = isc_buffer_allocate(gmctx, &buf, bufsz);
-		check_result(result, "isc_buffer_allocate");
+		isc_buffer_allocate(gmctx, &buf, bufsz);
 		result = dns_message_totext(msg, style, 0, buf);
 		bufsz *= 2;
 	} while (result == ISC_R_NOSPACE);
@@ -2298,8 +2288,7 @@ update_completed(isc_task_t *task, isc_event_t *event) {
 		return;
 	}
 
-	result = dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &answer);
-	check_result(result, "dns_message_create");
+	dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &answer);
 	result = dns_request_getresponse(request, answer,
 					 DNS_MESSAGEPARSE_PRESERVEORDER);
 	switch (result) {
@@ -2480,8 +2469,7 @@ recvsoa(isc_task_t *task, isc_event_t *event) {
 	reqev = NULL;
 
 	ddebug("About to create rcvmsg");
-	result = dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
-	check_result(result, "dns_message_create");
+	dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
 	result = dns_request_getresponse(request, rcvmsg,
 					 DNS_MESSAGEPARSE_PRESERVEORDER);
 	if (result == DNS_R_TSIGERRORSET && servers != NULL) {
@@ -2793,11 +2781,7 @@ start_gssrequest(dns_name_t *master) {
 	if (gssring != NULL)
 		dns_tsigkeyring_detach(&gssring);
 	gssring = NULL;
-	result = dns_tsigkeyring_create(gmctx, &gssring);
-
-	if (result != ISC_R_SUCCESS)
-		fatal("dns_tsigkeyring_create failed: %s",
-		      isc_result_totext(result));
+	dns_tsigkeyring_create(gmctx, &gssring);
 
 	dns_name_format(master, namestr, sizeof(namestr));
 	if (kserver == NULL) {
@@ -2846,10 +2830,7 @@ start_gssrequest(dns_name_t *master) {
 	keyname->attributes |= DNS_NAMEATTR_NOCOMPRESS;
 
 	rmsg = NULL;
-	result = dns_message_create(gmctx, DNS_MESSAGE_INTENTRENDER, &rmsg);
-	if (result != ISC_R_SUCCESS)
-		fatal("dns_message_create failed: %s",
-		      isc_result_totext(result));
+	dns_message_create(gmctx, DNS_MESSAGE_INTENTRENDER, &rmsg);
 
 	/* Build first request. */
 	context = GSS_C_NO_CONTEXT;
@@ -2971,8 +2952,7 @@ recvgss(isc_task_t *task, isc_event_t *event) {
 	reqev = NULL;
 
 	ddebug("recvgss creating rcvmsg");
-	result = dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
-	check_result(result, "dns_message_create");
+	dns_message_create(gmctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
 
 	result = dns_request_getresponse(request, rcvmsg,
 					 DNS_MESSAGEPARSE_PRESERVEORDER);
@@ -3094,9 +3074,8 @@ start_update(void) {
 		return;
 	}
 
-	result = dns_message_create(gmctx, DNS_MESSAGE_INTENTRENDER,
+	dns_message_create(gmctx, DNS_MESSAGE_INTENTRENDER,
 				    &soaquery);
-	check_result(result, "dns_message_create");
 
 	if (default_servers)
 		soaquery->flags |= DNS_MESSAGEFLAG_RD;
@@ -3254,8 +3233,7 @@ main(int argc, char **argv) {
 
 	pre_parse_args(argc, argv);
 
-	result = isc_mem_create(0, 0, &gmctx);
-	check_result(result, "isc_mem_create");
+	isc_mem_create(0, 0, &gmctx);
 
 	parse_args(argc, argv);
 

bin/rndc/rndc.c

@@ -932,7 +932,7 @@ main(int argc, char **argv) {
 
 	serial = isc_random32();
 
-	DO("create memory context", isc_mem_create(0, 0, &rndc_mctx));
+	isc_mem_create(0, 0, &rndc_mctx);
 	DO("create socket manager", isc_socketmgr_create(rndc_mctx, &socketmgr));
 	DO("create task manager", isc_taskmgr_create(rndc_mctx, 1, 0, &taskmgr));
 	DO("create task", isc_task_create(taskmgr, 0, &task));
@@ -957,8 +957,7 @@ main(int argc, char **argv) {
 
 	command = *argv;
 
-	DO("allocate data buffer",
-	   isc_buffer_allocate(rndc_mctx, &databuf, 2048));
+	isc_buffer_allocate(rndc_mctx, &databuf, 2048);
 
 	/*
 	 * Convert argc/argv into a space-delimited command string

bin/tests/cfg_test.c

@@ -70,7 +70,7 @@ main(int argc, char **argv) {
 	char *filename = NULL;
 	unsigned int zonetype = 0;
 
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
 
 	result = isc_log_create(mctx, &lctx, &lcfg);
 	check_result(result, "isc_log_create()");

bin/tests/makejournal.c

@@ -97,7 +97,7 @@ main(int argc, char **argv) {
 	journal = argv[4];
 
 	isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
-	CHECK(isc_mem_create(0, 0, &mctx));
+	isc_mem_create(0, 0, &mctx);
 
 	CHECK(dst_lib_init(mctx, NULL));
 	dst_active = true;

bin/tests/system/dyndb/driver/db.c

@@ -769,7 +769,7 @@ create_db(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 	sampledb->common.attributes = 0;
 	sampledb->common.rdclass = rdclass;
 
-	CHECK(dns_name_dupwithoffsets(origin, mctx, &sampledb->common.origin));
+	dns_name_dupwithoffsets(origin, mctx, &sampledb->common.origin);
 
 	isc_refcount_init(&sampledb->refs, 1);
 

bin/tests/system/dyndb/driver/zone.c

@@ -51,7 +51,7 @@ create_zone(sample_instance_t * const inst, dns_name_t * const name,
 	CHECK(dns_zonemgr_managezone(inst->zmgr, raw));
 
 	/* This is completely insecure - use some sensible values instead! */
-	CHECK(dns_acl_any(inst->mctx, &acl_any));
+	dns_acl_any(inst->mctx, &acl_any);
 	dns_zone_setupdateacl(raw, acl_any);
 	dns_zone_setqueryacl(raw, acl_any);
 	dns_zone_setxfracl(raw, acl_any);

bin/tests/system/pipelined/pipequeries.c

@@ -88,8 +88,7 @@ recvresponse(isc_task_t *task, isc_event_t *event) {
 	query = reqev->ev_arg;
 
 	response = NULL;
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
-	CHECK("dns_message_create", result);
+	dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
 
 	result = dns_request_getresponse(reqev->request, response,
 					 DNS_MESSAGEPARSE_PRESERVEORDER);
@@ -152,8 +151,7 @@ sendquery(isc_task_t *task) {
 	CHECK("dns_name_fromtext", result);
 
 	message = NULL;
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &message);
-	CHECK("dns_message_create", result);
+	dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &message);
 
 	message->opcode = dns_opcode_query;
 	message->flags |= DNS_MESSAGEFLAG_RD;
@@ -270,7 +268,7 @@ main(int argc, char *argv[]) {
 	isc_sockaddr_fromin(&dstaddr, &inaddr, port);
 
 	mctx = NULL;
-	RUNCHECK(isc_mem_create(0, 0, &mctx));
+	isc_mem_create(0, 0, &mctx);
 
 	lctx = NULL;
 	lcfg = NULL;
@@ -284,11 +282,11 @@ main(int argc, char *argv[]) {
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;
 
-	RUNCHECK(isc_timermgr_create(mctx, &timermgr));
+	isc_timermgr_create(mctx, &timermgr);
 	socketmgr = NULL;
 	RUNCHECK(isc_socketmgr_create(mctx, &socketmgr));
 	dispatchmgr = NULL;
-	RUNCHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
+	dns_dispatchmgr_create(mctx, &dispatchmgr);
 
 	attrs = DNS_DISPATCHATTR_UDP |
 		DNS_DISPATCHATTR_MAKEQUERY |
@@ -303,9 +301,9 @@ main(int argc, char *argv[]) {
 				     4096, 4, 2, 3, 5,
 				     attrs, attrmask, &dispatchv4));
 	requestmgr = NULL;
-	RUNCHECK(dns_requestmgr_create(mctx, timermgr, socketmgr, taskmgr,
+	dns_requestmgr_create(mctx, timermgr, socketmgr, taskmgr,
 					    dispatchmgr, dispatchv4, NULL,
-					    &requestmgr));
+					    &requestmgr);
 
 	view = NULL;
 	RUNCHECK(dns_view_create(mctx, 0, "_test", &view));

bin/tests/system/rsabigexponent/bigkey.c

@@ -104,7 +104,7 @@ main(int argc, char **argv) {
 
 	dns_result_register();
 
-	CHECK(isc_mem_create(0, 0, &mctx), "isc_mem_create()");
+	isc_mem_create(0, 0, &mctx);
 	CHECK(dst_lib_init(mctx, NULL), "dst_lib_init()");
 	CHECK(isc_log_create(mctx, &log_, &logconfig), "isc_log_create()");
 	isc_log_setcontext(log_);

bin/tests/system/tkey/keycreate.c

@@ -87,8 +87,7 @@ recvquery(isc_task_t *task, isc_event_t *event) {
 	query = reqev->ev_arg;
 
 	response = NULL;
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
-	CHECK("dns_message_create", result);
+	dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
 
 	result = dns_request_getresponse(reqev->request, response,
 					 DNS_MESSAGEPARSE_PRESERVEORDER);
@@ -176,8 +175,7 @@ sendquery(isc_task_t *task, isc_event_t *event) {
 	CHECK("dns_tsigkey_create", result);
 
 	query = NULL;
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &query);
-	CHECK("dns_message_create", result);
+	dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &query);
 
 	result = dns_tkey_builddhquery(query, ourkey,
 				       dns_fixedname_name(&ownername),
@@ -230,7 +228,7 @@ main(int argc, char *argv[]) {
 
 	mctx = NULL;
 	isc_mem_debugging = ISC_MEM_DEBUGRECORD;
-	RUNCHECK(isc_mem_create(0, 0, &mctx));
+	isc_mem_create(0, 0, &mctx);
 
 	log = NULL;
 	logconfig = NULL;
@@ -243,11 +241,11 @@ main(int argc, char *argv[]) {
 	task = NULL;
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;
-	RUNCHECK(isc_timermgr_create(mctx, &timermgr));
+	isc_timermgr_create(mctx, &timermgr);
 	socketmgr = NULL;
 	RUNCHECK(isc_socketmgr_create(mctx, &socketmgr));
 	dispatchmgr = NULL;
-	RUNCHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
+	dns_dispatchmgr_create(mctx, &dispatchmgr);
 	isc_sockaddr_any(&bind_any);
 	attrs = DNS_DISPATCHATTR_UDP |
 		DNS_DISPATCHATTR_MAKEQUERY |
@@ -261,12 +259,12 @@ main(int argc, char *argv[]) {
 					  &bind_any, 4096, 4, 2, 3, 5,
 					  attrs, attrmask, &dispatchv4));
 	requestmgr = NULL;
-	RUNCHECK(dns_requestmgr_create(mctx, timermgr, socketmgr, taskmgr,
+	dns_requestmgr_create(mctx, timermgr, socketmgr, taskmgr,
 					    dispatchmgr, dispatchv4, NULL,
-					    &requestmgr));
+					    &requestmgr);
 
 	ring = NULL;
-	RUNCHECK(dns_tsigkeyring_create(mctx, &ring));
+	dns_tsigkeyring_create(mctx, &ring);
 	tctx = NULL;
 	RUNCHECK(dns_tkeyctx_create(mctx, &tctx));
 

bin/tests/system/tkey/keydelete.c

@@ -79,8 +79,7 @@ recvquery(isc_task_t *task, isc_event_t *event) {
 	query = reqev->ev_arg;
 
 	response = NULL;
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
-	CHECK("dns_message_create", result);
+	dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
 
 	result = dns_request_getresponse(reqev->request, response,
 					 DNS_MESSAGEPARSE_PRESERVEORDER);
@@ -120,8 +119,7 @@ sendquery(isc_task_t *task, isc_event_t *event) {
 	isc_sockaddr_fromin(&address, &inaddr, PORT);
 
 	query = NULL;
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &query);
-	CHECK("dns_message_create", result);
+	dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &query);
 
 	result = dns_tkey_builddeletequery(query, tsigkey);
 	CHECK("dns_tkey_builddeletequery", result);
@@ -169,7 +167,7 @@ main(int argc, char **argv) {
 	dns_result_register();
 
 	mctx = NULL;
-	RUNCHECK(isc_mem_create(0, 0, &mctx));
+	isc_mem_create(0, 0, &mctx);
 
 	log = NULL;
 	logconfig = NULL;
@@ -182,11 +180,11 @@ main(int argc, char **argv) {
 	task = NULL;
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;
-	RUNCHECK(isc_timermgr_create(mctx, &timermgr));
+	isc_timermgr_create(mctx, &timermgr);
 	socketmgr = NULL;
 	RUNCHECK(isc_socketmgr_create(mctx, &socketmgr));
 	dispatchmgr = NULL;
-	RUNCHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
+	dns_dispatchmgr_create(mctx, &dispatchmgr);
 	isc_sockaddr_any(&bind_any);
 	attrs = DNS_DISPATCHATTR_UDP |
 		DNS_DISPATCHATTR_MAKEQUERY |
@@ -200,12 +198,12 @@ main(int argc, char **argv) {
 					  &bind_any, 4096, 4, 2, 3, 5,
 					  attrs, attrmask, &dispatchv4));
 	requestmgr = NULL;
-	RUNCHECK(dns_requestmgr_create(mctx, timermgr, socketmgr, taskmgr,
+	dns_requestmgr_create(mctx, timermgr, socketmgr, taskmgr,
 					    dispatchmgr, dispatchv4, NULL,
-					    &requestmgr));
+					    &requestmgr);
 
 	ring = NULL;
-	RUNCHECK(dns_tsigkeyring_create(mctx, &ring));
+	dns_tsigkeyring_create(mctx, &ring);
 	tctx = NULL;
 	RUNCHECK(dns_tkeyctx_create(mctx, &tctx));
 

bin/tests/wire_test.c

@@ -138,7 +138,7 @@ main(int argc, char *argv[]) {
 	}
 	isc_commandline_reset = true;
 
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
 
 	while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
 		switch (ch) {
@@ -181,8 +181,7 @@ main(int argc, char *argv[]) {
 	} else
 		f = stdin;
 
-	result = isc_buffer_allocate(mctx, &input, 64 * 1024);
-	RUNTIME_CHECK(result == ISC_R_SUCCESS);
+	isc_buffer_allocate(mctx, &input, 64 * 1024);
 
 	if (rawdata) {
 		while (fread(&c, 1, 1, f) != 0) {
@@ -266,8 +265,7 @@ process_message(isc_buffer_t *source) {
 	int i;
 
 	message = NULL;
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &message);
-	CHECKRESULT(result, "dns_message_create failed");
+	dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &message);
 
 	result = dns_message_parse(message, source, parseflags);
 	if (result == DNS_R_RECOVERABLE)
@@ -297,8 +295,7 @@ process_message(isc_buffer_t *source) {
 		for (i = 0; i < DNS_SECTION_MAX; i++)
 			message->counts[i] = 0;  /* Another hack XXX */
 
-		result = dns_compress_init(&cctx, -1, mctx);
-		CHECKRESULT(result, "dns_compress_init() failed");
+		dns_compress_init(&cctx, -1, mctx);
 
 		result = dns_message_renderbegin(message, &cctx, &buffer);
 		CHECKRESULT(result, "dns_message_renderbegin() failed");
@@ -334,9 +331,8 @@ process_message(isc_buffer_t *source) {
 		if (printmemstats)
 			isc_mem_stats(mctx, stdout);
 
-		result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE,
+		dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE,
 					    &message);
-		CHECKRESULT(result, "dns_message_create failed");
 
 		result = dns_message_parse(message, &buffer, parseflags);
 		CHECKRESULT(result, "dns_message_parse failed");

bin/tools/mdig.c

@@ -234,8 +234,7 @@ recvresponse(isc_task_t *task, isc_event_t *event) {
 			exit(-1);
 	}
 
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
-	CHECK("dns_message_create", result);
+	dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &response);
 
 	parseflags |= DNS_MESSAGEPARSE_PRESERVEORDER;
 	if (besteffort) {
@@ -292,8 +291,7 @@ recvresponse(isc_task_t *task, isc_event_t *event) {
 	if (!display_comments)
 		flags |= DNS_MESSAGETEXTFLAG_NOCOMMENTS;
 
-	result = isc_buffer_allocate(mctx, &buf, len);
-	CHECK("isc_buffer_allocate", result);
+	isc_buffer_allocate(mctx, &buf, len);
 
 	if (display_comments && !display_short_form) {
 		printf(";; Got answer:\n");
@@ -346,11 +344,8 @@ repopulate_buffer:
 buftoosmall:
 			len += OUTPUTBUF;
 			isc_buffer_free(&buf);
-			result = isc_buffer_allocate(mctx, &buf, len);
-			if (result == ISC_R_SUCCESS)
-				goto repopulate_buffer;
-			else
-				goto cleanup;
+			isc_buffer_allocate(mctx, &buf, len);
+			goto repopulate_buffer;
 		}
 		CHECK("dns_message_pseudosectiontotext", result);
 	}
@@ -536,8 +531,7 @@ sendquery(struct query *query, isc_task_t *task)
 	CHECK("dns_name_fromtext", result);
 
 	message = NULL;
-	result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &message);
-	CHECK("dns_message_create", result);
+	dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &message);
 
 	message->opcode = dns_opcode_query;
 	if (query->recurse)
@@ -608,7 +602,6 @@ sendquery(struct query *query, isc_task_t *task)
 			INSIST(i < DNS_EDNSOPTIONS);
 			opts[i].code = DNS_OPT_CLIENT_SUBNET;
 			opts[i].length = (uint16_t) addrl + 4;
-			CHECK("isc_buffer_allocate", result);
 			isc_buffer_init(&b, ecsbuf, sizeof(ecsbuf));
 			if (sa->sa_family == AF_INET) {
 				family = 1;
@@ -1941,7 +1934,7 @@ main(int argc, char *argv[]) {
 	preparse_args(argc, argv);
 
 	mctx = NULL;
-	RUNCHECK(isc_mem_create(0, 0, &mctx));
+	isc_mem_create(0, 0, &mctx);
 
 	lctx = NULL;
 	lcfg = NULL;
@@ -1978,11 +1971,11 @@ main(int argc, char *argv[]) {
 	RUNCHECK(isc_task_create(taskmgr, 0, &task));
 	timermgr = NULL;
 
-	RUNCHECK(isc_timermgr_create(mctx, &timermgr));
+	isc_timermgr_create(mctx, &timermgr);
 	socketmgr = NULL;
 	RUNCHECK(isc_socketmgr_create(mctx, &socketmgr));
 	dispatchmgr = NULL;
-	RUNCHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
+	dns_dispatchmgr_create(mctx, &dispatchmgr);
 
 	attrs = DNS_DISPATCHATTR_UDP |
 		DNS_DISPATCHATTR_MAKEQUERY;
@@ -2003,11 +1996,11 @@ main(int argc, char *argv[]) {
 				     4096, 100, 100, 17, 19,
 				     attrs, attrmask, &dispatchvx));
 	requestmgr = NULL;
-	RUNCHECK(dns_requestmgr_create(mctx, timermgr, socketmgr,
+	dns_requestmgr_create(mctx, timermgr, socketmgr,
 				       taskmgr, dispatchmgr,
 				       have_ipv4 ? dispatchvx : NULL,
 				       have_ipv6 ? dispatchvx : NULL,
-				       &requestmgr));
+				       &requestmgr);
 
 	view = NULL;
 	RUNCHECK(dns_view_create(mctx, 0, "_test", &view));

bin/tools/named-journalprint.c

@@ -68,7 +68,7 @@ main(int argc, char **argv) {
 
 	file = argv[1];
 
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
 	RUNTIME_CHECK(setup_logging(mctx, stderr, &lctx) == ISC_R_SUCCESS);
 
 	result = dns_journal_print(mctx, file, stdout);

bin/tools/named-rrchecker.c

@@ -148,8 +148,8 @@ main(int argc, char *argv[]) {
 	if (doexit)
 		exit(0);
 
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
-	RUNTIME_CHECK(isc_lex_create(mctx, 256, &lex) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
+	isc_lex_create(mctx, 256, &lex);
 
 	/*
 	 * Set up to lex DNS master file.
@@ -162,7 +162,7 @@ main(int argc, char *argv[]) {
 	options = ISC_LEXOPT_EOL;
 	isc_lex_setcomments(lex, ISC_LEXCOMMENT_DNSMASTERFILE);
 
-	RUNTIME_CHECK(isc_lex_openstream(lex, stdin) == ISC_R_SUCCESS);
+	isc_lex_openstream(lex, stdin);
 
 	if (origin != NULL) {
 		name = dns_fixedname_initname(&fixed);

fuzz/fuzz.h

@@ -30,7 +30,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
 static isc_mem_t *mctx = NULL;
 
 static void __attribute__((constructor)) init(void) {
-	RUNTIME_CHECK(isc_mem_create(0, 0, &mctx) == ISC_R_SUCCESS);
+	isc_mem_create(0, 0, &mctx);
 	RUNTIME_CHECK(dst_lib_init(mctx, NULL) == ISC_R_SUCCESS);
 }
 

lib/dns/acl.c

@@ -30,9 +30,8 @@
  * for 'n' ACL elements.  The elements are uninitialized and the
  * length is 0.
  */
-isc_result_t
+void
 dns_acl_create(isc_mem_t *mctx, int n, dns_acl_t **target) {
-	isc_result_t result;
 	dns_acl_t *acl;
 
 	/*
@@ -42,9 +41,6 @@ dns_acl_create(isc_mem_t *mctx, int n, dns_acl_t **target) {
 		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);
 
@@ -52,11 +48,7 @@ dns_acl_create(isc_mem_t *mctx, int n, dns_acl_t **target) {
 
 	isc_refcount_init(&acl->refcount, 1);
 
-	result = dns_iptable_create(mctx, &acl->iptable);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, acl, sizeof(*acl));
-		return (result);
-	}
+	dns_iptable_create(mctx, &acl->iptable);
 
 	acl->elements = NULL;
 	acl->alloc = 0;
@@ -70,18 +62,9 @@ dns_acl_create(isc_mem_t *mctx, int n, dns_acl_t **target) {
 	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);
 }
 
 /*
@@ -90,39 +73,30 @@ dns_acl_create(isc_mem_t *mctx, int n, dns_acl_t **target) {
  * "any" is a positive iptable entry with bit length 0.
  * "none" is the same as "!any".
  */
-static isc_result_t
+static void
 dns_acl_anyornone(isc_mem_t *mctx, bool neg, dns_acl_t **target) {
-	isc_result_t result;
 	dns_acl_t *acl = NULL;
 
-	result = dns_acl_create(mctx, 0, &acl);
-	if (result != ISC_R_SUCCESS)
-		return (result);
-
-	result = dns_iptable_addprefix(acl->iptable, NULL, 0, !neg);
-	if (result != ISC_R_SUCCESS) {
-		dns_acl_detach(&acl);
-		return (result);
-	}
+	dns_acl_create(mctx, 0, &acl);
 
+	dns_iptable_addprefix(acl->iptable, NULL, 0, !neg);
 	*target = acl;
-	return (result);
 }
 
 /*
  * Create a new ACL that matches everything.
  */
-isc_result_t
+void
 dns_acl_any(isc_mem_t *mctx, dns_acl_t **target) {
-	return (dns_acl_anyornone(mctx, false, target));
+	dns_acl_anyornone(mctx, false, target);
 }
 
 /*
  * Create a new ACL that matches nothing.
  */
-isc_result_t
+void
 dns_acl_none(isc_mem_t *mctx, dns_acl_t **target) {
-	return (dns_acl_anyornone(mctx, true, target));
+	dns_acl_anyornone(mctx, true, target);
 }
 
 /*
@@ -262,10 +236,9 @@ dns_acl_match(const isc_netaddr_t *reqaddr,
  * but leave negatives alone, so as to prevent a double-negative causing
  * an unexpected positive match in the parent ACL.
  */
-isc_result_t
+void
 dns_acl_merge(dns_acl_t *dest, dns_acl_t *source, bool pos)
 {
-	isc_result_t result;
 	unsigned int newalloc, nelem, i;
 	int max_node = 0, nodes;
 
@@ -279,8 +252,6 @@ dns_acl_merge(dns_acl_t *dest, dns_acl_t *source, bool pos)
 
 		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));
@@ -324,11 +295,9 @@ dns_acl_merge(dns_acl_t *dest, dns_acl_t *source, bool pos)
 		/* Duplicate key name. */
 		if (source->elements[i].type == dns_aclelementtype_keyname) {
 			dns_name_init(&dest->elements[nelem+i].keyname, NULL);
-			result = dns_name_dup(&source->elements[i].keyname,
-					      dest->mctx,
-					      &dest->elements[nelem+i].keyname);
-			if (result != ISC_R_SUCCESS)
-				return result;
+			dns_name_dup(&source->elements[i].keyname,
+				     dest->mctx,
+				     &dest->elements[nelem+i].keyname);
 		}
 
 #ifdef HAVE_GEOIP
@@ -353,13 +322,9 @@ dns_acl_merge(dns_acl_t *dest, dns_acl_t *source, bool pos)
 	 * node_count value is set correctly afterward.
 	 */
 	nodes = max_node + dest->node_count;
-	result = dns_iptable_merge(dest->iptable, source->iptable, pos);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dns_iptable_merge(dest->iptable, source->iptable, pos);
 	if (nodes > dest->node_count)
 		dest->node_count = nodes;
-
-	return (ISC_R_SUCCESS);
 }
 
 /*
@@ -498,7 +463,7 @@ static bool	insecure_prefix_found;
 
 static void
 initialize_action(void) {
-	RUNTIME_CHECK(isc_mutex_init(&insecure_prefix_lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&insecure_prefix_lock);
 }
 
 /*
@@ -625,28 +590,18 @@ dns_acl_allowed(isc_netaddr_t *addr, dns_name_t *signer,
 /*
  * Initialize ACL environment, setting up localhost and localnets ACLs
  */
-isc_result_t
+void
 dns_aclenv_init(isc_mem_t *mctx, dns_aclenv_t *env) {
 	isc_result_t result;
 
 	env->localhost = NULL;
 	env->localnets = NULL;
-	result = dns_acl_create(mctx, 0, &env->localhost);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_nothing;
-	result = dns_acl_create(mctx, 0, &env->localnets);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_localhost;
+	dns_acl_create(mctx, 0, &env->localhost);
+	dns_acl_create(mctx, 0, &env->localnets);
 	env->match_mapped = false;
 #ifdef HAVE_GEOIP
 	env->geoip = NULL;
 #endif
-	return (ISC_R_SUCCESS);
-
- cleanup_localhost:
-	dns_acl_detach(&env->localhost);
- cleanup_nothing:
-	return (result);
 }
 
 void

lib/dns/adb.c

@@ -602,17 +602,11 @@ grow_entries(isc_task_t *task, isc_event_t *ev) {
 	newentrylocks = isc_mem_get(adb->mctx, sizeof(*newentrylocks) * n);
 	newentry_sd = isc_mem_get(adb->mctx, sizeof(*newentry_sd) * n);
 	newentry_refcnt = isc_mem_get(adb->mctx, sizeof(*newentry_refcnt) * n);
-	if (newentries == NULL || newdeadentries == NULL ||
-	    newentrylocks == NULL || newentry_sd == NULL ||
-	    newentry_refcnt == NULL)
-		goto cleanup;
 
 	/*
 	 * Initialise the new resources.
 	 */
-	result = isc_mutexblock_init(newentrylocks, n);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mutexblock_init(newentrylocks, n);
 
 	for (i = 0; i < n; i++) {
 		ISC_LIST_INIT(newentries[i]);
@@ -655,7 +649,7 @@ grow_entries(isc_task_t *task, isc_event_t *ev) {
 	/*
 	 * Cleanup old resources.
 	 */
-	DESTROYMUTEXBLOCK(adb->entrylocks, adb->nentries);
+	isc_mutexblock_destroy(adb->entrylocks, adb->nentries);
 	isc_mem_put(adb->mctx, adb->entries,
 		    sizeof(*adb->entries) * adb->nentries);
 	isc_mem_put(adb->mctx, adb->deadentries,
@@ -759,17 +753,11 @@ grow_names(isc_task_t *task, isc_event_t *ev) {
 	newnamelocks = isc_mem_get(adb->mctx, sizeof(*newnamelocks) * n);
 	newname_sd = isc_mem_get(adb->mctx, sizeof(*newname_sd) * n);
 	newname_refcnt = isc_mem_get(adb->mctx, sizeof(*newname_refcnt) * n);
-	if (newnames == NULL || newdeadnames == NULL ||
-	    newnamelocks == NULL || newname_sd == NULL ||
-	    newname_refcnt == NULL)
-		goto cleanup;
 
 	/*
 	 * Initialise the new resources.
 	 */
-	result = isc_mutexblock_init(newnamelocks, n);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mutexblock_init(newnamelocks, n);
 
 	for (i = 0; i < n; i++) {
 		ISC_LIST_INIT(newnames[i]);
@@ -812,7 +800,7 @@ grow_names(isc_task_t *task, isc_event_t *ev) {
 	/*
 	 * Cleanup old resources.
 	 */
-	DESTROYMUTEXBLOCK(adb->namelocks, adb->nnames);
+	isc_mutexblock_destroy(adb->namelocks, adb->nnames);
 	isc_mem_put(adb->mctx, adb->names,
 		    sizeof(*adb->names) * adb->nnames);
 	isc_mem_put(adb->mctx, adb->deadnames,
@@ -1408,10 +1396,8 @@ set_target(dns_adb_t *adb, const dns_name_t *name, const dns_name_t *fname,
 		result = dns_rdata_tostruct(&rdata, &cname, NULL);
 		if (result != ISC_R_SUCCESS)
 			return (result);
-		result = dns_name_dup(&cname.cname, adb->mctx, target);
+		dns_name_dup(&cname.cname, adb->mctx, target);
 		dns_rdata_freestruct(&cname);
-		if (result != ISC_R_SUCCESS)
-			return (result);
 	} else {
 		dns_rdata_dname_t dname;
 
@@ -1439,9 +1425,7 @@ set_target(dns_adb_t *adb, const dns_name_t *name, const dns_name_t *fname,
 		dns_rdata_freestruct(&dname);
 		if (result != ISC_R_SUCCESS)
 			return (result);
-		result = dns_name_dup(new_target, adb->mctx, target);
-		if (result != ISC_R_SUCCESS)
-			return (result);
+		dns_name_dup(new_target, adb->mctx, target);
 	}
 
 	return (ISC_R_SUCCESS);
@@ -1676,10 +1660,7 @@ new_adbname(dns_adb_t *adb, const dns_name_t *dnsname) {
 		return (NULL);
 
 	dns_name_init(&name->name, NULL);
-	if (dns_name_dup(dnsname, adb->mctx, &name->name) != ISC_R_SUCCESS) {
-		isc_mempool_put(adb->nmp, name);
-		return (NULL);
-	}
+	dns_name_dup(dnsname, adb->mctx, &name->name);
 	dns_name_init(&name->target, NULL);
 	name->magic = DNS_ADBNAME_MAGIC;
 	name->adb = adb;
@@ -1782,10 +1763,7 @@ new_adblameinfo(dns_adb_t *adb, const dns_name_t *qname,
 		return (NULL);
 
 	dns_name_init(&li->qname, NULL);
-	if (dns_name_dup(qname, adb->mctx, &li->qname) != ISC_R_SUCCESS) {
-		isc_mempool_put(adb->limp, li);
-		return (NULL);
-	}
+	dns_name_dup(qname, adb->mctx, &li->qname);
 	li->magic = DNS_ADBLAMEINFO_MAGIC;
 	li->lame_timer = 0;
 	li->qtype = qtype;
@@ -1921,11 +1899,7 @@ new_adbfind(dns_adb_t *adb) {
 	/*
 	 * private members
 	 */
-	result = isc_mutex_init(&h->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mempool_put(adb->ahmp, h);
-		return (NULL);
-	}
+	isc_mutex_init(&h->lock);
 
 	ISC_EVENT_INIT(&h->event, sizeof(isc_event_t), 0, 0, 0, NULL, NULL,
 		       NULL, NULL, h);
@@ -2481,7 +2455,7 @@ destroy(dns_adb_t *adb) {
 	isc_mempool_destroy(&adb->aimp);
 	isc_mempool_destroy(&adb->afmp);
 
-	DESTROYMUTEXBLOCK(adb->entrylocks, adb->nentries);
+	isc_mutexblock_destroy(adb->entrylocks, adb->nentries);
 	isc_mem_put(adb->mctx, adb->entries,
 		    sizeof(*adb->entries) * adb->nentries);
 	isc_mem_put(adb->mctx, adb->deadentries,
@@ -2493,7 +2467,7 @@ destroy(dns_adb_t *adb) {
 	isc_mem_put(adb->mctx, adb->entry_refcnt,
 		    sizeof(*adb->entry_refcnt) * adb->nentries);
 
-	DESTROYMUTEXBLOCK(adb->namelocks, adb->nnames);
+	isc_mutexblock_destroy(adb->namelocks, adb->nnames);
 	isc_mem_put(adb->mctx, adb->names,
 		    sizeof(*adb->names) * adb->nnames);
 	isc_mem_put(adb->mctx, adb->deadnames,
@@ -2520,7 +2494,7 @@ destroy(dns_adb_t *adb) {
  * Public functions.
  */
 
-isc_result_t
+void
 dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
 	       isc_taskmgr_t *taskmgr, dns_adb_t **newadb)
 {
@@ -2537,8 +2511,6 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
 	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
@@ -2607,69 +2579,30 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
 
 	isc_mem_attach(mem, &adb->mctx);
 
-	result = isc_mutex_init(&adb->lock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0b;
+	isc_mutex_init(&adb->lock);
+	isc_mutex_init(&adb->mplock);
+	isc_mutex_init(&adb->reflock);
+	isc_mutex_init(&adb->overmemlock);
+	isc_mutex_init(&adb->entriescntlock);
+	isc_mutex_init(&adb->namescntlock);
 
-	result = isc_mutex_init(&adb->mplock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0c;
-
-	result = isc_mutex_init(&adb->reflock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0d;
-
-	result = isc_mutex_init(&adb->overmemlock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0e;
-
-	result = isc_mutex_init(&adb->entriescntlock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0f;
-
-	result = isc_mutex_init(&adb->namescntlock);
-	if (result != ISC_R_SUCCESS)
-		goto fail0g;
-
-#define ALLOCENTRY(adb, el) \
-	do { \
-		(adb)->el = isc_mem_get((adb)->mctx, \
-				     sizeof(*(adb)->el) * (adb)->nentries); \
-		if ((adb)->el == NULL) { \
-			result = ISC_R_NOMEMORY; \
-			goto fail1; \
-		}\
-	} while (0)
-	ALLOCENTRY(adb, entries);
-	ALLOCENTRY(adb, deadentries);
-	ALLOCENTRY(adb, entrylocks);
-	ALLOCENTRY(adb, entry_sd);
-	ALLOCENTRY(adb, entry_refcnt);
-#undef ALLOCENTRY
-
-#define ALLOCNAME(adb, el) \
-	do { \
-		(adb)->el = isc_mem_get((adb)->mctx, \
-				     sizeof(*(adb)->el) * (adb)->nnames); \
-		if ((adb)->el == NULL) { \
-			result = ISC_R_NOMEMORY; \
-			goto fail1; \
-		}\
-	} while (0)
-	ALLOCNAME(adb, names);
-	ALLOCNAME(adb, deadnames);
-	ALLOCNAME(adb, namelocks);
-	ALLOCNAME(adb, name_sd);
-	ALLOCNAME(adb, name_refcnt);
-#undef ALLOCNAME
+	adb->entries = isc_mem_get(adb->mctx, sizeof(*adb->entries) * adb->nentries);
+	adb->deadentries = isc_mem_get(adb->mctx, sizeof(*adb->deadentries) * adb->nentries);
+	adb->entrylocks = isc_mem_get(adb->mctx, sizeof(*adb->entrylocks) * adb->nentries);
+	adb->entry_sd = isc_mem_get(adb->mctx, sizeof(*adb->entry_sd) * adb->nentries);
+	adb->entry_refcnt = isc_mem_get(adb->mctx, sizeof(*adb->entry_refcnt) * adb->nentries);
+	
+	adb->names = isc_mem_get(adb->mctx, sizeof(*adb->names) * adb->nnames);
+	adb->deadnames = isc_mem_get(adb->mctx, sizeof(*adb->deadnames) * adb->nnames);
+	adb->namelocks = isc_mem_get(adb->mctx, sizeof(*adb->namelocks) * adb->nnames);
+	adb->name_sd = isc_mem_get(adb->mctx, sizeof(*adb->name_sd) * adb->nnames);
+	adb->name_refcnt = isc_mem_get(adb->mctx, sizeof(*adb->name_refcnt) * adb->nnames);
 
 	/*
 	 * Initialize the bucket locks for names and elements.
 	 * May as well initialize the list heads, too.
 	 */
-	result = isc_mutexblock_init(adb->namelocks, adb->nnames);
-	if (result != ISC_R_SUCCESS)
-		goto fail1;
+	isc_mutexblock_init(adb->namelocks, adb->nnames);
 	for (i = 0; i < adb->nnames; i++) {
 		ISC_LIST_INIT(adb->names[i]);
 		ISC_LIST_INIT(adb->deadnames[i]);
@@ -2684,17 +2617,13 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
 		adb->entry_refcnt[i] = 0;
 		adb->irefcnt++;
 	}
-	result = isc_mutexblock_init(adb->entrylocks, adb->nentries);
-	if (result != ISC_R_SUCCESS)
-		goto fail2;
+	isc_mutexblock_init(adb->entrylocks, adb->nentries);
 
 	/*
 	 * Memory pools
 	 */
 #define MPINIT(t, p, n) do { \
-	result = isc_mempool_create(mem, sizeof(t), &(p)); \
-	if (result != ISC_R_SUCCESS) \
-		goto fail3; \
+	isc_mempool_create(mem, sizeof(t), &(p)); \
 	isc_mempool_setfreemax((p), FREE_ITEMS); \
 	isc_mempool_setfillcount((p), FILL_COUNT); \
 	isc_mempool_setname((p), n); \
@@ -2714,15 +2643,11 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
 	/*
 	 * Allocate an internal task.
 	 */
-	result = isc_task_create(adb->taskmgr, 0, &adb->task);
-	if (result != ISC_R_SUCCESS)
-		goto fail3;
+	RUNTIME_CHECK(isc_task_create(adb->taskmgr, 0, &adb->task) == ISC_R_SUCCESS);
 
 	isc_task_setname(adb->task, "ADB", adb);
 
-	result = isc_stats_create(adb->mctx, &view->adbstats, dns_adbstats_max);
-	if (result != ISC_R_SUCCESS)
-		goto fail3;
+	isc_stats_create(adb->mctx, &view->adbstats, dns_adbstats_max);
 
 	set_adbstat(adb, adb->nentries, dns_adbstats_nentries);
 	set_adbstat(adb, adb->nnames, dns_adbstats_nnames);
@@ -2732,81 +2657,6 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
 	 */
 	adb->magic = DNS_ADB_MAGIC;
 	*newadb = adb;
-	return (ISC_R_SUCCESS);
-
- fail3:
-	if (adb->task != NULL)
-		isc_task_detach(&adb->task);
-
-	/* clean up entrylocks */
-	DESTROYMUTEXBLOCK(adb->entrylocks, adb->nentries);
-
- fail2: /* clean up namelocks */
-	DESTROYMUTEXBLOCK(adb->namelocks, adb->nnames);
-
- fail1: /* clean up only allocated memory */
-	if (adb->entries != NULL)
-		isc_mem_put(adb->mctx, adb->entries,
-			    sizeof(*adb->entries) * adb->nentries);
-	if (adb->deadentries != NULL)
-		isc_mem_put(adb->mctx, adb->deadentries,
-			    sizeof(*adb->deadentries) * adb->nentries);
-	if (adb->entrylocks != NULL)
-		isc_mem_put(adb->mctx, adb->entrylocks,
-			    sizeof(*adb->entrylocks) * adb->nentries);
-	if (adb->entry_sd != NULL)
-		isc_mem_put(adb->mctx, adb->entry_sd,
-			    sizeof(*adb->entry_sd) * adb->nentries);
-	if (adb->entry_refcnt != NULL)
-		isc_mem_put(adb->mctx, adb->entry_refcnt,
-			    sizeof(*adb->entry_refcnt) * adb->nentries);
-	if (adb->names != NULL)
-		isc_mem_put(adb->mctx, adb->names,
-			    sizeof(*adb->names) * adb->nnames);
-	if (adb->deadnames != NULL)
-		isc_mem_put(adb->mctx, adb->deadnames,
-			    sizeof(*adb->deadnames) * adb->nnames);
-	if (adb->namelocks != NULL)
-		isc_mem_put(adb->mctx, adb->namelocks,
-			    sizeof(*adb->namelocks) * adb->nnames);
-	if (adb->name_sd != NULL)
-		isc_mem_put(adb->mctx, adb->name_sd,
-			    sizeof(*adb->name_sd) * adb->nnames);
-	if (adb->name_refcnt != NULL)
-		isc_mem_put(adb->mctx, adb->name_refcnt,
-			    sizeof(*adb->name_refcnt) * adb->nnames);
-	if (adb->nmp != NULL)
-		isc_mempool_destroy(&adb->nmp);
-	if (adb->nhmp != NULL)
-		isc_mempool_destroy(&adb->nhmp);
-	if (adb->limp != NULL)
-		isc_mempool_destroy(&adb->limp);
-	if (adb->emp != NULL)
-		isc_mempool_destroy(&adb->emp);
-	if (adb->ahmp != NULL)
-		isc_mempool_destroy(&adb->ahmp);
-	if (adb->aimp != NULL)
-		isc_mempool_destroy(&adb->aimp);
-	if (adb->afmp != NULL)
-		isc_mempool_destroy(&adb->afmp);
-
-	DESTROYLOCK(&adb->namescntlock);
- fail0g:
-	DESTROYLOCK(&adb->entriescntlock);
- fail0f:
-	DESTROYLOCK(&adb->overmemlock);
- fail0e:
-	DESTROYLOCK(&adb->reflock);
- fail0d:
-	DESTROYLOCK(&adb->mplock);
- fail0c:
-	DESTROYLOCK(&adb->lock);
- fail0b:
-	if (adb->excl != NULL)
-		isc_task_detach(&adb->excl);
-	isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
-
-	return (result);
 }
 
 void

lib/dns/badcache.c

@@ -58,32 +58,23 @@ struct dns_bcentry {
 	dns_name_t		name;
 };
 
-static isc_result_t
+static void
 badcache_resize(dns_badcache_t *bc, isc_time_t *now, bool grow);
 
-isc_result_t
+void
 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);
-	result = isc_mutex_init(&bc->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	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 *));
@@ -93,13 +84,6 @@ dns_badcache_init(isc_mem_t *mctx, unsigned int size, dns_badcache_t **bcp) {
 	bc->magic = BADCACHE_MAGIC;
 
 	*bcp = bc;
-	return (ISC_R_SUCCESS);
-
- destroy_lock:
-	DESTROYLOCK(&bc->lock);
- cleanup:
-	isc_mem_putanddetach(&bc->mctx, bc, sizeof(dns_badcache_t));
-	return (result);
 }
 
 void
@@ -118,7 +102,7 @@ dns_badcache_destroy(dns_badcache_t **bcp) {
 	*bcp = NULL;
 }
 
-static isc_result_t
+static void
 badcache_resize(dns_badcache_t *bc, isc_time_t *now, bool grow) {
 	dns_bcentry_t **newtable, *bad, *next;
 	unsigned int newsize, i;
@@ -129,8 +113,6 @@ badcache_resize(dns_badcache_t *bc, isc_time_t *now, bool grow) {
 		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++) {
@@ -151,8 +133,6 @@ badcache_resize(dns_badcache_t *bc, isc_time_t *now, bool grow) {
 	isc_mem_put(bc->mctx, bc->table, sizeof(*bc->table) * bc->size);
 	bc->size = newsize;
 	bc->table = newtable;
-
-	return (ISC_R_SUCCESS);
 }
 
 void

lib/dns/byaddr.c

@@ -132,17 +132,9 @@ copy_ptr_targets(dns_byaddr_t *byaddr, dns_rdataset_t *rdataset) {
 		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_name_dup(&ptr.ptr, byaddr->mctx, name);
 		dns_rdata_freestruct(&ptr);
-		if (result != ISC_R_SUCCESS) {
-			isc_mem_put(byaddr->mctx, name, sizeof(*name));
-			return (ISC_R_NOMEMORY);
-		}
 		ISC_LIST_APPEND(byaddr->event->names, name, link);
 		dns_rdata_reset(&rdata);
 		result = dns_rdataset_next(rdataset);
@@ -214,10 +206,7 @@ dns_byaddr_create(isc_mem_t *mctx, const isc_netaddr_t *address,
 	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);
@@ -227,9 +216,7 @@ dns_byaddr_create(isc_mem_t *mctx, const isc_netaddr_t *address,
 	byaddr->task = NULL;
 	isc_task_attach(task, &byaddr->task);
 
-	result = isc_mutex_init(&byaddr->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_event;
+	isc_mutex_init(&byaddr->lock);
 
 	dns_fixedname_init(&byaddr->name);
 
@@ -254,15 +241,12 @@ dns_byaddr_create(isc_mem_t *mctx, const isc_netaddr_t *address,
 
  cleanup_lock:
 	DESTROYLOCK(&byaddr->lock);
-
- cleanup_event:
 	ievent = (isc_event_t *)byaddr->event;
 	isc_event_free(&ievent);
 	byaddr->event = NULL;
 
 	isc_task_detach(&byaddr->task);
 
- cleanup_byaddr:
 	isc_mem_putanddetach(&mctx, byaddr, sizeof(*byaddr));
 
 	return (result);

lib/dns/cache.c

@@ -196,8 +196,6 @@ dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
 	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);
@@ -206,19 +204,10 @@ dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
 	cache->name = NULL;
 	if (cachename != NULL) {
 		cache->name = isc_mem_strdup(cmctx, cachename);
-		if (cache->name == NULL) {
-			result = ISC_R_NOMEMORY;
-			goto cleanup_mem;
-		}
 	}
 
-	result = isc_mutex_init(&cache->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_mem;
-
-	result = isc_mutex_init(&cache->filelock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_lock;
+	isc_mutex_init(&cache->lock);
+	isc_mutex_init(&cache->filelock);
 
 	cache->references = 1;
 	cache->live_tasks = 0;
@@ -226,16 +215,10 @@ dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
 	cache->serve_stale_ttl = 0;
 
 	cache->stats = NULL;
-	result = isc_stats_create(cmctx, &cache->stats,
+	isc_stats_create(cmctx, &cache->stats,
 				  dns_cachestatscounter_max);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_filelock;
 
 	cache->db_type = isc_mem_strdup(cmctx, db_type);
-	if (cache->db_type == NULL) {
-		result = ISC_R_NOMEMORY;
-		goto cleanup_stats;
-	}
 
 	/*
 	 * For databases of type "rbt" we pass hmctx to dns_db_create()
@@ -251,10 +234,6 @@ dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
 	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;
@@ -263,10 +242,6 @@ dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
 		for (i = extra; i < cache->db_argc; i++) {
 			cache->db_argv[i] = isc_mem_strdup(cmctx,
 							   db_argv[i - extra]);
-			if (cache->db_argv[i] == NULL) {
-				result = ISC_R_NOMEMORY;
-				goto cleanup_dbargv;
-			}
 		}
 	}
 
@@ -279,9 +254,7 @@ dns_cache_create(isc_mem_t *cmctx, isc_mem_t *hmctx, isc_taskmgr_t *taskmgr,
 		goto cleanup_dbargv;
 	if (taskmgr != NULL) {
 		dbtask = NULL;
-		result = isc_task_create(taskmgr, 1, &dbtask);
-		if (result != ISC_R_SUCCESS)
-			goto cleanup_db;
+		RUNTIME_CHECK(isc_task_create(taskmgr, 1, &dbtask) == ISC_R_SUCCESS);
 
 		isc_task_setname(dbtask, "cache_dbtask", NULL);
 		dns_db_settask(cache->db, dbtask);
@@ -596,9 +569,7 @@ cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
 {
 	isc_result_t result;
 
-	result = isc_mutex_init(&cleaner->lock);
-	if (result != ISC_R_SUCCESS)
-		goto fail;
+	isc_mutex_init(&cleaner->lock);
 
 	cleaner->increment = DNS_CACHE_CLEANERINCREMENT;
 	cleaner->state = cleaner_s_idle;
@@ -619,14 +590,7 @@ cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
 		goto cleanup;
 
 	if (taskmgr != NULL && timermgr != NULL) {
-		result = isc_task_create(taskmgr, 1, &cleaner->task);
-		if (result != ISC_R_SUCCESS) {
-			UNEXPECTED_ERROR(__FILE__, __LINE__,
-					 "isc_task_create() failed: %s",
-					 dns_result_totext(result));
-			result = ISC_R_UNEXPECTED;
-			goto cleanup;
-		}
+		RUNTIME_CHECK(isc_task_create(taskmgr, 1, &cleaner->task) == ISC_R_SUCCESS);
 		cleaner->cache->live_tasks++;
 		isc_task_setname(cleaner->task, "cachecleaner", cleaner);
 
@@ -657,20 +621,12 @@ cache_cleaner_init(dns_cache_t *cache, isc_taskmgr_t *taskmgr,
 					   DNS_EVENT_CACHECLEAN,
 					   incremental_cleaning_action,
 					   cleaner, sizeof(isc_event_t));
-		if (cleaner->resched_event == NULL) {
-			result = ISC_R_NOMEMORY;
-			goto cleanup;
-		}
 
 		cleaner->overmem_event =
 			isc_event_allocate(cache->mctx, cleaner,
 					   DNS_EVENT_CACHEOVERMEM,
 					   overmem_cleaning_action,
 					   cleaner, sizeof(isc_event_t));
-		if (cleaner->overmem_event == NULL) {
-			result = ISC_R_NOMEMORY;
-			goto cleanup;
-		}
 	}
 
 	return (ISC_R_SUCCESS);

lib/dns/catz.c

@@ -190,9 +190,7 @@ dns_catz_entry_new(isc_mem_t *mctx, const dns_name_t *domain,
 
 	dns_name_init(&nentry->name, NULL);
 	if (domain != NULL) {
-		result = dns_name_dup(domain, mctx, &nentry->name);
-		if (result != ISC_R_SUCCESS)
-			goto cleanup;
+		dns_name_dup(domain, mctx, &nentry->name);
 	}
 
 	dns_catz_options_init(&nentry->opts);
@@ -354,33 +352,19 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) {
 
 	dns_name_format(&target->name, czname, DNS_NAME_FORMATSIZE);
 
-	result = isc_ht_init(&toadd, target->catzs->mctx, 16);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_ht_init(&toadd, target->catzs->mctx, 16);
 
-	result = isc_ht_init(&tomod, target->catzs->mctx, 16);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_ht_init(&tomod, target->catzs->mctx, 16);
+	isc_ht_iter_create(newzone->entries, &iter1);
 
-	result = isc_ht_iter_create(newzone->entries, &iter1);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
-
-	result = isc_ht_iter_create(target->entries, &iter2);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_ht_iter_create(target->entries, &iter2);
 
 	/*
 	 * We can create those iterators now, even though toadd and tomod are
 	 * empty
 	 */
-	result = isc_ht_iter_create(toadd, &iteradd);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
-
-	result = isc_ht_iter_create(tomod, &itermod);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_ht_iter_create(toadd, &iteradd);
+	isc_ht_iter_create(tomod, &itermod);
 
 	/*
 	 * First - walk the new zone and find all nodes that are not in the
@@ -541,7 +525,7 @@ cleanup:
 
 }
 
-isc_result_t
+void
 dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm,
 		   isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
 		   isc_timermgr_t *timermgr)
@@ -553,41 +537,22 @@ dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm,
 	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));
 
-	result = isc_mutex_init(&new_zones->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_newzones;
+	isc_mutex_init(&new_zones->lock);
 
 	isc_refcount_init(&new_zones->refs, 1);
 
-	result = isc_ht_init(&new_zones->zones, mctx, 4);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_refcount;
+	isc_ht_init(&new_zones->zones, mctx, 4);
 
 	isc_mem_attach(mctx, &new_zones->mctx);
 	new_zones->zmm = zmm;
 	new_zones->timermgr = timermgr;
 	new_zones->taskmgr = taskmgr;
 
-	result = isc_task_create(taskmgr, 0, &new_zones->updater);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_ht;
+	RUNTIME_CHECK(isc_task_create(taskmgr, 0, &new_zones->updater) == ISC_R_SUCCESS);
 
 	*catzsp = new_zones;
-	return (ISC_R_SUCCESS);
-
-  cleanup_ht:
-	isc_ht_destroy(&new_zones->zones);
-  cleanup_refcount:
-	isc_refcount_destroy(&new_zones->refs);
-	isc_mutex_destroy(&new_zones->lock);
-  cleanup_newzones:
-	isc_mem_put(mctx, new_zones, sizeof(*new_zones));
-
-	return (result);
 }
 
 void
@@ -617,13 +582,9 @@ dns_catz_new_zone(dns_catz_zones_t *catzs, dns_catz_zone_t **zonep,
 
 	dns_name_init(&new_zone->name, NULL);
 
-	result = dns_name_dup(name, catzs->mctx, &new_zone->name);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_newzone;
+	dns_name_dup(name, catzs->mctx, &new_zone->name);
 
-	result = isc_ht_init(&new_zone->entries, catzs->mctx, 4);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_name;
+	isc_ht_init(&new_zone->entries, catzs->mctx, 4);
 
 	new_zone->updatetimer = NULL;
 	result = isc_timer_create(catzs->timermgr, isc_timertype_inactive,
@@ -744,8 +705,7 @@ dns_catz_zone_detach(dns_catz_zone_t **zonep) {
 		if (zone->entries != NULL) {
 			isc_ht_iter_t *iter = NULL;
 			isc_result_t result;
-			result = isc_ht_iter_create(zone->entries, &iter);
-			INSIST(result == ISC_R_SUCCESS);
+			isc_ht_iter_create(zone->entries, &iter);
 			for (result = isc_ht_iter_first(iter);
 			     result == ISC_R_SUCCESS;
 			     result = isc_ht_iter_delcurrent_next(iter))
@@ -800,8 +760,7 @@ dns_catz_catzs_detach(dns_catz_zones_t **catzsp) {
 		if (catzs->zones != NULL) {
 			isc_ht_iter_t *iter = NULL;
 			isc_result_t result;
-			result = isc_ht_iter_create(catzs->zones, &iter);
-			INSIST(result == ISC_R_SUCCESS);
+			isc_ht_iter_create(catzs->zones, &iter);
 			for (result = isc_ht_iter_first(iter);
 			     result == ISC_R_SUCCESS;)
 			{
@@ -917,12 +876,8 @@ catz_process_zones_entry(dns_catz_zone_t *zone, dns_rdataset_t *value,
 			dns_rdata_freestruct(&ptr);
 			return (ISC_R_FAILURE);
 		} else {
-			result = dns_name_dup(&ptr.ptr, zone->catzs->mctx,
+			dns_name_dup(&ptr.ptr, zone->catzs->mctx,
 					      &entry->name);
-			if (result != ISC_R_SUCCESS) {
-				dns_rdata_freestruct(&ptr);
-				return (result);
-			}
 		}
 	} else {
 		result = dns_catz_entry_new(zone->catzs->mctx, &ptr.ptr,
@@ -1116,11 +1071,7 @@ catz_process_masters(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl,
 				memmove(&ipkl->addrs[i], &sockaddr,
 					sizeof(isc_sockaddr_t));
 		} else {
-			result = dns_ipkeylist_resize(mctx, ipkl,
-						      i+1);
-			if (result != ISC_R_SUCCESS) {
-				return (result);
-			}
+			dns_ipkeylist_resize(mctx, ipkl, i+1);
 
 			ipkl->labels[i] = isc_mem_get(mctx, sizeof(dns_name_t));
 			if (ipkl->labels[i] == NULL)  {
@@ -1132,15 +1083,7 @@ catz_process_masters(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl,
 				return (ISC_R_NOMEMORY);
 			}
 			dns_name_init(ipkl->labels[i], NULL);
-			result = dns_name_dup(name, mctx, ipkl->labels[i]);
-			if (result != ISC_R_SUCCESS) {
-				if (keyname != NULL) {
-					dns_name_free(keyname, mctx);
-					isc_mem_put(mctx, keyname,
-						    sizeof(dns_name_t));
-				}
-				return (result);
-			}
+			dns_name_dup(name, mctx, ipkl->labels[i]);
 
 			if (value->type == dns_rdatatype_txt)
 				ipkl->keys[i] = keyname;
@@ -1159,10 +1102,7 @@ catz_process_masters(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl,
 
 	rcount = dns_rdataset_count(value) + ipkl->count;
 
-	result = dns_ipkeylist_resize(mctx, ipkl, rcount);
-	if (result != ISC_R_SUCCESS) {
-		return (result);
-	}
+	dns_ipkeylist_resize(mctx, ipkl, rcount);
 
 	for (result = dns_rdataset_first(value);
 	     result == ISC_R_SUCCESS;
@@ -1228,10 +1168,9 @@ catz_process_apl(dns_catz_zone_t *zone, isc_buffer_t **aclbp,
 	result = dns_rdata_tostruct(&rdata, &rdata_apl, zone->catzs->mctx);
 	if (result != ISC_R_SUCCESS)
 		return (result);
-	result = isc_buffer_allocate(zone->catzs->mctx, &aclb, 16);
+	isc_buffer_allocate(zone->catzs->mctx, &aclb, 16);
 	isc_buffer_setautorealloc(aclb, true);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+
 	for (result = dns_rdata_apl_first(&rdata_apl);
 	     result == ISC_R_SUCCESS;
 	     result = dns_rdata_apl_next(&rdata_apl)) {
@@ -1434,11 +1373,9 @@ dns_catz_generate_masterfilename(dns_catz_zone_t *zone, dns_catz_entry_t *entry,
 	REQUIRE(entry != NULL);
 	REQUIRE(buffer != NULL && *buffer != NULL);
 
-	result = isc_buffer_allocate(zone->catzs->mctx, &tbuf,
+	isc_buffer_allocate(zone->catzs->mctx, &tbuf,
 				     strlen(zone->catzs->view->name) +
 				     2 * DNS_NAME_FORMATSIZE + 2);
-	if (result != ISC_R_SUCCESS)
-		return (result);
 	INSIST(tbuf != NULL);
 
 	isc_buffer_putstr(tbuf, zone->catzs->view->name);
@@ -1515,11 +1452,8 @@ dns_catz_generate_zonecfg(dns_catz_zone_t *zone, dns_catz_entry_t *entry,
 	 * The buffer will be reallocated if something won't fit,
 	 * ISC_BUFFER_INCR seems like a good start.
 	 */
-	result = isc_buffer_allocate(zone->catzs->mctx, &buffer,
+	isc_buffer_allocate(zone->catzs->mctx, &buffer,
 				     ISC_BUFFER_INCR);
-	if (result != ISC_R_SUCCESS) {
-		goto cleanup;
-	}
 
 	isc_buffer_setautorealloc(buffer, true);
 	isc_buffer_putstr(buffer, "zone ");
@@ -1892,11 +1826,10 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) {
 	 * call onupdate() artificially so we can register the callback here.
 	 */
 	if (oldzone->db_registered == false) {
-		result = dns_db_updatenotify_register(db,
+		dns_db_updatenotify_register(db,
 						    dns_catz_dbupdate_callback,
 						    oldzone->catzs);
-		if (result == ISC_R_SUCCESS)
-			oldzone->db_registered = true;
+		oldzone->db_registered = true;
 	}
 }
 
@@ -1908,8 +1841,7 @@ dns_catz_prereconfig(dns_catz_zones_t *catzs) {
 
 	REQUIRE(catzs != NULL);
 
-	result = isc_ht_iter_create(catzs->zones, &iter);
-	INSIST(result == ISC_R_SUCCESS);
+	isc_ht_iter_create(catzs->zones, &iter);
 	for (result = isc_ht_iter_first(iter);
 	     result == ISC_R_SUCCESS;
 	     result = isc_ht_iter_next(iter))
@@ -1929,8 +1861,7 @@ dns_catz_postreconfig(dns_catz_zones_t *catzs) {
 	dns_catz_zone_t *zone;
 
 	LOCK(&catzs->lock);
-	result = isc_ht_iter_create(catzs->zones, &iter);
-	INSIST(result == ISC_R_SUCCESS);
+	isc_ht_iter_create(catzs->zones, &iter);
 	for (result = isc_ht_iter_first(iter);
 	     result == ISC_R_SUCCESS;)
 	{
@@ -1967,7 +1898,7 @@ dns_catz_postreconfig(dns_catz_zones_t *catzs) {
 	isc_ht_iter_destroy(&iter);
 }
 
-isc_result_t
+void
 dns_catz_get_iterator(dns_catz_zone_t *catz, isc_ht_iter_t **itp) {
-	return (isc_ht_iter_create(catz->entries, itp));
+	isc_ht_iter_create(catz->entries, itp);
 }

lib/dns/client.c

@@ -320,19 +320,11 @@ createview(isc_mem_t *mctx, dns_rdataclass_t rdclass,
 		return (result);
 
 	/* Initialize view security roots */
-	result = dns_view_initsecroots(view, mctx);
-	if (result != ISC_R_SUCCESS) {
-		dns_view_detach(&view);
-		return (result);
-	}
+	dns_view_initsecroots(view, mctx);
 
-	result = dns_view_createresolver(view, taskmgr, ntasks, 1,
+	dns_view_createresolver(view, taskmgr, ntasks, 1,
 					 socketmgr, timermgr, 0,
 					 dispatchmgr, dispatchv4, dispatchv6);
-	if (result != ISC_R_SUCCESS) {
-		dns_view_detach(&view);
-		return (result);
-	}
 
 	/*
 	 * Set cache DB.
@@ -369,9 +361,8 @@ dns_client_create(dns_client_t **clientp, unsigned int options) {
 	unsigned int logdebuglevel = 0;
 #endif
 
-	result = isc_mem_create(0, 0, &mctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_mem_create(0, 0, &mctx);
+
 	result = isc_appctx_create(mctx, &actx);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
@@ -384,9 +375,7 @@ dns_client_create(dns_client_t **clientp, unsigned int options) {
 	result = isc_socketmgr_createinctx(mctx, actx, &socketmgr);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
-	result = isc_timermgr_createinctx(mctx, actx, &timermgr);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_timermgr_createinctx(mctx, actx, &timermgr);
 #if 0
 	result = isc_log_create(mctx, &lctx, &logconfig);
 	if (result != ISC_R_SUCCESS)
@@ -446,14 +435,8 @@ dns_client_createx(isc_mem_t *mctx, isc_appctx_t *actx,
 	REQUIRE(clientp != NULL && *clientp == NULL);
 
 	client = isc_mem_get(mctx, sizeof(*client));
-	if (client == NULL)
-		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&client->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, client, sizeof(*client));
-		return (result);
-	}
+	isc_mutex_init(&client->lock);
 
 	client->actx = actx;
 	client->taskmgr = taskmgr;
@@ -461,13 +444,9 @@ dns_client_createx(isc_mem_t *mctx, isc_appctx_t *actx,
 	client->timermgr = timermgr;
 
 	client->task = NULL;
-	result = isc_task_create(client->taskmgr, 0, &client->task);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	RUNTIME_CHECK(isc_task_create(client->taskmgr, 0, &client->task) == ISC_R_SUCCESS);
 
-	result = dns_dispatchmgr_create(mctx, &dispatchmgr);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	dns_dispatchmgr_create(mctx, &dispatchmgr);
 	client->dispatchmgr = dispatchmgr;
 
 	/*
@@ -897,10 +876,7 @@ client_resfind(resctx_t *rctx, dns_fetchevent_t *event) {
 
 				aname = dns_fixedname_name(&rctx->name);
 				dns_name_init(ansname, NULL);
-				tresult = dns_name_dup(aname, mctx, ansname);
-				if (tresult != ISC_R_SUCCESS)
-					isc_mem_put(mctx, ansname,
-						    sizeof(*ansname));
+				dns_name_dup(aname, mctx, ansname);
 			}
 			if (tresult != ISC_R_SUCCESS)
 				result = tresult;
@@ -1240,14 +1216,8 @@ dns_client_resolve(dns_client_t *client, const dns_name_t *name,
 		actx = client->actx;
 
 	resarg = isc_mem_get(client->mctx, sizeof(*resarg));
-	if (resarg == NULL)
-		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&resarg->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(client->mctx, resarg, sizeof(*resarg));
-		return (result);
-	}
+	isc_mutex_init(&resarg->lock);
 
 	resarg->actx = actx;
 	resarg->client = client;
@@ -1352,17 +1322,7 @@ dns_client_startresolve(dns_client_t *client, const dns_name_t *name,
 	ISC_LIST_INIT(event->answerlist);
 
 	rctx = isc_mem_get(mctx, sizeof(*rctx));
-	if (rctx == NULL)
-		result = ISC_R_NOMEMORY;
-	else {
-		result = isc_mutex_init(&rctx->lock);
-		if (result != ISC_R_SUCCESS) {
-			isc_mem_put(mctx, rctx, sizeof(*rctx));
-			rctx = NULL;
-		}
-	}
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mutex_init(&rctx->lock);
 
 	result = getrdataset(mctx, &rdataset);
 	if (result != ISC_R_SUCCESS)
@@ -1651,14 +1611,8 @@ dns_client_request(dns_client_t *client, dns_message_t *qmessage,
 		actx = client->actx;
 
 	reqarg = isc_mem_get(client->mctx, sizeof(*reqarg));
-	if (reqarg == NULL)
-		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&reqarg->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(client->mctx, reqarg, sizeof(*reqarg));
-		return (result);
-	}
+	isc_mutex_init(&reqarg->lock);
 
 	reqarg->actx = actx;
 	reqarg->client = client;
@@ -1757,17 +1711,7 @@ dns_client_startrequest(dns_client_t *client, dns_message_t *qmessage,
 	}
 
 	ctx = isc_mem_get(client->mctx, sizeof(*ctx));
-	if (ctx == NULL)
-		result = ISC_R_NOMEMORY;
-	else {
-		result = isc_mutex_init(&ctx->lock);
-		if (result != ISC_R_SUCCESS) {
-			isc_mem_put(client->mctx, ctx, sizeof(*ctx));
-			ctx = NULL;
-		}
-	}
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mutex_init(&ctx->lock);
 
 	ctx->client = client;
 	ISC_LINK_INIT(ctx, link);
@@ -1951,10 +1895,8 @@ update_done(isc_task_t *task, isc_event_t *event) {
 	if (result != ISC_R_SUCCESS)
 		goto out;
 
-	result = dns_message_create(client->mctx, DNS_MESSAGE_INTENTPARSE,
+	dns_message_create(client->mctx, DNS_MESSAGE_INTENTPARSE,
 				    &answer);
-	if (result != ISC_R_SUCCESS)
-		goto out;
 	uctx->state = dns_clientupdatestate_done;
 	result = dns_request_getresponse(request, answer,
 					 DNS_MESSAGEPARSE_PRESERVEORDER);
@@ -2297,10 +2239,8 @@ receive_soa(isc_task_t *task, isc_event_t *event) {
 		goto out;
 	}
 
-	result = dns_message_create(uctx->client->mctx,
+	dns_message_create(uctx->client->mctx,
 				    DNS_MESSAGE_INTENTPARSE, &rcvmsg);
-	if (result != ISC_R_SUCCESS)
-		goto out;
 	result = dns_request_getresponse(request, rcvmsg,
 					 DNS_MESSAGEPARSE_PRESERVEORDER);
 
@@ -2454,11 +2394,9 @@ request_soa(updatectx_t *uctx) {
 	unsigned int reqoptions;
 
 	if (soaquery == NULL) {
-		result = dns_message_create(uctx->client->mctx,
+		dns_message_create(uctx->client->mctx,
 					    DNS_MESSAGE_INTENTRENDER,
 					    &soaquery);
-		if (result != ISC_R_SUCCESS)
-			return (result);
 	}
 	soaquery->flags |= DNS_MESSAGEFLAG_RD;
 	result = dns_message_gettempname(soaquery, &name);
@@ -2586,9 +2524,7 @@ copy_name(isc_mem_t *mctx, dns_message_t *msg, const dns_name_t *name,
 	result = dns_message_gettempname(msg, &newname);
 	if (result != ISC_R_SUCCESS)
 		return (result);
-	result = isc_buffer_allocate(mctx, &namebuf, DNS_NAME_MAXWIRE);
-	if (result != ISC_R_SUCCESS)
-		goto fail;
+	isc_buffer_allocate(mctx, &namebuf, DNS_NAME_MAXWIRE);
 	dns_name_init(newname, NULL);
 	dns_name_setbuffer(newname, namebuf);
 	dns_message_takebuffer(msg, &namebuf);
@@ -2619,10 +2555,8 @@ copy_name(isc_mem_t *mctx, dns_message_t *msg, const dns_name_t *name,
 				goto fail;
 			dns_rdata_toregion(&rdata, &r);
 			rdatabuf = NULL;
-			result = isc_buffer_allocate(mctx, &rdatabuf,
+			isc_buffer_allocate(mctx, &rdatabuf,
 						     r.length);
-			if (result != ISC_R_SUCCESS)
-				goto fail;
 			isc_buffer_putmem(rdatabuf, r.base, r.length);
 			isc_buffer_usedregion(rdatabuf, &r);
 			dns_rdata_init(newrdata);
@@ -2710,14 +2644,8 @@ dns_client_update(dns_client_t *client, dns_rdataclass_t rdclass,
 		actx = client->actx;
 
 	uarg = isc_mem_get(client->mctx, sizeof(*uarg));
-	if (uarg == NULL)
-		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&uarg->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(client->mctx, uarg, sizeof(*uarg));
-		return (result);
-	}
+	isc_mutex_init(&uarg->lock);
 
 	uarg->actx = actx;
 	uarg->client = client;
@@ -2860,12 +2788,7 @@ dns_client_startupdate(dns_client_t *client, dns_rdataclass_t rdclass,
 		return (ISC_R_NOMEMORY);
 	}
 
-	result = isc_mutex_init(&uctx->lock);
-	if (result != ISC_R_SUCCESS) {
-		dns_view_detach(&view);
-		isc_mem_put(client->mctx, uctx, sizeof(*uctx));
-		return (ISC_R_NOMEMORY);
-	}
+	isc_mutex_init(&uctx->lock);
 
 	tclone = NULL;
 	isc_task_attach(task, &tclone);
@@ -2922,10 +2845,8 @@ dns_client_startupdate(dns_client_t *client, dns_rdataclass_t rdclass,
 	}
 
 	/* Make update message */
-	result = dns_message_create(client->mctx, DNS_MESSAGE_INTENTRENDER,
+	dns_message_create(client->mctx, DNS_MESSAGE_INTENTRENDER,
 				    &uctx->updatemsg);
-	if (result != ISC_R_SUCCESS)
-		goto fail;
 	uctx->updatemsg->opcode = dns_opcode_update;
 
 	if (prerequisites != NULL) {

lib/dns/compress.c

@@ -142,7 +142,7 @@ static unsigned char tableindex[256] = {
  ***	Compression
  ***/
 
-isc_result_t
+void
 dns_compress_init(dns_compress_t *cctx, int edns, isc_mem_t *mctx) {
 	REQUIRE(cctx != NULL);
 	REQUIRE(mctx != NULL);	/* See: rdataset.c:towiresorted(). */
@@ -155,8 +155,6 @@ dns_compress_init(dns_compress_t *cctx, int edns, isc_mem_t *mctx) {
 	memset(&cctx->table[0], 0, sizeof(cctx->table));
 
 	cctx->magic = CCTX_MAGIC;
-
-	return (ISC_R_SUCCESS);
 }
 
 void

lib/dns/db.c

@@ -68,7 +68,7 @@ static dns_dbimplementation_t rbtimp;
 
 static void
 initialize(void) {
-	RUNTIME_CHECK(isc_rwlock_init(&implock, 0, 0) == ISC_R_SUCCESS);
+	isc_rwlock_init(&implock, 0, 0);
 
 	rbtimp.name = "rbt";
 	rbtimp.create = dns_rbtdb_create;
@@ -881,10 +881,6 @@ dns_db_register(const char *name, dns_dbcreatefunc_t create, void *driverarg,
 	}
 
 	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;
@@ -1031,7 +1027,7 @@ dns_db_rpz_ready(dns_db_t *db) {
 /**
  * Attach a notify-on-update function the database
  */
-isc_result_t
+void
 dns_db_updatenotify_register(dns_db_t *db,
 			     dns_dbupdate_callback_t fn,
 			     void *fn_arg)
@@ -1042,16 +1038,12 @@ dns_db_updatenotify_register(dns_db_t *db,
 	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;
 
 	ISC_LINK_INIT(listener, link);
 	ISC_LIST_APPEND(db->update_listeners, listener, link);
-
-	return (ISC_R_SUCCESS);
 }
 
 isc_result_t

lib/dns/dbtable.c

@@ -48,7 +48,7 @@ dbdetach(void *data, void *arg) {
 	dns_db_detach(&db);
 }
 
-isc_result_t
+void
 dns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
 		   dns_dbtable_t **dbtablep)
 {
@@ -59,21 +59,13 @@ dns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
 	REQUIRE(dbtablep != NULL && *dbtablep == NULL);
 
 	dbtable = (dns_dbtable_t *)isc_mem_get(mctx, sizeof(*dbtable));
-	if (dbtable == NULL)
-		return (ISC_R_NOMEMORY);
 
 	dbtable->rbt = NULL;
-	result = dns_rbt_create(mctx, dbdetach, NULL, &dbtable->rbt);
-	if (result != ISC_R_SUCCESS)
-		goto clean1;
+	dns_rbt_create(mctx, dbdetach, NULL, &dbtable->rbt);
 
-	result = isc_mutex_init(&dbtable->lock);
-	if (result != ISC_R_SUCCESS)
-		goto clean2;
+	isc_mutex_init(&dbtable->lock);
 
-	result = isc_rwlock_init(&dbtable->tree_lock, 0, 0);
-	if (result != ISC_R_SUCCESS)
-		goto clean3;
+	isc_rwlock_init(&dbtable->tree_lock, 0, 0);
 
 	dbtable->default_db = NULL;
 	dbtable->mctx = NULL;
@@ -83,19 +75,6 @@ dns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
 	dbtable->references = 1;
 
 	*dbtablep = dbtable;
-
-	return (ISC_R_SUCCESS);
-
- clean3:
-	DESTROYLOCK(&dbtable->lock);
-
- clean2:
-	dns_rbt_destroy(&dbtable->rbt);
-
- clean1:
-	isc_mem_putanddetach(&mctx, dbtable, sizeof(*dbtable));
-
-	return (result);
 }
 
 static inline void

lib/dns/dispatch.c

@@ -310,9 +310,9 @@ static isc_result_t dispatch_createudp(dns_dispatchmgr_t *mgr,
 				       isc_socket_t *dup_socket);
 static bool destroy_mgr_ok(dns_dispatchmgr_t *mgr);
 static void destroy_mgr(dns_dispatchmgr_t **mgrp);
-static isc_result_t qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
-				 unsigned int increment, dns_qid_t **qidp,
-				 bool needaddrtable);
+static void qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
+			 unsigned int increment, dns_qid_t **qidp,
+			 bool needaddrtable);
 static void qid_destroy(isc_mem_t *mctx, dns_qid_t **qidp);
 static isc_result_t open_socket(isc_socketmgr_t *mgr,
 				const isc_sockaddr_t *local,
@@ -983,8 +983,6 @@ allocate_devent(dns_dispatch_t *disp) {
 	dns_dispatchevent_t *ev;
 
 	ev = isc_mempool_get(disp->mgr->depool);
-	if (ev == NULL)
-		return (NULL);
 	ISC_EVENT_INIT(ev, sizeof(*ev), 0, NULL, 0,
 		       NULL, NULL, NULL, NULL, NULL);
 
@@ -1249,10 +1247,6 @@ udp_recv(isc_event_t *ev_in, dns_dispatch_t *disp, dispsocket_t *dispsock) {
   sendresponse:
 	queue_response = resp->item_out;
 	rev = allocate_devent(resp->disp);
-	if (rev == NULL) {
-		free_buffer(disp, ev->region.base, ev->region.length);
-		goto unlock;
-	}
 
 	/*
 	 * At this point, rev contains the event we want to fill in, and
@@ -1446,8 +1440,6 @@ tcp_recv(isc_task_t *task, isc_event_t *ev_in) {
 		goto unlock;
 	queue_response = resp->item_out;
 	rev = allocate_devent(disp);
-	if (rev == NULL)
-		goto unlock;
 
 	/*
 	 * At this point, rev contains the event we want to fill in, and
@@ -1718,27 +1710,22 @@ open_socket(isc_socketmgr_t *mgr, const isc_sockaddr_t *local,
  * normally set the ports explicitly, but is provided to fill some minor corner
  * cases.
  */
-static isc_result_t
+static void
 create_default_portset(isc_mem_t *mctx, isc_portset_t **portsetp) {
 	isc_result_t result;
 
-	result = isc_portset_create(mctx, portsetp);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_portset_create(mctx, portsetp);
 	isc_portset_addrange(*portsetp, 1024, 65535);
-
-	return (ISC_R_SUCCESS);
 }
 
 /*
  * Publics.
  */
 
-isc_result_t
+void
 dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp)
 {
 	dns_dispatchmgr_t *mgr;
-	isc_result_t result;
 	isc_portset_t *v4portset = NULL;
 	isc_portset_t *v6portset = NULL;
 
@@ -1746,8 +1733,6 @@ dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp)
 	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);
@@ -1755,54 +1740,24 @@ dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp)
 	mgr->blackhole = NULL;
 	mgr->stats = NULL;
 
-	result = isc_mutex_init(&mgr->lock);
-	if (result != ISC_R_SUCCESS)
-		goto deallocate;
-
-	result = isc_mutex_init(&mgr->buffer_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_lock;
-
-	result = isc_mutex_init(&mgr->depool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_buffer_lock;
-
-	result = isc_mutex_init(&mgr->rpool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_depool_lock;
-
-	result = isc_mutex_init(&mgr->dpool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_rpool_lock;
-
-	result = isc_mutex_init(&mgr->bpool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_dpool_lock;
-
-	result = isc_mutex_init(&mgr->spool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_bpool_lock;
-
+	isc_mutex_init(&mgr->lock);
+	isc_mutex_init(&mgr->buffer_lock);
+	isc_mutex_init(&mgr->depool_lock);
+	isc_mutex_init(&mgr->rpool_lock);
+	isc_mutex_init(&mgr->dpool_lock);
+	isc_mutex_init(&mgr->bpool_lock);
+	isc_mutex_init(&mgr->spool_lock);
+	
 	mgr->depool = NULL;
-	if (isc_mempool_create(mgr->mctx, sizeof(dns_dispatchevent_t),
-			       &mgr->depool) != ISC_R_SUCCESS) {
-		result = ISC_R_NOMEMORY;
-		goto kill_spool_lock;
-	}
-
+	isc_mempool_create(mgr->mctx, sizeof(dns_dispatchevent_t),
+			       &mgr->depool);
 	mgr->rpool = NULL;
-	if (isc_mempool_create(mgr->mctx, sizeof(dns_dispentry_t),
-			       &mgr->rpool) != ISC_R_SUCCESS) {
-		result = ISC_R_NOMEMORY;
-		goto kill_depool;
-	}
+	isc_mempool_create(mgr->mctx, sizeof(dns_dispentry_t),
+			       &mgr->rpool);
 
 	mgr->dpool = NULL;
-	if (isc_mempool_create(mgr->mctx, sizeof(dns_dispatch_t),
-			       &mgr->dpool) != ISC_R_SUCCESS) {
-		result = ISC_R_NOMEMORY;
-		goto kill_rpool;
-	}
+	isc_mempool_create(mgr->mctx, sizeof(dns_dispatch_t),
+			       &mgr->dpool);
 
 	isc_mempool_setname(mgr->depool, "dispmgr_depool");
 	isc_mempool_setmaxalloc(mgr->depool, 32768);
@@ -1836,50 +1791,16 @@ dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp)
 	mgr->nv6ports = 0;
 	mgr->magic = DNS_DISPATCHMGR_MAGIC;
 
-	result = create_default_portset(mctx, &v4portset);
-	if (result == ISC_R_SUCCESS) {
-		result = create_default_portset(mctx, &v6portset);
-		if (result == ISC_R_SUCCESS) {
-			result = dns_dispatchmgr_setavailports(mgr,
-							       v4portset,
-							       v6portset);
-		}
-	}
+	create_default_portset(mctx, &v4portset);
+	create_default_portset(mctx, &v6portset);
+	dns_dispatchmgr_setavailports(mgr, v4portset, v6portset);
+
 	if (v4portset != NULL)
 		isc_portset_destroy(mctx, &v4portset);
 	if (v6portset != NULL)
 		isc_portset_destroy(mctx, &v6portset);
-	if (result != ISC_R_SUCCESS)
-		goto kill_dpool;
 
 	*mgrp = mgr;
-	return (ISC_R_SUCCESS);
-
- kill_dpool:
-	isc_mempool_destroy(&mgr->dpool);
- kill_rpool:
-	isc_mempool_destroy(&mgr->rpool);
- kill_depool:
-	isc_mempool_destroy(&mgr->depool);
- kill_spool_lock:
-	DESTROYLOCK(&mgr->spool_lock);
- kill_bpool_lock:
-	DESTROYLOCK(&mgr->bpool_lock);
- kill_dpool_lock:
-	DESTROYLOCK(&mgr->dpool_lock);
- kill_rpool_lock:
-	DESTROYLOCK(&mgr->rpool_lock);
- kill_depool_lock:
-	DESTROYLOCK(&mgr->depool_lock);
- kill_buffer_lock:
-	DESTROYLOCK(&mgr->buffer_lock);
- kill_lock:
-	DESTROYLOCK(&mgr->lock);
- deallocate:
-	isc_mem_put(mctx, mgr, sizeof(dns_dispatchmgr_t));
-	isc_mem_detach(&mctx);
-
-	return (result);
 }
 
 void
@@ -1913,7 +1834,7 @@ dns_dispatchmgr_getblackportlist(dns_dispatchmgr_t *mgr) {
 	return (NULL);		/* this function is deprecated */
 }
 
-isc_result_t
+void
 dns_dispatchmgr_setavailports(dns_dispatchmgr_t *mgr, isc_portset_t *v4portset,
 			      isc_portset_t *v6portset)
 {
@@ -1928,20 +1849,10 @@ dns_dispatchmgr_setavailports(dns_dispatchmgr_t *mgr, isc_portset_t *v4portset,
 	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;
@@ -1974,18 +1885,14 @@ dns_dispatchmgr_setavailports(dns_dispatchmgr_t *mgr, isc_portset_t *v4portset,
 	mgr->v6ports = v6ports;
 	mgr->nv6ports = nv6ports;
 	PORTBUFUNLOCK(mgr);
-
-	return (ISC_R_SUCCESS);
 }
 
-static isc_result_t
+static void
 dns_dispatchmgr_setudp(dns_dispatchmgr_t *mgr,
 		       unsigned int buffersize, unsigned int maxbuffers,
 		       unsigned int maxrequests, unsigned int buckets,
 		       unsigned int increment)
 {
-	isc_result_t result;
-
 	REQUIRE(VALID_DISPATCHMGR(mgr));
 	REQUIRE(buffersize >= 512 && buffersize < (64 * 1024));
 	REQUIRE(maxbuffers > 0);
@@ -2026,11 +1933,7 @@ dns_dispatchmgr_setudp(dns_dispatchmgr_t *mgr,
 			mgr->maxbuffers = maxbuffers;
 		}
 	} else {
-		result = isc_mempool_create(mgr->mctx, buffersize, &mgr->bpool);
-		if (result != ISC_R_SUCCESS) {
-			UNLOCK(&mgr->buffer_lock);
-			return (result);
-		}
+		isc_mempool_create(mgr->mctx, buffersize, &mgr->bpool);
 		isc_mempool_setname(mgr->bpool, "dispmgr_bpool");
 		isc_mempool_setmaxalloc(mgr->bpool, maxbuffers);
 		isc_mempool_setfreemax(mgr->bpool, maxbuffers);
@@ -2047,12 +1950,10 @@ dns_dispatchmgr_setudp(dns_dispatchmgr_t *mgr,
 					       DNS_DISPATCH_POOLSOCKS * 2);
 		}
 		UNLOCK(&mgr->buffer_lock);
-		return (ISC_R_SUCCESS);
+		return;
 	}
-	result = isc_mempool_create(mgr->mctx, sizeof(dispsocket_t),
+	isc_mempool_create(mgr->mctx, sizeof(dispsocket_t),
 				    &mgr->spool);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
 
 	isc_mempool_setname(mgr->spool, "dispmgr_spool");
 	isc_mempool_setmaxalloc(mgr->spool, maxrequests);
@@ -2060,21 +1961,11 @@ dns_dispatchmgr_setudp(dns_dispatchmgr_t *mgr,
 	isc_mempool_associatelock(mgr->spool, &mgr->spool_lock);
 	isc_mempool_setfillcount(mgr->spool, 32);
 
-	result = qid_allocate(mgr, buckets, increment, &mgr->qid, true);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	qid_allocate(mgr, buckets, increment, &mgr->qid, true);
 
 	mgr->buffersize = buffersize;
 	mgr->maxbuffers = maxbuffers;
 	UNLOCK(&mgr->buffer_lock);
-	return (ISC_R_SUCCESS);
-
- cleanup:
-	isc_mempool_destroy(&mgr->bpool);
-	if (mgr->spool != NULL)
-		isc_mempool_destroy(&mgr->spool);
-	UNLOCK(&mgr->buffer_lock);
-	return (result);
 }
 
 void
@@ -2250,7 +2141,7 @@ dispatch_find(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *local,
 	return (result);
 }
 
-static isc_result_t
+static void
 qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
 	     unsigned int increment, dns_qid_t **qidp,
 	     bool needsocktable)
@@ -2265,40 +2156,16 @@ qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
 	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);
-		}
-	}
-
-	result = isc_mutex_init(&qid->lock);
-	if (result != ISC_R_SUCCESS) {
-		if (qid->sock_table != NULL) {
-			isc_mem_put(mgr->mctx, qid->sock_table,
-				    buckets * sizeof(dispsocketlist_t));
-		}
-		isc_mem_put(mgr->mctx, qid->qid_table,
-			    buckets * sizeof(dns_displist_t));
-		isc_mem_put(mgr->mctx, qid, sizeof(*qid));
-		return (result);
 	}
 
+	isc_mutex_init(&qid->lock);
 	for (i = 0; i < buckets; i++) {
 		ISC_LIST_INIT(qid->qid_table[i]);
 		if (qid->sock_table != NULL)
@@ -2309,7 +2176,6 @@ qid_allocate(dns_dispatchmgr_t *mgr, unsigned int buckets,
 	qid->qid_increment = increment;
 	qid->magic = QID_MAGIC;
 	*qidp = qid;
-	return (ISC_R_SUCCESS);
 }
 
 static void
@@ -2336,7 +2202,7 @@ qid_destroy(isc_mem_t *mctx, dns_qid_t **qidp) {
 /*
  * Allocate and set important limits.
  */
-static isc_result_t
+static void
 dispatch_allocate(dns_dispatchmgr_t *mgr, unsigned int maxrequests,
 		  dns_dispatch_t **dispp)
 {
@@ -2352,8 +2218,6 @@ dispatch_allocate(dns_dispatchmgr_t *mgr, unsigned int maxrequests,
 	 */
 
 	disp = isc_mempool_get(mgr->dpool);
-	if (disp == NULL)
-		return (ISC_R_NOMEMORY);
 
 	disp->magic = 0;
 	disp->mgr = mgr;
@@ -2380,30 +2244,12 @@ dispatch_allocate(dns_dispatchmgr_t *mgr, unsigned int maxrequests,
 	disp->portpool = NULL;
 	disp->dscp = -1;
 
-	result = isc_mutex_init(&disp->lock);
-	if (result != ISC_R_SUCCESS)
-		goto deallocate;
+	isc_mutex_init(&disp->lock);
 
 	disp->failsafe_ev = allocate_devent(disp);
-	if (disp->failsafe_ev == NULL) {
-		result = ISC_R_NOMEMORY;
-		goto kill_lock;
-	}
-
 	disp->magic = DISPATCH_MAGIC;
 
 	*dispp = disp;
-	return (ISC_R_SUCCESS);
-
-	/*
-	 * error returns
-	 */
- kill_lock:
-	DESTROYLOCK(&disp->lock);
- deallocate:
-	isc_mempool_put(mgr->dpool, disp);
-
-	return (result);
 }
 
 
@@ -2457,7 +2303,7 @@ dispatch_free(dns_dispatch_t **dispp) {
 	isc_mempool_put(mgr->dpool, disp);
 }
 
-isc_result_t
+void
 dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
 		       isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
 		       const isc_sockaddr_t *destaddr, unsigned int buffersize,
@@ -2465,7 +2311,6 @@ dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
 		       unsigned int buckets, unsigned int increment,
 		       unsigned int attributes, dns_dispatch_t **dispp)
 {
-	isc_result_t result;
 	dns_dispatch_t *disp;
 
 	UNUSED(maxbuffers);
@@ -2486,15 +2331,9 @@ dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
 	 * qid_allocate() checks buckets and increment for us.
 	 */
 	disp = NULL;
-	result = dispatch_allocate(mgr, maxrequests, &disp);
-	if (result != ISC_R_SUCCESS) {
-		UNLOCK(&mgr->lock);
-		return (result);
-	}
+	dispatch_allocate(mgr, maxrequests, &disp);
 
-	result = qid_allocate(mgr, buckets, increment, &disp->qid, false);
-	if (result != ISC_R_SUCCESS)
-		goto deallocate_dispatch;
+	qid_allocate(mgr, buckets, increment, &disp->qid, false);
 
 	disp->socktype = isc_sockettype_tcp;
 	disp->socket = NULL;
@@ -2504,19 +2343,12 @@ dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
 
 	disp->ntasks = 1;
 	disp->task[0] = NULL;
-	result = isc_task_create(taskmgr, 0, &disp->task[0]);
-	if (result != ISC_R_SUCCESS)
-		goto kill_socket;
+	RUNTIME_CHECK(isc_task_create(taskmgr, 0, &disp->task[0]) == ISC_R_SUCCESS);
 
 	disp->ctlevent = isc_event_allocate(mgr->mctx, disp,
 					    DNS_EVENT_DISPATCHCONTROL,
 					    destroy_disp, disp,
 					    sizeof(isc_event_t));
-	if (disp->ctlevent == NULL) {
-		result = ISC_R_NOMEMORY;
-		goto kill_task;
-	}
-
 	isc_task_setname(disp->task[0], "tcpdispatch", disp);
 
 	dns_tcpmsg_init(mgr->mctx, disp->socket, &disp->tcpmsg);
@@ -2550,22 +2382,6 @@ dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
 	mgr_log(mgr, LVL(90), "created TCP dispatcher %p", disp);
 	dispatch_log(disp, LVL(90), "created task %p", disp->task[0]);
 	*dispp = disp;
-
-	return (ISC_R_SUCCESS);
-
-	/*
-	 * Error returns.
-	 */
- kill_task:
-	isc_task_detach(&disp->task[0]);
- kill_socket:
-	isc_socket_detach(&disp->socket);
- deallocate_dispatch:
-	dispatch_free(&disp);
-
-	UNLOCK(&mgr->lock);
-
-	return (result);
 }
 
 isc_result_t
@@ -2669,10 +2485,8 @@ dns_dispatch_getudp_dup(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 	REQUIRE(dispp != NULL && *dispp == NULL);
 	REQUIRE((attributes & DNS_DISPATCHATTR_TCP) == 0);
 
-	result = dns_dispatchmgr_setudp(mgr, buffersize, maxbuffers,
+	dns_dispatchmgr_setudp(mgr, buffersize, maxbuffers,
 					maxrequests, buckets, increment);
-	if (result != ISC_R_SUCCESS)
-		return (result);
 
 	LOCK(&mgr->lock);
 
@@ -2878,9 +2692,7 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 	 * dispatch_allocate() checks mgr for us.
 	 */
 	disp = NULL;
-	result = dispatch_allocate(mgr, maxrequests, &disp);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dispatch_allocate(mgr, maxrequests, &disp);
 
 	disp->socktype = isc_sockettype_udp;
 
@@ -2921,15 +2733,11 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 		disp->port_table = isc_mem_get(mgr->mctx,
 					       sizeof(disp->port_table[0]) *
 					       DNS_DISPATCH_PORTTABLESIZE);
-		if (disp->port_table == NULL)
-			goto deallocate_dispatch;
 		for (i = 0; i < DNS_DISPATCH_PORTTABLESIZE; i++)
 			ISC_LIST_INIT(disp->port_table[i]);
 
-		result = isc_mempool_create(mgr->mctx, sizeof(dispportentry_t),
+		isc_mempool_create(mgr->mctx, sizeof(dispportentry_t),
 					    &disp->portpool);
-		if (result != ISC_R_SUCCESS)
-			goto deallocate_dispatch;
 		isc_mempool_setname(disp->portpool, "disp_portpool");
 		isc_mempool_setfreemax(disp->portpool, 128);
 	}
@@ -2942,14 +2750,7 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 		disp->ntasks = 1;
 	for (i = 0; i < disp->ntasks; i++) {
 		disp->task[i] = NULL;
-		result = isc_task_create(taskmgr, 0, &disp->task[i]);
-		if (result != ISC_R_SUCCESS) {
-			while (--i >= 0) {
-				isc_task_shutdown(disp->task[i]);
-				isc_task_detach(&disp->task[i]);
-			}
-			goto kill_socket;
-		}
+		RUNTIME_CHECK(isc_task_create(taskmgr, 0, &disp->task[i]) == ISC_R_SUCCESS);
 		isc_task_setname(disp->task[i], "udpdispatch", disp);
 	}
 
@@ -2957,22 +2758,11 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 					    DNS_EVENT_DISPATCHCONTROL,
 					    destroy_disp, disp,
 					    sizeof(isc_event_t));
-	if (disp->ctlevent == NULL) {
-		result = ISC_R_NOMEMORY;
-		goto kill_task;
-	}
-
 	disp->sepool = NULL;
-	if (isc_mempool_create(mgr->mctx, sizeof(isc_socketevent_t),
-			       &disp->sepool) != ISC_R_SUCCESS)
-	{
-		result = ISC_R_NOMEMORY;
-		goto kill_ctlevent;
-	}
+	isc_mempool_create(mgr->mctx, sizeof(isc_socketevent_t),
+			       &disp->sepool);
 
-	result = isc_mutex_init(&disp->sepool_lock);
-	if (result != ISC_R_SUCCESS)
-		goto kill_sepool;
+	isc_mutex_init(&disp->sepool_lock);
 
 	isc_mempool_setname(disp->sepool, "disp_sepool");
 	isc_mempool_setmaxalloc(disp->sepool, 32768);
@@ -3001,16 +2791,6 @@ dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
 	/*
 	 * Error returns.
 	 */
- kill_sepool:
-	isc_mempool_destroy(&disp->sepool);
- kill_ctlevent:
-	isc_event_free(&disp->ctlevent);
- kill_task:
-	for (i = 0; i < disp->ntasks; i++)
-		isc_task_detach(&disp->task[i]);
- kill_socket:
-	if (disp->socket != NULL)
-		isc_socket_detach(&disp->socket);
  deallocate_dispatch:
 	dispatch_free(&disp);
 
@@ -3122,22 +2902,7 @@ dns_dispatch_addresponse(dns_dispatch_t *disp, unsigned int options,
 		oldestsocket = ISC_LIST_HEAD(disp->activesockets);
 		oldestresp = oldestsocket->resp;
 		if (oldestresp != NULL && !oldestresp->item_out) {
-			rev = allocate_devent(oldestresp->disp);
-			if (rev != NULL) {
-				rev->buffer.base = NULL;
-				rev->result = ISC_R_CANCELED;
-				rev->id = oldestresp->id;
-				ISC_EVENT_INIT(rev, sizeof(*rev), 0,
-					       NULL, DNS_EVENT_DISPATCH,
-					       oldestresp->action,
-					       oldestresp->arg, oldestresp,
-					       NULL, NULL);
-				oldestresp->item_out = true;
-				isc_task_send(oldestresp->task,
-					      ISC_EVENT_PTR(&rev));
-				inc_stats(disp->mgr,
-					  dns_resstatscounter_dispabort);
-			}
+			allocate_devent(oldestresp->disp);
 		}
 
 		/*
@@ -3667,19 +3432,11 @@ dns_dispatchset_create(isc_mem_t *mctx, isc_socketmgr_t *sockmgr,
 	mgr = source->mgr;
 
 	dset = isc_mem_get(mctx, sizeof(dns_dispatchset_t));
-	if (dset == NULL)
-		return (ISC_R_NOMEMORY);
 	memset(dset, 0, sizeof(*dset));
 
-	result = isc_mutex_init(&dset->lock);
-	if (result != ISC_R_SUCCESS)
-		goto fail_alloc;
+	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;

lib/dns/dlz.c

@@ -83,7 +83,7 @@ static isc_once_t once = ISC_ONCE_INIT;
 
 static void
 dlz_initialize(void) {
-	RUNTIME_CHECK(isc_rwlock_init(&dlz_implock, 0, 0) == ISC_R_SUCCESS);
+	isc_rwlock_init(&dlz_implock, 0, 0);
 	ISC_LIST_INIT(dlz_implementations);
 }
 
@@ -476,10 +476,8 @@ dns_dlz_writeablezone(dns_view_t *view, dns_dlzdb_t *dlzdb,
 	dns_zone_setadded(zone, true);
 
 	if (dlzdb->ssutable == NULL) {
-		result = dns_ssutable_createdlz(dlzdb->mctx,
+		dns_ssutable_createdlz(dlzdb->mctx,
 						&dlzdb->ssutable, dlzdb);
-		if (result != ISC_R_SUCCESS)
-			goto cleanup;
 	}
 	dns_zone_setssutable(zone, dlzdb->ssutable);
 

lib/dns/dnssec.c

@@ -257,12 +257,8 @@ dns_dnssec_sign(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
 	 * 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)
-		goto cleanup_signature;
+	isc_buffer_allocate(mctx, &databuf, sigsize + 256 + 18);
 
 	dns_rdata_init(&tmpsigrdata);
 	ret = dns_rdata_fromstruct(&tmpsigrdata, sig.common.rdclass,
@@ -972,7 +968,7 @@ dns_dnssec_signmessage(dns_message_t *msg, dst_key_t *key) {
 
 	rdata = NULL;
 	RETERR(dns_message_gettemprdata(msg, &rdata));
-	RETERR(isc_buffer_allocate(msg->mctx, &dynbuf, 1024));
+	isc_buffer_allocate(msg->mctx, &dynbuf, 1024);
 	RETERR(dns_rdata_fromstruct(rdata, dns_rdataclass_any,
 				    dns_rdatatype_sig /* SIG(0) */,
 				    &sig, dynbuf));

lib/dns/dst_api.c

@@ -1,4 +1,4 @@
-/*
+	/*
  * Portions Copyright (C) Internet Systems Consortium, Inc. ("ISC")
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
@@ -159,10 +159,8 @@ dst_lib_init(isc_mem_t *mctx, const char *engine) {
 	 * ISC_MEMFLAG_INTERNAL as it will free up memory still being used
 	 * by libcrypto.
 	 */
-	result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
+	isc_mem_createx2(0, 0, default_memalloc, default_memfree,
 				  NULL, &dst__memory_pool, 0);
-	if (result != ISC_R_SUCCESS)
-		return (result);
 	isc_mem_setname(dst__memory_pool, "dst", NULL);
 #ifndef OPENSSL_LEAKS
 	isc_mem_setdestroycheck(dst__memory_pool, false);
@@ -606,7 +604,7 @@ dst_key_fromnamedfile(const char *filename, const char *dirname,
 			   dirname, filename, ".private");
 	INSIST(result == ISC_R_SUCCESS);
 
-	RETERR(isc_lex_create(mctx, 1500, &lex));
+	isc_lex_create(mctx, 1500, &lex);
 	RETERR(isc_lex_openfile(lex, newfilename));
 	isc_mem_put(mctx, newfilename, newfilenamelen);
 
@@ -760,8 +758,8 @@ dst_key_privatefrombuffer(dst_key_t *key, isc_buffer_t *buffer) {
 	if (key->func->parse == NULL)
 		RETERR(DST_R_UNSUPPORTEDALG);
 
-	RETERR(isc_lex_create(key->mctx, 1500, &lex));
-	RETERR(isc_lex_openbuffer(lex, buffer));
+	isc_lex_create(key->mctx, 1500, &lex);
+	isc_lex_openbuffer(lex, buffer);
 	RETERR(key->func->parse(key, lex, NULL));
  out:
 	if (lex != NULL)
@@ -797,8 +795,8 @@ dst_key_fromgssapi(const dns_name_t *name, gss_ctx_id_t gssctx,
 		 * Keep the token for use by external ssu rules. They may need
 		 * to examine the PAC in the kerberos ticket.
 		 */
-		RETERR(isc_buffer_allocate(key->mctx, &key->key_tkeytoken,
-		       intoken->length));
+		isc_buffer_allocate(key->mctx, &key->key_tkeytoken,
+		       intoken->length);
 		RETERR(isc_buffer_copyregion(key->key_tkeytoken, intoken));
 	}
 
@@ -1340,12 +1338,7 @@ get_key_struct(const dns_name_t *name, unsigned int alg,
 	}
 
 	dns_name_init(key->key_name, NULL);
-	result = dns_name_dup(name, mctx, key->key_name);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, key->key_name, sizeof(dns_name_t));
-		isc_mem_put(mctx, key, sizeof(dst_key_t));
-		return (NULL);
-	}
+	dns_name_dup(name, mctx, key->key_name);
 
 	isc_refcount_init(&key->refs, 1);
 	isc_mem_attach(mctx, &key->mctx);
@@ -1412,9 +1405,7 @@ dst_key_read_public(const char *filename, int type,
 	 */
 
 	/* 1500 should be large enough for any key */
-	ret = isc_lex_create(mctx, 1500, &lex);
-	if (ret != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_lex_create(mctx, 1500, &lex);
 
 	memset(specials, 0, sizeof(specials));
 	specials['('] = 1;

lib/dns/dyndb.c

@@ -67,7 +67,7 @@ static isc_once_t once = ISC_ONCE_INIT;
 
 static void
 dyndb_initialize(void) {
-	RUNTIME_CHECK(isc_mutex_init(&dyndb_lock) == ISC_R_SUCCESS);
+	isc_mutex_init(&dyndb_lock);
 	INIT_LIST(dyndb_implementations);
 }
 

lib/dns/ecdb.c

@@ -349,25 +349,11 @@ findnode(dns_db_t *db, const dns_name_t *name, bool create,
 
 	mctx = ecdb->common.mctx;
 	node = isc_mem_get(mctx, sizeof(*node));
-	if (node == NULL)
-		return (ISC_R_NOMEMORY);
 
-	result = isc_mutex_init(&node->lock);
-	if (result != ISC_R_SUCCESS) {
-		UNEXPECTED_ERROR(__FILE__, __LINE__,
-				 "isc_mutex_init() failed: %s",
-				 isc_result_totext(result));
-		isc_mem_put(mctx, node, sizeof(*node));
-		return (ISC_R_UNEXPECTED);
-	}
+	isc_mutex_init(&node->lock);
 
 	dns_name_init(&node->name, NULL);
-	result = dns_name_dup(name, mctx, &node->name);
-	if (result != ISC_R_SUCCESS) {
-		DESTROYLOCK(&node->lock);
-		isc_mem_put(mctx, node, sizeof(*node));
-		return (result);
-	}
+	dns_name_dup(name, mctx, &node->name);
 	node->ecdb= ecdb;
 	node->references = 1;
 	ISC_LIST_INIT(node->rdatasets);
@@ -617,22 +603,9 @@ dns_ecdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
 	ecdb->common.rdclass = rdclass;
 	ecdb->common.methods = &ecdb_methods;
 	dns_name_init(&ecdb->common.origin, NULL);
-	result = dns_name_dupwithoffsets(origin, mctx, &ecdb->common.origin);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, ecdb, sizeof(*ecdb));
-		return (result);
-	}
+	dns_name_dupwithoffsets(origin, mctx, &ecdb->common.origin);
 
-	result = isc_mutex_init(&ecdb->lock);
-	if (result != ISC_R_SUCCESS) {
-		UNEXPECTED_ERROR(__FILE__, __LINE__,
-				 "isc_mutex_init() failed: %s",
-				 isc_result_totext(result));
-		if (dns_name_dynamic(&ecdb->common.origin))
-			dns_name_free(&ecdb->common.origin, mctx);
-		isc_mem_put(mctx, ecdb, sizeof(*ecdb));
-		return (ISC_R_UNEXPECTED);
-	}
+	isc_mutex_init(&ecdb->lock);
 
 	ecdb->references = 1;
 	ISC_LIST_INIT(ecdb->nodes);

lib/dns/forward.c

@@ -38,7 +38,7 @@ struct dns_fwdtable {
 static void
 auto_detach(void *, void *);
 
-isc_result_t
+void
 dns_fwdtable_create(isc_mem_t *mctx, dns_fwdtable_t **fwdtablep) {
 	dns_fwdtable_t *fwdtable;
 	isc_result_t result;
@@ -46,32 +46,16 @@ dns_fwdtable_create(isc_mem_t *mctx, dns_fwdtable_t **fwdtablep) {
 	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);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_fwdtable;
+	dns_rbt_create(mctx, auto_detach, fwdtable, &fwdtable->table);
 
-	result = isc_rwlock_init(&fwdtable->rwlock, 0, 0);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_rbt;
+	isc_rwlock_init(&fwdtable->rwlock, 0, 0);
 
 	fwdtable->mctx = NULL;
 	isc_mem_attach(mctx, &fwdtable->mctx);
 	fwdtable->magic = FWDTABLEMAGIC;
 	*fwdtablep = fwdtable;
-
-	return (ISC_R_SUCCESS);
-
-   cleanup_rbt:
-	dns_rbt_destroy(&fwdtable->table);
-
-   cleanup_fwdtable:
-	isc_mem_put(mctx, fwdtable, sizeof(dns_fwdtable_t));
-
-	return (result);
 }
 
 isc_result_t
@@ -85,8 +69,6 @@ dns_fwdtable_addfwd(dns_fwdtable_t *fwdtable, const dns_name_t *name,
 	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);
@@ -94,10 +76,6 @@ dns_fwdtable_addfwd(dns_fwdtable_t *fwdtable, const dns_name_t *name,
 	     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);
@@ -135,8 +113,6 @@ dns_fwdtable_add(dns_fwdtable_t *fwdtable, const dns_name_t *name,
 	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);
@@ -144,10 +120,6 @@ dns_fwdtable_add(dns_fwdtable_t *fwdtable, const dns_name_t *name,
 	     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);

lib/dns/gssapi_link.c

@@ -61,18 +61,11 @@ gssapi_create_signverify_ctx(dst_key_t *key, dst_context_t *dctx) {
 	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,
+	isc_buffer_allocate(dctx->mctx, &ctx->buffer,
 				     INITIAL_BUFFER_SIZE);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(dctx->mctx, ctx, sizeof(dst_gssapi_signverifyctx_t));
-		return (result);
-	}
 
 	dctx->ctxdata.gssctx = ctx;
-
 	return (ISC_R_SUCCESS);
 }
 
@@ -111,9 +104,7 @@ gssapi_adddata(dst_context_t *dctx, const isc_region_t *data) {
 
 	length = isc_buffer_length(ctx->buffer) + data->length + BUFFER_EXTRA;
 
-	result = isc_buffer_allocate(dctx->mctx, &newbuffer, length);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_buffer_allocate(dctx->mctx, &newbuffer, length);
 
 	isc_buffer_usedregion(ctx->buffer, &r);
 	(void)isc_buffer_copyregion(newbuffer, &r);
@@ -121,7 +112,6 @@ gssapi_adddata(dst_context_t *dctx, const isc_region_t *data) {
 
 	isc_buffer_free(&ctx->buffer);
 	ctx->buffer = newbuffer;
-
 	return (ISC_R_SUCCESS);
 }
 
@@ -291,9 +281,7 @@ gssapi_restore(dst_key_t *key, const char *keystr) {
 
 	len = (len / 4) * 3;
 
-	result = isc_buffer_allocate(key->mctx, &b, len);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_buffer_allocate(key->mctx, &b, len);
 
 	result = isc_base64_decodestring(keystr, b);
 	if (result != ISC_R_SUCCESS) {

lib/dns/gssapictx.c

@@ -756,8 +756,8 @@ dst_gssapi_acceptctx(gss_cred_id_t cred,
 	}
 
 	if (gouttoken.length > 0U) {
-		RETERR(isc_buffer_allocate(mctx, outtoken,
-					   (unsigned int)gouttoken.length));
+		isc_buffer_allocate(mctx, outtoken,
+					   (unsigned int)gouttoken.length);
 		GBUFFER_TO_REGION(gouttoken, r);
 		RETERR(isc_buffer_copyregion(*outtoken, &r));
 		(void)gss_release_buffer(&minor, &gouttoken);

lib/dns/include/dns/acl.h

@@ -109,7 +109,7 @@ struct dns_aclenv {
 
 ISC_LANG_BEGINDECLS
 
-isc_result_t
+void
 dns_acl_create(isc_mem_t *mctx, int n, dns_acl_t **target);
 /*%<
  * Create a new ACL, including an IP table and an array with room
@@ -117,13 +117,13 @@ dns_acl_create(isc_mem_t *mctx, int n, dns_acl_t **target);
  * length is 0.
  */
 
-isc_result_t
+void
 dns_acl_any(isc_mem_t *mctx, dns_acl_t **target);
 /*%<
  * Create a new ACL that matches everything.
  */
 
-isc_result_t
+void
 dns_acl_none(isc_mem_t *mctx, dns_acl_t **target);
 /*%<
  * Create a new ACL that matches nothing.
@@ -141,7 +141,7 @@ dns_acl_isnone(dns_acl_t *acl);
  * Test whether ACL is set to "{ none; }"
  */
 
-isc_result_t
+void
 dns_acl_merge(dns_acl_t *dest, dns_acl_t *source, bool pos);
 /*%<
  * Merge the contents of one ACL into another.  Call dns_iptable_merge()
@@ -195,7 +195,7 @@ dns_acl_allowed(isc_netaddr_t *addr, dns_name_t *signer,
  * permitted by 'acl' in environment 'aclenv'.
  */
 
-isc_result_t
+void
 dns_aclenv_init(isc_mem_t *mctx, dns_aclenv_t *env);
 /*%<
  * Initialize ACL environment, setting up localhost and localnets ACLs

lib/dns/include/dns/adb.h

@@ -251,7 +251,7 @@ struct dns_adbaddrinfo {
  ****/
 
 
-isc_result_t
+void
 dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *tmgr,
 	       isc_taskmgr_t *taskmgr, dns_adb_t **newadb);
 /*%<
@@ -273,11 +273,6 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *tmgr,
  *\li	'taskmgr' be a pointer to a valid task manager.
  *
  *\li	'newadb' != NULL && '*newadb' == NULL.
- *
- * Returns:
- *
- *\li	#ISC_R_SUCCESS	after happiness.
- *\li	#ISC_R_NOMEMORY	after resource allocation failure.
  */
 
 void

lib/dns/include/dns/badcache.h

@@ -52,7 +52,7 @@ ISC_LANG_BEGINDECLS
  ***	Functions
  ***/
 
-isc_result_t
+void
 dns_badcache_init(isc_mem_t *mctx, unsigned int size, dns_badcache_t **bcp);
 /*%
  * Allocate and initialize a badcache and store it in '*bcp'.

lib/dns/include/dns/catz.h

@@ -331,7 +331,7 @@ struct dns_catz_zonemodmethods {
 };
 
 
-isc_result_t
+void
 dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm,
 		   isc_mem_t *mctx, isc_taskmgr_t *taskmgr,
 		   isc_timermgr_t *timermgr);
@@ -455,7 +455,7 @@ dns_catz_postreconfig(dns_catz_zones_t *catzs);
  * \li	catzs is not NULL
  */
 
-isc_result_t
+void
 dns_catz_get_iterator(dns_catz_zone_t *catz, isc_ht_iter_t **itp);
 /*%<
  * Get the hashtable iterator on catalog zone members, point '*itp' to it.

lib/dns/include/dns/compress.h

@@ -88,7 +88,7 @@ struct dns_decompress {
 	dns_decompresstype_t	type;		/*%< Strict checking */
 };
 
-isc_result_t
+void
 dns_compress_init(dns_compress_t *cctx, int edns, isc_mem_t *mctx);
 /*%<
  *	Initialise the compression context structure pointed to by
@@ -101,9 +101,6 @@ dns_compress_init(dns_compress_t *cctx, int edns, isc_mem_t *mctx);
  *	\li	'mctx' is an initialized memory context.
  *	Ensures:
  *	\li	cctx->global is initialized.
- *
- *	Returns:
- *	\li	#ISC_R_SUCCESS
  */
 
 void

lib/dns/include/dns/db.h

@@ -1626,7 +1626,7 @@ dns_db_rpz_ready(dns_db_t *db)
  * Finish loading a response policy zone.
  */
 
-isc_result_t
+void
 dns_db_updatenotify_register(dns_db_t *db,
 			     dns_dbupdate_callback_t fn,
 			     void *fn_arg);

lib/dns/include/dns/dbtable.h

@@ -48,7 +48,7 @@
 
 ISC_LANG_BEGINDECLS
 
-isc_result_t
+void
 dns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
 		   dns_dbtable_t **dbtablep);
 /*%<
@@ -58,11 +58,6 @@ dns_dbtable_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
  *\li	mctx != NULL
  * \li	dbtablep != NULL && *dptablep == NULL
  *\li	'rdclass' is a valid class
- *
- * Returns:
- *\li	#ISC_R_SUCCESS
- *\li	#ISC_R_NOMEMORY
- *\li	#ISC_R_UNEXPECTED
  */
 
 void

lib/dns/include/dns/dispatch.h

@@ -146,7 +146,7 @@ struct dns_dispatchset {
  */
 #define DNS_DISPATCHOPT_FIXEDID		0x00000001U
 
-isc_result_t
+void
 dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp);
 /*%<
  * Creates a new dispatchmgr object.
@@ -155,11 +155,6 @@ dns_dispatchmgr_create(isc_mem_t *mctx, dns_dispatchmgr_t **mgrp);
  *\li	"mctx" be a valid memory context.
  *
  *\li	mgrp != NULL && *mgrp == NULL
- *
- * Returns:
- *\li	ISC_R_SUCCESS	-- all ok
- *
- *\li	anything else	-- failure
  */
 
 
@@ -217,7 +212,7 @@ dns_dispatchmgr_getblackportlist(dns_dispatchmgr_t *mgr);
  *\li	mgr is a valid dispatchmgr
  */
 
-isc_result_t
+void
 dns_dispatchmgr_setavailports(dns_dispatchmgr_t *mgr, isc_portset_t *v4portset,
 			      isc_portset_t *v6portset);
 /*%<
@@ -286,7 +281,7 @@ dns_dispatch_getudp_dup(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
  *\li	Anything else	-- failure.
  */
 
-isc_result_t
+void
 dns_dispatch_createtcp(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
 		       isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
 		       const isc_sockaddr_t *destaddr, unsigned int buffersize,

lib/dns/include/dns/forward.h

@@ -35,7 +35,7 @@ struct dns_forwarders {
 	dns_fwdpolicy_t		fwdpolicy;
 };
 
-isc_result_t
+void
 dns_fwdtable_create(isc_mem_t *mctx, dns_fwdtable_t **fwdtablep);
 /*%<
  * Creates a new forwarding table.
@@ -43,10 +43,6 @@ dns_fwdtable_create(isc_mem_t *mctx, dns_fwdtable_t **fwdtablep);
  * Requires:
  * \li 	mctx is a valid memory context.
  * \li	fwdtablep != NULL && *fwdtablep == NULL
- *
- * Returns:
- * \li	#ISC_R_SUCCESS
- * \li	#ISC_R_NOMEMORY
  */
 
 isc_result_t

lib/dns/include/dns/ipkeylist.h

@@ -52,7 +52,7 @@ dns_ipkeylist_clear(isc_mem_t *mctx, dns_ipkeylist_t *ipkl);
  *\li	'ipkl' to be non NULL.
  */
 
-isc_result_t
+void
 dns_ipkeylist_copy(isc_mem_t *mctx, const dns_ipkeylist_t *src,
 		   dns_ipkeylist_t *dst);
 /*%<
@@ -63,12 +63,8 @@ dns_ipkeylist_copy(isc_mem_t *mctx, const dns_ipkeylist_t *src,
  *\li	'src' to be non NULL
  *\li	'dst' to be non NULL and point to an empty \ref dns_ipkeylist_t
  *       with all pointers set to `NULL` and count set to 0.
- *
- * Returns:
- *\li	#ISC_R_SUCCESS	-- success
- *\li	any other value -- failure
  */
-isc_result_t
+void
 dns_ipkeylist_resize(isc_mem_t *mctx, dns_ipkeylist_t *ipkl, unsigned int n);
 /*%<
  * Resize ipkl to contain n elements. Size (count) is not changed, and the
@@ -78,10 +74,6 @@ dns_ipkeylist_resize(isc_mem_t *mctx, dns_ipkeylist_t *ipkl, unsigned int n);
  * \li	'mctx' to be a valid memory context.
  * \li	'ipk' to be non NULL
  * \li	'n' >= ipkl->count
- *
- * Returns:
- * \li	#ISC_R_SUCCESS if successs
- * \li	#ISC_R_NOMEMORY if there's no memory, ipkeylist is left untoched
  */
 
 #endif

lib/dns/include/dns/iptable.h

@@ -38,20 +38,20 @@ struct dns_iptable {
 
 ISC_LANG_BEGINDECLS
 
-isc_result_t
+void
 dns_iptable_create(isc_mem_t *mctx, dns_iptable_t **target);
 /*
  * Create a new IP table and the underlying radix structure
  */
 
-isc_result_t
+void
 dns_iptable_addprefix(dns_iptable_t *tab, const isc_netaddr_t *addr,
 		      uint16_t bitlen, bool pos);
 /*
  * Add an IP prefix to an existing IP table
  */
 
-isc_result_t
+void
 dns_iptable_merge(dns_iptable_t *tab, dns_iptable_t *source, bool pos);
 /*
  * Merge one IP table into another one.

lib/dns/include/dns/keytable.h

@@ -48,7 +48,7 @@
 
 ISC_LANG_BEGINDECLS
 
-isc_result_t
+void
 dns_keytable_create(isc_mem_t *mctx, dns_keytable_t **keytablep);
 /*%<
  * Create a keytable.

lib/dns/include/dns/message.h

@@ -280,7 +280,7 @@ struct dns_ednsopt {
 
 ISC_LANG_BEGINDECLS
 
-isc_result_t
+void
 dns_message_create(isc_mem_t *mctx, unsigned int intent, dns_message_t **msgp);
 
 /*%<
@@ -300,10 +300,6 @@ dns_message_create(isc_mem_t *mctx, unsigned int intent, dns_message_t **msgp);
  * Ensures:
  *\li	The data in "*msg" is set to indicate an unused and empty msg
  *	structure.
- *
- * Returns:
- *\li	#ISC_R_NOMEMORY		-- out of memory
- *\li	#ISC_R_SUCCESS		-- success
  */
 
 void

lib/dns/include/dns/name.h

@@ -1026,7 +1026,7 @@ dns_name_split(const dns_name_t *name, unsigned int suffixlabels,
  *\li	#ISC_R_SUCCESS	No worries.  (This function should always success).
  */
 
-isc_result_t
+void
 dns_name_dup(const dns_name_t *source, isc_mem_t *mctx,
 	     dns_name_t *target);
 /*%<
@@ -1041,7 +1041,7 @@ dns_name_dup(const dns_name_t *source, isc_mem_t *mctx,
  *\li	'mctx' is a valid memory context.
  */
 
-isc_result_t
+void
 dns_name_dupwithoffsets(const dns_name_t *source, isc_mem_t *mctx,
 			dns_name_t *target);
 /*%<

lib/dns/include/dns/portlist.h

@@ -24,7 +24,7 @@
 
 ISC_LANG_BEGINDECLS
 
-isc_result_t
+void
 dns_portlist_create(isc_mem_t *mctx, dns_portlist_t **portlistp);
 /*%<
  * Create a port list.
@@ -32,14 +32,9 @@ dns_portlist_create(isc_mem_t *mctx, dns_portlist_t **portlistp);
  * Requires:
  *\li	'mctx' to be valid.
  *\li	'portlistp' to be non NULL and '*portlistp' to be NULL;
- *
- * Returns:
- *\li	#ISC_R_SUCCESS
- *\li	#ISC_R_NOMEMORY
- *\li	#ISC_R_UNEXPECTED
  */
 
-isc_result_t
+void
 dns_portlist_add(dns_portlist_t *portlist, int af, in_port_t port);
 /*%<
  * Add the given <port,af> tuple to the portlist.
@@ -47,10 +42,6 @@ dns_portlist_add(dns_portlist_t *portlist, int af, in_port_t port);
  * Requires:
  *\li	'portlist' to be valid.
  *\li	'af' to be AF_INET or AF_INET6
- *
- * Returns:
- *\li	#ISC_R_SUCCESS
- *\li	#ISC_R_NOMEMORY
  */
 
 void

lib/dns/include/dns/rbt.h

@@ -280,7 +280,7 @@ typedef struct dns_rbtnodechain {
 /*****
  ***** Public interfaces.
  *****/
-isc_result_t
+void
 dns_rbt_create(isc_mem_t *mctx, dns_rbtdeleter_t deleter,
 	       void *deleter_arg, dns_rbt_t **rbtp);
 /*%<
@@ -304,10 +304,6 @@ dns_rbt_create(isc_mem_t *mctx, dns_rbtdeleter_t deleter,
  *
  *\li   If result is failure:
  *              *rbtp does not point to a valid red-black tree manager.
- *
- * Returns:
- *\li   #ISC_R_SUCCESS  Success
- *\li   #ISC_R_NOMEMORY Resource limit: Out of Memory
  */
 
 isc_result_t

lib/dns/include/dns/request.h

@@ -54,7 +54,7 @@ typedef struct dns_requestevent {
 
 ISC_LANG_BEGINDECLS
 
-isc_result_t
+void
 dns_requestmgr_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
 		      isc_socketmgr_t *socketmgr, isc_taskmgr_t *taskmgr,
 		      dns_dispatchmgr_t *dispatchmgr,

lib/dns/include/dns/resolver.h

@@ -151,7 +151,7 @@ typedef enum {
 #define DNS_QMIN_MAX_NO_DELEGATION	3
 #define DNS_MAX_LABELS			127
 
-isc_result_t
+void
 dns_resolver_create(dns_view_t *view,
 		    isc_taskmgr_t *taskmgr,
 		    unsigned int ntasks, unsigned int ndisp,
@@ -190,12 +190,6 @@ dns_resolver_create(dns_view_t *view,
  *	If not NULL, 'ndisp' clones of it will be created by the resolver.
  *
  *\li	resp != NULL && *resp == NULL.
- *
- * Returns:
- *
- *\li	#ISC_R_SUCCESS				On success.
- *
- *\li	Anything else				Failure.
  */
 
 void

lib/dns/include/dns/rrl.h

@@ -269,7 +269,7 @@ dns_rrl(dns_view_t *view,
 void
 dns_rrl_view_destroy(dns_view_t *view);
 
-isc_result_t
+void
 dns_rrl_init(dns_rrl_t **rrlp, dns_view_t *view, int min_entries);
 
 ISC_LANG_ENDDECLS

lib/dns/include/dns/sdlz.h

@@ -359,7 +359,7 @@ dns_sdlz_putsoa_t dns_sdlz_putsoa;
  */
 
 
-typedef isc_result_t dns_sdlz_setdb_t(dns_dlzdb_t *dlzdatabase,
+typedef void dns_sdlz_setdb_t(dns_dlzdb_t *dlzdatabase,
 				      dns_rdataclass_t rdclass,
 				      const dns_name_t *name,
 				      dns_db_t **dbp);

lib/dns/include/dns/ssu.h

@@ -46,7 +46,7 @@ typedef enum {
 	dns_ssumatchtype_dlz = 16	/* intentionally higher than _max */
 } dns_ssumatchtype_t;
 
-isc_result_t
+void
 dns_ssutable_create(isc_mem_t *mctx, dns_ssutable_t **table);
 /*%<
  *	Creates a table that will be used to store simple-secure-update rules.
@@ -56,12 +56,9 @@ dns_ssutable_create(isc_mem_t *mctx, dns_ssutable_t **table);
  *\li		'mctx' is a valid memory context
  *\li		'table' is not NULL, and '*table' is NULL
  *
- *	Returns:
- *\li		ISC_R_SUCCESS
- *\li		ISC_R_NOMEMORY
  */
 
-isc_result_t
+void
 dns_ssutable_createdlz(isc_mem_t *mctx, dns_ssutable_t **tablep,
 		       dns_dlzdb_t *dlzdatabase);
 /*%<
@@ -98,7 +95,7 @@ dns_ssutable_detach(dns_ssutable_t **tablep);
  *			resources used by the table will be freed.
  */
 
-isc_result_t
+void
 dns_ssutable_addrule(dns_ssutable_t *table, bool grant,
 		     const dns_name_t *identity, dns_ssumatchtype_t matchtype,
 		     const dns_name_t *name, unsigned int ntypes,
@@ -125,10 +122,6 @@ dns_ssutable_addrule(dns_ssutable_t *table, bool grant,
  *\li		'matchtype' must be one of the defined constants.
  *\li		'name' is a valid absolute name
  *\li		If 'ntypes' > 0, 'types' must not be NULL
- *
- *	Returns:
- *\li		ISC_R_SUCCESS
- *\li		ISC_R_NOMEMORY
  */
 
 bool

lib/dns/include/dns/stats.h

@@ -505,7 +505,7 @@ typedef void (*dns_rcodestats_dumper_t)(dns_rcode_t, uint64_t, void *);
 
 ISC_LANG_BEGINDECLS
 
-isc_result_t
+void
 dns_generalstats_create(isc_mem_t *mctx, dns_stats_t **statsp, int ncounters);
 /*%<
  * Create a statistics counter structure of general type.  It counts a general
@@ -524,7 +524,7 @@ dns_generalstats_create(isc_mem_t *mctx, dns_stats_t **statsp, int ncounters);
  *\li	anything else	-- failure
  */
 
-isc_result_t
+void
 dns_rdatatypestats_create(isc_mem_t *mctx, dns_stats_t **statsp);
 /*%<
  * Create a statistics counter structure per rdatatype.
@@ -540,7 +540,7 @@ dns_rdatatypestats_create(isc_mem_t *mctx, dns_stats_t **statsp);
  *\li	anything else	-- failure
  */
 
-isc_result_t
+void
 dns_rdatasetstats_create(isc_mem_t *mctx, dns_stats_t **statsp);
 /*%<
  * Create a statistics counter structure per RRset.
@@ -556,7 +556,7 @@ dns_rdatasetstats_create(isc_mem_t *mctx, dns_stats_t **statsp);
  *\li	anything else	-- failure
  */
 
-isc_result_t
+void
 dns_opcodestats_create(isc_mem_t *mctx, dns_stats_t **statsp);
 /*%<
  * Create a statistics counter structure per opcode.
@@ -572,7 +572,7 @@ dns_opcodestats_create(isc_mem_t *mctx, dns_stats_t **statsp);
  *\li	anything else	-- failure
  */
 
-isc_result_t
+void
 dns_rcodestats_create(isc_mem_t *mctx, dns_stats_t **statsp);
 /*%<
  * Create a statistics counter structure per assigned rcode.

lib/dns/include/dns/tsig.h

@@ -238,7 +238,7 @@ dns_tsigkey_find(dns_tsigkey_t **tsigkey, const dns_name_t *name,
  */
 
 
-isc_result_t
+void
 dns_tsigkeyring_create(isc_mem_t *mctx, dns_tsig_keyring_t **ringp);
 /*%<
  *	Create an empty TSIG key ring.
@@ -246,10 +246,6 @@ dns_tsigkeyring_create(isc_mem_t *mctx, dns_tsig_keyring_t **ringp);
  *	Requires:
  *\li		'mctx' is not NULL
  *\li		'ringp' is not NULL, and '*ringp' is NULL
- *
- *	Returns:
- *\li		#ISC_R_SUCCESS
- *\li		#ISC_R_NOMEMORY
  */
 
 isc_result_t

lib/dns/include/dns/view.h

@@ -372,7 +372,7 @@ dns_view_weakdetach(dns_view_t **targetp);
  *\li	*viewp is NULL.
  */
 
-isc_result_t
+void
 dns_view_createzonetable(dns_view_t *view);
 /*%<
  * Create a zonetable for the view.
@@ -383,14 +383,9 @@ dns_view_createzonetable(dns_view_t *view);
  *
  *\li	'view' does not have a zonetable already.
  *
- * Returns:
- *
- *\li   	#ISC_R_SUCCESS
- *
- *\li	Any error that dns_zt_create() can return.
  */
 
-isc_result_t
+void
 dns_view_createresolver(dns_view_t *view,
 			isc_taskmgr_t *taskmgr,
 			unsigned int ntasks, unsigned int ndisp,
@@ -412,12 +407,6 @@ dns_view_createresolver(dns_view_t *view,
  *\li	The requirements of dns_resolver_create() apply to 'taskmgr',
  *	'ntasks', 'socketmgr', 'timermgr', 'options', 'dispatchv4', and
  *	'dispatchv6'.
- *
- * Returns:
- *
- *\li   	#ISC_R_SUCCESS
- *
- *\li	Any error that dns_resolver_create() can return.
  */
 
 void
@@ -950,7 +939,7 @@ dns_view_flushname(dns_view_t *view, const dns_name_t *name);
  *	other returns are failures.
  */
 
-isc_result_t
+void
 dns_view_adddelegationonly(dns_view_t *view, const dns_name_t *name);
 /*%<
  * Add the given name to the delegation only table.
@@ -958,13 +947,9 @@ dns_view_adddelegationonly(dns_view_t *view, const dns_name_t *name);
  * Requires:
  *\li	'view' is valid.
  *\li	'name' is valid.
- *
- * Returns:
- *\li	#ISC_R_SUCCESS
- *\li	#ISC_R_NOMEMORY
  */
 
-isc_result_t
+void
 dns_view_excludedelegationonly(dns_view_t *view, const dns_name_t *name);
 /*%<
  * Add the given name to be excluded from the root-delegation-only.
@@ -973,10 +958,6 @@ dns_view_excludedelegationonly(dns_view_t *view, const dns_name_t *name);
  * Requires:
  *\li	'view' is valid.
  *\li	'name' is valid.
- *
- * Returns:
- *\li	#ISC_R_SUCCESS
- *\li	#ISC_R_NOMEMORY
  */
 
 bool
@@ -1142,7 +1123,7 @@ dns_view_getntatable(dns_view_t *view, dns_ntatable_t **ntp);
  *\li	ISC_R_NOTFOUND
  */
 
-isc_result_t
+void
 dns_view_initsecroots(dns_view_t *view, isc_mem_t *mctx);
 /*%<
  * Initialize security roots for the view, detaching any previously
@@ -1154,10 +1135,6 @@ dns_view_initsecroots(dns_view_t *view, isc_mem_t *mctx);
  *
  * Requires:
  * \li	'view' is valid.
- *
- * Returns:
- *\li	ISC_R_SUCCESS
- *\li	Any other result indicates failure
  */
 
 isc_result_t

lib/dns/include/dns/zt.h

@@ -41,17 +41,13 @@ typedef isc_result_t
  * can be informed via a callback function with this signature.
  */
 
-isc_result_t
+void
 dns_zt_create(isc_mem_t *mctx, dns_rdataclass_t rdclass, dns_zt_t **zt);
 /*%<
  * Creates a new zone table.
  *
  * Requires:
  * \li	'mctx' to be initialized.
- *
- * Returns:
- * \li	#ISC_R_SUCCESS on success.
- * \li	#ISC_R_NOMEMORY
  */
 
 isc_result_t

lib/dns/ipkeylist.c

@@ -75,11 +75,10 @@ dns_ipkeylist_clear(isc_mem_t *mctx, dns_ipkeylist_t *ipkl) {
 	dns_ipkeylist_init(ipkl);
 }
 
-isc_result_t
+void
 dns_ipkeylist_copy(isc_mem_t *mctx, const dns_ipkeylist_t *src,
 		   dns_ipkeylist_t *dst)
 {
-	isc_result_t result = ISC_R_SUCCESS;
 	uint32_t i;
 
 	REQUIRE(dst != NULL);
@@ -87,11 +86,9 @@ dns_ipkeylist_copy(isc_mem_t *mctx, const dns_ipkeylist_t *src,
 	REQUIRE(dst->count == 0);
 
 	if (src->count == 0)
-		return (ISC_R_SUCCESS);
+		return;
 
-	result = dns_ipkeylist_resize(mctx, dst, src->count);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	dns_ipkeylist_resize(mctx, dst, src->count);
 
 	memmove(dst->addrs, src->addrs, src->count * sizeof(isc_sockaddr_t));
 
@@ -105,15 +102,9 @@ dns_ipkeylist_copy(isc_mem_t *mctx, const dns_ipkeylist_t *src,
 			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,
+				dns_name_dup(src->keys[i], mctx,
 						      dst->keys[i]);
-				if (result != ISC_R_SUCCESS)
-					goto cleanup_keys;
 			} else {
 				dst->keys[i] = NULL;
 			}
@@ -125,47 +116,18 @@ dns_ipkeylist_copy(isc_mem_t *mctx, const dns_ipkeylist_t *src,
 			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;
-				}
 				dns_name_init(dst->labels[i], NULL);
-				result = dns_name_dup(src->labels[i], mctx,
+				dns_name_dup(src->labels[i], mctx,
 						      dst->labels[i]);
-				if (result != ISC_R_SUCCESS)
-					goto cleanup_labels;
 			} else {
 				dst->labels[i] = NULL;
 			}
 		}
 	}
 	dst->count = src->count;
-	return (ISC_R_SUCCESS);
-
-  cleanup_labels:
-	do {
-		if (dst->labels[i] != NULL) {
-			if (dns_name_dynamic(dst->labels[i]))
-				dns_name_free(dst->labels[i], mctx);
-			isc_mem_put(mctx, dst->labels[i], sizeof(dns_name_t));
-			dst->labels[i] = NULL;
-		}
-	} while (i-- > 0);
-
-  cleanup_keys:
-	do {
-		if (dst->keys[i] != NULL) {
-			if (dns_name_dynamic(dst->keys[i]))
-				dns_name_free(dst->keys[i], mctx);
-			isc_mem_put(mctx, dst->keys[i], sizeof(dns_name_t));
-			dst->keys[i] = NULL;
-		}
-	} while (i-- > 0);
-
-	return (result);
 }
 
-isc_result_t
+void
 dns_ipkeylist_resize(isc_mem_t *mctx, dns_ipkeylist_t *ipkl, unsigned int n) {
 	isc_sockaddr_t *addrs = NULL;
 	isc_dscp_t *dscps = NULL;
@@ -176,20 +138,12 @@ dns_ipkeylist_resize(isc_mem_t *mctx, dns_ipkeylist_t *ipkl, unsigned int n) {
 	REQUIRE(n > ipkl->count);
 
 	if (n <= ipkl->allocated)
-		return (ISC_R_SUCCESS);
+		return;
 
 	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,
@@ -232,17 +186,4 @@ dns_ipkeylist_resize(isc_mem_t *mctx, dns_ipkeylist_t *ipkl, unsigned int n) {
 	       (n - ipkl->allocated) * sizeof(dns_name_t *));
 
 	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 *));
-
-	return (ISC_R_NOMEMORY);
 }

lib/dns/iptable.c

@@ -25,30 +25,20 @@ static void destroy_iptable(dns_iptable_t *dtab);
 /*
  * Create a new IP table and the underlying radix structure
  */
-isc_result_t
+void
 dns_iptable_create(isc_mem_t *mctx, dns_iptable_t **target) {
-	isc_result_t result;
 	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);
 	tab->radix = NULL;
 	tab->magic = DNS_IPTABLE_MAGIC;
 
-	result = isc_radix_create(mctx, &tab->radix, RADIX_MAXBITS);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_radix_create(mctx, &tab->radix, RADIX_MAXBITS);
 
 	*target = tab;
-	return (ISC_R_SUCCESS);
-
- cleanup:
-	dns_iptable_detach(&tab);
-	return (result);
 }
 
 static bool dns_iptable_neg = false;
@@ -57,7 +47,7 @@ static bool dns_iptable_pos = true;
 /*
  * Add an IP prefix to an existing IP table
  */
-isc_result_t
+void
 dns_iptable_addprefix(dns_iptable_t *tab, const isc_netaddr_t *addr,
 		      uint16_t bitlen, bool pos)
 {
@@ -71,11 +61,7 @@ dns_iptable_addprefix(dns_iptable_t *tab, const isc_netaddr_t *addr,
 
 	NETADDR_TO_PREFIX_T(addr, pfx, bitlen);
 
-	result = isc_radix_insert(tab->radix, &node, NULL, &pfx);
-	if (result != ISC_R_SUCCESS) {
-		isc_refcount_destroy(&pfx.refcount);
-		return(result);
-	}
+	isc_radix_insert(tab->radix, &node, NULL, &pfx);
 
 	/* If a node already contains data, don't overwrite it */
 	if (pfx.family == AF_UNSPEC) {
@@ -96,13 +82,12 @@ dns_iptable_addprefix(dns_iptable_t *tab, const isc_netaddr_t *addr,
 	}
 
 	isc_refcount_destroy(&pfx.refcount);
-	return (ISC_R_SUCCESS);
 }
 
 /*
  * Merge one IP table into another one.
  */
-isc_result_t
+void
 dns_iptable_merge(dns_iptable_t *tab, dns_iptable_t *source, bool pos)
 {
 	isc_result_t result;
@@ -111,10 +96,7 @@ dns_iptable_merge(dns_iptable_t *tab, dns_iptable_t *source, bool pos)
 
 	RADIX_WALK (source->radix->head, node) {
 		new_node = NULL;
-		result = isc_radix_insert (tab->radix, &new_node, node, NULL);
-
-		if (result != ISC_R_SUCCESS)
-			return(result);
+		isc_radix_insert (tab->radix, &new_node, node, NULL);
 
 		/*
 		 * If we're negating a nested ACL, then we should
@@ -136,7 +118,6 @@ dns_iptable_merge(dns_iptable_t *tab, dns_iptable_t *source, bool pos)
 	} RADIX_WALK_END;
 
 	tab->radix->num_added_node += max_node;
-	return (ISC_R_SUCCESS);
 }
 
 void

lib/dns/keytable.c

@@ -62,7 +62,7 @@ free_keynode(void *node, void *arg) {
 	dns_keynode_detachall(mctx, &keynode);
 }
 
-isc_result_t
+void
 dns_keytable_create(isc_mem_t *mctx, dns_keytable_t **keytablep) {
 	dns_keytable_t *keytable;
 	isc_result_t result;
@@ -74,20 +74,11 @@ dns_keytable_create(isc_mem_t *mctx, dns_keytable_t **keytablep) {
 	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);
-	if (result != ISC_R_SUCCESS) {
-		goto cleanup_keytable;
-	}
+	dns_rbt_create(mctx, free_keynode, mctx, &keytable->table);
 
-	result = isc_rwlock_init(&keytable->rwlock, 0, 0);
-	if (result != ISC_R_SUCCESS) {
-		goto cleanup_rbt;
-	}
+	isc_rwlock_init(&keytable->rwlock, 0, 0);
 
 	isc_refcount_init(&keytable->active_nodes, 0);
 	isc_refcount_init(&keytable->references, 1);
@@ -96,16 +87,6 @@ dns_keytable_create(isc_mem_t *mctx, dns_keytable_t **keytablep) {
 	isc_mem_attach(mctx, &keytable->mctx);
 	keytable->magic = KEYTABLE_MAGIC;
 	*keytablep = keytable;
-
-	return (ISC_R_SUCCESS);
-
- cleanup_rbt:
-	dns_rbt_destroy(&keytable->table);
-
- cleanup_keytable:
-	isc_mem_putanddetach(&mctx, keytable, sizeof(*keytable));
-
-	return (result);
 }
 
 void
@@ -636,9 +617,7 @@ dns_keytable_dump(dns_keytable_t *keytable, FILE *fp) {
 	REQUIRE(VALID_KEYTABLE(keytable));
 	REQUIRE(fp != NULL);
 
-	result = isc_buffer_allocate(keytable->mctx, &text, 4096);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_buffer_allocate(keytable->mctx, &text, 4096);
 
 	result = dns_keytable_totext(keytable, &text);
 

lib/dns/lib.c

@@ -79,9 +79,7 @@ initialize(void) {
 
 	REQUIRE(initialize_done == false);
 
-	result = isc_mem_create(0, 0, &dns_g_mctx);
-	if (result != ISC_R_SUCCESS)
-		return;
+	isc_mem_create(0, 0, &dns_g_mctx);
 	dns_result_register();
 	result = dns_ecdb_register(dns_g_mctx, &dbimp);
 	if (result != ISC_R_SUCCESS)
@@ -91,15 +89,10 @@ initialize(void) {
 	if (result != ISC_R_SUCCESS)
 		goto cleanup_db;
 
-	result = isc_mutex_init(&reflock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_dst;
-
+	isc_mutex_init(&reflock);
 	initialize_done = true;
 	return;
 
-  cleanup_dst:
-	dst_lib_destroy();
   cleanup_db:
 	if (dbimp != NULL)
 		dns_ecdb_unregister(&dbimp);

lib/dns/lookup.c

@@ -96,7 +96,7 @@ start_fetch(dns_lookup_t *lookup) {
 	return (result);
 }
 
-static isc_result_t
+static void
 build_event(dns_lookup_t *lookup) {
 	dns_name_t *name = NULL;
 	dns_rdataset_t *rdataset = NULL;
@@ -104,22 +104,12 @@ build_event(dns_lookup_t *lookup) {
 	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),
+	dns_name_dup(dns_fixedname_name(&lookup->name),
 			      lookup->mctx, name);
-	if (result != ISC_R_SUCCESS)
-		goto fail;
 
 	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);
 	}
@@ -127,10 +117,6 @@ build_event(dns_lookup_t *lookup) {
 	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);
 	}
@@ -138,21 +124,6 @@ build_event(dns_lookup_t *lookup) {
 	lookup->event->name = name;
 	lookup->event->rdataset = rdataset;
 	lookup->event->sigrdataset = sigrdataset;
-
-	return (ISC_R_SUCCESS);
-
- fail:
-	if (name != NULL) {
-		if (dns_name_dynamic(name))
-			dns_name_free(name, lookup->mctx);
-		isc_mem_put(lookup->mctx, name, sizeof(dns_name_t));
-	}
-	if (rdataset != NULL) {
-		if (dns_rdataset_isassociated(rdataset))
-			dns_rdataset_disassociate(rdataset);
-		isc_mem_put(lookup->mctx, rdataset, sizeof(dns_rdataset_t));
-	}
-	return (result);
 }
 
 static isc_result_t
@@ -248,7 +219,7 @@ lookup_find(dns_lookup_t *lookup, dns_fetchevent_t *event) {
 
 		switch (result) {
 		case ISC_R_SUCCESS:
-			result = build_event(lookup);
+			build_event(lookup);
 			if (event == NULL)
 				break;
 			if (event->db != NULL)
@@ -410,9 +381,7 @@ dns_lookup_create(isc_mem_t *mctx, const dns_name_t *name, dns_rdatatype_t type,
 	lookup->task = NULL;
 	isc_task_attach(task, &lookup->task);
 
-	result = isc_mutex_init(&lookup->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_event;
+	isc_mutex_init(&lookup->lock);
 
 	dns_fixedname_init(&lookup->name);
 

lib/dns/master.c

@@ -471,15 +471,13 @@ loadctx_destroy(dns_loadctx_t *lctx) {
 	isc_mem_detach(&mctx);
 }
 
-static isc_result_t
+static void
 incctx_create(isc_mem_t *mctx, dns_name_t *origin, dns_incctx_t **ictxp) {
 	dns_incctx_t *ictx;
 	isc_region_t r;
 	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]);
@@ -503,10 +501,9 @@ incctx_create(isc_mem_t *mctx, dns_name_t *origin, dns_incctx_t **ictxp) {
 	ictx->origin_changed = true;
 
 	*ictxp = ictx;
-	return (ISC_R_SUCCESS);
 }
 
-static isc_result_t
+static void
 loadctx_create(dns_masterformat_t format, isc_mem_t *mctx,
 	       unsigned int options, uint32_t resign, dns_name_t *top,
 	       dns_rdataclass_t zclass, dns_name_t *origin,
@@ -532,18 +529,10 @@ loadctx_create(dns_masterformat_t format, isc_mem_t *mctx,
 		(task != NULL && done != NULL));
 
 	lctx = isc_mem_get(mctx, sizeof(*lctx));
-	if (lctx == NULL)
-		return (ISC_R_NOMEMORY);
-	result = isc_mutex_init(&lctx->lock);
-	if (result != ISC_R_SUCCESS) {
-		isc_mem_put(mctx, lctx, sizeof(*lctx));
-		return (result);
-	}
+	isc_mutex_init(&lctx->lock);
 
 	lctx->inc = NULL;
-	result = incctx_create(mctx, origin, &lctx->inc);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_ctx;
+	incctx_create(mctx, origin, &lctx->inc);
 
 	lctx->maxttl = 0;
 
@@ -570,9 +559,7 @@ loadctx_create(dns_masterformat_t format, isc_mem_t *mctx,
 		lctx->keep_lex = true;
 	} else {
 		lctx->lex = NULL;
-		result = isc_lex_create(mctx, TOKENSIZ, &lctx->lex);
-		if (result != ISC_R_SUCCESS)
-			goto cleanup_inc;
+		isc_lex_create(mctx, TOKENSIZ, &lctx->lex);
 		lctx->keep_lex = false;
 		memset(specials, 0, sizeof(specials));
 		specials[0] = 1;
@@ -620,13 +607,6 @@ loadctx_create(dns_masterformat_t format, isc_mem_t *mctx,
 	lctx->references = 1;			/* Implicit attach. */
 	lctx->magic = DNS_LCTX_MAGIC;
 	*lctxp = lctx;
-	return (ISC_R_SUCCESS);
-
- cleanup_inc:
-	incctx_destroy(mctx, lctx->inc);
- cleanup_ctx:
-	isc_mem_put(mctx, lctx, sizeof(*lctx));
-	return (result);
 }
 
 static const char *hex = "0123456789abcdef0123456789ABCDEF";
@@ -888,9 +868,7 @@ generate(dns_loadctx_t *lctx, char *range, char *lhs, char *gtype, char *rhs,
 		isc_buffer_add(&buffer, strlen(rhsbuf));
 		isc_buffer_setactive(&buffer, strlen(rhsbuf));
 
-		result = isc_lex_openbuffer(lctx->lex, &buffer);
-		if (result != ISC_R_SUCCESS)
-			goto error_cleanup;
+		isc_lex_openbuffer(lctx->lex, &buffer);
 
 		isc_buffer_init(&target, target_mem, target_size);
 		result = dns_rdata_fromtext(&rdata, lctx->zclass, type,
@@ -2106,9 +2084,7 @@ pushfile(const char *master_file, dns_name_t *origin, dns_loadctx_t *lctx) {
 	ictx = lctx->inc;
 	lctx->seen_include = true;
 
-	result = incctx_create(lctx->mctx, origin, &newctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	incctx_create(lctx->mctx, origin, &newctx);
 
 	/*
 	 * Push origin_changed.
@@ -2608,11 +2584,9 @@ dns_master_loadfile(const char *master_file, dns_name_t *top,
 	dns_loadctx_t *lctx = NULL;
 	isc_result_t result;
 
-	result = loadctx_create(format, mctx, options, resign, top, zclass,
+	loadctx_create(format, mctx, options, resign, top, zclass,
 				origin, callbacks, NULL, NULL, NULL,
 				include_cb, include_arg, NULL, &lctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
 
 	lctx->maxttl = maxttl;
 
@@ -2645,11 +2619,9 @@ dns_master_loadfileinc(const char *master_file, dns_name_t *top,
 	REQUIRE(task != NULL);
 	REQUIRE(done != NULL);
 
-	result = loadctx_create(format, mctx, options, resign, top, zclass,
+	loadctx_create(format, mctx, options, resign, top, zclass,
 				origin, callbacks, task, done, done_arg,
 				include_cb, include_arg, NULL, &lctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
 
 	lctx->maxttl = maxttl;
 
@@ -2678,15 +2650,11 @@ dns_master_loadstream(FILE *stream, dns_name_t *top, dns_name_t *origin,
 
 	REQUIRE(stream != NULL);
 
-	result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
+	loadctx_create(dns_masterformat_text, mctx, options, 0, top,
 				zclass, origin, callbacks, NULL, NULL, NULL,
 				NULL, NULL, NULL, &lctx);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
 
-	result = isc_lex_openstream(lctx->lex, stream);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_lex_openstream(lctx->lex, stream);
 
 	result = (lctx->load)(lctx);
 	INSIST(result != DNS_R_CONTINUE);
@@ -2711,15 +2679,11 @@ dns_master_loadstreaminc(FILE *stream, dns_name_t *top, dns_name_t *origin,
 	REQUIRE(task != NULL);
 	REQUIRE(done != NULL);
 
-	result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
+	loadctx_create(dns_masterformat_text, mctx, options, 0, top,
 				zclass, origin, callbacks, task, done,
 				done_arg, NULL, NULL, NULL, &lctx);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
 
-	result = isc_lex_openstream(lctx->lex, stream);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_lex_openstream(lctx->lex, stream);
 
 	result = task_send(lctx);
 	if (result == ISC_R_SUCCESS) {
@@ -2744,15 +2708,10 @@ dns_master_loadbuffer(isc_buffer_t *buffer, dns_name_t *top,
 
 	REQUIRE(buffer != NULL);
 
-	result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
+	loadctx_create(dns_masterformat_text, mctx, options, 0, top,
 				zclass, origin, callbacks, NULL, NULL, NULL,
 				NULL, NULL, NULL, &lctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
-
-	result = isc_lex_openbuffer(lctx->lex, buffer);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_lex_openbuffer(lctx->lex, buffer);
 
 	result = (lctx->load)(lctx);
 	INSIST(result != DNS_R_CONTINUE);
@@ -2777,15 +2736,11 @@ dns_master_loadbufferinc(isc_buffer_t *buffer, dns_name_t *top,
 	REQUIRE(task != NULL);
 	REQUIRE(done != NULL);
 
-	result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
+	loadctx_create(dns_masterformat_text, mctx, options, 0, top,
 				zclass, origin, callbacks, task, done,
 				done_arg, NULL, NULL, NULL, &lctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
 
-	result = isc_lex_openbuffer(lctx->lex, buffer);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_lex_openbuffer(lctx->lex, buffer);
 
 	result = task_send(lctx);
 	if (result == ISC_R_SUCCESS) {
@@ -2809,11 +2764,9 @@ dns_master_loadlexer(isc_lex_t *lex, dns_name_t *top,
 
 	REQUIRE(lex != NULL);
 
-	result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
+	loadctx_create(dns_masterformat_text, mctx, options, 0, top,
 				zclass, origin, callbacks, NULL, NULL, NULL,
 				NULL, NULL, lex, &lctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
 
 	result = (lctx->load)(lctx);
 	INSIST(result != DNS_R_CONTINUE);
@@ -2837,11 +2790,9 @@ dns_master_loadlexerinc(isc_lex_t *lex, dns_name_t *top,
 	REQUIRE(task != NULL);
 	REQUIRE(done != NULL);
 
-	result = loadctx_create(dns_masterformat_text, mctx, options, 0, top,
+	loadctx_create(dns_masterformat_text, mctx, options, 0, top,
 				zclass, origin, callbacks, task, done,
 				done_arg, NULL, NULL, lex, &lctx);
-	if (result != ISC_R_SUCCESS)
-		return (result);
 
 	result = task_send(lctx);
 	if (result == ISC_R_SUCCESS) {

lib/dns/masterdump.c

@@ -1527,9 +1527,7 @@ dumpctx_create(isc_mem_t *mctx, dns_db_t *db, dns_dbversion_t *version,
 	if (result != ISC_R_SUCCESS)
 		goto cleanup;
 
-	result = isc_mutex_init(&dctx->lock);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mutex_init(&dctx->lock);
 	if (version != NULL)
 		dns_db_attachversion(dctx->db, version, &dctx->version);
 	else if (!dns_db_iscache(db))

lib/dns/message.c

@@ -191,8 +191,6 @@ msgblock_allocate(isc_mem_t *mctx, unsigned int sizeof_type,
 	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;
@@ -245,18 +243,15 @@ msgblock_free(isc_mem_t *mctx, dns_msgblock_t *block, unsigned int sizeof_type)
  * "current" buffer.  (which is always the last on the list, for our
  * uses)
  */
-static inline isc_result_t
+static inline void
 newbuffer(dns_message_t *msg, unsigned int size) {
 	isc_result_t result;
 	isc_buffer_t *dynbuf;
 
 	dynbuf = NULL;
-	result = isc_buffer_allocate(msg->mctx, &dynbuf, size);
-	if (result != ISC_R_SUCCESS)
-		return (ISC_R_NOMEMORY);
+	isc_buffer_allocate(msg->mctx, &dynbuf, size);
 
 	ISC_LIST_APPEND(msg->scratchpad, dynbuf, link);
-	return (ISC_R_SUCCESS);
 }
 
 static inline isc_buffer_t *
@@ -290,9 +285,6 @@ newrdata(dns_message_t *msg) {
 	if (rdata == NULL) {
 		msgblock = msgblock_allocate(msg->mctx, sizeof(dns_rdata_t),
 					     RDATA_COUNT);
-		if (msgblock == NULL)
-			return (NULL);
-
 		ISC_LIST_APPEND(msg->rdatas, msgblock, link);
 
 		rdata = msgblock_get(msgblock, dns_rdata_t);
@@ -324,9 +316,6 @@ newrdatalist(dns_message_t *msg) {
 		msgblock = msgblock_allocate(msg->mctx,
 					     sizeof(dns_rdatalist_t),
 					     RDATALIST_COUNT);
-		if (msgblock == NULL)
-			return (NULL);
-
 		ISC_LIST_APPEND(msg->rdatalists, msgblock, link);
 
 		rdatalist = msgblock_get(msgblock, dns_rdatalist_t);
@@ -349,9 +338,6 @@ newoffsets(dns_message_t *msg) {
 		msgblock = msgblock_allocate(msg->mctx,
 					     sizeof(dns_offsets_t),
 					     OFFSET_COUNT);
-		if (msgblock == NULL)
-			return (NULL);
-
 		ISC_LIST_APPEND(msg->offsets, msgblock, link);
 
 		offsets = msgblock_get(msgblock, dns_offsets_t);
@@ -700,7 +686,7 @@ spacefortsig(dns_tsigkey_t *key, int otherlen) {
 	return (26 + r1.length + r2.length + x + otherlen);
 }
 
-isc_result_t
+void
 dns_message_create(isc_mem_t *mctx, unsigned int intent, dns_message_t **msgp)
 {
 	dns_message_t *m;
@@ -715,8 +701,6 @@ dns_message_create(isc_mem_t *mctx, unsigned int intent, dns_message_t **msgp)
 		|| 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
@@ -747,49 +731,24 @@ dns_message_create(isc_mem_t *mctx, unsigned int intent, dns_message_t **msgp)
 	 * Ok, it is safe to allocate (and then "goto cleanup" if failure)
 	 */
 
-	result = isc_mempool_create(m->mctx, sizeof(dns_name_t), &m->namepool);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_mempool_create(m->mctx, sizeof(dns_name_t), &m->namepool);
 	isc_mempool_setfillcount(m->namepool, NAME_COUNT);
 	isc_mempool_setfreemax(m->namepool, NAME_COUNT);
 	isc_mempool_setname(m->namepool, "msg:names");
 
-	result = isc_mempool_create(m->mctx, sizeof(dns_rdataset_t),
+	isc_mempool_create(m->mctx, sizeof(dns_rdataset_t),
 				    &m->rdspool);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
 	isc_mempool_setfillcount(m->rdspool, RDATASET_COUNT);
 	isc_mempool_setfreemax(m->rdspool, RDATASET_COUNT);
 	isc_mempool_setname(m->rdspool, "msg:rdataset");
 
 	dynbuf = NULL;
-	result = isc_buffer_allocate(mctx, &dynbuf, SCRATCHPAD_SIZE);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_buffer_allocate(mctx, &dynbuf, SCRATCHPAD_SIZE);
 	ISC_LIST_APPEND(m->scratchpad, dynbuf, link);
 
 	m->cctx = NULL;
 
 	*msgp = m;
-	return (ISC_R_SUCCESS);
-
-	/*
-	 * Cleanup for error returns.
-	 */
- cleanup:
-	dynbuf = ISC_LIST_HEAD(m->scratchpad);
-	if (dynbuf != NULL) {
-		ISC_LIST_UNLINK(m->scratchpad, dynbuf, link);
-		isc_buffer_free(&dynbuf);
-	}
-	if (m->namepool != NULL)
-		isc_mempool_destroy(&m->namepool);
-	if (m->rdspool != NULL)
-		isc_mempool_destroy(&m->rdspool);
-	m->magic = 0;
-	isc_mem_putanddetach(&mctx, m, sizeof(dns_message_t));
-
-	return (ISC_R_NOMEMORY);
 }
 
 void
@@ -909,9 +868,7 @@ getname(dns_name_t *name, isc_buffer_t *source, dns_message_t *msg,
 		if (result == ISC_R_NOSPACE) {
 			tries++;
 
-			result = newbuffer(msg, SCRATCHPAD_SIZE);
-			if (result != ISC_R_SUCCESS)
-				return (result);
+			newbuffer(msg, SCRATCHPAD_SIZE);
 
 			scratch = currentbuffer(msg);
 			dns_name_reset(name);
@@ -966,10 +923,7 @@ getrdata(isc_buffer_t *source, dns_message_t *msg, dns_decompress_t *dctx,
 				trysize *= 2;
 			}
 			tries++;
-			result = newbuffer(msg, trysize);
-			if (result != ISC_R_SUCCESS)
-				return (result);
-
+			newbuffer(msg, trysize);
 			scratch = currentbuffer(msg);
 		} else {
 			return (result);
@@ -1764,8 +1718,6 @@ dns_message_parse(dns_message_t *msg, isc_buffer_t *source,
 	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;
@@ -2924,9 +2876,7 @@ dns_message_setquerytsig(dns_message_t *msg, isc_buffer_t *querytsig) {
 		goto cleanup;
 
 	isc_buffer_usedregion(querytsig, &r);
-	result = isc_buffer_allocate(msg->mctx, &buf, r.length);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup;
+	isc_buffer_allocate(msg->mctx, &buf, r.length);
 	isc_buffer_putmem(buf, r.base, r.length);
 	isc_buffer_usedregion(buf, &r);
 	dns_rdata_init(rdata);
@@ -2971,9 +2921,7 @@ dns_message_getquerytsig(dns_message_t *msg, isc_mem_t *mctx,
 	dns_rdataset_current(msg->tsig, &rdata);
 	dns_rdata_toregion(&rdata, &r);
 
-	result = isc_buffer_allocate(mctx, querytsig, r.length);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_buffer_allocate(mctx, querytsig, r.length);
 	isc_buffer_putmem(*querytsig, r.base, r.length);
 	return (ISC_R_SUCCESS);
 }
@@ -3092,9 +3040,7 @@ dns_message_signer(dns_message_t *msg, dns_name_t *signer) {
 
 	if (!dns_name_hasbuffer(signer)) {
 		isc_buffer_t *dynbuf = NULL;
-		result = isc_buffer_allocate(msg->mctx, &dynbuf, 512);
-		if (result != ISC_R_SUCCESS)
-			return (result);
+		isc_buffer_allocate(msg->mctx, &dynbuf, 512);
 		dns_name_setbuffer(signer, dynbuf);
 		dns_message_takebuffer(msg, &dynbuf);
 	}
@@ -4307,8 +4253,6 @@ logfmtpacket(dns_message_t *message, const char *description,
 
 	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) {
@@ -4377,9 +4321,7 @@ dns_message_buildopt(dns_message_t *message, dns_rdataset_t **rdatasetp,
 			goto cleanup;
 		}
 
-		result = isc_buffer_allocate(message->mctx, &buf, len);
-		if (result != ISC_R_SUCCESS)
-			goto cleanup;
+		isc_buffer_allocate(message->mctx, &buf, len);
 
 		for (i = 0; i < count; i++)  {
 			if (ednsopts[i].code == DNS_OPT_PAD &&

lib/dns/name.c

@@ -1283,7 +1283,7 @@ free_specific(void *arg) {
 
 static void
 thread_key_mutex_init(void) {
-	RUNTIME_CHECK(isc_mutex_init(&thread_key_mutex) == ISC_R_SUCCESS);
+	isc_mutex_init(&thread_key_mutex);
 }
 
 static isc_result_t
@@ -1301,9 +1301,7 @@ totext_filter_proc_key_init(void) {
 	if (!thread_key_initialized) {
 		LOCK(&thread_key_mutex);
 		if (thread_key_mctx == NULL)
-			result = isc_mem_create2(0, 0, &thread_key_mctx, 0);
-		if (result != ISC_R_SUCCESS)
-			goto unlock;
+			isc_mem_create2(0, 0, &thread_key_mctx, 0);
 		isc_mem_setname(thread_key_mctx, "threadkey", NULL);
 		isc_mem_setdestroycheck(thread_key_mctx, false);
 
@@ -1312,8 +1310,10 @@ totext_filter_proc_key_init(void) {
 					   free_specific) != 0) {
 			result = ISC_R_FAILURE;
 			isc_mem_detach(&thread_key_mctx);
-		} else
+		} else {
+			result = ISC_R_SUCCESS;
 			thread_key_initialized = 1;
+		}
  unlock:
 		UNLOCK(&thread_key_mutex);
 	}
@@ -2158,7 +2158,7 @@ dns_name_split(const dns_name_t *name, unsigned int suffixlabels,
 	return;
 }
 
-isc_result_t
+void
 dns_name_dup(const dns_name_t *source, isc_mem_t *mctx,
 	     dns_name_t *target)
 {
@@ -2177,8 +2177,6 @@ dns_name_dup(const dns_name_t *source, isc_mem_t *mctx,
 	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);
 
@@ -2194,11 +2192,9 @@ dns_name_dup(const dns_name_t *source, isc_mem_t *mctx,
 		else
 			set_offsets(target, target->offsets, NULL);
 	}
-
-	return (ISC_R_SUCCESS);
 }
 
-isc_result_t
+void
 dns_name_dupwithoffsets(const dns_name_t *source, isc_mem_t *mctx,
 			dns_name_t *target)
 {
@@ -2219,8 +2215,6 @@ dns_name_dupwithoffsets(const dns_name_t *source, isc_mem_t *mctx,
 	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);
 
@@ -2235,8 +2229,6 @@ dns_name_dupwithoffsets(const dns_name_t *source, isc_mem_t *mctx,
 		memmove(target->offsets, source->offsets, source->labels);
 	else
 		set_offsets(target, target->offsets, NULL);
-
-	return (ISC_R_SUCCESS);
 }
 
 void
@@ -2452,8 +2444,7 @@ dns_name_fromstring2(dns_name_t *target, const char *src,
 	if (result != ISC_R_SUCCESS)
 		return (result);
 
-	if (name != target)
-		result = dns_name_dupwithoffsets(name, mctx, target);
+	dns_name_dupwithoffsets(name, mctx, target);
 	return (result);
 }
 

lib/dns/nta.c

@@ -112,24 +112,19 @@ dns_ntatable_create(dns_view_t *view,
 	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);
+	REQUIRE(result == ISC_R_SUCCESS);
 	if (result != ISC_R_SUCCESS)
 		goto cleanup_ntatable;
 	isc_task_setname(ntatable->task, "ntatable", ntatable);
 
 	ntatable->table = NULL;
-	result = dns_rbt_create(view->mctx, free_nta, view->mctx,
+	dns_rbt_create(view->mctx, free_nta, view->mctx,
 				&ntatable->table);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_task;
 
-	result = isc_rwlock_init(&ntatable->rwlock, 0, 0);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_rbt;
+	isc_rwlock_init(&ntatable->rwlock, 0, 0);
 
 	ntatable->timermgr = timermgr;
 	ntatable->taskmgr = taskmgr;
@@ -142,12 +137,6 @@ dns_ntatable_create(dns_view_t *view,
 
 	return (ISC_R_SUCCESS);
 
-   cleanup_rbt:
-	dns_rbt_destroy(&ntatable->table);
-
-   cleanup_task:
-	isc_task_detach(&ntatable->task);
-
    cleanup_ntatable:
 	isc_mem_put(ntatable->view->mctx, ntatable, sizeof(*ntatable));
 
@@ -584,9 +573,7 @@ dns_ntatable_dump(dns_ntatable_t *ntatable, FILE *fp) {
 	isc_buffer_t *text = NULL;
 	int len = 4096;
 
-	result = isc_buffer_allocate(ntatable->view->mctx, &text, len);
-	if (result != ISC_R_SUCCESS)
-		return (result);
+	isc_buffer_allocate(ntatable->view->mctx, &text, len);
 
 	result = dns_ntatable_totext(ntatable, &text);
 

lib/dns/openssl_link.c

@@ -156,9 +156,7 @@ dst__openssl_init(const char *engine) {
 	locks = mem_alloc(sizeof(isc_mutex_t) * nlocks FILELINE);
 	if (locks == NULL)
 		return (ISC_R_NOMEMORY);
-	result = isc_mutexblock_init(locks, nlocks);
-	if (result != ISC_R_SUCCESS)
-		goto cleanup_mutexalloc;
+	isc_mutexblock_init(locks, nlocks);
 	CRYPTO_set_locking_callback(lock_callback);
 # if defined(LIBRESSL_VERSION_NUMBER)
 	CRYPTO_set_id_callback(id_callback);
@@ -220,7 +218,7 @@ dst__openssl_init(const char *engine) {
 #endif
 #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER)
 	CRYPTO_set_locking_callback(NULL);
-	DESTROYMUTEXBLOCK(locks, nlocks);
+	isc_mutexblock_destroy(locks, nlocks);
  cleanup_mutexalloc:
 	mem_free(locks FILELINE);
 	locks = NULL;
@@ -258,7 +256,7 @@ dst__openssl_destroy(void) {
 
 	if (locks != NULL) {
 		CRYPTO_set_locking_callback(NULL);
-		DESTROYMUTEXBLOCK(locks, nlocks);
+		isc_mutexblock_destroy(locks, nlocks);
 		mem_free(locks FILELINE);
 		locks = NULL;
 	}

lib/dns/peer.c

@@ -654,15 +654,9 @@ dns_peer_setkeybycharp(dns_peer_t *peer, const char *keyval) {
 		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 (result != ISC_R_SUCCESS) {
-		isc_mem_put(peer->mem, name, sizeof(dns_name_t));
-		return (result);
-	}
+	dns_name_dup(dns_fixedname_name(&fname), peer->mem, name);
 
 	result = dns_peer_setkey(peer, &name);
 	if (result != ISC_R_SUCCESS)