DNS_ZONEOPT_WARNMXCNAME | DNS_ZONEOPT_WARNSRVCNAME;
static isc_symtab_t *symtab = NULL;
-static isc_mem_t *sym_mctx;
static void
freekey(char *key, unsigned int type, isc_symvalue_t value, void *userarg) {
isc_result_t result;
isc_symvalue_t symvalue;
- if (sym_mctx == NULL) {
- isc_mem_create("check-tool", &sym_mctx);
+ if (isc_g_mctx == NULL) {
+ isc_mem_create("check-tool", &isc_g_mctx);
}
if (symtab == NULL) {
- isc_symtab_create(sym_mctx, freekey, sym_mctx, false, &symtab);
+ isc_symtab_create(isc_g_mctx, freekey, isc_g_mctx, false,
+ &symtab);
}
- key = isc_mem_strdup(sym_mctx, key);
+ key = isc_mem_strdup(isc_g_mctx, key);
symvalue.as_pointer = NULL;
result = isc_symtab_define(symtab, key, value, symvalue,
isc_symexists_reject);
if (result != ISC_R_SUCCESS) {
- isc_mem_free(sym_mctx, key);
+ isc_mem_free(isc_g_mctx, key);
}
}
}
static isc_result_t
-configure_hint(const char *zfile, const char *zclass, isc_mem_t *mctx) {
+configure_hint(const char *zfile, const char *zclass) {
isc_result_t result;
dns_db_t *db = NULL;
dns_rdataclass_t rdclass;
return result;
}
- result = dns_rootns_create(mctx, rdclass, zfile, &db);
+ result = dns_rootns_create(isc_g_mctx, rdclass, zfile, &db);
if (result != ISC_R_SUCCESS) {
return result;
}
/*% configure the zone */
static isc_result_t
configure_zone(const char *vclass, const char *view, const cfg_obj_t *zconfig,
- const cfg_obj_t *vconfig, const cfg_obj_t *config,
- isc_mem_t *mctx, bool list) {
+ const cfg_obj_t *vconfig, const cfg_obj_t *config, bool list) {
int i = 0;
isc_result_t result;
const char *zclass;
* master and redirect
*/
if (strcasecmp(cfg_obj_asstring(typeobj), "hint") == 0) {
- return configure_hint(zfile, zclass, mctx);
+ return configure_hint(zfile, zclass);
} else if ((strcasecmp(cfg_obj_asstring(typeobj), "primary") != 0) &&
(strcasecmp(cfg_obj_asstring(typeobj), "master") != 0) &&
(strcasecmp(cfg_obj_asstring(typeobj), "redirect") != 0))
zone_options |= DNS_ZONEOPT_CHECKTTL;
}
- result = load_zone(mctx, zname, zfile, masterformat, zclass, maxttl,
- NULL);
+ result = load_zone(isc_g_mctx, zname, zfile, masterformat, zclass,
+ maxttl, NULL);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "%s/%s/%s: %s\n", view, zname, zclass,
isc_result_totext(result));
/*% configure a view */
static isc_result_t
configure_view(const char *vclass, const char *view, const cfg_obj_t *config,
- const cfg_obj_t *vconfig, isc_mem_t *mctx, bool list) {
+ const cfg_obj_t *vconfig, bool list) {
const cfg_obj_t *voptions = NULL;
const cfg_obj_t *zonelist = NULL;
isc_result_t result = ISC_R_SUCCESS;
CFG_LIST_FOREACH (zonelist, element) {
const cfg_obj_t *zconfig = cfg_listelt_value(element);
tresult = configure_zone(vclass, view, zconfig, vconfig, config,
- mctx, list);
+ list);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
/*% load zones from the configuration */
static isc_result_t
-load_zones_fromconfig(const cfg_obj_t *config, isc_mem_t *mctx,
- bool list_zones) {
+load_zones_fromconfig(const cfg_obj_t *config, bool list_zones) {
const cfg_obj_t *views = NULL;
const cfg_obj_t *vconfig = NULL;
isc_result_t result = ISC_R_SUCCESS;
dns_rdataclass_format(viewclass, buf, sizeof(buf));
vname = cfg_obj_asstring(cfg_tuple_get(vconfig, "name"));
- tresult = configure_view(buf, vname, config, vconfig, mctx,
+ tresult = configure_view(buf, vname, config, vconfig,
list_zones);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
}
if (views == NULL) {
- tresult = configure_view("IN", "_default", config, NULL, mctx,
+ tresult = configure_view("IN", "_default", config, NULL,
list_zones);
if (tresult != ISC_R_SUCCESS) {
result = tresult;
cfg_parser_t *parser = NULL;
cfg_obj_t *config = NULL;
const char *conffile = NULL;
- isc_mem_t *mctx = NULL;
isc_result_t result = ISC_R_SUCCESS;
bool load_zones = false;
bool list_zones = false;
}
isc_commandline_reset = true;
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
while ((c = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != EOF) {
switch (c) {
}
FALLTHROUGH;
case 'h':
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
usage();
default:
}
if (isc_commandline_index + 1 < argc) {
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
usage();
}
if (argv[isc_commandline_index] != NULL) {
CHECK(setup_logging(stdout));
- CHECK(cfg_parser_create(mctx, &parser));
+ CHECK(cfg_parser_create(isc_g_mctx, &parser));
if (nodeprecate) {
cfg_parser_setflags(parser, CFG_PCTX_NODEPRECATED, true);
cfg_parser_setcallback(parser, directory_callback, NULL);
CHECK(cfg_parse_file(parser, conffile, &cfg_type_namedconf, &config));
- CHECK(isccfg_check_namedconf(config, checkflags, mctx));
+ CHECK(isccfg_check_namedconf(config, checkflags, isc_g_mctx));
if (load_zones || list_zones) {
- CHECK(load_zones_fromconfig(config, mctx, list_zones));
+ CHECK(load_zones_fromconfig(config, list_zones));
}
if (print) {
cfg_parser_destroy(&parser);
}
- if (mctx != NULL) {
- isc_mem_detach(&mctx);
+ if (isc_g_mctx != NULL) {
+ isc_mem_detach(&isc_g_mctx);
}
return result == ISC_R_SUCCESS ? 0 : 1;
#include "check-tool.h"
static int quiet = 0;
-static isc_mem_t *mctx = NULL;
dns_zone_t *zone = NULL;
dns_zonetype_t zonetype = dns_zone_primary;
static int dumpzone = 0;
usage();
}
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
if (!quiet) {
RUNTIME_CHECK(setup_logging(errout) == ISC_R_SUCCESS);
}
isc_commandline_index++;
- result = load_zone(mctx, origin, filename, inputformat, classname,
+ result = load_zone(isc_g_mctx, origin, filename, inputformat, classname,
maxttl, &zone);
if (snset) {
fprintf(errout, "OK\n");
}
destroy();
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return (result == ISC_R_SUCCESS) ? 0 : 1;
}
bool show_final_mem = false;
isc_buffer_t key_txtbuffer;
char key_txtsecret[256];
- isc_mem_t *mctx = NULL;
const char *keyname = NULL;
const char *serveraddr = NULL;
dns_secalg_t alg;
}
algname = dst_hmac_algorithm_totext(alg);
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
isc_buffer_init(&key_txtbuffer, &key_txtsecret, sizeof(key_txtsecret));
- generate_key(mctx, alg, keysize, &key_txtbuffer);
+ generate_key(isc_g_mctx, alg, keysize, &key_txtbuffer);
if (keyonly) {
write_key_file(keyfile, chrootdir == NULL ? user : NULL,
if (chrootdir != NULL) {
char *buf;
len = strlen(chrootdir) + strlen(keyfile) + 2;
- buf = isc_mem_get(mctx, len);
+ buf = isc_mem_get(isc_g_mctx, len);
snprintf(buf, len, "%s%s%s", chrootdir,
(*keyfile != '/') ? "/" : "", keyfile);
if (!quiet) {
printf("wrote key file \"%s\"\n", buf);
}
- isc_mem_put(mctx, buf, len);
+ isc_mem_put(isc_g_mctx, buf, len);
}
} else {
printf("\
}
if (show_final_mem) {
- isc_mem_stats(mctx, stderr);
+ isc_mem_stats(isc_g_mctx, stderr);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return 0;
}
bool quiet = false;
isc_buffer_t key_txtbuffer;
char key_txtsecret[256];
- isc_mem_t *mctx = NULL;
const char *keyname = NULL;
const char *zone = NULL;
const char *self_domain = NULL;
/* Use canonical algorithm name */
algname = dst_hmac_algorithm_totext(alg);
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
if (keyname == NULL) {
const char *suffix = NULL;
}
if (suffix != NULL) {
len = strlen(keyname) + strlen(suffix) + 2;
- keybuf = isc_mem_get(mctx, len);
+ keybuf = isc_mem_get(isc_g_mctx, len);
snprintf(keybuf, len, "%s.%s", keyname, suffix);
keyname = (const char *)keybuf;
}
isc_buffer_init(&key_txtbuffer, &key_txtsecret, sizeof(key_txtsecret));
- generate_key(mctx, alg, keysize, &key_txtbuffer);
+ generate_key(isc_g_mctx, alg, keysize, &key_txtbuffer);
if (!quiet) {
printf("\
}
if (keybuf != NULL) {
- isc_mem_put(mctx, keybuf, len);
+ isc_mem_put(isc_g_mctx, keybuf, len);
}
if (show_final_mem) {
- isc_mem_stats(mctx, stderr);
+ isc_mem_stats(isc_g_mctx, stderr);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return 0;
}
#define MAX_RESTARTS 11
/* Variables used internally by delv. */
-static isc_mem_t *mctx = NULL;
static dns_view_t *view = NULL;
static ns_server_t *sctx = NULL;
static ns_interface_t *ifp = NULL;
}
do {
- t = isc_mem_get(mctx, len);
+ t = isc_mem_get(isc_g_mctx, len);
isc_buffer_init(&target, t, len);
if (short_form) {
}
if (result == ISC_R_NOSPACE) {
- isc_mem_put(mctx, t, len);
+ isc_mem_put(isc_g_mctx, t, len);
len += 1024;
} else if (result == ISC_R_NOMORE) {
result = ISC_R_SUCCESS;
cleanup:
if (t != NULL) {
- isc_mem_put(mctx, t, len);
+ isc_mem_put(isc_g_mctx, t, len);
}
}
if (multiline || (nottl && noclass)) {
result = dns_master_stylecreate(&style, styleflags, 24, 24, 24,
- 32, 80, 8, splitwidth, mctx);
+ 32, 80, 8, splitwidth,
+ isc_g_mctx);
} else if (nottl || noclass) {
result = dns_master_stylecreate(&style, styleflags, 24, 24, 32,
- 40, 80, 8, splitwidth, mctx);
+ 40, 80, 8, splitwidth,
+ isc_g_mctx);
} else {
result = dns_master_stylecreate(&style, styleflags, 24, 32, 40,
- 48, 80, 8, splitwidth, mctx);
+ 48, 80, 8, splitwidth,
+ isc_g_mctx);
}
return result;
}
if (trust_anchor == NULL) {
- trust_anchor = isc_mem_strdup(mctx, ".");
+ trust_anchor = isc_mem_strdup(isc_g_mctx, ".");
}
if (trust_anchor != NULL) {
CHECK(convert_name(&afn, &anchor_name, trust_anchor));
}
- CHECK(cfg_parser_create(mctx, &parser));
+ CHECK(cfg_parser_create(isc_g_mctx, &parser));
if (anchorfile != NULL) {
if (access(anchorfile, R_OK) != 0) {
if (!use_ipv4) {
fatal("Use of IPv4 disabled by -6");
}
- sa = isc_mem_get(mctx, sizeof(*sa));
+ sa = isc_mem_get(isc_g_mctx, sizeof(*sa));
ISC_LINK_INIT(sa, link);
isc_sockaddr_fromin(sa, &in4, destport);
ISC_LIST_APPEND(servers, sa, link);
if (!use_ipv6) {
fatal("Use of IPv6 disabled by -4");
}
- sa = isc_mem_get(mctx, sizeof(*sa));
+ sa = isc_mem_get(isc_g_mctx, sizeof(*sa));
ISC_LINK_INIT(sa, link);
isc_sockaddr_fromin6(sa, &in6, destport);
ISC_LIST_APPEND(servers, sa, link);
{
continue;
}
- sa = isc_mem_get(mctx, sizeof(*sa));
+ sa = isc_mem_get(isc_g_mctx, sizeof(*sa));
*sa = (isc_sockaddr_t){
.length = (unsigned int)cur->ai_addrlen,
};
cleanup:
ISC_LIST_FOREACH (servers, s, link) {
ISC_LIST_UNLINK(servers, s, link);
- isc_mem_put(mctx, s, sizeof(*s));
+ isc_mem_put(isc_g_mctx, s, sizeof(*s));
}
if (result != ISC_R_SUCCESS) {
irs_resconf_t *resconf = NULL;
isc_sockaddrlist_t *nameservers = NULL;
- result = irs_resconf_load(mctx, "/etc/resolv.conf", &resconf);
+ result = irs_resconf_load(isc_g_mctx, "/etc/resolv.conf", &resconf);
if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
delv_log(ISC_LOG_ERROR, "irs_resconf_load: %s",
isc_result_totext(result));
/* Incompatible protocol family */
ISC_LIST_UNLINK(*nameservers, sa, link);
- isc_mem_put(mctx, sa, sizeof(*sa));
+ isc_mem_put(isc_g_mctx, sa, sizeof(*sa));
}
/* None found, use localhost */
if (use_ipv4) {
struct in_addr localhost;
localhost.s_addr = htonl(INADDR_LOOPBACK);
- isc_sockaddr_t *sa = isc_mem_get(mctx, sizeof(*sa));
+ isc_sockaddr_t *sa = isc_mem_get(isc_g_mctx,
+ sizeof(*sa));
isc_sockaddr_fromin(sa, &localhost, destport);
ISC_LINK_INIT(sa, link);
}
if (use_ipv6) {
- isc_sockaddr_t *sa = isc_mem_get(mctx, sizeof(*sa));
+ isc_sockaddr_t *sa = isc_mem_get(isc_g_mctx,
+ sizeof(*sa));
isc_sockaddr_fromin6(sa, &in6addr_loopback, destport);
ISC_LINK_INIT(sa, link);
}
root_validation = state;
if (value != NULL) {
- trust_anchor = isc_mem_strdup(mctx, value);
+ trust_anchor = isc_mem_strdup(isc_g_mctx,
+ value);
}
break;
case 'r': /* rrcomments */
}
switch (opt) {
case 'a':
- anchorfile = isc_mem_strdup(mctx, value);
+ anchorfile = isc_mem_strdup(isc_g_mctx, value);
return value_from_next;
case 'b':
hash = strchr(value, '#');
case 'q':
if (curqname != NULL) {
warn("extra query name");
- isc_mem_free(mctx, curqname);
+ isc_mem_free(isc_g_mctx, curqname);
}
- curqname = isc_mem_strdup(mctx, value);
+ curqname = isc_mem_strdup(isc_g_mctx, value);
return value_from_next;
case 't':
*open_type_class = false;
result = get_reverse(textname, sizeof(textname), value, false);
if (result == ISC_R_SUCCESS) {
if (curqname != NULL) {
- isc_mem_free(mctx, curqname);
+ isc_mem_free(isc_g_mctx, curqname);
warn("extra query name");
}
- curqname = isc_mem_strdup(mctx, textname);
+ curqname = isc_mem_strdup(isc_g_mctx, textname);
if (typeset) {
warn("extra query type");
}
}
if (curqname == NULL) {
- curqname = isc_mem_strdup(mctx, argv[0]);
+ curqname = isc_mem_strdup(isc_g_mctx, argv[0]);
}
}
}
}
if (curqname == NULL) {
- qname = isc_mem_strdup(mctx, ".");
+ qname = isc_mem_strdup(isc_g_mctx, ".");
if (!typeset) {
qtype = dns_rdatatype_ns;
}
dns_client_freeresanswer(client, namelist);
- isc_mem_put(mctx, namelist, sizeof(*namelist));
+ isc_mem_put(isc_g_mctx, namelist, sizeof(*namelist));
dns_client_detach(&client);
UNUSED(arg);
- namelist = isc_mem_get(mctx, sizeof(*namelist));
+ namelist = isc_mem_get(isc_g_mctx, sizeof(*namelist));
ISC_LIST_INIT(*namelist);
/* Construct QNAME */
}
/* Create client */
- CHECK(dns_client_create(mctx, 0, tlsctx_client_cache, &client, srcaddr4,
- srcaddr6));
+ CHECK(dns_client_create(isc_g_mctx, 0, tlsctx_client_cache, &client,
+ srcaddr4, srcaddr6));
dns_client_setmaxrestarts(client, restarts);
dns_client_setmaxqueries(client, maxtotal);
isc_result_totext(result));
}
- isc_mem_put(mctx, namelist, sizeof(*namelist));
+ isc_mem_put(isc_g_mctx, namelist, sizeof(*namelist));
isc_loopmgr_shutdown();
dns_client_detach(&client);
fatal("request event result: %s", isc_result_totext(result));
}
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
&response);
result = dns_request_getresponse(request, response,
/* Construct query message */
CHECK(convert_name(&qfn, &query_name, qname));
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
&message);
message->opcode = dns_opcode_query;
message->flags = DNS_MESSAGEFLAG_RD | DNS_MESSAGEFLAG_AD;
NULL, 0));
CHECK(dns_message_setopt(message, opt));
- CHECK(dns_requestmgr_create(mctx, dispatchmgr, NULL, NULL,
+ CHECK(dns_requestmgr_create(isc_g_mctx, dispatchmgr, NULL, NULL,
&requestmgr));
dns_view_attach(view, &(dns_view_t *){ NULL });
RUNTIME_CHECK(inet_pton(AF_INET, "127.0.0.1", &in));
isc_sockaddr_fromin(&addr, &in, 0);
- ns_server_create(mctx, matchview, &sctx);
+ ns_server_create(isc_g_mctx, matchview, &sctx);
- CHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
+ CHECK(dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr));
if (use_ipv4) {
isc_sockaddr_any(&any);
CHECK(dns_dispatch_createudp(dispatchmgr, a, &dispatch6));
}
- CHECK(ns_interfacemgr_create(mctx, sctx, dispatchmgr, NULL,
+ CHECK(ns_interfacemgr_create(isc_g_mctx, sctx, dispatchmgr, NULL,
&interfacemgr));
- dns_view_create(mctx, dispatchmgr, dns_rdataclass_in, "_default",
+ dns_view_create(isc_g_mctx, dispatchmgr, dns_rdataclass_in, "_default",
&view);
- CHECK(dns_cache_create(dns_rdataclass_in, "", mctx, &cache));
+ CHECK(dns_cache_create(dns_rdataclass_in, "", isc_g_mctx, &cache));
dns_view_setcache(view, cache, false);
dns_cache_detach(&cache);
dns_view_setdstport(view, destport);
dns_view_setmaxrestarts(view, restarts);
dns_view_setmaxqueries(view, maxtotal);
- CHECK(dns_rootns_create(mctx, dns_rdataclass_in, hintfile, &roothints));
+ CHECK(dns_rootns_create(isc_g_mctx, dns_rdataclass_in, hintfile,
+ &roothints));
dns_view_sethints(view, roothints);
dns_db_detach(&roothints);
dispatch6));
dns_resolver_setmaxqueries(view->resolver, maxqueries);
- isc_stats_create(mctx, &resstats, dns_resstatscounter_max);
+ isc_stats_create(isc_g_mctx, &resstats, dns_resstatscounter_max);
dns_resolver_setstats(view->resolver, resstats);
isc_stats_detach(&resstats);
- dns_rdatatypestats_create(mctx, &resquerystats);
+ dns_rdatatypestats_create(isc_g_mctx, &resquerystats);
dns_resolver_setquerystats(view->resolver, resquerystats);
dns_stats_detach(&resquerystats);
argc--;
argv++;
- isc_managers_create(&mctx, 1);
+ isc_managers_create(1);
loop = isc_loop_main();
parse_args(argc, argv);
server);
}
- isc_tlsctx_cache_create(mctx, &tlsctx_client_cache);
+ isc_tlsctx_cache_create(isc_g_mctx, &tlsctx_client_cache);
isc_loop_setup(loop, fulltrace ? run_server : run_resolve, NULL);
isc_loopmgr_run();
isc_tlsctx_cache_detach(&tlsctx_client_cache);
}
if (trust_anchor != NULL) {
- isc_mem_free(mctx, trust_anchor);
+ isc_mem_free(isc_g_mctx, trust_anchor);
}
if (anchorfile != NULL) {
- isc_mem_free(mctx, anchorfile);
+ isc_mem_free(isc_g_mctx, anchorfile);
}
if (qname != NULL) {
- isc_mem_free(mctx, qname);
+ isc_mem_free(isc_g_mctx, qname);
}
if (style != NULL) {
- dns_master_styledestroy(&style, mctx);
+ dns_master_styledestroy(&style, isc_g_mctx);
}
- isc_managers_destroy(&mctx);
+ isc_managers_destroy();
return 0;
}
(query->lookup->nottl && query->lookup->noclass))
{
result = dns_master_stylecreate(&style, styleflags, 24, 24, 24,
- 32, 80, 8, splitwidth, mctx);
+ 32, 80, 8, splitwidth,
+ isc_g_mctx);
} else if (query->lookup->nottl || query->lookup->noclass) {
result = dns_master_stylecreate(&style, styleflags, 24, 24, 32,
- 40, 80, 8, splitwidth, mctx);
+ 40, 80, 8, splitwidth,
+ isc_g_mctx);
} else {
result = dns_master_stylecreate(&style, styleflags, 24, 32, 40,
- 48, 80, 8, splitwidth, mctx);
+ 48, 80, 8, splitwidth,
+ isc_g_mctx);
}
check_result(result, "dns_master_stylecreate");
flags |= DNS_MESSAGETEXTFLAG_NOCOMMENTS;
}
- isc_buffer_allocate(mctx, &buf, len);
+ isc_buffer_allocate(isc_g_mctx, &buf, len);
if (yaml) {
enum { Q = 0x1, R = 0x2 }; /* Q:query; R:ecursive */
buftoosmall:
len += OUTPUTBUF;
isc_buffer_free(&buf);
- isc_buffer_allocate(mctx, &buf, len);
+ isc_buffer_allocate(isc_g_mctx, &buf, len);
goto repopulate_buffer;
}
check_result(result, "dns_message_pseudosectiontotext");
isc_buffer_free(&buf);
if (style != NULL) {
- dns_master_styledestroy(&style, mctx);
+ dns_master_styledestroy(&style, isc_g_mctx);
}
dig_idnsetup(query->lookup, false);
FULLCHECK("tls-ca");
lookup->tls_ca_set = state;
if (state && value != NULL) {
- lookup->tls_ca_file =
- isc_mem_strdup(mctx, value);
+ lookup->tls_ca_file = isc_mem_strdup(
+ isc_g_mctx, value);
}
break;
case 'e':
if (state) {
if (value != NULL && *value != '\0') {
lookup->tls_cert_file =
- isc_mem_strdup(mctx,
- value);
+ isc_mem_strdup(
+ isc_g_mctx,
+ value);
} else {
fprintf(stderr,
";; TLS certificate "
lookup->tls_hostname_set = state;
if (state) {
if (value != NULL && *value != '\0') {
- lookup->tls_hostname =
- isc_mem_strdup(mctx, value);
+ lookup->tls_hostname = isc_mem_strdup(
+ isc_g_mctx, value);
} else {
fprintf(stderr, ";; TLS hostname is "
"not specified\n");
lookup->tls_key_file_set = state;
if (state) {
if (value != NULL && *value != '\0') {
- lookup->tls_key_file =
- isc_mem_strdup(mctx, value);
+ lookup->tls_key_file = isc_mem_strdup(
+ isc_g_mctx, value);
} else {
fprintf(stderr,
";; TLS private key file is "
"http-plain-post");
#if HAVE_LIBNGHTTP2
if (lookup->https_path != NULL) {
- isc_mem_free(mctx, lookup->https_path);
+ isc_mem_free(isc_g_mctx, lookup->https_path);
lookup->https_path = NULL;
}
if (!state) {
}
if (value == NULL) {
lookup->https_path = isc_mem_strdup(
- mctx, ISC_NM_HTTP_DEFAULT_PATH);
+ isc_g_mctx, ISC_NM_HTTP_DEFAULT_PATH);
} else {
if (!isc_nm_http_path_isvalid(value)) {
fprintf(stderr,
value);
goto invalid_option;
}
- lookup->https_path = isc_mem_strdup(mctx,
+ lookup->https_path = isc_mem_strdup(isc_g_mctx,
value);
}
#else
}
if (!state) {
if (lookup->ecs_addr != NULL) {
- isc_mem_put(mctx, lookup->ecs_addr,
+ isc_mem_put(isc_g_mctx,
+ lookup->ecs_addr,
sizeof(*lookup->ecs_addr));
lookup->ecs_addr = NULL;
}
lookup->edns = DEFAULT_EDNS_VERSION;
}
if (lookup->ecs_addr != NULL) {
- isc_mem_put(mctx, lookup->ecs_addr,
+ isc_mem_put(isc_g_mctx, lookup->ecs_addr,
sizeof(*lookup->ecs_addr));
lookup->ecs_addr = NULL;
}
bool port_set = false;
unsigned int timeout = 0;
unsigned int extrabytes;
-isc_mem_t *mctx = NULL;
isc_loop_t *mainloop = NULL;
isc_sockaddr_t localaddr;
isc_refcount_t sendcount = 0;
REQUIRE(servname != NULL);
debug("make_server(%s)", servname);
- srv = isc_mem_allocate(mctx, sizeof(struct dig_server));
+ srv = isc_mem_allocate(isc_g_mctx, sizeof(struct dig_server));
strlcpy(srv->servername, servname, MXNAME);
strlcpy(srv->userarg, userarg, MXNAME);
ISC_LINK_INIT(srv, link);
debug("flush_server_list()");
ISC_LIST_FOREACH (server_list, s, link) {
ISC_LIST_DEQUEUE(server_list, s, link);
- isc_mem_free(mctx, s);
+ isc_mem_free(isc_g_mctx, s);
}
}
INSIST(!free_now);
- looknew = isc_mem_allocate(mctx, sizeof(*looknew));
+ looknew = isc_mem_allocate(isc_g_mctx, sizeof(*looknew));
*looknew = (dig_lookup_t){
.pending = true,
.rdtype = dns_rdatatype_a,
ISC_LIST_INIT(looknew->q);
ISC_LIST_INIT(looknew->my_server_list);
- isc_tlsctx_cache_create(mctx, &looknew->tls_ctx_cache);
+ isc_tlsctx_cache_create(isc_g_mctx, &looknew->tls_ctx_cache);
isc_refcount_init(&looknew->references, 1);
cloneopts(dig_lookup_t *looknew, dig_lookup_t *lookold) {
size_t len = sizeof(looknew->ednsopts[0]) * EDNSOPT_OPTIONS;
size_t i;
- looknew->ednsopts = isc_mem_allocate(mctx, len);
+ looknew->ednsopts = isc_mem_allocate(isc_g_mctx, len);
for (i = 0; i < EDNSOPT_OPTIONS; i++) {
looknew->ednsopts[i].code = 0;
looknew->ednsopts[i].length = 0;
len = lookold->ednsopts[i].length;
if (len != 0) {
INSIST(lookold->ednsopts[i].value != NULL);
- looknew->ednsopts[i].value = isc_mem_allocate(mctx,
- len);
+ looknew->ednsopts[i].value =
+ isc_mem_allocate(isc_g_mctx, len);
memmove(looknew->ednsopts[i].value,
lookold->ednsopts[i].value, len);
}
looknew->header_only = lookold->header_only;
looknew->https_mode = lookold->https_mode;
if (lookold->https_path != NULL) {
- looknew->https_path = isc_mem_strdup(mctx, lookold->https_path);
+ looknew->https_path = isc_mem_strdup(isc_g_mctx,
+ lookold->https_path);
}
looknew->https_get = lookold->https_get;
looknew->http_plain = lookold->http_plain;
looknew->tls_ca_set = lookold->tls_ca_set;
if (lookold->tls_ca_file != NULL) {
- looknew->tls_ca_file = isc_mem_strdup(mctx,
+ looknew->tls_ca_file = isc_mem_strdup(isc_g_mctx,
lookold->tls_ca_file);
};
looknew->tls_hostname_set = lookold->tls_hostname_set;
if (lookold->tls_hostname != NULL) {
- looknew->tls_hostname = isc_mem_strdup(mctx,
+ looknew->tls_hostname = isc_mem_strdup(isc_g_mctx,
lookold->tls_hostname);
}
looknew->tls_key_file_set = lookold->tls_key_file_set;
if (lookold->tls_key_file != NULL) {
- looknew->tls_key_file = isc_mem_strdup(mctx,
+ looknew->tls_key_file = isc_mem_strdup(isc_g_mctx,
lookold->tls_key_file);
}
looknew->tls_cert_file_set = lookold->tls_cert_file_set;
if (lookold->tls_cert_file != NULL) {
- looknew->tls_cert_file = isc_mem_strdup(mctx,
+ looknew->tls_cert_file = isc_mem_strdup(isc_g_mctx,
lookold->tls_cert_file);
}
looknew->proxy_dst_addr = lookold->proxy_dst_addr;
if (lookold->ecs_addr != NULL) {
- looknew->ecs_addr = isc_mem_get(mctx,
+ looknew->ecs_addr = isc_mem_get(isc_g_mctx,
sizeof(*looknew->ecs_addr));
memmove(looknew->ecs_addr, lookold->ecs_addr,
sizeof(*looknew->ecs_addr));
unsigned char *secretstore;
debug("setup_text_key()");
- isc_buffer_allocate(mctx, &namebuf, MXNAME);
+ isc_buffer_allocate(isc_g_mctx, &namebuf, MXNAME);
isc_buffer_putstr(namebuf, keynametext);
secretsize = (unsigned int)strlen(keysecret) * 3 / 4;
- secretstore = isc_mem_allocate(mctx, secretsize);
+ secretstore = isc_mem_allocate(isc_g_mctx, secretsize);
isc_buffer_init(&secretbuf, secretstore, secretsize);
result = isc_base64_decodestring(keysecret, &secretbuf);
if (result != ISC_R_SUCCESS) {
}
result = dns_tsigkey_create(keyname, hmac_alg, secretstore,
- (int)secretsize, mctx, &tsigkey);
+ (int)secretsize, isc_g_mctx, &tsigkey);
failure:
if (result != ISC_R_SUCCESS) {
printf(";; Couldn't create key %s: %s\n", keynametext,
dst_key_setbits(tsigkey->key, digestbits);
}
- isc_mem_free(mctx, secretstore);
+ isc_mem_free(isc_g_mctx, secretstore);
isc_buffer_free(&namebuf);
}
fatal("invalid prefix '%s'\n", value);
}
- sa = isc_mem_get(mctx, sizeof(*sa));
+ sa = isc_mem_get(isc_g_mctx, sizeof(*sa));
*sa = (isc_sockaddr_t){ .length = 0 };
if (strcmp(buf, "0") == 0) {
return ISC_R_FILENOTFOUND;
}
- result = cfg_parser_create(mctx, &pctx);
+ result = cfg_parser_create(isc_g_mctx, &pctx);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
}
/* Try reading the key from a K* pair */
- result = dst_key_fromnamedfile(
- keyfile, NULL, DST_TYPE_PRIVATE | DST_TYPE_KEY, mctx, &dstkey);
+ result = dst_key_fromnamedfile(keyfile, NULL,
+ DST_TYPE_PRIVATE | DST_TYPE_KEY,
+ isc_g_mctx, &dstkey);
/* If that didn't work, try reading it as a session.key keyfile */
if (result != ISC_R_SUCCESS) {
if (dstkey != NULL) {
result = dns_tsigkey_createfromkey(
dst_key_name(dstkey), hmac_alg, dstkey, false, false,
- NULL, 0, 0, mctx, &tsigkey);
+ NULL, 0, 0, isc_g_mctx, &tsigkey);
if (result != ISC_R_SUCCESS) {
printf(";; Couldn't create key %s: %s\n", keynametext,
isc_result_totext(result));
static dig_searchlist_t *
make_searchlist_entry(char *domain) {
dig_searchlist_t *search;
- search = isc_mem_allocate(mctx, sizeof(*search));
+ search = isc_mem_allocate(isc_g_mctx, sizeof(*search));
strlcpy(search->origin, domain, MXNAME);
search->origin[MXNAME - 1] = 0;
ISC_LINK_INIT(search, link);
clear_searchlist(void) {
ISC_LIST_FOREACH (search_list, search, link) {
ISC_LIST_UNLINK(search_list, search, link);
- isc_mem_free(mctx, search);
+ isc_mem_free(isc_g_mctx, search);
}
}
}
}
- result = irs_resconf_load(mctx, RESOLV_CONF, &resconf);
+ result = irs_resconf_load(isc_g_mctx, RESOLV_CONF, &resconf);
if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
fatal("parse of %s failed", RESOLV_CONF);
}
fatal("can't find either v4 or v6 networking");
}
- isc_managers_create(&mctx, 1);
+ isc_managers_create(1);
logconfig = isc_logconfig_get();
isc_log_createandusechannel(logconfig, "debug", ISC_LOG_TOFILEDESC,
INSIST(lookup->ednsopts != NULL);
if (lookup->ednsopts[lookup->ednsoptscnt].value != NULL) {
- isc_mem_free(mctx, lookup->ednsopts[lookup->ednsoptscnt].value);
+ isc_mem_free(isc_g_mctx,
+ lookup->ednsopts[lookup->ednsoptscnt].value);
}
lookup->ednsopts[lookup->ednsoptscnt].code = num;
if (value != NULL) {
char *buf;
- buf = isc_mem_allocate(mctx, strlen(value) / 2 + 1);
+ buf = isc_mem_allocate(isc_g_mctx, strlen(value) / 2 + 1);
isc_buffer_init(&b, buf, (unsigned int)strlen(value) / 2 + 1);
result = isc_hex_decodestring(value, &b);
check_result(result, "isc_hex_decodestring");
ISC_LIST_FOREACH (lookup->my_server_list, s, link) {
debug("freeing server %p belonging to %p", s, lookup);
ISC_LIST_DEQUEUE(lookup->my_server_list, s, link);
- isc_mem_free(mctx, s);
+ isc_mem_free(isc_g_mctx, s);
}
if (lookup->sendmsg != NULL) {
dns_message_detach(&lookup->sendmsg);
isc_buffer_free(&lookup->querysig);
}
if (lookup->sendspace != NULL) {
- isc_mem_put(mctx, lookup->sendspace, COMMSIZE);
+ isc_mem_put(isc_g_mctx, lookup->sendspace, COMMSIZE);
}
if (lookup->tsigctx != NULL) {
}
if (lookup->ecs_addr != NULL) {
- isc_mem_put(mctx, lookup->ecs_addr, sizeof(*lookup->ecs_addr));
+ isc_mem_put(isc_g_mctx, lookup->ecs_addr,
+ sizeof(*lookup->ecs_addr));
}
if (lookup->ednsopts != NULL) {
size_t i;
for (i = 0; i < EDNSOPT_OPTIONS; i++) {
if (lookup->ednsopts[i].value != NULL) {
- isc_mem_free(mctx, lookup->ednsopts[i].value);
+ isc_mem_free(isc_g_mctx,
+ lookup->ednsopts[i].value);
}
}
- isc_mem_free(mctx, lookup->ednsopts);
+ isc_mem_free(isc_g_mctx, lookup->ednsopts);
}
if (lookup->https_path) {
- isc_mem_free(mctx, lookup->https_path);
+ isc_mem_free(isc_g_mctx, lookup->https_path);
}
if (lookup->tls_ctx_cache != NULL) {
}
if (lookup->tls_ca_file != NULL) {
- isc_mem_free(mctx, lookup->tls_ca_file);
+ isc_mem_free(isc_g_mctx, lookup->tls_ca_file);
}
if (lookup->tls_hostname != NULL) {
- isc_mem_free(mctx, lookup->tls_hostname);
+ isc_mem_free(isc_g_mctx, lookup->tls_hostname);
}
if (lookup->tls_key_file != NULL) {
- isc_mem_free(mctx, lookup->tls_key_file);
+ isc_mem_free(isc_g_mctx, lookup->tls_key_file);
}
if (lookup->tls_cert_file != NULL) {
- isc_mem_free(mctx, lookup->tls_cert_file);
+ isc_mem_free(isc_g_mctx, lookup->tls_cert_file);
}
- isc_mem_free(mctx, lookup);
+ isc_mem_free(isc_g_mctx, lookup);
}
#define lookup_attach(s, t) _lookup_attach(s, t, __FILE__, __LINE__)
INSIST(query->recvspace != NULL);
- isc_mem_put(mctx, query->recvspace, COMMSIZE);
- isc_mem_put(mctx, query->tmpsendspace, COMMSIZE);
+ isc_mem_put(isc_g_mctx, query->recvspace, COMMSIZE);
+ isc_mem_put(isc_g_mctx, query->tmpsendspace, COMMSIZE);
query->magic = 0;
- isc_mem_free(mctx, query);
+ isc_mem_free(isc_g_mctx, query);
}
#define query_attach(s, t) _query_attach(s, t, __FILE__, __LINE__)
dns_name_t *soaname = NULL;
debug("insert_soa()");
- soa.mctx = mctx;
+ soa.mctx = isc_g_mctx;
soa.serial = lookup->ixfr_serial;
soa.refresh = 0;
soa.retry = 0;
const char *file, unsigned int line) {
dig_query_t *query = NULL;
- query = isc_mem_allocate(mctx, sizeof(dig_query_t));
+ query = isc_mem_allocate(isc_g_mctx, sizeof(dig_query_t));
debug("create query %p linked to lookup %p", query, lookup);
*query = (dig_query_t){ .sendbuf = lookup->renderbuf,
.servname = servname,
.userarg = userarg,
.warn_id = true,
- .recvspace = isc_mem_get(mctx, COMMSIZE),
- .tmpsendspace = isc_mem_get(mctx, COMMSIZE) };
+ .recvspace = isc_mem_get(isc_g_mctx, COMMSIZE),
+ .tmpsendspace = isc_mem_get(isc_g_mctx,
+ COMMSIZE) };
lookup_attach(lookup, &query->lookup);
debug("setup_lookup(%p)", lookup);
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
&lookup->sendmsg);
if (lookup->new_search) {
lookup->sendmsg->fuzztime = lookup->fuzztime;
}
- lookup->sendspace = isc_mem_get(mctx, COMMSIZE);
+ lookup->sendspace = isc_mem_get(isc_g_mctx, COMMSIZE);
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
debug("starting to render the message");
isc_buffer_init(&lookup->renderbuf, lookup->sendspace, COMMSIZE);
#endif /* HAVE_LIBNGHTTP2 */
isc_tlsctx_client_session_cache_create(
- mctx, ctx, ISC_TLSCTX_CLIENT_SESSION_CACHE_DEFAULT_SIZE,
+ isc_g_mctx, ctx,
+ ISC_TLSCTX_CLIENT_SESSION_CACHE_DEFAULT_SIZE,
&sess_cache);
result = isc_tlsctx_cache_add(
goto keep_query;
}
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &msg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &msg);
if (tsigkey != NULL) {
if (l->querysig == NULL) {
debug("getting initial querysig");
- result = dns_message_getquerytsig(l->sendmsg, mctx,
- &l->querysig);
+ result = dns_message_getquerytsig(
+ l->sendmsg, isc_g_mctx, &l->querysig);
check_result(result, "dns_message_getquerytsig");
}
dns_message_setquerytsig(msg, l->querysig);
debug("freeing querysig buffer %p", l->querysig);
isc_buffer_free(&l->querysig);
}
- result = dns_message_getquerytsig(msg, mctx, &l->querysig);
+ result = dns_message_getquerytsig(msg, isc_g_mctx,
+ &l->querysig);
check_result(result, "dns_message_getquerytsig");
}
debug("Destroy memory");
if (memdebugging != 0) {
- isc_mem_stats(mctx, stderr);
+ isc_mem_stats(isc_g_mctx, stderr);
}
- isc_managers_destroy(&mctx);
+ isc_managers_destroy();
#if ENABLE_LEAK_DETECTION
isc__crypto_setdestroycheck(true);
extern in_port_t port;
extern bool port_set;
extern unsigned int timeout;
-extern isc_mem_t *mctx;
extern isc_refcount_t sendcount;
extern int ndots;
extern int lookup_counter;
dns_name_format(name, namestr, sizeof(namestr));
retry:
- isc_buffer_allocate(mctx, &b, bufsize);
+ isc_buffer_allocate(isc_g_mctx, &b, bufsize);
result = dns_rdata_totext(rdata, NULL, b);
if (result == ISC_R_NOSPACE) {
isc_buffer_free(&b);
}
while (!done) {
- isc_buffer_allocate(mctx, &b, size);
+ isc_buffer_allocate(isc_g_mctx, &b, size);
result = dns_rdata_totext(rdata, NULL, b);
if (result == ISC_R_SUCCESS) {
printf("%.*s\n", (int)isc_buffer_usedlength(b),
#include "dnssectool.h"
-/*
- * Infrastructure
- */
-static isc_mem_t *mctx = NULL;
-
/*
* The domain we are working on
*/
ISC_LIST_FOREACH (rdlist->rdata, rdata, link) {
ISC_LIST_UNLINK(rdlist->rdata, rdata, link);
- isc_mem_put(mctx, rdata, sizeof(*rdata));
+ isc_mem_put(isc_g_mctx, rdata, sizeof(*rdata));
}
- isc_mem_put(mctx, rdlist, sizeof(*rdlist));
+ isc_mem_put(isc_g_mctx, rdlist, sizeof(*rdlist));
dns_rdataset_disassociate(rdataset);
}
load_db(const char *filename, dns_db_t **dbp, dns_dbnode_t **nodep) {
isc_result_t result;
- result = dns_db_create(mctx, ZONEDB_DEFAULT, name, dns_dbtype_zone,
- rdclass, 0, NULL, dbp);
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name,
+ dns_dbtype_zone, rdclass, 0, NULL, dbp);
check_result(result, "dns_db_create()");
result = dns_db_load(*dbp, filename, dns_masterformat_text,
* eliminates any tab characters.
*/
result = dns_master_stylecreate(&style, styleflags, 0, 0, 0, 0, 0,
- 1000000, 0, mctx);
+ 1000000, 0, isc_g_mctx);
check_result(result, "dns_master_stylecreate2 failed");
- isc_buffer_allocate(mctx, &buf, MAX_CDS_RDATA_TEXT_SIZE);
+ isc_buffer_allocate(isc_g_mctx, &buf, MAX_CDS_RDATA_TEXT_SIZE);
result = dns_master_rdatasettotext(name, rdataset, style, NULL, buf);
- dns_master_styledestroy(&style, mctx);
+ dns_master_styledestroy(&style, isc_g_mctx);
if ((result == ISC_R_SUCCESS) && isc_buffer_availablelength(buf) < 1) {
result = ISC_R_NOSPACE;
nkey = dns_rdataset_count(keyset);
- keytable = isc_mem_cget(mctx, nkey, sizeof(keytable[0]));
+ keytable = isc_mem_cget(isc_g_mctx, nkey, sizeof(keytable[0]));
ki = keytable;
DNS_RDATASET_FOREACH (keyset) {
continue;
}
- result = dns_dnssec_keyfromrdata(name, keyrdata, mctx,
+ result = dns_dnssec_keyfromrdata(name, keyrdata, isc_g_mctx,
&ki->dst);
if (result != ISC_R_SUCCESS) {
vbprintf(3,
}
}
- isc_mem_cput(mctx, keytable, nkey, sizeof(keytable[0]));
+ isc_mem_cput(isc_g_mctx, keytable, nkey, sizeof(keytable[0]));
}
/*
REQUIRE(keytbl != NULL);
- algo = isc_mem_cget(mctx, nkey, sizeof(algo[0]));
+ algo = isc_mem_cget(isc_g_mctx, nkey, sizeof(algo[0]));
DNS_RDATASET_FOREACH (sigset) {
dns_rdata_t sigrdata = DNS_RDATA_INIT;
}
result = dns_dnssec_verify(name, rdataset, ki->dst,
- false, mctx, &sigrdata,
+ false, isc_g_mctx, &sigrdata,
NULL);
if (result != ISC_R_SUCCESS &&
ok = true;
}
}
- isc_mem_cput(mctx, algo, nkey, sizeof(algo[0]));
+ isc_mem_cput(isc_g_mctx, algo, nkey, sizeof(algo[0]));
return ok;
}
}
}
- isc_mem_cput(mctx, algo, nkey, sizeof(algo[0]));
+ isc_mem_cput(isc_g_mctx, algo, nkey, sizeof(algo[0]));
return all_ok;
}
dns_rdataset_current(crdset, &crdata);
- ds = isc_mem_get(mctx, sizeof(*ds));
+ ds = isc_mem_get(isc_g_mctx, sizeof(*ds));
dns_rdata_init(ds);
result = ds_from_rdata(buf, ds, dt, &crdata);
ISC_LIST_APPEND(dslist->rdata, ds, link);
break;
case ISC_R_IGNORE:
- isc_mem_put(mctx, ds, sizeof(*ds));
+ isc_mem_put(isc_g_mctx, ds, sizeof(*ds));
continue;
case ISC_R_NOSPACE:
- isc_mem_put(mctx, ds, sizeof(*ds));
+ isc_mem_put(isc_g_mctx, ds, sizeof(*ds));
return result;
default:
- isc_mem_put(mctx, ds, sizeof(*ds));
+ isc_mem_put(isc_g_mctx, ds, sizeof(*ds));
check_result(result, "ds_from_rdata()");
}
}
dns_rdatalist_t *dslist = NULL;
size_t n;
- dslist = isc_mem_get(mctx, sizeof(*dslist));
+ dslist = isc_mem_get(isc_g_mctx, sizeof(*dslist));
dns_rdatalist_init(dslist);
dslist->rdclass = rdclass;
dslist->type = dns_rdatatype_ds;
dns_rdataset_init(&new_ds_set);
dns_rdatalist_tordataset(dslist, &new_ds_set);
- isc_buffer_allocate(mctx, &new_ds_buf, size);
+ isc_buffer_allocate(isc_g_mctx, &new_ds_buf, size);
n = sizeof(dtype) / sizeof(dtype[0]);
for (size_t i = 0; i < n && dtype[i] != 0; i++) {
n = dns_rdataset_count(dsset);
- arrdata = isc_mem_cget(mctx, n, sizeof(dns_rdata_t));
+ arrdata = isc_mem_cget(isc_g_mctx, n, sizeof(dns_rdata_t));
DNS_RDATASET_FOREACH (dsset) {
dns_rdata_init(&arrdata[i]);
/*
* Convert sorted arrdata to more accessible format
*/
- ds = isc_mem_cget(mctx, n, sizeof(dns_rdata_ds_t));
+ ds = isc_mem_cget(isc_g_mctx, n, sizeof(dns_rdata_ds_t));
for (i = 0; i < n; i++) {
result = dns_rdata_tostruct(&arrdata[i], &ds[i], NULL);
/*
* Done!
*/
- isc_mem_cput(mctx, ds, n, sizeof(dns_rdata_ds_t));
- isc_mem_cput(mctx, arrdata, n, sizeof(dns_rdata_t));
+ isc_mem_cput(isc_g_mctx, ds, n, sizeof(dns_rdata_ds_t));
+ isc_mem_cput(isc_g_mctx, arrdata, n, sizeof(dns_rdata_t));
return match;
}
dns_rdataset_t diffset;
uint32_t save;
- result = dns_db_create(mctx, ZONEDB_DEFAULT, name, dns_dbtype_zone,
- rdclass, 0, NULL, &update_db);
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name,
+ dns_dbtype_zone, rdclass, 0, NULL, &update_db);
check_result(result, "dns_db_create()");
result = dns_db_newversion(update_db, &update_version);
free_keytable(&new_key_tbl);
}
free_all_sets();
- if (mctx != NULL) {
+ if (isc_g_mctx != NULL) {
if (print_mem_stats && verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
}
}
isc_commandline_init(argc, argv);
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
isc_commandline_errprint = false;
static dns_rdataclass_t rdclass;
static dns_fixedname_t fixed;
static dns_name_t *name = NULL;
-static isc_mem_t *mctx = NULL;
static uint32_t ttl;
static bool emitttl = false;
static unsigned int split_width = 0;
}
result = dns_master_loadstream(fp, name, name, rdclass, 0, &callbacks,
- mctx);
+ isc_g_mctx);
if (result != ISC_R_SUCCESS) {
fatal("can't load from input: %s", isc_result_totext(result));
}
dns_name_format(name, setname, sizeof(setname));
- result = dns_db_create(mctx, ZONEDB_DEFAULT, name, dns_dbtype_zone,
- rdclass, 0, NULL, &db);
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name,
+ dns_dbtype_zone, rdclass, 0, NULL, &db);
if (result != ISC_R_SUCCESS) {
fatal("can't create database");
}
isc_buffer_init(&keyb, key_buf, key_buf_size);
- result = dst_key_fromnamedfile(filename, NULL, DST_TYPE_PUBLIC, mctx,
- &key);
+ result = dst_key_fromnamedfile(filename, NULL, DST_TYPE_PUBLIC,
+ isc_g_mctx, &key);
if (result != ISC_R_SUCCESS) {
fatal("can't load %s.key: %s", filename,
isc_result_totext(result));
isc_buffer_init(&buf, rdata->data, rdata->length);
isc_buffer_add(&buf, rdata->length);
- result = dst_key_fromdns(name, rdclass, &buf, mctx, &key);
+ result = dst_key_fromdns(name, rdclass, &buf, isc_g_mctx, &key);
if (result != ISC_R_SUCCESS) {
return;
}
isc_commandline_init(argc, argv);
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
isc_commandline_errprint = false;
dns_rdataset_disassociate(&rdataset);
}
if (verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
fflush(stdout);
if (ferror(stdout)) {
static dns_rdataclass_t rdclass;
static dns_fixedname_t fixed;
static dns_name_t *name = NULL;
-static isc_mem_t *mctx = NULL;
static bool setpub = false, setdel = false;
static bool setttl = false;
static isc_stdtime_t pub = 0, del = 0;
}
result = dns_master_loadstream(fp, name, name, rdclass, 0, &callbacks,
- mctx);
+ isc_g_mctx);
if (result != ISC_R_SUCCESS) {
fatal("can't load from input: %s", isc_result_totext(result));
}
dns_name_format(name, setname, sizeof(setname));
- result = dns_db_create(mctx, ZONEDB_DEFAULT, name, dns_dbtype_zone,
- rdclass, 0, NULL, &db);
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name,
+ dns_dbtype_zone, rdclass, 0, NULL, &db);
if (result != ISC_R_SUCCESS) {
fatal("can't create database");
}
isc_buffer_init(&keyb, key_buf, key_buf_size);
- result = dst_key_fromnamedfile(filename, NULL, DST_TYPE_PUBLIC, mctx,
- &key);
+ result = dst_key_fromnamedfile(filename, NULL, DST_TYPE_PUBLIC,
+ isc_g_mctx, &key);
if (result != ISC_R_SUCCESS) {
fatal("invalid keyfile name %s: %s", filename,
isc_result_totext(result));
isc_buffer_init(&buf, rdata->data, rdata->length);
isc_buffer_add(&buf, rdata->length);
- result = dst_key_fromdns(name, rdclass, &buf, mctx, &key);
+ result = dst_key_fromdns(name, rdclass, &buf, isc_g_mctx, &key);
if (result != ISC_R_SUCCESS) {
fatal("dst_key_fromdns: %s", isc_result_totext(result));
}
result = dst_key_fromfile(
dst_key_name(key), dst_key_id(key), dst_key_alg(key),
- DST_TYPE_PUBLIC | DST_TYPE_PRIVATE, dir, mctx, &tmp);
+ DST_TYPE_PUBLIC | DST_TYPE_PRIVATE, dir, isc_g_mctx, &tmp);
if (result == ISC_R_SUCCESS) {
if (dst_key_isprivate(tmp) && !dst_key_isexternal(tmp)) {
fatal("Private key already exists in %s", priname);
isc_commandline_init(argc, argv);
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
isc_commandline_errprint = false;
dns_rdataset_disassociate(&rdataset);
}
if (verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
fflush(stdout);
if (ferror(stdout)) {
uint16_t flags = 0, kskflag = 0, revflag = 0;
dst_algorithm_t alg;
bool oldstyle = false;
- isc_mem_t *mctx = NULL;
int ch;
isc_result_t ret;
isc_textregion_t r;
isc_commandline_init(argc, argv);
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
isc_commandline_errprint = false;
setttl = true;
break;
case 'l':
- label = isc_mem_strdup(mctx, isc_commandline_argument);
+ label = isc_mem_strdup(isc_g_mctx,
+ isc_commandline_argument);
break;
case 'M': {
unsigned long ul;
int len;
len = strlen(label) + 8;
- l = isc_mem_allocate(mctx, len);
+ l = isc_mem_allocate(isc_g_mctx, len);
snprintf(l, len, "pkcs11:%s", label);
- isc_mem_free(mctx, label);
+ isc_mem_free(isc_g_mctx, label);
label = l;
}
ret = dst_key_fromnamedfile(predecessor, directory,
DST_TYPE_PUBLIC | DST_TYPE_PRIVATE,
- mctx, &prevkey);
+ isc_g_mctx, &prevkey);
if (ret != ISC_R_SUCCESS) {
fatal("Invalid keyfile %s: %s", predecessor,
isc_result_totext(ret));
/* associate the key */
ret = dst_key_fromlabel(name, alg, flags, DNS_KEYPROTO_DNSSEC, rdclass,
- label, NULL, mctx, &key);
+ label, NULL, isc_g_mctx, &key);
if (ret != ISC_R_SUCCESS) {
char namestr[DNS_NAME_FORMATSIZE];
* is a risk of ID collision due to this key or another key
* being revoked.
*/
- if (key_collision(key, name, directory, mctx, tag_min, tag_max, &exact))
+ if (key_collision(key, name, directory, isc_g_mctx, tag_min, tag_max,
+ &exact))
{
isc_buffer_clear(&buf);
ret = dst_key_buildfilename(key, 0, directory, &buf);
}
if (verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_mem_free(mctx, label);
- isc_mem_detach(&mctx);
+ isc_mem_free(isc_g_mctx, label);
+ isc_mem_detach(&isc_g_mctx);
if (freeit != NULL) {
free(freeit);
}
static void
-keygen(keygen_ctx_t *ctx, isc_mem_t *mctx, int argc, char **argv) {
+keygen(keygen_ctx_t *ctx, int argc, char **argv) {
char filename[255];
char algstr[DNS_SECALG_FORMATSIZE];
uint16_t flags = 0;
ret = dst_key_fromnamedfile(ctx->predecessor, ctx->directory,
DST_TYPE_PUBLIC | DST_TYPE_PRIVATE |
DST_TYPE_STATE,
- mctx, &prevkey);
+ isc_g_mctx, &prevkey);
if (ret != ISC_R_SUCCESS) {
fatal("Invalid keyfile %s: %s", ctx->predecessor,
isc_result_totext(ret));
if (ctx->keystore != NULL && ctx->policy != NULL) {
ret = dns_keystore_keygen(
ctx->keystore, name, ctx->policy, ctx->rdclass,
- mctx, ctx->alg, ctx->size, flags, &key);
+ isc_g_mctx, ctx->alg, ctx->size, flags, &key);
} else if (!ctx->quiet && show_progress) {
ret = dst_key_generate(name, ctx->alg, ctx->size, 0,
flags, DNS_KEYPROTO_DNSSEC,
- ctx->rdclass, NULL, mctx, &key,
- &progress);
+ ctx->rdclass, NULL, isc_g_mctx,
+ &key, &progress);
} else {
ret = dst_key_generate(name, ctx->alg, ctx->size, 0,
flags, DNS_KEYPROTO_DNSSEC,
- ctx->rdclass, NULL, mctx, &key,
- NULL);
+ ctx->rdclass, NULL, isc_g_mctx,
+ &key, NULL);
}
if (!ctx->quiet && show_progress) {
* if there is a risk of ID collision due to this key
* or another key being revoked.
*/
- if (key_collision(key, name, ctx->directory, mctx, ctx->tag_min,
- ctx->tag_max, NULL))
+ if (key_collision(key, name, ctx->directory, isc_g_mctx,
+ ctx->tag_min, ctx->tag_max, NULL))
{
conflict = true;
if (null_key) {
char *algname = NULL, *freeit = NULL;
char *classname = NULL;
char *endp;
- isc_mem_t *mctx = NULL;
isc_result_t ret;
isc_textregion_t r;
unsigned char c;
}
isc_commandline_reset = true;
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) {
ctx.tag_min = 0;
ctx.tag_max = 0xffff;
- keygen(&ctx, mctx, argc, argv);
+ keygen(&ctx, argc, argv);
} else {
cfg_parser_t *parser = NULL;
cfg_obj_t *config = NULL;
dns_kasp_t *kasp = NULL;
- RUNTIME_CHECK(cfg_parser_create(mctx, &parser) ==
+ RUNTIME_CHECK(cfg_parser_create(isc_g_mctx, &parser) ==
ISC_R_SUCCESS);
if (cfg_parse_file(parser, ctx.configfile,
&cfg_type_namedconf,
ctx.policy, ctx.configfile);
}
- kasp_from_conf(config, mctx, ctx.policy, ctx.directory,
- &kasp);
+ kasp_from_conf(config, isc_g_mctx, ctx.policy,
+ ctx.directory, &kasp);
if (kasp == NULL) {
fatal("failed to load dnssec-policy '%s'",
ctx.policy);
{
continue;
}
- keygen(&ctx, mctx, argc, argv);
+ keygen(&ctx, argc, argv);
}
dns_kasp_detach(&kasp);
cfg_parser_destroy(&parser);
}
} else {
- keygen(&ctx, mctx, argc, argv);
+ keygen(&ctx, argc, argv);
}
if (verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
if (freeit != NULL) {
free(freeit);
#include "dnssectool.h"
-/*
- * Infrastructure
- */
-static isc_mem_t *mctx = NULL;
/*
* The domain we are working on
*/
cfg_parser_t *parser = NULL;
cfg_obj_t *config = NULL;
- RUNTIME_CHECK(cfg_parser_create(mctx, &parser) == ISC_R_SUCCESS);
+ RUNTIME_CHECK(cfg_parser_create(isc_g_mctx, &parser) == ISC_R_SUCCESS);
if (cfg_parse_file(parser, ksr->configfile, &cfg_type_namedconf,
&config) != ISC_R_SUCCESS)
{
fatal("unable to load dnssec-policy '%s' from '%s'",
ksr->policy, ksr->configfile);
}
- kasp_from_conf(config, mctx, ksr->policy, ksr->keydir, kasp);
+ kasp_from_conf(config, isc_g_mctx, ksr->policy, ksr->keydir, kasp);
if (*kasp == NULL) {
fatal("failed to load dnssec-policy '%s'", ksr->policy);
}
ISC_LIST_INIT(*keys);
ISC_LIST_INIT(keys_read);
ret = dns_dnssec_findmatchingkeys(name, NULL, ksr->keydir, NULL,
- ksr->now, mctx, &keys_read);
+ ksr->now, isc_g_mctx, &keys_read);
if (ret != ISC_R_SUCCESS && ret != ISC_R_NOTFOUND) {
fatal("failed to load existing keys from %s: %s", ksr->keydir,
isc_result_totext(ret));
ISC_LIST_FOREACH (keys_read, dk, link) {
n++;
}
- keys_sorted = isc_mem_cget(mctx, n, sizeof(dns_dnsseckey_t *));
+ keys_sorted = isc_mem_cget(isc_g_mctx, n, sizeof(dns_dnsseckey_t *));
ISC_LIST_FOREACH (keys_read, dk, link) {
keys_sorted[i++] = dk;
}
ISC_LIST_APPEND(*keys, keys_sorted[i], link);
}
INSIST(ISC_LIST_EMPTY(keys_read));
- isc_mem_cput(mctx, keys_sorted, n, sizeof(dns_dnsseckey_t *));
+ isc_mem_cput(isc_g_mctx, keys_sorted, n, sizeof(dns_dnsseckey_t *));
}
static void
ISC_LIST_FOREACH (*keys, key, link) {
ISC_LIST_UNLINK(*keys, key, link);
dst_key_free(&key->key);
- dns_dnsseckey_destroy(mctx, &key);
+ dns_dnsseckey_destroy(isc_g_mctx, &key);
}
dns_kasp_detach(&kasp);
ISC_LIST_FOREACH (rdlist->rdata, rdata, link) {
ISC_LIST_UNLINK(rdlist->rdata, rdata, link);
- isc_mem_put(mctx, rdata, sizeof(*rdata));
+ isc_mem_put(isc_g_mctx, rdata, sizeof(*rdata));
}
- isc_mem_put(mctx, rdlist, sizeof(*rdlist));
+ isc_mem_put(isc_g_mctx, rdlist, sizeof(*rdlist));
dns_rdataset_disassociate(rdataset);
}
if (ksr->keystore != NULL && ksr->policy != NULL) {
ret = dns_keystore_keygen(
ksr->keystore, name, ksr->policy,
- dns_rdataclass_in, mctx, ksr->alg, ksr->size,
- flags, &key);
+ dns_rdataclass_in, isc_g_mctx, ksr->alg,
+ ksr->size, flags, &key);
} else if (show_progress) {
ret = dst_key_generate(name, ksr->alg, ksr->size, 0,
flags, DNS_KEYPROTO_DNSSEC,
- dns_rdataclass_in, NULL, mctx,
- &key, &progress);
+ dns_rdataclass_in, NULL,
+ isc_g_mctx, &key, &progress);
fflush(stderr);
} else {
ret = dst_key_generate(name, ksr->alg, ksr->size, 0,
flags, DNS_KEYPROTO_DNSSEC,
- dns_rdataclass_in, NULL, mctx,
- &key, NULL);
+ dns_rdataclass_in, NULL,
+ isc_g_mctx, &key, NULL);
}
if (ret != ISC_R_SUCCESS) {
}
/* Do not overwrite an existing key. */
- if (key_collision(key, name, ksr->keydir, mctx,
+ if (key_collision(key, name, ksr->keydir, isc_g_mctx,
dns_kasp_key_tagmin(kaspkey),
dns_kasp_key_tagmax(kaspkey), NULL))
{
sizeof(algstr));
/* Fetch matching key pair. */
- rdatalist = isc_mem_get(mctx, sizeof(*rdatalist));
+ rdatalist = isc_mem_get(isc_g_mctx, sizeof(*rdatalist));
dns_rdatalist_init(rdatalist);
rdatalist->rdclass = dns_rdataclass_in;
rdatalist->type = dns_rdatatype_dnskey;
isc_region_t r;
unsigned char rdatabuf[DST_KEY_MAXSIZE];
- rdata = isc_mem_get(mctx, sizeof(*rdata));
+ rdata = isc_mem_get(isc_g_mctx, sizeof(*rdata));
dns_rdata_init(rdata);
isc_buffer_init(&buf, rdatabuf, sizeof(rdatabuf));
CHECK(dst_key_todns(dk->key, &buf));
isc_buffer_usedregion(&buf, &r);
- isc_buffer_allocate(mctx, &newbuf, r.length);
+ isc_buffer_allocate(isc_g_mctx, &newbuf, r.length);
isc_buffer_putmem(newbuf, r.base, r.length);
isc_buffer_usedregion(newbuf, &r);
dns_rdata_fromregion(rdata, dns_rdataclass_in,
print_rdata(rrset);
/* Signatures */
- rrsiglist = isc_mem_get(mctx, sizeof(*rrsiglist));
+ rrsiglist = isc_mem_get(isc_g_mctx, sizeof(*rrsiglist));
dns_rdatalist_init(rrsiglist);
rrsiglist->rdclass = dns_rdataclass_in;
rrsiglist->type = dns_rdatatype_rrsig;
continue;
}
- rrsig = isc_mem_get(mctx, sizeof(*rrsig));
+ rrsig = isc_mem_get(isc_g_mctx, sizeof(*rrsig));
dns_rdata_init(rrsig);
isc_buffer_init(&buf, rdatabuf, sizeof(rdatabuf));
ret = dns_dnssec_sign(name, rrset, dk->key, &clockskew,
- &expiration, mctx, &buf, &rdata);
+ &expiration, isc_g_mctx, &buf, &rdata);
if (ret != ISC_R_SUCCESS) {
fatal("failed to sign KSR");
}
isc_buffer_usedregion(&buf, &rs);
- isc_buffer_allocate(mctx, &newbuf, rs.length);
+ isc_buffer_allocate(isc_g_mctx, &newbuf, rs.length);
isc_buffer_putmem(newbuf, rs.base, rs.length);
isc_buffer_usedregion(newbuf, &rs);
dns_rdata_fromregion(rrsig, dns_rdataclass_in,
dns_rdataset_t *dnskeyset, dns_rdataset_t *cdnskeyset,
dns_rdataset_t *cdsset) {
dns_kasp_digestlist_t digests = dns_kasp_digests(kasp);
- dns_rdatalist_t *dnskeylist = isc_mem_get(mctx, sizeof(*dnskeylist));
- dns_rdatalist_t *cdnskeylist = isc_mem_get(mctx, sizeof(*cdnskeylist));
- dns_rdatalist_t *cdslist = isc_mem_get(mctx, sizeof(*cdslist));
+ dns_rdatalist_t *dnskeylist = isc_mem_get(isc_g_mctx,
+ sizeof(*dnskeylist));
+ dns_rdatalist_t *cdnskeylist = isc_mem_get(isc_g_mctx,
+ sizeof(*cdnskeylist));
+ dns_rdatalist_t *cdslist = isc_mem_get(isc_g_mctx, sizeof(*cdslist));
isc_result_t ret = ISC_R_SUCCESS;
isc_stdtime_t next_bundle = next_inception;
if (published) {
newbuf = NULL;
- rdata = isc_mem_get(mctx, sizeof(*rdata));
+ rdata = isc_mem_get(isc_g_mctx, sizeof(*rdata));
dns_rdata_init(rdata);
isc_buffer_init(&buf, kskbuf, sizeof(kskbuf));
CHECK(dst_key_todns(dk->key, &buf));
isc_buffer_usedregion(&buf, &r);
- isc_buffer_allocate(mctx, &newbuf, r.length);
+ isc_buffer_allocate(isc_g_mctx, &newbuf, r.length);
isc_buffer_putmem(newbuf, r.base, r.length);
isc_buffer_usedregion(newbuf, &r);
dns_rdata_fromregion(rdata, dns_rdataclass_in,
/* CDNSKEY */
newbuf = NULL;
- rdata = isc_mem_get(mctx, sizeof(*rdata));
+ rdata = isc_mem_get(isc_g_mctx, sizeof(*rdata));
dns_rdata_init(rdata);
isc_buffer_init(&buf, cdnskeybuf, sizeof(cdnskeybuf));
CHECK(dst_key_todns(dk->key, &buf));
isc_buffer_usedregion(&buf, &r);
- isc_buffer_allocate(mctx, &newbuf, r.length);
+ isc_buffer_allocate(isc_g_mctx, &newbuf, r.length);
isc_buffer_putmem(newbuf, r.base, r.length);
isc_buffer_usedregion(newbuf, &r);
dns_rdata_fromregion(rdata, dns_rdataclass_in,
dns_rdata_t *rdata2 = NULL;
dns_rdata_t cds = DNS_RDATA_INIT;
- rdata2 = isc_mem_get(mctx, sizeof(*rdata2));
+ rdata2 = isc_mem_get(isc_g_mctx, sizeof(*rdata2));
dns_rdata_init(rdata2);
CHECK(dns_ds_buildrdata(name, rdata, alg->digest,
cdsbuf, sizeof(cdsbuf), &cds));
cds.type = dns_rdatatype_cds;
dns_rdata_toregion(&cds, &rcds);
- isc_buffer_allocate(mctx, &newbuf2, rcds.length);
+ isc_buffer_allocate(isc_g_mctx, &newbuf2, rcds.length);
isc_buffer_putmem(newbuf2, rcds.base, rcds.length);
isc_buffer_usedregion(newbuf2, &rcds);
dns_rdata_fromregion(rdata2, dns_rdataclass_in,
}
if (!dns_kasp_cdnskey(kasp)) {
- isc_mem_put(mctx, rdata, sizeof(*rdata));
+ isc_mem_put(isc_g_mctx, rdata, sizeof(*rdata));
}
}
/* All good */
/* DNSKEY RRset */
dns_rdatalist_t *dnskeylist;
- dnskeylist = isc_mem_get(mctx, sizeof(*dnskeylist));
+ dnskeylist = isc_mem_get(isc_g_mctx, sizeof(*dnskeylist));
dns_rdatalist_init(dnskeylist);
dnskeylist->rdclass = dns_rdataclass_in;
dnskeylist->type = dns_rdatatype_dnskey;
for (isc_result_t r = dns_rdatalist_first(&ksk);
r == ISC_R_SUCCESS; r = dns_rdatalist_next(&ksk))
{
- dns_rdata_t *clone = isc_mem_get(mctx, sizeof(*clone));
+ dns_rdata_t *clone = isc_mem_get(isc_g_mctx,
+ sizeof(*clone));
dns_rdata_init(clone);
dns_rdatalist_current(&ksk, clone);
ISC_LIST_APPEND(dnskeylist->rdata, clone, link);
for (isc_result_t r = dns_rdatalist_first(&zsk);
r == ISC_R_SUCCESS; r = dns_rdatalist_next(&zsk))
{
- dns_rdata_t *clone = isc_mem_get(mctx, sizeof(*clone));
+ dns_rdata_t *clone = isc_mem_get(isc_g_mctx,
+ sizeof(*clone));
dns_rdata_init(clone);
dns_rdatalist_current(&zsk, clone);
ISC_LIST_APPEND(dnskeylist->rdata, clone, link);
}
ret = dns_rdata_fromtext(NULL, rdclass, dns_rdatatype_dnskey, lex, name,
- 0, mctx, buf, NULL);
+ 0, isc_g_mctx, buf, NULL);
cleanup:
isc_lex_setcomments(lex, 0);
setcontext(ksr, kasp);
/* Sign request */
inception = ksr->start;
- isc_lex_create(mctx, KSR_LINESIZE, &lex);
+ isc_lex_create(isc_g_mctx, KSR_LINESIZE, &lex);
memset(specials, 0, sizeof(specials));
specials['('] = 1;
specials[')'] = 1;
}
/* Start next bundle */
- rdatalist = isc_mem_get(mctx, sizeof(*rdatalist));
+ rdatalist = isc_mem_get(isc_g_mctx, sizeof(*rdatalist));
dns_rdatalist_init(rdatalist);
rdatalist->rdclass = dns_rdataclass_in;
rdatalist->type = dns_rdatatype_dnskey;
INSIST(rdatalist != NULL);
- rdata = isc_mem_get(mctx, sizeof(*rdata));
+ rdata = isc_mem_get(isc_g_mctx, sizeof(*rdata));
dns_rdata_init(rdata);
isc_buffer_init(&buf, rdatabuf, sizeof(rdatabuf));
ret = parse_dnskey(lex, STR(token), &buf, &ttl);
isc_result_totext(ret));
}
isc_buffer_usedregion(&buf, &r);
- isc_buffer_allocate(mctx, &newbuf, r.length);
+ isc_buffer_allocate(isc_g_mctx, &newbuf, r.length);
isc_buffer_putmem(newbuf, r.base, r.length);
isc_buffer_usedregion(newbuf, &r);
dns_rdata_fromregion(rdata, dns_rdataclass_in,
isc_commandline_init(argc, argv);
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
isc_commandline_errprint = false;
#include "dnssectool.h"
-static isc_mem_t *mctx = NULL;
-
ISC_NORETURN static void
usage(void);
usage();
}
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
isc_commandline_errprint = false;
* We don't have to copy it here, but do it to
* simplify cleanup later
*/
- dir = isc_mem_strdup(mctx, isc_commandline_argument);
+ dir = isc_mem_strdup(isc_g_mctx,
+ isc_commandline_argument);
break;
case 'r':
removefile = true;
if (dir != NULL) {
filename = argv[isc_commandline_index];
} else {
- result = isc_file_splitpath(mctx, argv[isc_commandline_index],
- &dir, &filename);
+ result = isc_file_splitpath(isc_g_mctx,
+ argv[isc_commandline_index], &dir,
+ &filename);
if (result != ISC_R_SUCCESS) {
fatal("cannot process filename %s: %s",
argv[isc_commandline_index],
isc_result_totext(result));
}
if (strcmp(dir, ".") == 0) {
- isc_mem_free(mctx, dir);
+ isc_mem_free(isc_g_mctx, dir);
}
}
- result = dst_key_fromnamedfile(
- filename, dir, DST_TYPE_PUBLIC | DST_TYPE_PRIVATE, mctx, &key);
+ result = dst_key_fromnamedfile(filename, dir,
+ DST_TYPE_PUBLIC | DST_TYPE_PRIVATE,
+ isc_g_mctx, &key);
if (result != ISC_R_SUCCESS) {
fatal("Invalid keyfile name %s: %s", filename,
isc_result_totext(result));
cleanup:
dst_key_free(&key);
if (verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
if (dir != NULL) {
- isc_mem_free(mctx, dir);
+ isc_mem_free(isc_g_mctx, dir);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return 0;
}
#include "dnssectool.h"
-static isc_mem_t *mctx = NULL;
-
ISC_NORETURN static void
usage(void);
usage();
}
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
setup_logging();
* We don't have to copy it here, but do it to
* simplify cleanup later
*/
- directory = isc_mem_strdup(mctx,
+ directory = isc_mem_strdup(isc_g_mctx,
isc_commandline_argument);
break;
case 'k':
}
result = dst_key_fromnamedfile(predecessor, directory, options,
- mctx, &prevkey);
+ isc_g_mctx, &prevkey);
if (result != ISC_R_SUCCESS) {
fatal("Invalid keyfile %s: %s", filename,
isc_result_totext(result));
if (directory != NULL) {
filename = argv[isc_commandline_index];
} else {
- result = isc_file_splitpath(mctx, argv[isc_commandline_index],
+ result = isc_file_splitpath(isc_g_mctx,
+ argv[isc_commandline_index],
&directory, &filename);
if (result != ISC_R_SUCCESS) {
fatal("cannot process filename %s: %s",
}
}
- result = dst_key_fromnamedfile(filename, directory, options, mctx,
+ result = dst_key_fromnamedfile(filename, directory, options, isc_g_mctx,
&key);
if (result != ISC_R_SUCCESS) {
fatal("Invalid keyfile %s: %s", filename,
}
dst_key_free(&key);
if (verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_mem_free(mctx, directory);
- isc_mem_detach(&mctx);
+ isc_mem_free(isc_g_mctx, directory);
+ isc_mem_detach(&isc_g_mctx);
return 0;
}
static int jitter = 0;
static bool tryverify = false;
static bool printstats = false;
-static isc_mem_t *mctx = NULL;
static dns_ttl_t zone_soa_min_ttl;
static dns_ttl_t soa_ttl;
static FILE *outfp = NULL;
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0, &iter);
check_result(result, "dns_db_allrdatasets");
- isc_buffer_allocate(mctx, &buffer, bufsize);
+ isc_buffer_allocate(isc_g_mctx, &buffer, bufsize);
DNS_RDATASETITER_FOREACH (iter) {
dns_rdataset_t rds = DNS_RDATASET_INIT;
bufsize <<= 1;
isc_buffer_free(&buffer);
- isc_buffer_allocate(mctx, &buffer, bufsize);
+ isc_buffer_allocate(isc_g_mctx, &buffer, bufsize);
}
check_result(result, "dns_master_rdatasettotext");
jendtime = (jitter != 0) ? expiry - isc_random_uniform(jitter) : expiry;
isc_buffer_init(&b, array, sizeof(array));
result = dns_dnssec_sign(name, rdataset, key, &starttime, &jendtime,
- mctx, &b, &trdata);
+ isc_g_mctx, &b, &trdata);
if (result != ISC_R_SUCCESS) {
fatal("dnskey '%s' failed to sign data: %s", keystr,
isc_result_totext(result));
INCSTAT(nsigned);
if (tryverify) {
- result = dns_dnssec_verify(name, rdataset, key, true, mctx,
- &trdata, NULL);
+ result = dns_dnssec_verify(name, rdataset, key, true,
+ isc_g_mctx, &trdata, NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_FROMWILDCARD) {
vbprintf(3, "\tsignature verified\n");
INCSTAT(nverified);
}
tuple = NULL;
- dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN, name, ttl, &trdata,
- &tuple);
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_ADDRESIGN, name, ttl,
+ &trdata, &tuple);
dns_diff_append(add, &tuple);
}
result = dst_key_fromfile(&rrsig->signer, rrsig->keyid,
rrsig->algorithm, DST_TYPE_PUBLIC, directory,
- mctx, &pubkey);
+ isc_g_mctx, &pubkey);
if (result != ISC_R_SUCCESS) {
isc_rwlock_unlock(&keylist_lock, isc_rwlocktype_write);
return NULL;
}
- result = dst_key_fromfile(
- &rrsig->signer, rrsig->keyid, rrsig->algorithm,
- DST_TYPE_PUBLIC | DST_TYPE_PRIVATE, directory, mctx, &privkey);
+ result = dst_key_fromfile(&rrsig->signer, rrsig->keyid,
+ rrsig->algorithm,
+ DST_TYPE_PUBLIC | DST_TYPE_PRIVATE, directory,
+ isc_g_mctx, &privkey);
if (result == ISC_R_SUCCESS) {
dst_key_free(&pubkey);
- dns_dnsseckey_create(mctx, &privkey, &key);
+ dns_dnsseckey_create(isc_g_mctx, &privkey, &key);
} else {
- dns_dnsseckey_create(mctx, &pubkey, &key);
+ dns_dnsseckey_create(isc_g_mctx, &pubkey, &key);
key->pubkey = true;
}
setverifies(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
dns_rdata_t *rrsig) {
isc_result_t result;
- result = dns_dnssec_verify(name, set, key, false, mctx, rrsig, NULL);
+ result = dns_dnssec_verify(name, set, key, false, isc_g_mctx, rrsig,
+ NULL);
if (result == ISC_R_SUCCESS || result == DNS_R_FROMWILDCARD) {
INCSTAT(nverified);
return true;
if (!nosigs) {
arraysize += dns_rdataset_count(&sigset);
}
- wassignedby = isc_mem_cget(mctx, arraysize, sizeof(bool));
- nowsignedby = isc_mem_cget(mctx, arraysize, sizeof(bool));
+ wassignedby = isc_mem_cget(isc_g_mctx, arraysize, sizeof(bool));
+ nowsignedby = isc_mem_cget(isc_g_mctx, arraysize, sizeof(bool));
for (i = 0; i < arraysize; i++) {
wassignedby[i] = nowsignedby[i] = false;
sigstr);
tuple = NULL;
dns_difftuple_create(
- mctx, DNS_DIFFOP_DELRESIGN,
- name, sigset.ttl, &sigrdata,
- &tuple);
+ isc_g_mctx,
+ DNS_DIFFOP_DELRESIGN, name,
+ sigset.ttl, &sigrdata, &tuple);
dns_diff_append(del, &tuple);
dns_difftuple_create(
- mctx, DNS_DIFFOP_ADDRESIGN,
- name, ttl, &sigrdata, &tuple);
+ isc_g_mctx,
+ DNS_DIFFOP_ADDRESIGN, name, ttl,
+ &sigrdata, &tuple);
dns_diff_append(add, &tuple);
}
} else {
tuple = NULL;
vbprintf(2, "\tremoving signature by %s\n",
sigstr);
- dns_difftuple_create(mctx, DNS_DIFFOP_DELRESIGN,
- name, sigset.ttl,
- &sigrdata, &tuple);
+ dns_difftuple_create(
+ isc_g_mctx, DNS_DIFFOP_DELRESIGN, name,
+ sigset.ttl, &sigrdata, &tuple);
dns_diff_append(del, &tuple);
INCSTAT(ndropped);
}
}
}
- isc_mem_cput(mctx, wassignedby, arraysize, sizeof(bool));
- isc_mem_cput(mctx, nowsignedby, arraysize, sizeof(bool));
+ isc_mem_cput(isc_g_mctx, wassignedby, arraysize, sizeof(bool));
+ isc_mem_cput(isc_g_mctx, nowsignedby, arraysize, sizeof(bool));
}
struct hashlist {
}
isc_buffer_putuint8(&b, 0);
- result = dns_db_create(mctx, ZONEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, dns_rootname,
dns_dbtype_zone, rdclass, 0, NULL, dbp);
check_result(result, "dns_db_create()");
result = dns_db_newversion(db, &ver);
check_result(result, "dns_db_newversion");
- dns_diff_init(mctx, &diff);
+ dns_diff_init(isc_g_mctx, &diff);
DNS_RDATASET_FOREACH (&keyset) {
dns_rdata_t key = DNS_RDATA_INIT;
dsbuf, sizeof(dsbuf), &ds);
check_result(result, "dns_ds_buildrdata");
- dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN, name, ttl, &ds,
- &tuple);
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_ADDRESIGN, name,
+ ttl, &ds, &tuple);
dns_diff_append(&diff, &tuple);
}
/*
* Now iterate through the rdatasets.
*/
- dns_diff_init(mctx, &del);
- dns_diff_init(mctx, &add);
+ dns_diff_init(isc_g_mctx, &del);
+ dns_diff_init(isc_g_mctx, &add);
rdsiter = NULL;
result = dns_db_allrdatasets(gdb, node, gversion, 0, 0, &rdsiter);
check_result(result, "dns_db_allrdatasets()");
{
vbprintf(2, "removing duplicate at %s/%s\n",
namestr, typestr);
- dns_difftuple_create(mctx, DNS_DIFFOP_DELRESIGN,
- name, rdataset->ttl,
- &rdata2, &tuple);
+ dns_difftuple_create(
+ isc_g_mctx, DNS_DIFFOP_DELRESIGN, name,
+ rdataset->ttl, &rdata2, &tuple);
dns_diff_append(del, &tuple);
} else if (set_maxttl && rdataset->ttl > maxttl) {
vbprintf(2,
"from %d to %d\n",
namestr, typestr, rdataset->ttl,
maxttl);
- dns_difftuple_create(mctx, DNS_DIFFOP_DELRESIGN,
- name, rdataset->ttl,
- &rdata2, &tuple);
+ dns_difftuple_create(
+ isc_g_mctx, DNS_DIFFOP_DELRESIGN, name,
+ rdataset->ttl, &rdata2, &tuple);
dns_diff_append(del, &tuple);
tuple = NULL;
- dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN,
- name, maxttl, &rdata2,
- &tuple);
+ dns_difftuple_create(isc_g_mctx,
+ DNS_DIFFOP_ADDRESIGN, name,
+ maxttl, &rdata2, &tuple);
dns_diff_append(add, &tuple);
}
}
dns_fixedname_t fname;
dns_name_t *name = dns_fixedname_initname(&fname);
- dns_diff_init(mctx, &add);
- dns_diff_init(mctx, &del);
+ dns_diff_init(isc_g_mctx, &add);
+ dns_diff_init(isc_g_mctx, &del);
result = dns_db_createiterator(gdb, 0, &dbiter);
check_result(result, "dns_db_createiterator()");
isc_result_totext(result));
}
- result = dns_db_create(mctx, ZONEDB_DEFAULT, name, dns_dbtype_zone,
- rdclass, 0, NULL, db);
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name,
+ dns_dbtype_zone, rdclass, 0, NULL, db);
check_result(result, "dns_db_create()");
result = dns_db_load(*db, file, inputformat, 0);
/* Load keys corresponding to the existing DNSKEY RRset. */
result = dns_dnssec_keylistfromrdataset(
- gorigin, NULL, directory, mctx, &rdataset, &keysigs, &soasigs,
- preserve_keys, load_public, &keylist);
+ gorigin, NULL, directory, isc_g_mctx, &rdataset, &keysigs,
+ &soasigs, preserve_keys, load_public, &keylist);
if (result != ISC_R_SUCCESS) {
fatal("failed to load the zone keys: %s",
isc_result_totext(result));
dns_dnsseckey_t *key = NULL;
dst_key_t *newkey = NULL;
- result = dst_key_fromnamedfile(
- keyfiles[i], directory,
- DST_TYPE_PUBLIC | DST_TYPE_PRIVATE, mctx, &newkey);
+ result = dst_key_fromnamedfile(keyfiles[i], directory,
+ DST_TYPE_PUBLIC |
+ DST_TYPE_PRIVATE,
+ isc_g_mctx, &newkey);
if (result != ISC_R_SUCCESS) {
fatal("cannot load dnskey %s: %s", keyfiles[i],
isc_result_totext(result));
if (key == NULL) {
/* We haven't seen this key before */
- dns_dnsseckey_create(mctx, &newkey, &key);
+ dns_dnsseckey_create(isc_g_mctx, &newkey, &key);
ISC_LIST_APPEND(keylist, key, link);
key->source = dns_keysource_user;
} else {
clear_keylist(dns_dnsseckeylist_t *list) {
ISC_LIST_FOREACH (*list, key, link) {
ISC_LIST_UNLINK(*list, key, link);
- dns_dnsseckey_destroy(mctx, &key);
+ dns_dnsseckey_destroy(isc_g_mctx, &key);
}
}
}
}
- digest = isc_mem_get(mctx, sizeof(*digest));
+ digest = isc_mem_get(isc_g_mctx, sizeof(*digest));
digest->digest = alg;
ISC_LINK_INIT(digest, link);
ISC_LIST_APPEND(*digests, digest, link);
* Find keys that match this zone in the key repository.
*/
result = dns_dnssec_findmatchingkeys(gorigin, NULL, directory, NULL,
- now, mctx, &matchkeys);
+ now, isc_g_mctx, &matchkeys);
if (result == ISC_R_NOTFOUND) {
result = ISC_R_SUCCESS;
}
dns_rdataset_disassociate(&cdnskeyset);
}
- dns_diff_init(mctx, &diff);
+ dns_diff_init(isc_g_mctx, &diff);
/*
* Update keylist with information from from the key repository.
*/
dns_dnssec_updatekeys(&keylist, &matchkeys, NULL, gorigin, keyttl,
- &diff, mctx, report);
+ &diff, isc_g_mctx, report);
/*
* Update keylist with sync records.
*/
dns_dnssec_syncupdate(&keylist, &rmkeys, &cdsset, &cdnskeyset, now,
- &digests, cdnskey, keyttl, &diff, mctx);
+ &digests, cdnskey, keyttl, &diff, isc_g_mctx);
dns_name_format(gorigin, name, sizeof(name));
ISC_LIST_FOREACH (digests, d, link) {
ISC_LIST_UNLINK(digests, d, link);
- isc_mem_put(mctx, d, sizeof(*d));
+ isc_mem_put(isc_g_mctx, d, sizeof(*d));
}
INSIST(ISC_LIST_EMPTY(digests));
}
if (dsdir != NULL) {
filenamelen += strlen(dsdir) + 1;
}
- filename = isc_mem_get(mctx, filenamelen);
+ filename = isc_mem_get(isc_g_mctx, filenamelen);
if (dsdir != NULL) {
snprintf(filename, filenamelen, "%s/", dsdir);
} else {
strlcat(filename, prefix, filenamelen);
strlcat(filename, namestr, filenamelen);
- dns_diff_init(mctx, &diff);
+ dns_diff_init(isc_g_mctx, &diff);
name = gorigin;
DNS_DSDIGEST_SHA256, dsbuf,
sizeof(dsbuf), &ds);
check_result(result, "dns_ds_buildrdata");
- dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN, name,
- 0, &ds, &tuple);
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_ADDRESIGN,
+ name, 0, &ds, &tuple);
} else {
- dns_difftuple_create(mctx, DNS_DIFFOP_ADDRESIGN,
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_ADDRESIGN,
gorigin, zone_soa_min_ttl, &rdata,
&tuple);
}
dns_diff_append(&diff, &tuple);
}
- result = dns_db_create(mctx, ZONEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, dns_rootname,
dns_dbtype_zone, gclass, 0, NULL, &db);
check_result(result, "dns_db_create");
check_result(result, "dns_diff_apply");
dns_diff_clear(&diff);
- result = dns_master_dump(mctx, db, dbversion, style, filename,
+ result = dns_master_dump(isc_g_mctx, db, dbversion, style, filename,
dns_masterformat_text, NULL);
check_result(result, "dns_master_dump");
- isc_mem_put(mctx, filename, filenamelen);
+ isc_mem_put(isc_g_mctx, filename, filenamelen);
dns_db_closeversion(db, &dbversion, false);
dns_db_detach(&db);
directory = ".";
}
- isc_managers_create(&mctx, nloops);
+ isc_managers_create(nloops);
setup_logging();
size_t size;
free_output = true;
size = strlen(file) + strlen(".signed") + 1;
- output = isc_mem_allocate(mctx, size);
+ output = isc_mem_allocate(isc_g_mctx, size);
snprintf(output, size, "%s.signed", file);
}
}
result = dns_master_stylecreate(&dsstyle, DNS_STYLEFLAG_NO_TTL, 0, 24,
- 0, 0, 0, 8, 0xffffffff, mctx);
+ 0, 0, 0, 8, 0xffffffff, isc_g_mctx);
check_result(result, "dns_master_stylecreate");
gdb = NULL;
timer_start = isc_time_now();
loadzone(file, origin, rdclass, &gdb);
if (journal != NULL) {
- loadjournal(mctx, gdb, journal);
+ loadjournal(isc_g_mctx, gdb, journal);
}
gorigin = dns_db_origin(gdb);
gclass = dns_db_class(gdb);
}
} else {
tempfilelen = strlen(output) + 20;
- tempfile = isc_mem_get(mctx, tempfilelen);
+ tempfile = isc_mem_get(isc_g_mctx, tempfilelen);
result = isc_file_mktemplate(output, tempfile, tempfilelen);
check_result(result, "isc_file_mktemplate");
if (disable_zone_check) {
vresult = ISC_R_SUCCESS;
} else {
- vresult = dns_zoneverify_dnssec(NULL, gdb, gversion, gorigin,
- NULL, mctx, ignore_kskflag,
- keyset_kskonly, report);
+ vresult = dns_zoneverify_dnssec(
+ NULL, gdb, gversion, gorigin, NULL, isc_g_mctx,
+ ignore_kskflag, keyset_kskonly, report);
if (vresult != ISC_R_SUCCESS) {
fprintf(output_stdout ? stderr : stdout,
"Zone verification failed (%s)\n",
header.flags = DNS_MASTERRAW_SOURCESERIALSET;
header.sourceserial = serialnum;
}
- result = dns_master_dumptostream(mctx, gdb, gversion,
+ result = dns_master_dumptostream(isc_g_mctx, gdb, gversion,
masterstyle, outputformat,
&header, outfp);
check_result(result, "dns_master_dumptostream");
ISC_LIST_FOREACH (keylist, key, link) {
ISC_LIST_UNLINK(keylist, key, link);
- dns_dnsseckey_destroy(mctx, &key);
+ dns_dnsseckey_destroy(isc_g_mctx, &key);
}
if (tempfilelen != 0) {
- isc_mem_put(mctx, tempfile, tempfilelen);
+ isc_mem_put(isc_g_mctx, tempfile, tempfilelen);
}
if (free_output) {
- isc_mem_free(mctx, output);
+ isc_mem_free(isc_g_mctx, output);
}
- dns_master_styledestroy(&dsstyle, mctx);
+ dns_master_styledestroy(&dsstyle, isc_g_mctx);
if (verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_managers_destroy(&mctx);
+ isc_managers_destroy();
if (printstats) {
timer_finish = isc_time_now();
#include "dnssectool.h"
static isc_stdtime_t now;
-static isc_mem_t *mctx = NULL;
static dns_masterformat_t inputformat = dns_masterformat_text;
static dns_db_t *gdb = NULL; /* The database */
static dns_dbversion_t *gversion = NULL; /* The database version */
isc_result_totext(result));
}
- result = dns_db_create(mctx, ZONEDB_DEFAULT, name, dns_dbtype_zone,
- rdclass, 0, NULL, db);
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name,
+ dns_dbtype_zone, rdclass, 0, NULL, db);
check_result(result, "dns_db_create()");
result = dns_db_load(*db, file, inputformat, 0);
}
isc_commandline_reset = true;
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
isc_commandline_errprint = false;
report("Loading zone '%s' from file '%s'\n", origin, file);
loadzone(file, origin, rdclass, &gdb);
if (journal != NULL) {
- loadjournal(mctx, gdb, journal);
+ loadjournal(isc_g_mctx, gdb, journal);
}
gorigin = dns_db_origin(gdb);
gclass = dns_db_class(gdb);
result = dns_db_newversion(gdb, &gversion);
check_result(result, "dns_db_newversion()");
- result = dns_zoneverify_dnssec(NULL, gdb, gversion, gorigin, NULL, mctx,
- ignore_kskflag, keyset_kskonly, report);
+ result = dns_zoneverify_dnssec(NULL, gdb, gversion, gorigin, NULL,
+ isc_g_mctx, ignore_kskflag,
+ keyset_kskonly, report);
dns_db_closeversion(gdb, &gversion, false);
dns_db_detach(&gdb);
if (verbose > 10) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return result == ISC_R_SUCCESS ? 0 : 1;
}
isc_refcount_destroy(&bdb->common.references);
if (bdb->server != NULL) {
- isc_mem_free(named_g_mctx, bdb->server);
+ isc_mem_free(isc_g_mctx, bdb->server);
}
if (bdb->contact != NULL) {
- isc_mem_free(named_g_mctx, bdb->contact);
+ isc_mem_free(isc_g_mctx, bdb->contact);
}
bdb->common.magic = 0;
goto cleanup;
}
- bdb->server = isc_mem_strdup(named_g_mctx, argv[1]);
- bdb->contact = isc_mem_strdup(named_g_mctx, argv[2]);
+ bdb->server = isc_mem_strdup(isc_g_mctx, argv[1]);
+ bdb->contact = isc_mem_strdup(isc_g_mctx, argv[2]);
} else if (argc != 1) {
result = DNS_R_SYNTAX;
goto cleanup;
cleanup:
dns_name_free(&bdb->common.origin, mctx);
if (bdb->server != NULL) {
- isc_mem_free(named_g_mctx, bdb->server);
+ isc_mem_free(isc_g_mctx, bdb->server);
}
if (bdb->contact != NULL) {
- isc_mem_free(named_g_mctx, bdb->contact);
+ isc_mem_free(isc_g_mctx, bdb->contact);
}
isc_mem_putanddetach(&bdb->common.mctx, bdb, sizeof(bdb_t));
named_builtin_init(void) {
isc_result_t result;
- result = dns_db_register("_builtin", create, &builtin, named_g_mctx,
+ result = dns_db_register("_builtin", create, &builtin, isc_g_mctx,
&builtin.dbimp);
if (result != ISC_R_SUCCESS) {
return result;
}
- result = dns_db_register("_dns64", create, &dns64, named_g_mctx,
+ result = dns_db_register("_dns64", create, &dns64, isc_g_mctx,
&dns64.dbimp);
if (result != ISC_R_SUCCESS) {
dns_db_unregister(&builtin.dbimp);
* registered.)
*/
result = isccfg_check_namedconf(*conf, BIND_CHECK_ALGORITHMS,
- named_g_mctx);
+ isc_g_mctx);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
return result;
}
- isc_lex_create(named_g_mctx, strlen(cmdline), &lex);
+ isc_lex_create(isc_g_mctx, strlen(cmdline), &lex);
isc_buffer_init(&src, cmdline, strlen(cmdline));
isc_buffer_add(&src, strlen(cmdline));
#define NAMED_RUN_PID_DIR 1
#endif /* ifndef NAMED_RUN_PID_DIR */
-EXTERN isc_mem_t *named_g_mctx INIT(NULL);
EXTERN unsigned int named_g_cpus INIT(0);
EXTERN bool named_g_loopmgr_running INIT(false);
EXTERN dns_dispatchmgr_t *named_g_dispatchmgr INIT(NULL);
printf(" named PID file: %s\n", named_g_defaultpidfile);
#if defined(HAVE_GEOIP2)
#define RTC(x) RUNTIME_CHECK((x) == ISC_R_SUCCESS)
- isc_mem_t *mctx = NULL;
- isc_mem_create("geoip", &mctx);
- RTC(cfg_parser_create(mctx, &parser));
+ isc_mem_t *geoip_mctx = NULL;
+ isc_mem_create("geoip", &geoip_mctx);
+ RTC(cfg_parser_create(geoip_mctx, &parser));
RTC(named_config_parsedefaults(parser, &config));
RTC(cfg_map_get(config, "options", &defaults));
RTC(cfg_map_get(defaults, "geoip-directory", &obj));
}
cfg_obj_destroy(parser, &config);
cfg_parser_destroy(&parser);
- isc_mem_detach(&mctx);
+ isc_mem_detach(&geoip_mctx);
#endif /* HAVE_GEOIP2 */
}
"thread count limit)"
: "");
- isc_managers_create(&named_g_mctx, named_g_cpus);
+ isc_managers_create(named_g_cpus);
isc_nm_maxudp(maxudp);
#ifdef HAVE_LIBSCF
/* Check if named is under smf control, before chroot. */
- result = named_smf_get_instance(&instance, 0, named_g_mctx);
+ result = named_smf_get_instance(&instance, 0, isc_g_mctx);
/* We don't care about instance, just check if we got one. */
if (result == ISC_R_SUCCESS) {
named_smf_got_instance = 1;
named_smf_got_instance = 0;
}
if (instance != NULL) {
- isc_mem_free(named_g_mctx, instance);
+ isc_mem_free(isc_g_mctx, instance);
}
#endif /* HAVE_LIBSCF */
/*
* Register the DLZ "dlopen" driver.
*/
- result = dlz_dlopen_init(named_g_mctx);
+ result = dlz_dlopen_init(isc_g_mctx);
if (result != ISC_R_SUCCESS) {
named_main_earlyfatal("dlz_dlopen_init() failed: %s",
isc_result_totext(result));
}
- named_server_create(named_g_mctx, &named_g_server);
+ named_server_create(isc_g_mctx, &named_g_server);
ENSURE(named_g_server != NULL);
sctx = named_g_server->sctx;
#ifdef HAVE_LIBSCF
if (named_smf_want_disable == 1) {
- result = named_smf_get_instance(&instance, 1, named_g_mctx);
+ result = named_smf_get_instance(&instance, 1, isc_g_mctx);
if (result == ISC_R_SUCCESS && instance != NULL) {
if (smf_disable_instance(instance, 0) != 0) {
UNEXPECTED_ERROR("smf_disable_instance() "
}
}
if (instance != NULL) {
- isc_mem_free(named_g_mctx, instance);
+ isc_mem_free(isc_g_mctx, instance);
}
}
#endif /* HAVE_LIBSCF */
cleanup();
if (want_stats) {
- isc_mem_stats(named_g_mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
if (named_g_memstatistics && memstats != NULL) {
FILE *fp = NULL;
result = isc_stdio_open(memstats, "w", &fp);
if (result == ISC_R_SUCCESS) {
- isc_mem_stats(named_g_mctx, fp);
+ isc_mem_stats(isc_g_mctx, fp);
(void)isc_stdio_close(fp);
}
}
- isc_managers_destroy(&named_g_mctx);
+ isc_managers_destroy();
#if ENABLE_LEAK_DETECTION
isc__crypto_setdestroycheck(true);
}
if (auto_root) {
- CHECK(add_keydata_zone(view, directory, named_g_mctx));
+ CHECK(add_keydata_zone(view, directory, isc_g_mctx));
}
cleanup:
result = cfg_map_get(map, "exempt-clients", &obj);
if (result == ISC_R_SUCCESS) {
result = cfg_acl_fromconfig(obj, config, named_g_aclconfctx,
- named_g_mctx, 0, &rrl->exempt);
+ isc_g_mctx, 0, &rrl->exempt);
CHECK_RRL(result == ISC_R_SUCCESS, "invalid %s%s",
"address match list", "");
}
fstrm_iothr_options_set_reopen_interval(fopt, i);
}
- CHECKM(dns_dt_create(named_g_mctx, dmode, dpath, &fopt,
+ CHECKM(dns_dt_create(isc_g_mctx, dmode, dpath, &fopt,
isc_loop_main(), &named_g_server->dtenv),
"unable to create dnstap environment");
isc_netaddr_fromin6(&addr, &in6);
- dns_acl_create(named_g_mctx, 1, &acl);
+ dns_acl_create(isc_g_mctx, 1, &acl);
result = dns_iptable_addprefix(acl->iptable, &addr, 96, true);
if (result == ISC_R_SUCCESS) {
result = ns_plugin_register(full_path, parameters, config,
cfg_obj_file(obj), cfg_obj_line(obj),
- named_g_mctx, named_g_aclconfctx, view);
+ isc_g_mctx, named_g_aclconfctx, view);
if (result != ISC_R_SUCCESS) {
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_ERROR,
* can be retrieved.)
*/
CHECK(configure_view_acl(vconfig, config, NULL, "match-clients", NULL,
- actx, named_g_mctx, &view->matchclients));
+ actx, isc_g_mctx, &view->matchclients));
CHECK(configure_view_acl(vconfig, config, NULL, "match-destinations",
- NULL, actx, named_g_mctx,
+ NULL, actx, isc_g_mctx,
&view->matchdestinations));
/*
/* named.conf only */
CHECK(configure_view_acl(vconfig, config, NULL, "allow-query", NULL,
- actx, named_g_mctx, &view->queryacl));
+ actx, isc_g_mctx, &view->queryacl));
/* named.conf only */
CHECK(configure_view_acl(vconfig, config, NULL, "allow-query-cache",
- NULL, actx, named_g_mctx, &view->cacheacl));
+ NULL, actx, isc_g_mctx, &view->cacheacl));
/* named.conf only */
CHECK(configure_view_acl(vconfig, config, NULL, "allow-query-cache-on",
- NULL, actx, named_g_mctx, &view->cacheonacl));
+ NULL, actx, isc_g_mctx, &view->cacheonacl));
CHECK(configure_view_acl(vconfig, config, named_g_defaultconfig,
- "allow-query-on", NULL, actx, named_g_mctx,
+ "allow-query-on", NULL, actx, isc_g_mctx,
&view->queryonacl));
CHECK(configure_view_acl(vconfig, config, named_g_defaultconfig,
- "allow-proxy", NULL, actx, named_g_mctx,
+ "allow-proxy", NULL, actx, isc_g_mctx,
&view->proxyacl));
CHECK(configure_view_acl(vconfig, config, named_g_defaultconfig,
- "allow-proxy-on", NULL, actx, named_g_mctx,
+ "allow-proxy-on", NULL, actx, isc_g_mctx,
&view->proxyonacl));
if (strcmp(view->name, "_bind") != 0 &&
/* named.conf only */
CHECK(configure_view_acl(vconfig, config, NULL,
"allow-recursion", NULL, actx,
- named_g_mctx, &view->recursionacl));
+ isc_g_mctx, &view->recursionacl));
/* named.conf only */
CHECK(configure_view_acl(vconfig, config, NULL,
"allow-recursion-on", NULL, actx,
- named_g_mctx, &view->recursiononacl));
+ isc_g_mctx, &view->recursiononacl));
}
if (view->recursion) {
/* global default only */
CHECK(configure_view_acl(
NULL, NULL, named_g_defaultconfig,
- "allow-recursion", NULL, actx, named_g_mctx,
+ "allow-recursion", NULL, actx, isc_g_mctx,
&view->recursionacl));
}
if (view->recursiononacl == NULL) {
/* global default only */
CHECK(configure_view_acl(
NULL, NULL, named_g_defaultconfig,
- "allow-recursion-on", NULL, actx, named_g_mctx,
+ "allow-recursion-on", NULL, actx, isc_g_mctx,
&view->recursiononacl));
}
if (view->cacheacl == NULL) {
/* global default only */
CHECK(configure_view_acl(
NULL, NULL, named_g_defaultconfig,
- "allow-query-cache", NULL, actx, named_g_mctx,
+ "allow-query-cache", NULL, actx, isc_g_mctx,
&view->cacheacl));
}
if (view->cacheonacl == NULL) {
/* global default only */
CHECK(configure_view_acl(
NULL, NULL, named_g_defaultconfig,
- "allow-query-cache-on", NULL, actx,
- named_g_mctx, &view->cacheonacl));
+ "allow-query-cache-on", NULL, actx, isc_g_mctx,
+ &view->cacheonacl));
}
} else {
/*
if (view->queryacl == NULL) {
/* global default only */
CHECK(configure_view_acl(NULL, NULL, named_g_defaultconfig,
- "allow-query", NULL, actx,
- named_g_mctx, &view->queryacl));
+ "allow-query", NULL, actx, isc_g_mctx,
+ &view->queryacl));
}
/*
* and is needed by some broken clients.
*/
CHECK(configure_view_acl(vconfig, config, named_g_defaultconfig,
- "no-case-compress", NULL, actx, named_g_mctx,
+ "no-case-compress", NULL, actx, isc_g_mctx,
&view->nocasecompress));
/*
*/
CHECK(configure_view_acl(vconfig, config, named_g_defaultconfig,
"deny-answer-addresses", "acl", actx,
- named_g_mctx, &view->denyansweracl));
+ isc_g_mctx, &view->denyansweracl));
CHECK(configure_view_nametable(vconfig, config, "deny-answer-addresses",
- "except-from", named_g_mctx,
+ "except-from", isc_g_mctx,
&view->answeracl_exclude));
/*
* Filter setting on names (CNAME/DNAME targets) in the answer section.
*/
CHECK(configure_view_nametable(vconfig, config, "deny-answer-aliases",
- "name", named_g_mctx,
+ "name", isc_g_mctx,
&view->denyanswernames));
CHECK(configure_view_nametable(vconfig, config, "deny-answer-aliases",
- "except-from", named_g_mctx,
+ "except-from", isc_g_mctx,
&view->answernames_exclude));
/*
*/
if (view->updateacl == NULL) {
CHECK(configure_view_acl(NULL, NULL, named_g_defaultconfig,
- "allow-update", NULL, actx,
- named_g_mctx, &view->updateacl));
+ "allow-update", NULL, actx, isc_g_mctx,
+ &view->updateacl));
}
if (view->upfwdacl == NULL) {
CHECK(configure_view_acl(NULL, NULL, named_g_defaultconfig,
"allow-update-forwarding", NULL, actx,
- named_g_mctx, &view->upfwdacl));
+ isc_g_mctx, &view->upfwdacl));
}
/*
if (view->transferacl == NULL) {
CHECK(configure_view_acl(vconfig, config, named_g_defaultconfig,
"allow-transfer", NULL, actx,
- named_g_mctx, &view->transferacl));
+ isc_g_mctx, &view->transferacl));
}
if (view->notifyacl == NULL) {
CHECK(configure_view_acl(vconfig, config, named_g_defaultconfig,
- "allow-notify", NULL, actx,
- named_g_mctx, &view->notifyacl));
+ "allow-notify", NULL, actx, isc_g_mctx,
+ &view->notifyacl));
}
obj = NULL;
padding = 512U;
}
view->padding = (uint16_t)padding;
- CHECK(cfg_acl_fromconfig(aclobj, config, actx, named_g_mctx, 0,
+ CHECK(cfg_acl_fromconfig(aclobj, config, actx, isc_g_mctx, 0,
&view->pad_acl));
}
}
INSIST(view == NULL);
- dns_view_create(named_g_mctx, named_g_dispatchmgr, viewclass, viewname,
+ dns_view_create(isc_g_mctx, named_g_dispatchmgr, viewclass, viewname,
&view);
isc_nonce_buf(view->secret, sizeof(view->secret));
if (named_g_aclconfctx != NULL) {
cfg_aclconfctx_detach(&named_g_aclconfctx);
}
- result = cfg_aclconfctx_create(named_g_mctx, &named_g_aclconfctx);
+ result = cfg_aclconfctx_create(isc_g_mctx, &named_g_aclconfctx);
if (result != ISC_R_SUCCESS) {
goto cleanup_exclusive;
}
isc_tlsctx_cache_detach(&server->tlsctx_server_cache);
}
- isc_tlsctx_cache_create(named_g_mctx, &server->tlsctx_server_cache);
+ isc_tlsctx_cache_create(isc_g_mctx, &server->tlsctx_server_cache);
if (server->tlsctx_client_cache != NULL) {
isc_tlsctx_cache_detach(&server->tlsctx_client_cache);
}
- isc_tlsctx_cache_create(named_g_mctx, &server->tlsctx_client_cache);
+ isc_tlsctx_cache_create(isc_g_mctx, &server->tlsctx_client_cache);
dns_zonemgr_set_tlsctx_cache(server->zonemgr,
server->tlsctx_client_cache);
"keys instead",
server->bindkeysfile);
} else {
- result = cfg_parser_create(named_g_mctx,
+ result = cfg_parser_create(isc_g_mctx,
&bindkeys_parser);
if (result != ISC_R_SUCCESS) {
goto cleanup_bindkeys_parser;
result = named_config_get(maps, "sig0checks-quota-exempt", &obj);
if (result == ISC_R_SUCCESS) {
result = cfg_acl_fromconfig(
- obj, config, named_g_aclconfctx, named_g_mctx, 0,
+ obj, config, named_g_aclconfctx, isc_g_mctx, 0,
&server->sctx->sig0checksquota_exempt);
INSIST(result == ISC_R_SUCCESS);
}
* no default.
*/
result = configure_view_acl(NULL, config, NULL, "blackhole", NULL,
- named_g_aclconfctx, named_g_mctx,
+ named_g_aclconfctx, isc_g_mctx,
&server->sctx->blackholeacl);
if (result != ISC_R_SUCCESS) {
goto cleanup_bindkeys_parser;
/*
* Configure sets of UDP query source ports.
*/
- isc_portset_create(named_g_mctx, &v4portset);
- isc_portset_create(named_g_mctx, &v6portset);
+ isc_portset_create(isc_g_mctx, &v4portset);
+ isc_portset_create(isc_g_mctx, &v6portset);
result = isc_net_getudpportrange(AF_INET, &udpport_low, &udpport_high);
if (result != ISC_R_SUCCESS) {
goto cleanup_portsets;
}
result = listenlist_fromconfig(
- clistenon, config, named_g_aclconfctx, named_g_mctx,
+ clistenon, config, named_g_aclconfctx, isc_g_mctx,
AF_INET, server->tlsctx_server_cache, &listenon);
if (result != ISC_R_SUCCESS) {
goto cleanup_portsets;
goto cleanup_portsets;
}
result = listenlist_fromconfig(
- clistenon, config, named_g_aclconfctx, named_g_mctx,
+ clistenon, config, named_g_aclconfctx, isc_g_mctx,
AF_INET6, server->tlsctx_server_cache, &listenon);
if (result != ISC_R_SUCCESS) {
goto cleanup_portsets;
* turns out that a session key is really needed but doesn't exist,
* we'll treat it as a fatal error then.
*/
- (void)configure_session_key(maps, server, named_g_mctx, first_time);
+ (void)configure_session_key(maps, server, isc_g_mctx, first_time);
/*
* Create the built-in key store ("key-directory").
*/
- result = cfg_keystore_fromconfig(NULL, named_g_mctx, &keystorelist,
- NULL);
+ result = cfg_keystore_fromconfig(NULL, isc_g_mctx, &keystorelist, NULL);
if (result != ISC_R_SUCCESS) {
goto cleanup_keystorelist;
}
CFG_LIST_FOREACH (keystores, element) {
cfg_obj_t *kconfig = cfg_listelt_value(element);
- result = cfg_keystore_fromconfig(kconfig, named_g_mctx,
+ result = cfg_keystore_fromconfig(kconfig, isc_g_mctx,
&keystorelist, NULL);
if (result != ISC_R_SUCCESS) {
goto cleanup_keystorelist;
dns_kasp_t *kasp = NULL;
result = cfg_kasp_fromconfig(kconfig, default_kasp, true,
- named_g_mctx, &keystorelist,
+ isc_g_mctx, &keystorelist,
&kasplist, &kasp);
if (result != ISC_R_SUCCESS) {
goto cleanup_kasplist;
dns_kasp_t *kasp = NULL;
result = cfg_kasp_fromconfig(kconfig, default_kasp, true,
- named_g_mctx, &keystorelist,
+ isc_g_mctx, &keystorelist,
&kasplist, &kasp);
if (result != ISC_R_SUCCESS) {
goto cleanup_kasplist;
&cachelist, &server->cachelist,
&server->kasplist,
&server->keystorelist, bindkeys,
- named_g_mctx, named_g_aclconfctx, true);
+ isc_g_mctx, named_g_aclconfctx, true);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
goto cleanup_cachelist;
&cachelist, &server->cachelist,
&server->kasplist,
&server->keystorelist, bindkeys,
- named_g_mctx, named_g_aclconfctx, true);
+ isc_g_mctx, named_g_aclconfctx, true);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
goto cleanup_cachelist;
goto cleanup_cachelist;
}
- result = configure_view(
- view, &viewlist, config, vconfig, &cachelist,
- &server->cachelist, &server->kasplist,
- &server->keystorelist, bindkeys, named_g_mctx,
- named_g_aclconfctx, false);
+ result = configure_view(view, &viewlist, config, vconfig,
+ &cachelist, &server->cachelist,
+ &server->kasplist,
+ &server->keystorelist, bindkeys,
+ isc_g_mctx, named_g_aclconfctx, false);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
goto cleanup_cachelist;
if (options != NULL) {
dns_tkeyctx_t *tkeyctx = NULL;
- result = named_tkeyctx_fromconfig(options, named_g_mctx,
+ result = named_tkeyctx_fromconfig(options, isc_g_mctx,
&tkeyctx);
if (result != ISC_R_SUCCESS) {
isc_log_write(NAMED_LOGCATEGORY_GENERAL,
}
cleanup_portsets:
- isc_portset_destroy(named_g_mctx, &v6portset);
- isc_portset_destroy(named_g_mctx, &v4portset);
+ isc_portset_destroy(isc_g_mctx, &v6portset);
+ isc_portset_destroy(isc_g_mctx, &v4portset);
cleanup_bindkeys_parser:
if (bindkeys_parser != NULL) {
isc_log_write(NAMED_LOGCATEGORY_GENERAL, NAMED_LOGMODULE_SERVER,
ISC_LOG_DEBUG(1), "load_configuration");
- result = cfg_parser_create(named_g_mctx, &parser);
+ result = cfg_parser_create(isc_g_mctx, &parser);
if (result != ISC_R_SUCCESS) {
goto out;
}
named_server_t *server = (named_server_t *)arg;
dns_geoip_databases_t *geoip = NULL;
- dns_zonemgr_create(named_g_mctx, &server->zonemgr);
+ dns_zonemgr_create(isc_g_mctx, &server->zonemgr);
- CHECKFATAL(dns_dispatchmgr_create(named_g_mctx, &named_g_dispatchmgr),
+ CHECKFATAL(dns_dispatchmgr_create(isc_g_mctx, &named_g_dispatchmgr),
"creating dispatch manager");
dns_dispatchmgr_setstats(named_g_dispatchmgr, server->resolverstats);
geoip = NULL;
#endif /* if defined(HAVE_GEOIP2) */
- CHECKFATAL(ns_interfacemgr_create(named_g_mctx, server->sctx,
+ CHECKFATAL(ns_interfacemgr_create(isc_g_mctx, server->sctx,
named_g_dispatchmgr, geoip,
&server->interfacemgr),
"creating interface manager");
isc_timer_create(isc_loop_main(), pps_timer_tick, server,
&server->pps_timer);
- CHECKFATAL(cfg_parser_create(named_g_mctx, &named_g_parser),
+ CHECKFATAL(cfg_parser_create(isc_g_mctx, &named_g_parser),
"creating default configuration parser");
CHECKFATAL(named_config_parsedefaults(named_g_parser,
&named_g_defaultoptions),
"missing 'options' in default config");
- CHECKFATAL(cfg_parser_create(named_g_mctx, &named_g_addparser),
+ CHECKFATAL(cfg_parser_create(isc_g_mctx, &named_g_addparser),
"creating additional configuration parser");
CHECKFATAL(load_configuration(server, true), "loading configuration");
isc_sockstatscounter_max);
isc_nm_setstats(server->sockstats);
- isc_stats_create(named_g_mctx, &server->zonestats,
+ isc_stats_create(isc_g_mctx, &server->zonestats,
dns_zonestatscounter_max);
- isc_stats_create(named_g_mctx, &server->resolverstats,
+ isc_stats_create(isc_g_mctx, &server->resolverstats,
dns_resstatscounter_max);
CHECKFATAL(named_controls_create(server, &server->controls),
dns_zone_detach(&raw);
}
dns_zone_detach(&zone);
- isc_mem_put(named_g_mctx, dz, sizeof(*dz));
+ isc_mem_put(isc_g_mctx, dz, sizeof(*dz));
}
/*
}
/* Send cleanup event */
- dz = isc_mem_get(named_g_mctx, sizeof(*dz));
+ dz = isc_mem_get(isc_g_mctx, sizeof(*dz));
*dz = (ns_dzctx_t){
.cleanup = cleanup,
};
}
parse_acl:
- result = cfg_acl_fromconfig(aclobj, config, actx, named_g_mctx, 0,
- &acl);
+ result = cfg_acl_fromconfig(aclobj, config, actx, isc_g_mctx, 0, &acl);
if (result != ISC_R_SUCCESS) {
return result;
}
static bool usevc = false;
static bool usegsstsig = false;
static bool local_only = false;
-static isc_mem_t *gmctx = NULL;
static dns_dispatchmgr_t *dispatchmgr = NULL;
static dns_requestmgr_t *requestmgr = NULL;
static dns_dispatch_t *dispatchv4 = NULL;
static void
primary_from_servers(void) {
if (primary_servers != NULL && primary_servers != servers) {
- isc_mem_cput(gmctx, primary_servers, primary_alloc,
+ isc_mem_cput(isc_g_mctx, primary_servers, primary_alloc,
sizeof(isc_sockaddr_t));
}
primary_servers = servers;
if (updatemsg != NULL) {
dns_message_reset(updatemsg, DNS_MESSAGE_INTENTRENDER);
} else {
- dns_message_create(gmctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
- &updatemsg);
+ dns_message_create(isc_g_mctx, NULL, NULL,
+ DNS_MESSAGE_INTENTRENDER, &updatemsg);
}
updatemsg->opcode = dns_opcode_update;
if (usegsstsig) {
check_result(result, "dns_name_fromtext");
secretlen = strlen(secretstr) * 3 / 4;
- secret = isc_mem_allocate(gmctx, secretlen);
+ secret = isc_mem_allocate(isc_g_mctx, secretlen);
isc_buffer_init(&secretbuf, secret, secretlen);
result = isc_base64_decodestring(secretstr, &secretbuf);
debug("keycreate");
result = dns_tsigkey_create(mykeyname, hmac_alg, secret, secretlen,
- gmctx, &tsigkey);
+ isc_g_mctx, &tsigkey);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "could not create key from %s: %s\n", keystr,
isc_result_totext(result));
}
failure:
if (secret != NULL) {
- isc_mem_free(gmctx, secret);
+ isc_mem_free(isc_g_mctx, secret);
}
}
* to NULL.
*/
if (primary_servers != NULL && primary_servers != servers) {
- isc_mem_cput(gmctx, primary_servers, primary_alloc,
+ isc_mem_cput(isc_g_mctx, primary_servers, primary_alloc,
sizeof(isc_sockaddr_t));
}
if (servers != NULL) {
- isc_mem_cput(gmctx, servers, ns_alloc, sizeof(isc_sockaddr_t));
+ isc_mem_cput(isc_g_mctx, servers, ns_alloc,
+ sizeof(isc_sockaddr_t));
}
if (localaddr4 != NULL) {
- isc_mem_put(gmctx, localaddr4, sizeof(isc_sockaddr_t));
+ isc_mem_put(isc_g_mctx, localaddr4, sizeof(isc_sockaddr_t));
}
if (localaddr6 != NULL) {
- isc_mem_put(gmctx, localaddr6, sizeof(isc_sockaddr_t));
+ isc_mem_put(isc_g_mctx, localaddr6, sizeof(isc_sockaddr_t));
}
if (tsigkey != NULL) {
in_port_t udpport_low, udpport_high;
isc_result_t result;
- isc_portset_create(gmctx, &v4portset);
+ isc_portset_create(isc_g_mctx, &v4portset);
result = isc_net_getudpportrange(AF_INET, &udpport_low, &udpport_high);
check_result(result, "isc_net_getudpportrange (v4)");
isc_portset_addrange(v4portset, udpport_low, udpport_high);
- isc_portset_create(gmctx, &v6portset);
+ isc_portset_create(isc_g_mctx, &v6portset);
result = isc_net_getudpportrange(AF_INET6, &udpport_low, &udpport_high);
check_result(result, "isc_net_getudpportrange (v6)");
isc_portset_addrange(v6portset, udpport_low, udpport_high);
result = dns_dispatchmgr_setavailports(manager, v4portset, v6portset);
check_result(result, "dns_dispatchmgr_setavailports");
- isc_portset_destroy(gmctx, &v4portset);
- isc_portset_destroy(gmctx, &v6portset);
+ isc_portset_destroy(isc_g_mctx, &v4portset);
+ isc_portset_destroy(isc_g_mctx, &v6portset);
}
static isc_result_t
ISC_LOGMODULE_DEFAULT);
isc_log_setdebuglevel(logdebuglevel);
- result = irs_resconf_load(gmctx, resolvconf, &resconf);
+ result = irs_resconf_load(isc_g_mctx, resolvconf, &resconf);
if (result != ISC_R_SUCCESS && result != ISC_R_FILENOTFOUND) {
fatal("parse of %s failed", resolvconf);
}
if (primary_servers == servers) {
primary_servers = NULL;
}
- isc_mem_cput(gmctx, servers, ns_alloc, sizeof(isc_sockaddr_t));
+ isc_mem_cput(isc_g_mctx, servers, ns_alloc,
+ sizeof(isc_sockaddr_t));
}
ns_inuse = 0;
default_servers = !local_only;
ns_total = ns_alloc = (have_ipv4 ? 1 : 0) + (have_ipv6 ? 1 : 0);
- servers = isc_mem_cget(gmctx, ns_alloc, sizeof(isc_sockaddr_t));
+ servers = isc_mem_cget(isc_g_mctx, ns_alloc,
+ sizeof(isc_sockaddr_t));
if (have_ipv6) {
memset(&in6, 0, sizeof(in6));
}
ns_alloc = ns_total;
- servers = isc_mem_cget(gmctx, ns_alloc, sizeof(isc_sockaddr_t));
+ servers = isc_mem_cget(isc_g_mctx, ns_alloc,
+ sizeof(isc_sockaddr_t));
i = 0;
ISC_LIST_FOREACH (*nslist, sa, link) {
irs_resconf_destroy(&resconf);
- result = dns_dispatchmgr_create(gmctx, &dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr);
check_result(result, "dns_dispatchmgr_create");
set_source_ports(dispatchmgr);
&dispatchv4);
check_result(result, "dns_dispatch_createudp (v4)");
}
- transport_list = dns_transport_list_new(gmctx);
+ transport_list = dns_transport_list_new(isc_g_mctx);
- isc_tlsctx_cache_create(gmctx, &tls_ctx_cache);
+ isc_tlsctx_cache_create(isc_g_mctx, &tls_ctx_cache);
if (tls_client_key_file == NULL) {
result = create_name("tls-non-auth-client", tlsname);
dns_transport_set_always_verify_remote(transport,
tls_always_verify_remote);
- result = dns_requestmgr_create(gmctx, dispatchmgr, dispatchv4,
+ result = dns_requestmgr_create(isc_g_mctx, dispatchmgr, dispatchv4,
dispatchv6, &requestmgr);
check_result(result, "dns_requestmgr_create");
if (keystr != NULL) {
setup_keystr();
} else if (local_only) {
- result = read_sessionkey(gmctx);
+ result = read_sessionkey(isc_g_mctx);
if (result != ISC_R_SUCCESS) {
fatal("can't read key from %s: %s\n", keyfile,
isc_result_totext(result));
}
} else if (keyfile != NULL) {
- setup_keyfile(gmctx);
+ setup_keyfile(isc_g_mctx);
}
isc_mutex_init(&answer_lock);
if (*cmdline != 0) {
dns_rdatacallbacks_init(&callbacks);
- isc_lex_create(gmctx, strlen(cmdline), &lex);
+ isc_lex_create(isc_g_mctx, 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");
- isc_buffer_allocate(gmctx, &buf, MAXWIRE);
+ isc_buffer_allocate(isc_g_mctx, &buf, MAXWIRE);
result = dns_rdata_fromtext(NULL, rdataclass, rdatatype, lex,
- dns_rootname, 0, gmctx, buf,
+ dns_rootname, 0, isc_g_mctx, buf,
&callbacks);
isc_lex_destroy(&lex);
if (result == ISC_R_SUCCESS) {
isc_buffer_usedregion(buf, &r);
- isc_buffer_allocate(gmctx, &newbuf, r.length);
+ isc_buffer_allocate(isc_g_mctx, &newbuf, r.length);
isc_buffer_putmem(newbuf, r.base, r.length);
isc_buffer_usedregion(newbuf, &r);
dns_rdata_fromregion(rdata, rdataclass, rdatatype, &r);
if (primary_servers == servers) {
primary_servers = NULL;
}
- isc_mem_cput(gmctx, servers, ns_alloc, sizeof(isc_sockaddr_t));
+ isc_mem_cput(isc_g_mctx, servers, ns_alloc,
+ sizeof(isc_sockaddr_t));
}
default_servers = false;
ns_alloc = MAX_SERVERADDRS;
ns_inuse = 0;
- servers = isc_mem_cget(gmctx, ns_alloc, sizeof(isc_sockaddr_t));
+ servers = isc_mem_cget(isc_g_mctx, ns_alloc, sizeof(isc_sockaddr_t));
ns_total = get_addresses(server, (in_port_t)port, servers, ns_alloc);
if (ns_total == 0) {
return STATUS_SYNTAX;
if (have_ipv6 && inet_pton(AF_INET6, local, &in6) == 1) {
if (localaddr6 == NULL) {
- localaddr6 = isc_mem_get(gmctx, sizeof(isc_sockaddr_t));
+ localaddr6 = isc_mem_get(isc_g_mctx,
+ sizeof(isc_sockaddr_t));
}
isc_sockaddr_fromin6(localaddr6, &in6, (in_port_t)port);
} else if (have_ipv4 && inet_pton(AF_INET, local, &in4) == 1) {
if (localaddr4 == NULL) {
- localaddr4 = isc_mem_get(gmctx, sizeof(isc_sockaddr_t));
+ localaddr4 = isc_mem_get(isc_g_mctx,
+ sizeof(isc_sockaddr_t));
}
isc_sockaddr_fromin(localaddr4, &in4, (in_port_t)port);
} else {
return STATUS_SYNTAX;
}
secretlen = strlen(secretstr) * 3 / 4;
- secret = isc_mem_allocate(gmctx, secretlen);
+ secret = isc_mem_allocate(isc_g_mctx, secretlen);
isc_buffer_init(&secretbuf, secret, secretlen);
result = isc_base64_decodestring(secretstr, &secretbuf);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "could not create key from %s: %s\n", secretstr,
isc_result_totext(result));
- isc_mem_free(gmctx, secret);
+ isc_mem_free(isc_g_mctx, secret);
return STATUS_SYNTAX;
}
secretlen = isc_buffer_usedlength(&secretbuf);
dns_tsigkey_detach(&tsigkey);
}
result = dns_tsigkey_create(mykeyname, hmac_alg, secret, secretlen,
- gmctx, &tsigkey);
- isc_mem_free(gmctx, secret);
+ isc_g_mctx, &tsigkey);
+ isc_mem_free(isc_g_mctx, secret);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "could not create key from %s %s: %s\n",
namestr, secretstr, isc_result_totext(result));
int n;
if (realm != NULL) {
- isc_mem_free(gmctx, realm);
+ isc_mem_free(isc_g_mctx, realm);
}
word = nsu_strsep(&cmdline, " \t\r\n");
error("realm is too long");
return STATUS_SYNTAX;
}
- realm = isc_mem_strdup(gmctx, buf);
+ realm = isc_mem_strdup(isc_g_mctx, buf);
return STATUS_MORE;
#else /* HAVE_GSSAPI */
UNUSED(cmdline);
if (buf != NULL) {
isc_buffer_free(&buf);
}
- isc_buffer_allocate(gmctx, &buf, bufsz);
+ isc_buffer_allocate(isc_g_mctx, &buf, bufsz);
result = dns_message_totext(msg, style, 0, buf);
bufsz *= 2;
} while (result == ISC_R_NOSPACE);
}
LOCK(&answer_lock);
- dns_message_create(gmctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &answer);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &answer);
result = dns_request_getresponse(request, answer,
DNS_MESSAGEPARSE_PRESERVEORDER);
switch (result) {
done:
dns_request_destroy(&request);
if (usegsstsig) {
- dns_name_free(&tmpzonename, gmctx);
- dns_name_free(&restart_primary, gmctx);
+ dns_name_free(&tmpzonename, isc_g_mctx);
+ dns_name_free(&restart_primary, isc_g_mctx);
dns_name_init(&tmpzonename);
dns_name_init(&restart_primary);
}
if (shuttingdown) {
dns_request_destroy(&request);
dns_message_detach(&soaquery);
- isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t));
+ isc_mem_put(isc_g_mctx, reqinfo, sizeof(nsu_requestinfo_t));
maybeshutdown();
return;
}
dns_message_renderreset(soaquery);
dns_message_settsigkey(soaquery, NULL);
sendrequest(&servers[ns_inuse], soaquery, &request);
- isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t));
+ isc_mem_put(isc_g_mctx, reqinfo, sizeof(nsu_requestinfo_t));
setzoneclass(dns_rdataclass_none);
return;
}
- isc_mem_put(gmctx, reqinfo, sizeof(nsu_requestinfo_t));
+ isc_mem_put(isc_g_mctx, reqinfo, sizeof(nsu_requestinfo_t));
ddebug("About to create rcvmsg");
- dns_message_create(gmctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &rcvmsg);
result = dns_request_getresponse(request, rcvmsg,
DNS_MESSAGEPARSE_PRESERVEORDER);
if (result == DNS_R_TSIGERRORSET && servers != NULL) {
dns_message_detach(&rcvmsg);
ddebug("Destroying request [%p]", request);
dns_request_destroy(&request);
- reqinfo = isc_mem_get(gmctx, sizeof(nsu_requestinfo_t));
+ reqinfo = isc_mem_get(isc_g_mctx, sizeof(nsu_requestinfo_t));
reqinfo->msg = soaquery;
reqinfo->addr = addr;
dns_message_renderreset(soaquery);
serverstr[isc_buffer_usedlength(&buf)] = 0;
if (primary_servers != NULL && primary_servers != servers) {
- isc_mem_cput(gmctx, primary_servers, primary_alloc,
+ isc_mem_cput(isc_g_mctx, primary_servers, primary_alloc,
sizeof(isc_sockaddr_t));
}
primary_alloc = MAX_SERVERADDRS;
- primary_servers = isc_mem_cget(gmctx, primary_alloc,
+ primary_servers = isc_mem_cget(isc_g_mctx, primary_alloc,
sizeof(isc_sockaddr_t));
primary_total = get_addresses(serverstr, dnsport,
primary_servers, primary_alloc);
#if HAVE_GSSAPI
if (usegsstsig) {
dns_name_init(&tmpzonename);
- dns_name_dup(zname, gmctx, &tmpzonename);
+ dns_name_dup(zname, isc_g_mctx, &tmpzonename);
dns_name_init(&restart_primary);
- dns_name_dup(&primary, gmctx, &restart_primary);
+ dns_name_dup(&primary, isc_g_mctx, &restart_primary);
start_gssrequest(&primary);
} else {
send_update(zname, &primary_servers[primary_inuse]);
}
}
- reqinfo = isc_mem_get(gmctx, sizeof(nsu_requestinfo_t));
+ reqinfo = isc_mem_get(isc_g_mctx, sizeof(nsu_requestinfo_t));
reqinfo->msg = msg;
reqinfo->addr = destaddr;
failed_gssrequest(void) {
seenerror = true;
- dns_name_free(&tmpzonename, gmctx);
- dns_name_free(&restart_primary, gmctx);
+ dns_name_free(&tmpzonename, isc_g_mctx);
+ dns_name_free(&restart_primary, isc_g_mctx);
dns_name_init(&tmpzonename);
dns_name_init(&restart_primary);
dns_tsigkeyring_detach(&gssring);
}
- dns_tsigkeyring_create(gmctx, &gssring);
+ dns_tsigkeyring_create(isc_g_mctx, &gssring);
dns_name_format(primary, namestr, sizeof(namestr));
if (kserver == NULL) {
- kserver = isc_mem_get(gmctx, sizeof(isc_sockaddr_t));
+ kserver = isc_mem_get(isc_g_mctx, sizeof(isc_sockaddr_t));
}
memmove(kserver, &primary_servers[primary_inuse],
servname = dns_fixedname_initname(&fname);
if (realm == NULL) {
- get_ticket_realm(gmctx);
+ get_ticket_realm(isc_g_mctx);
}
result = snprintf(servicename, sizeof(servicename), "DNS/%s%s", namestr,
keyname->attributes.nocompress = true;
rmsg = NULL;
- dns_message_create(gmctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER, &rmsg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
+ &rmsg);
/* Build first request. */
context = GSS_C_NO_CONTEXT;
result = dns_tkey_buildgssquery(rmsg, keyname, servname, 0, &context,
- gmctx, &err_message);
+ isc_g_mctx, &err_message);
if (result == ISC_R_FAILURE) {
fprintf(stderr, "tkey query failed: %s\n",
err_message != NULL ? err_message : "unknown error");
dns_message_detach(&rmsg);
}
if (err_message != NULL) {
- isc_mem_free(gmctx, err_message);
+ isc_mem_free(isc_g_mctx, err_message);
}
failed_gssrequest();
}
debug("send_gssrequest");
REQUIRE(destaddr != NULL);
- reqinfo = isc_mem_get(gmctx, sizeof(nsu_gssinfo_t));
+ reqinfo = isc_mem_get(isc_g_mctx, sizeof(nsu_gssinfo_t));
*reqinfo = (nsu_gssinfo_t){
.msg = msg,
.addr = destaddr,
if (shuttingdown) {
dns_request_destroy(&request);
dns_message_detach(&tsigquery);
- isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t));
+ isc_mem_put(isc_g_mctx, reqinfo, sizeof(nsu_gssinfo_t));
maybeshutdown();
return;
}
sizeof(isc_sockaddr_t));
send_gssrequest(kserver, tsigquery, &request, context);
}
- isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t));
+ isc_mem_put(isc_g_mctx, reqinfo, sizeof(nsu_gssinfo_t));
return;
}
- isc_mem_put(gmctx, reqinfo, sizeof(nsu_gssinfo_t));
+ isc_mem_put(isc_g_mctx, reqinfo, sizeof(nsu_gssinfo_t));
ddebug("recvgss creating rcvmsg");
- dns_message_create(gmctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &rcvmsg);
result = dns_request_getresponse(request, rcvmsg,
DNS_MESSAGEPARSE_PRESERVEORDER);
return;
}
- dns_message_create(gmctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
&soaquery);
if (default_servers) {
#ifdef HAVE_GSSAPI
if (kserver != NULL) {
- isc_mem_put(gmctx, kserver, sizeof(isc_sockaddr_t));
+ isc_mem_put(isc_g_mctx, kserver, sizeof(isc_sockaddr_t));
}
if (realm != NULL) {
- isc_mem_free(gmctx, realm);
+ isc_mem_free(isc_g_mctx, realm);
}
if (dns_name_dynamic(&tmpzonename)) {
- dns_name_free(&tmpzonename, gmctx);
+ dns_name_free(&tmpzonename, isc_g_mctx);
}
if (dns_name_dynamic(&restart_primary)) {
- dns_name_free(&restart_primary, gmctx);
+ dns_name_free(&restart_primary, isc_g_mctx);
}
#endif /* ifdef HAVE_GSSAPI */
ddebug("Destroying memory context");
if (memdebugging) {
- isc_mem_stats(gmctx, stderr);
+ isc_mem_stats(isc_g_mctx, stderr);
}
isc_mutex_destroy(&answer_lock);
ddebug("Shutting down managers");
- isc_managers_destroy(&gmctx);
+ isc_managers_destroy();
}
static void
pre_parse_args(argc, argv);
- isc_managers_create(&gmctx, 1);
+ isc_managers_create(1);
parse_args(argc, argv);
static isccc_region_t secret;
static bool failed = false;
static bool c_flag = false;
-static isc_mem_t *rndc_mctx = NULL;
static char *command = NULL;
static char *args = NULL;
static uint32_t serial;
r.length = databuf->used;
/* isccc_ccmsg_init() attaches to the handle */
- isccc_ccmsg_init(rndc_mctx, handle, ccmsg);
+ isccc_ccmsg_init(isc_g_mctx, handle, ccmsg);
isccc_ccmsg_setmaxsize(ccmsg, 1024 * 1024);
isccc_ccmsg_readmessage(ccmsg, rndc_recvnonce, ccmsg);
serial = isc_random32();
- isc_managers_create(&rndc_mctx, 1);
+ isc_managers_create(1);
isc_loopmgr_setup(rndc_start, NULL);
isc_nm_setinitialtimeout(timeout);
ISC_LOG_PRINTTAG | ISC_LOG_PRINTLEVEL, ISC_LOGCATEGORY_DEFAULT,
ISC_LOGMODULE_DEFAULT);
- parse_config(rndc_mctx, keyname, &pctx, &config);
+ parse_config(isc_g_mctx, keyname, &pctx, &config);
- isc_buffer_allocate(rndc_mctx, &databuf, 2048);
+ isc_buffer_allocate(isc_g_mctx, &databuf, 2048);
/*
* Convert argc/argv into a space-delimited command string
argslen += strlen(argv[i]) + 1;
}
- args = isc_mem_get(rndc_mctx, argslen);
+ args = isc_mem_get(isc_g_mctx, argslen);
p = args;
for (i = 0; i < argc; i++) {
cfg_obj_destroy(pctx, &config);
cfg_parser_destroy(&pctx);
- isc_mem_put(rndc_mctx, args, argslen);
+ isc_mem_put(isc_g_mctx, args, argslen);
isc_buffer_free(&databuf);
if (show_final_mem) {
- isc_mem_stats(rndc_mctx, stderr);
+ isc_mem_stats(isc_g_mctx, stderr);
}
- isc_managers_destroy(&rndc_mctx);
+ isc_managers_destroy();
if (failed) {
return 1;
#define PORT 5300
#define TIMEOUT 30
-static isc_mem_t *mctx = NULL;
static dns_requestmgr_t *requestmgr = NULL;
static bool have_src = false;
static isc_sockaddr_t srcaddr;
exit(EXIT_FAILURE);
}
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
&response);
result = dns_request_getresponse(request, response,
dns_rootname, 0);
CHECK("dns_name_fromtext", result);
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
&message);
message->opcode = dns_opcode_query;
}
isc_sockaddr_fromin(&dstaddr, &inaddr, port);
- isc_managers_create(&mctx, 1);
+ isc_managers_create(1);
- RUNCHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
+ RUNCHECK(dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr));
RUNCHECK(dns_dispatch_createudp(
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchv4));
- RUNCHECK(dns_requestmgr_create(mctx, dispatchmgr, dispatchv4, NULL,
- &requestmgr));
+ RUNCHECK(dns_requestmgr_create(isc_g_mctx, dispatchmgr, dispatchv4,
+ NULL, &requestmgr));
- dns_view_create(mctx, NULL, 0, "_test", &view);
+ dns_view_create(isc_g_mctx, NULL, 0, "_test", &view);
isc_loopmgr_setup(sendqueries, NULL);
isc_loopmgr_teardown(teardown_view, view);
isc_loopmgr_run();
- isc_managers_destroy(&mctx);
+ isc_managers_destroy();
return 0;
}
dns_fixedname_t fname;
dns_name_t *name;
unsigned int bits = 2048U;
-isc_mem_t *mctx;
isc_logconfig_t *logconfig;
int level = ISC_LOG_WARNING;
char filename[255];
exit(EXIT_FAILURE);
}
- isc_mem_create(argv[0], &mctx);
+ isc_mem_create(argv[0], &isc_g_mctx);
logconfig = isc_logconfig_get();
isc_log_settag(logconfig, "bigkey");
CHECK(dst_key_buildinternal(name, DNS_KEYALG_RSASHA256, bits,
DNS_KEYOWNER_ZONE, DNS_KEYPROTO_DNSSEC,
- dns_rdataclass_in, pkey, mctx, &key),
+ dns_rdataclass_in, pkey, isc_g_mctx, &key),
"dst_key_buildinternal(...)");
CHECK(dst_key_tofile(key, DST_TYPE_PRIVATE | DST_TYPE_PUBLIC, NULL),
printf("%s\n", filename);
dst_key_free(&key);
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return 0;
}
#include <dns/message.h>
int parseflags = 0;
-isc_mem_t *mctx = NULL;
bool printmemstats = false;
bool dorender = false;
isc_result_t result = ISC_R_SUCCESS;
do {
- buf = isc_mem_get(mctx, len);
+ buf = isc_mem_get(isc_g_mctx, len);
isc_buffer_init(&b, buf, len);
result = dns_message_totext(msg, &dns_master_style_debug, 0,
&b);
if (result == ISC_R_NOSPACE) {
- isc_mem_put(mctx, buf, len);
+ isc_mem_put(isc_g_mctx, buf, len);
len *= 2;
} else if (result == ISC_R_SUCCESS) {
printf("%.*s\n", (int)isc_buffer_usedlength(&b), buf);
} while (result == ISC_R_NOSPACE);
if (buf != NULL) {
- isc_mem_put(mctx, buf, len);
+ isc_mem_put(isc_g_mctx, buf, len);
}
return result;
}
isc_commandline_reset = true;
- isc_mem_create(argv[0], &mctx);
+ isc_mem_create(argv[0], &isc_g_mctx);
while ((ch = isc_commandline_parse(argc, argv, CMDLINE_FLAGS)) != -1) {
switch (ch) {
f = stdin;
}
- isc_buffer_allocate(mctx, &input, 64 * 1024);
+ isc_buffer_allocate(isc_g_mctx, &input, 64 * 1024);
if (rawdata) {
while (fread(&c, 1, 1, f) != 0) {
isc_buffer_free(&input);
if (printmemstats) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return 0;
}
int i;
message = NULL;
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &message);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &message);
result = dns_message_parse(message, source, parseflags);
if (result == DNS_R_RECOVERABLE) {
CHECKRESULT(result, "printmessage() failed");
if (printmemstats) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
if (dorender) {
message->counts[i] = 0; /* Another hack XXX */
}
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
result = dns_message_renderbegin(message, &cctx, &buffer);
CHECKRESULT(result, "dns_message_renderbegin() failed");
printf("Message rendered.\n");
if (printmemstats) {
- isc_mem_stats(mctx, stdout);
+ isc_mem_stats(isc_g_mctx, stdout);
}
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
- &message);
+ dns_message_create(isc_g_mctx, NULL, NULL,
+ DNS_MESSAGE_INTENTPARSE, &message);
result = dns_message_parse(message, &buffer, parseflags);
CHECKRESULT(result, "dns_message_parse failed");
"https-get", "http-plain-post",
"http-plain-get" };
-static isc_mem_t *mctx = NULL;
-
static protocol_t protocol;
static const char *address;
static const char *port;
static void
setup(void) {
- isc_managers_create(&mctx, workers);
+ isc_managers_create(workers);
}
static void
isc_tlsctx_free(&tls_ctx);
}
- isc_managers_destroy(&mctx);
+ isc_managers_destroy();
}
static void
static const char *protocols[] = { "udp", "tcp", "dot", "https", "http-plain" };
-static isc_mem_t *mctx = NULL;
-
static protocol_t protocol;
static in_port_t port;
static isc_netaddr_t netaddr;
static void
setup(void) {
- isc_managers_create(&mctx, workers);
+ isc_managers_create(workers);
}
static void
isc_tlsctx_free(&tls_ctx);
}
- isc_managers_destroy(&mctx);
+ isc_managers_destroy();
}
static void
((uint8_t *)region->base)[2] ^= 0x80;
}
- reply = isc_mem_get(mctx, sizeof(isc_region_t) + region->length);
+ reply = isc_mem_get(isc_g_mctx, sizeof(isc_region_t) + region->length);
reply->length = region->length;
reply->base = (uint8_t *)reply + sizeof(isc_region_t);
memmove(reply->base, region->base, region->length);
REQUIRE(handle != NULL);
REQUIRE(eresult == ISC_R_SUCCESS);
- isc_mem_put(mctx, cbarg, sizeof(isc_region_t) + reply->length);
+ isc_mem_put(isc_g_mctx, cbarg, sizeof(isc_region_t) + reply->length);
}
static isc_result_t
if (is_https) {
isc_tlsctx_createserver(NULL, NULL, &tls_ctx);
}
- eps = isc_nm_http_endpoints_new(mctx);
+ eps = isc_nm_http_endpoints_new(isc_g_mctx);
result = isc_nm_http_endpoints_add(
eps, ISC_NM_HTTP_DEFAULT_PATH, read_cb, NULL);
#include "dnstap.pb-c.h"
-isc_mem_t *mctx = NULL;
bool memrecord = false;
bool printmessage = false;
bool hexmessage = false;
isc_result_t result;
isc_buffer_t *b = NULL;
- isc_buffer_allocate(mctx, &b, 2048);
+ isc_buffer_allocate(isc_g_mctx, &b, 2048);
if (b == NULL) {
fatal("out of memory");
}
}
textlen = (dt->msgdata.length * 2) + 1;
- isc_buffer_allocate(mctx, &b, textlen);
+ isc_buffer_allocate(isc_g_mctx, &b, textlen);
if (b == NULL) {
fatal("out of memory");
}
if (dt->msg != NULL) {
size_t textlen = 2048;
- isc_buffer_allocate(mctx, &b, textlen);
+ isc_buffer_allocate(isc_g_mctx, &b, textlen);
if (b == NULL) {
fatal("out of memory");
}
fatal("no file specified");
}
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
- CHECKM(dns_dt_open(argv[0], dns_dtmode_file, mctx, &handle),
+ CHECKM(dns_dt_open(argv[0], dns_dtmode_file, isc_g_mctx, &handle),
"dns_dt_openfile");
for (;;) {
input.base = data;
input.length = datalen;
- result = dns_dt_parse(mctx, &input, &dt);
+ result = dns_dt_parse(isc_g_mctx, &input, &dt);
if (result != ISC_R_SUCCESS) {
continue;
}
if (message != NULL) {
dns_message_detach(&message);
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
exit(rv);
}
#define UDPTIMEOUT 5
#define MAXTRIES 0xffffffff
-static isc_mem_t *mctx = NULL;
static dns_requestmgr_t *requestmgr = NULL;
static const char *batchname = NULL;
static FILE *batchfp = NULL;
}
}
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
&response);
parseflags |= DNS_MESSAGEPARSE_PRESERVEORDER;
if (display_multiline || (!display_ttl && !display_class)) {
result = dns_master_stylecreate(&style, styleflags, 24, 24, 24,
32, 80, 8, display_splitwidth,
- mctx);
+ isc_g_mctx);
} else if (!display_ttl || !display_class) {
result = dns_master_stylecreate(&style, styleflags, 24, 24, 32,
40, 80, 8, display_splitwidth,
- mctx);
+ isc_g_mctx);
} else {
result = dns_master_stylecreate(&style, styleflags, 24, 32, 40,
48, 80, 8, display_splitwidth,
- mctx);
+ isc_g_mctx);
}
CHECK("dns_master_stylecreate2", result);
flags |= DNS_MESSAGETEXTFLAG_NOCOMMENTS;
}
- isc_buffer_allocate(mctx, &buf, len);
+ isc_buffer_allocate(isc_g_mctx, &buf, len);
if (yaml) {
char sockstr[ISC_SOCKADDR_FORMATSIZE];
buftoosmall:
len += OUTPUTBUF;
isc_buffer_free(&buf);
- isc_buffer_allocate(mctx, &buf, len);
+ isc_buffer_allocate(isc_g_mctx, &buf, len);
goto repopulate_buffer;
}
CHECK("dns_message_pseudosectiontotext", result);
cleanup:
fflush(stdout);
if (style != NULL) {
- dns_master_styledestroy(&style, mctx);
+ dns_master_styledestroy(&style, isc_g_mctx);
}
if (query != NULL) {
dns_message_detach(&query);
dns_rootname, 0);
CHECK("dns_name_fromtext", result);
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
&message);
message->opcode = dns_opcode_query;
size_t len = sizeof(query->ednsopts[0]) * EDNSOPTS;
size_t i;
- query->ednsopts = isc_mem_allocate(mctx, len);
+ query->ednsopts = isc_mem_allocate(isc_g_mctx, len);
for (i = 0; i < EDNSOPTS; i++) {
query->ednsopts[i].code = 0;
if (value != NULL) {
char *buf;
- buf = isc_mem_allocate(mctx, strlen(value) / 2 + 1);
+ buf = isc_mem_allocate(isc_g_mctx, strlen(value) / 2 + 1);
isc_buffer_init(&b, buf, strlen(value) / 2 + 1);
result = isc_hex_decodestring(value, &b);
CHECK("isc_hex_decodestring", result);
netmask = 0;
}
- sa = isc_mem_allocate(mctx, sizeof(*sa));
+ sa = isc_mem_allocate(isc_g_mctx, sizeof(*sa));
if (inet_pton(AF_INET6, buf, &in6) == 1) {
parsed = true;
isc_sockaddr_fromin6(sa, &in6, 0);
}
if (!state) {
if (query->ecs_addr != NULL) {
- isc_mem_free(mctx, query->ecs_addr);
+ isc_mem_free(isc_g_mctx,
+ query->ecs_addr);
}
break;
}
clone_default_query(void) {
struct query *query;
- query = isc_mem_allocate(mctx, sizeof(struct query));
+ query = isc_mem_allocate(isc_g_mctx, sizeof(struct query));
memmove(query, &default_query, sizeof(struct query));
if (default_query.ecs_addr != NULL) {
size_t len = sizeof(isc_sockaddr_t);
- query->ecs_addr = isc_mem_allocate(mctx, len);
+ query->ecs_addr = isc_mem_allocate(isc_g_mctx, len);
memmove(query->ecs_addr, default_query.ecs_addr, len);
}
}
if (query != &default_query) {
if (query->ecs_addr != NULL) {
- isc_mem_free(mctx, query->ecs_addr);
+ isc_mem_free(isc_g_mctx, query->ecs_addr);
}
- isc_mem_free(mctx, query);
+ isc_mem_free(isc_g_mctx, query);
}
}
in_port_t udpport_low, udpport_high;
isc_result_t result;
- isc_portset_create(mctx, &v4portset);
+ isc_portset_create(isc_g_mctx, &v4portset);
result = isc_net_getudpportrange(AF_INET, &udpport_low, &udpport_high);
if (result != ISC_R_SUCCESS) {
fatal("isc_net_getudpportrange (v4) failed");
isc_portset_addrange(v4portset, udpport_low, udpport_high);
- isc_portset_create(mctx, &v6portset);
+ isc_portset_create(isc_g_mctx, &v6portset);
result = isc_net_getudpportrange(AF_INET6, &udpport_low, &udpport_high);
if (result != ISC_R_SUCCESS) {
fatal("isc_net_getudpportrange (v6) failed");
fatal("dns_dispatchmgr_setavailports failed");
}
- isc_portset_destroy(mctx, &v4portset);
- isc_portset_destroy(mctx, &v6portset);
+ isc_portset_destroy(isc_g_mctx, &v4portset);
+ isc_portset_destroy(isc_g_mctx, &v6portset);
}
static void
static void
setup(void *arg ISC_ATTR_UNUSED) {
- RUNCHECK(dns_dispatchmgr_create(mctx, &dispatchmgr));
+ RUNCHECK(dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr));
set_source_ports(dispatchmgr);
dispatchmgr, have_src ? &srcaddr : &bind_any, &dispatchvx));
RUNCHECK(dns_requestmgr_create(
- mctx, dispatchmgr, have_ipv4 ? dispatchvx : NULL,
+ isc_g_mctx, dispatchmgr, have_ipv4 ? dispatchvx : NULL,
have_ipv6 ? dispatchvx : NULL, &requestmgr));
- dns_view_create(mctx, NULL, 0, "_mdig", &view);
+ dns_view_create(isc_g_mctx, NULL, 0, "_mdig", &view);
}
/*% Main processing routine for mdig */
preparse_args(argc, argv);
- isc_managers_create(&mctx, 1);
+ isc_managers_create(1);
isc_nonce_buf(cookie_secret, sizeof(cookie_secret));
if (query->ednsopts != NULL) {
for (i = 0; i < EDNSOPTS; i++) {
if (query->ednsopts[i].value != NULL) {
- isc_mem_free(mctx,
+ isc_mem_free(isc_g_mctx,
query->ednsopts[i].value);
}
}
- isc_mem_free(mctx, query->ednsopts);
+ isc_mem_free(isc_g_mctx, query->ednsopts);
}
if (query->ecs_addr != NULL) {
- isc_mem_free(mctx, query->ecs_addr);
+ isc_mem_free(isc_g_mctx, query->ecs_addr);
}
- isc_mem_free(mctx, query);
+ isc_mem_free(isc_g_mctx, query);
}
if (default_query.ecs_addr != NULL) {
- isc_mem_free(mctx, default_query.ecs_addr);
+ isc_mem_free(isc_g_mctx, default_query.ecs_addr);
}
- isc_managers_destroy(&mctx);
+ isc_managers_destroy();
return 0;
}
int
main(int argc, char **argv) {
char *file;
- isc_mem_t *mctx = NULL;
isc_result_t result;
uint32_t flags = 0U;
int ch;
}
file = argv[0];
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
setup_logging(stderr);
if (upgrade) {
flags = DNS_JOURNAL_COMPACTALL;
- result = dns_journal_compact(mctx, file, 0, flags, 0);
+ result = dns_journal_compact(isc_g_mctx, file, 0, flags, 0);
} else if (downgrade) {
flags = DNS_JOURNAL_COMPACTALL | DNS_JOURNAL_VERSION1;
- result = dns_journal_compact(mctx, file, 0, flags, 0);
+ result = dns_journal_compact(isc_g_mctx, file, 0, flags, 0);
} else if (compact) {
flags = 0;
- result = dns_journal_compact(mctx, file, serial, flags, 0);
+ result = dns_journal_compact(isc_g_mctx, file, serial, flags,
+ 0);
} else {
- result = dns_journal_print(mctx, flags, file, stdout);
+ result = dns_journal_print(isc_g_mctx, flags, file, stdout);
if (result == DNS_R_NOJOURNAL) {
fprintf(stderr, "%s\n", isc_result_totext(result));
}
}
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return result != ISC_R_SUCCESS ? 1 : 0;
}
#include <dns/name.h>
#include <dns/types.h>
-isc_mem_t *mctx = NULL;
char jbuf[PATH_MAX];
static void
return result;
}
- result = dns_db_create(mctx, ZONEDB_DEFAULT, name, dns_dbtype_zone,
- dns_rdataclass_in, 0, NULL, db);
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, name,
+ dns_dbtype_zone, dns_rdataclass_in, 0, NULL, db);
if (result != ISC_R_SUCCESS) {
return result;
}
dns_journal_t *jnl = NULL;
isc_result_t result;
- result = dns_journal_open(mctx, file, DNS_JOURNAL_READ, &jnl);
+ result = dns_journal_open(isc_g_mctx, file, DNS_JOURNAL_READ, &jnl);
if (result == ISC_R_NOTFOUND) {
return ISC_R_SUCCESS;
} else if (result != ISC_R_SUCCESS) {
journal = (const char *)jbuf;
}
- isc_mem_create(isc_commandline_progname, &mctx);
+ isc_mem_create("default", &isc_g_mctx);
logconfig = isc_logconfig_get();
isc_log_createandusechannel(
goto cleanup;
}
- result = dns_db_diff(mctx, newdb, NULL, olddb, NULL, journal);
+ result = dns_db_diff(isc_g_mctx, newdb, NULL, olddb, NULL, journal);
if (result != ISC_R_SUCCESS) {
fprintf(stderr, "Comparison failed: %s\n",
isc_result_totext(result));
dns_db_detach(&olddb);
}
- if (mctx != NULL) {
- isc_mem_detach(&mctx);
+ if (isc_g_mctx != NULL) {
+ isc_mem_detach(&isc_g_mctx);
}
return (result != ISC_R_SUCCESS) ? 1 : 0;
#include <dns/rdataclass.h>
#include <dns/rdatatype.h>
-static isc_mem_t *mctx;
static isc_lex_t *lex;
static isc_lexspecials_t specials;
isc_lex_close(lex);
isc_lex_destroy(&lex);
}
- if (mctx != NULL) {
- isc_mem_detach(&mctx);
+ if (isc_g_mctx != NULL) {
+ isc_mem_detach(&isc_g_mctx);
}
}
exit(EXIT_SUCCESS);
}
- isc_mem_create(argv[0], &mctx);
- isc_lex_create(mctx, 256, &lex);
+ isc_mem_create("default", &isc_g_mctx);
+ isc_lex_create(isc_g_mctx, 256, &lex);
/*
* Set up to lex DNS master file.
isc_buffer_init(&dbuf, data, sizeof(data));
result = dns_rdata_fromtext(&rdata, rdclass, rdtype, lex, name,
- 0, mctx, &dbuf, NULL);
+ 0, isc_g_mctx, &dbuf, NULL);
if (result != ISC_R_SUCCESS) {
fatal("dns_rdata_fromtext: %s",
isc_result_totext(result));
#pragma once
-#include <isc/netmgr.h>
-#include <isc/result.h>
-#include <isc/timer.h>
+#include <inttypes.h>
typedef struct isc_managers isc_managers_t;
void
-isc_managers_create(isc_mem_t **mctx, uint32_t workers);
+isc_managers_create(uint32_t workers);
void
-isc_managers_destroy(isc_mem_t **mctx);
+isc_managers_destroy(void);
#define ISC_MEMFLAG_DEFAULT 0
#endif /* if !ISC_MEM_USE_INTERNAL_MALLOC */
+/*%
+ * A global 'default' memory context that can be used when we don't need more
+ * specific memory context. It is always available.
+ */
+extern isc_mem_t *isc_g_mctx;
+
/*%
* isc_mem_putanddetach() is a convenience function for use where you
* have a structure with an attached memory context.
#include <isc/loop.h>
#include <isc/managers.h>
+#include <isc/mem.h>
+#include <isc/netmgr.h>
#include <isc/rwlock.h>
-#include <isc/util.h>
-#include <isc/uv.h>
void
-isc_managers_create(isc_mem_t **mctxp, uint32_t workers) {
- REQUIRE(mctxp != NULL && *mctxp == NULL);
- isc_mem_create("managers", mctxp);
- INSIST(*mctxp != NULL);
-
- isc_loopmgr_create(*mctxp, workers);
-
- isc_netmgr_create(*mctxp);
-
+isc_managers_create(uint32_t workers) {
+ isc_mem_create("default", &isc_g_mctx);
+ isc_loopmgr_create(isc_g_mctx, workers);
+ isc_netmgr_create(isc_g_mctx);
isc_rwlock_setworkers(workers);
}
void
-isc_managers_destroy(isc_mem_t **mctxp) {
- REQUIRE(mctxp != NULL && *mctxp != NULL);
-
+isc_managers_destroy(void) {
/*
* The sequence of operations here is important:
*/
-
isc_netmgr_destroy();
isc_loopmgr_destroy();
- isc_mem_detach(mctxp);
+ isc_mem_detach(&isc_g_mctx);
}
volatile void *isc__mem_malloc = mallocx;
+isc_mem_t *isc_g_mctx = NULL;
+
/*
* Constants.
*/
isc_rwlock_init(&rwl);
- isc_mem_create("test", &mctx);
+ isc_mem_create("test", &isc_g_mctx);
if (argc != 2) {
fprintf(stderr,
}
filesize = (size_t)fileoff;
- filetext = isc_mem_get(mctx, filesize + 1);
+ filetext = isc_mem_get(isc_g_mctx, filesize + 1);
fp = fopen(filename, "r");
if (fp == NULL || fread(filetext, 1, filesize, fp) < filesize) {
fprintf(stderr, "read(%s): %s\n", filename, strerror(errno));
#include <dns/types.h>
#include "dns/name.h"
+#include "tests/isc.h"
#include <tests/dns.h>
#include <tests/qp.h>
smallname_from_name(const dns_name_t *name, void **valp, uint32_t *ctxp) {
uint8_t labels = dns_name_countlabels(name);
size_t size = sizeof(isc_refcount_t) + name->length + labels;
- *valp = isc_mem_get(mctx, size);
+ *valp = isc_mem_get(isc_g_mctx, size);
*ctxp = labels << 8 | name->length;
isc_refcount_init(smallname_refcount(*valp, *ctxp), 0);
memmove(smallname_ndata(*valp, *ctxp), name->ndata, name->length);
smallname_free(void *pval, uint32_t ival) {
size_t size = sizeof(isc_refcount_t);
size += smallname_length(pval, ival) + smallname_labels(pval, ival);
- isc_mem_put(mctx, pval, size);
+ isc_mem_put(isc_g_mctx, pval, size);
}
static void
exit(EXIT_SUCCESS);
}
- isc_mem_create("test", &mctx);
+ isc_mem_create("test", &isc_g_mctx);
filename = argv[0];
result = isc_file_getsize(filename, &fileoff);
}
filesize = (size_t)fileoff;
- filetext = isc_mem_get(mctx, filesize + 1);
+ filetext = isc_mem_get(isc_g_mctx, filesize + 1);
fp = fopen(filename, "r");
if (fp == NULL || fread(filetext, 1, filesize, fp) < filesize) {
fprintf(stderr, "read(%s): %s\n", filename, strerror(errno));
fclose(fp);
filetext[filesize] = '\0';
- dns_qp_create(mctx, &methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &methods, NULL, &qp);
pos = filetext;
file_end = pos + filesize;
print_megabytes("qp-trie", bytes);
print_megabytes("qp-trie + smallnames", bytes + smallbytes);
print_megabytes("calculated", bytes + smallbytes + filesize);
- print_megabytes("allocated", isc_mem_inuse(mctx));
+ print_megabytes("allocated", isc_mem_inuse(isc_g_mctx));
printf("%6zu - height\n", qp_test_getheight(qp));
printf("%6zu - max key len\n", qp_test_maxkeylen(qp));
}
static void
smallname_from_name(const dns_name_t *name, void **valp, uint32_t *ctxp) {
size_t size = sizeof(isc_refcount_t) + name->length;
- *valp = isc_mem_get(mctx, size);
+ *valp = isc_mem_get(isc_g_mctx, size);
*ctxp = name->length;
isc_refcount_init(smallname_refcount(*valp, *ctxp), 0);
memmove(smallname_ndata(*valp, *ctxp), name->ndata, name->length);
smallname_free(void *pval, uint32_t ival) {
size_t size = sizeof(isc_refcount_t);
size += smallname_length(pval, ival);
- isc_mem_put(mctx, pval, size);
+ isc_mem_put(isc_g_mctx, pval, size);
}
static void
}
filesize = (size_t)fileoff;
- filetext = isc_mem_get(mctx, filesize + 1);
+ filetext = isc_mem_get(isc_g_mctx, filesize + 1);
fp = fopen(filename, "r");
if (fp == NULL || fread(filetext, 1, filesize, fp) < filesize) {
fprintf(stderr, "read(%s): %s\n", filename, strerror(errno));
usage();
}
- isc_mem_create("test", &mctx);
+ isc_mem_create("test", &isc_g_mctx);
- dns_qp_create(mctx, &methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &methods, NULL, &qp);
start = isc_time_monotonic();
n = load_qp(qp, argv[1]);
snprintf(buf, sizeof(buf), "load %zd names:", n);
printf("%-57s%7.3fsec\n", buf, (stop - start) / (double)NS_PER_SEC);
- items = isc_mem_cget(mctx, n, sizeof(dns_fixedname_t));
+ items = isc_mem_cget(isc_g_mctx, n, sizeof(dns_fixedname_t));
dns_qpiter_init(qp, &it);
start = isc_time_monotonic();
"look up %zd wrong names (dns_qp_lookup):", n);
printf("%-57s%7.3fsec\n", buf, (stop - start) / (double)NS_PER_SEC);
- isc_mem_cput(mctx, items, n, sizeof(dns_fixedname_t));
+ isc_mem_cput(isc_g_mctx, items, n, sizeof(dns_fixedname_t));
return 0;
}
UNUSED(state);
- result = dns_acl_any(mctx, &any);
+ result = dns_acl_any(isc_g_mctx, &any);
assert_int_equal(result, ISC_R_SUCCESS);
- result = dns_acl_none(mctx, &none);
+ result = dns_acl_none(isc_g_mctx, &none);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_acl_create(mctx, 1, ¬none);
+ dns_acl_create(isc_g_mctx, 1, ¬none);
- dns_acl_create(mctx, 1, ¬any);
+ dns_acl_create(isc_g_mctx, 1, ¬any);
result = dns_acl_merge(notnone, none, false);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(result, ISC_R_SUCCESS);
#if defined(HAVE_GEOIP2)
- dns_acl_create(mctx, 1, &geoip);
+ dns_acl_create(isc_g_mctx, 1, &geoip);
de = geoip->elements;
assert_non_null(de);
de->node_num = dns_acl_node_count(geoip);
geoip->length++;
- dns_acl_create(mctx, 1, ¬geoip);
+ dns_acl_create(isc_g_mctx, 1, ¬geoip);
result = dns_acl_merge(notgeoip, geoip, false);
assert_int_equal(result, ISC_R_SUCCESS);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
- bc = dns_badcache_new(mctx);
+ bc = dns_badcache_new(isc_g_mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
flags = 0;
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
- bc = dns_badcache_new(mctx);
+ bc = dns_badcache_new(isc_g_mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
dns_badcache_add(bc, name, dns_rdatatype_a, flags, now + 60);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
- bc = dns_badcache_new(mctx);
+ bc = dns_badcache_new(isc_g_mctx);
dns_badcache_add(bc, name, dns_rdatatype_a, flags, expire);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, expire);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
- bc = dns_badcache_new(mctx);
+ bc = dns_badcache_new(isc_g_mctx);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
result = dns_badcache_find(bc, name, dns_rdatatype_aaaa, &flags, now);
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
- bc = dns_badcache_new(mctx);
+ bc = dns_badcache_new(isc_g_mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
- bc = dns_badcache_new(mctx);
+ bc = dns_badcache_new(isc_g_mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now + 60);
isc_result_t result;
uint32_t flags = BADCACHE_TEST_FLAG;
- bc = dns_badcache_new(mctx);
+ bc = dns_badcache_new(isc_g_mctx);
dns_name_fromstring(name, "example.com.", NULL, 0, NULL);
dns_badcache_add(bc, name, dns_rdatatype_aaaa, flags, now);
dns_dbnode_t *node = NULL;
isc_result_t result;
- result = dns_db_create(mctx, ZONEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, dns_rootname,
dns_dbtype_zone, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
isc_result_t result;
dns_ttl_t ttl;
- result = dns_db_create(mctx, CACHEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(isc_g_mctx, CACHEDB_DEFAULT, dns_rootname,
dns_dbtype_cache, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
isc_result_t result;
unsigned char data[] = { 0x0a, 0x00, 0x00, 0x01 };
- result = dns_db_create(mctx, CACHEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(isc_g_mctx, CACHEDB_DEFAULT, dns_rootname,
dns_dbtype_cache, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
isc_result_t result;
dns_db_t *db = NULL;
- result = dns_db_create(mctx, ZONEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, dns_rootname,
dns_dbtype_zone, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
dns_db_t *db = NULL;
/* DB has zone semantics */
- result = dns_db_create(mctx, ZONEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, dns_rootname,
dns_dbtype_zone, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
dns_db_detach(&db);
/* DB has cache semantics */
- result = dns_db_create(mctx, CACHEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(isc_g_mctx, CACHEDB_DEFAULT, dns_rootname,
dns_dbtype_cache, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
test_create(TESTS_DIR "/testdata/diff/zone1.data", &olddb,
TESTS_DIR "/testdata/diff/zone1.data", &newdb);
- dns_diff_init(mctx, &diff);
+ dns_diff_init(isc_g_mctx, &diff);
result = dns_db_diffx(&diff, newdb, NULL, olddb, NULL, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
test_create(TESTS_DIR "/testdata/diff/zone1.data", &olddb,
TESTS_DIR "/testdata/diff/zone2.data", &newdb);
- dns_diff_init(mctx, &diff);
+ dns_diff_init(isc_g_mctx, &diff);
result = dns_db_diffx(&diff, newdb, NULL, olddb, NULL, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
test_create(TESTS_DIR "/testdata/diff/zone1.data", &olddb,
TESTS_DIR "/testdata/diff/zone3.data", &newdb);
- dns_diff_init(mctx, &diff);
+ dns_diff_init(isc_g_mctx, &diff);
result = dns_db_diffx(&diff, newdb, NULL, olddb, NULL, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
isc_assertion_setcallback(local_callback);
- res = dns_db_create(mctx, ZONEDB_DEFAULT, dns_rootname, dns_dbtype_zone,
- dns_rdataclass_in, 0, NULL, &db1);
+ res = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, dns_rootname,
+ dns_dbtype_zone, dns_rdataclass_in, 0, NULL, &db1);
assert_int_equal(res, ISC_R_SUCCESS);
dns_db_newversion(db1, &v1);
assert_non_null(v1);
- res = dns_db_create(mctx, ZONEDB_DEFAULT, dns_rootname, dns_dbtype_zone,
- dns_rdataclass_in, 0, NULL, &db2);
+ res = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, dns_rootname,
+ dns_dbtype_zone, dns_rdataclass_in, 0, NULL, &db2);
assert_int_equal(res, ISC_R_SUCCESS);
dns_db_newversion(db2, &v2);
assert_non_null(v1);
ISC_RUN_TEST_IMPL(dns_diff_size) {
dns_diff_t diff;
- dns_diff_init(mctx, &diff);
+ dns_diff_init(isc_g_mctx, &diff);
assert_true(dns_diff_size(&diff) == 0);
}
dns_difftuple_t *tup_1 = NULL, *tup_2 = NULL, *tup_3 = NULL;
- dns_difftuple_create(mctx, DNS_DIFFOP_ADD, &name_1, 1, &rdatas[0],
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_ADD, &name_1, 1, &rdatas[0],
&tup_1);
- dns_difftuple_create(mctx, DNS_DIFFOP_DEL, &name_2, 1, &rdatas[1],
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_DEL, &name_2, 1, &rdatas[1],
&tup_2);
- dns_difftuple_create(mctx, DNS_DIFFOP_DEL, &name_3, 1, &rdatas[2],
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_DEL, &name_3, 1, &rdatas[2],
&tup_3);
dns_difftuple_t *tup_dup = NULL, *tup_nodup = NULL;
- dns_difftuple_create(mctx, DNS_DIFFOP_DEL, &name_dup, 1, &rdatas[3],
- &tup_dup);
- dns_difftuple_create(mctx, DNS_DIFFOP_ADD, &name_nodup, 1, &rdatas[4],
- &tup_nodup);
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_DEL, &name_dup, 1,
+ &rdatas[3], &tup_dup);
+ dns_difftuple_create(isc_g_mctx, DNS_DIFFOP_ADD, &name_nodup, 1,
+ &rdatas[4], &tup_nodup);
dns_diff_append(&diff, &tup_1);
assert_true(dns_diff_size(&diff) == 1);
dns_dispatch_done(&test->dispentry);
dns_dispatch_detach(&test->dispatch);
dns_dispatchmgr_detach(&test->dispatchmgr);
- isc_mem_put(mctx, test, sizeof(*test));
+ isc_mem_put(isc_g_mctx, test, sizeof(*test));
}
static void
uv_os_sock_t socket = -1;
/* Create just 1 loop for this test */
- isc_loopmgr_create(mctx, 1);
+ isc_loopmgr_create(isc_g_mctx, 1);
setup_netmgr(state);
testdata.region.length = sizeof(testdata.rbuf);
memset(testdata.message, 0, sizeof(testdata.message));
- isc_tlsctx_cache_create(mctx, &tls_tlsctx_client_cache);
+ isc_tlsctx_cache_create(isc_g_mctx, &tls_tlsctx_client_cache);
if (isc_tlsctx_createserver(NULL, NULL, &tls_listen_tlsctx) !=
ISC_R_SUCCESS)
{
return -1;
}
- transport_list = dns_transport_list_new(mctx);
+ transport_list = dns_transport_list_new(isc_g_mctx);
tls_transport = dns_transport_new(tls_name, DNS_TRANSPORT_TLS,
transport_list);
dns_transport_set_tlsname(tls_transport, tls_name_str);
return result;
}
- result = dns_dispatchset_create(mctx, disp, dsetp, ndisps);
+ result = dns_dispatchset_create(isc_g_mctx, disp, dsetp, ndisps);
dns_dispatch_detach(&disp);
return result;
UNUSED(arg);
- result = dns_dispatchmgr_create(mctx, &dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_dispatchset(dispatchmgr, 1, &dset);
UNUSED(arg);
- result = dns_dispatchmgr_create(mctx, &dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = make_dispatchset(dispatchmgr, 1, &dset);
/* Client 2 */
isc_result_t result;
- test_dispatch_t *test2 = isc_mem_get(mctx, sizeof(*test2));
+ test_dispatch_t *test2 = isc_mem_get(isc_g_mctx, sizeof(*test2));
*test2 = (test_dispatch_t){
.dispatchmgr = dns_dispatchmgr_ref(test1->dispatchmgr),
};
/* Client - unshared */
isc_result_t result;
- test_dispatch_t *test4 = isc_mem_get(mctx, sizeof(*test4));
+ test_dispatch_t *test4 = isc_mem_get(isc_g_mctx, sizeof(*test4));
*test4 = (test_dispatch_t){
.dispatchmgr = dns_dispatchmgr_ref(test3->dispatchmgr),
};
ISC_LOOP_TEST_IMPL(dispatch_timeout_tcp_connect) {
isc_result_t result;
- test_dispatch_t *test = isc_mem_get(mctx, sizeof(*test));
+ test_dispatch_t *test = isc_mem_get(isc_g_mctx, sizeof(*test));
*test = (test_dispatch_t){ 0 };
/* Client */
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
ISC_LOOP_TEST_IMPL(dispatch_timeout_tcp_response) {
isc_result_t result;
- test_dispatch_t *test = isc_mem_get(mctx, sizeof(*test));
+ test_dispatch_t *test = isc_mem_get(isc_g_mctx, sizeof(*test));
*test = (test_dispatch_t){ 0 };
/* Server */
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
- result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
ISC_LOOP_TEST_IMPL(dispatch_tcp_response) {
isc_result_t result;
- test_dispatch_t *test = isc_mem_get(mctx, sizeof(*test));
+ test_dispatch_t *test = isc_mem_get(isc_g_mctx, sizeof(*test));
*test = (test_dispatch_t){ 0 };
/* Server */
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tcp_connect_addr,
ISC_LOOP_TEST_IMPL(dispatch_tls_response) {
isc_result_t result;
- test_dispatch_t *test = isc_mem_get(mctx, sizeof(*test));
+ test_dispatch_t *test = isc_mem_get(isc_g_mctx, sizeof(*test));
*test = (test_dispatch_t){ 0 };
/* Server */
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(test->dispatchmgr, &tls_connect_addr,
ISC_LOOP_TEST_IMPL(dispatch_timeout_udp_response) {
isc_result_t result;
- test_dispatch_t *test = isc_mem_get(mctx, sizeof(*test));
+ test_dispatch_t *test = isc_mem_get(isc_g_mctx, sizeof(*test));
*test = (test_dispatch_t){ 0 };
/* Server */
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client */
- result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createudp(test->dispatchmgr, &udp_connect_addr,
/* test dispatch getnext */
ISC_LOOP_TEST_IMPL(dispatch_getnext) {
isc_result_t result;
- test_dispatch_t *test = isc_mem_get(mctx, sizeof(*test));
+ test_dispatch_t *test = isc_mem_get(isc_g_mctx, sizeof(*test));
*test = (test_dispatch_t){ 0 };
/* Server */
testdata.region.base = testdata.message;
testdata.region.length = sizeof(testdata.message);
- result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createudp(test->dispatchmgr, &udp_connect_addr,
ISC_LOOP_TEST_IMPL(dispatch_gettcp) {
isc_result_t result;
- test_dispatch_t *test = isc_mem_get(mctx, sizeof(*test));
+ test_dispatch_t *test = isc_mem_get(isc_g_mctx, sizeof(*test));
*test = (test_dispatch_t){ 0 };
/* Server */
/* ensure we stop listening after the test is done */
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
- result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
/* Client */
ISC_LOOP_TEST_IMPL(dispatch_newtcp) {
isc_result_t result;
- test_dispatch_t *test = isc_mem_get(mctx, sizeof(*test));
+ test_dispatch_t *test = isc_mem_get(isc_g_mctx, sizeof(*test));
*test = (test_dispatch_t){ 0 };
/* Server */
isc_loop_teardown(isc_loop_main(), stop_listening, sock);
/* Client - unshared */
- result = dns_dispatchmgr_create(mctx, &test->dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &test->dispatchmgr);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_dispatch_createtcp(
assert_non_null(fopt);
fstrm_iothr_options_set_num_input_queues(fopt, 1);
- result = dns_dt_create(mctx, dns_dtmode_file, TAPFILE, &fopt, NULL,
- &dtenv);
+ result = dns_dt_create(isc_g_mctx, dns_dtmode_file, TAPFILE, &fopt,
+ NULL, &dtenv);
assert_int_equal(result, ISC_R_SUCCESS);
if (dtenv != NULL) {
dns_dt_detach(&dtenv);
assert_non_null(fopt);
fstrm_iothr_options_set_num_input_queues(fopt, 1);
- result = dns_dt_create(mctx, dns_dtmode_unix, TAPSOCK, &fopt, NULL,
- &dtenv);
+ result = dns_dt_create(isc_g_mctx, dns_dtmode_unix, TAPSOCK, &fopt,
+ NULL, &dtenv);
assert_int_equal(result, ISC_R_SUCCESS);
if (dtenv != NULL) {
dns_dt_detach(&dtenv);
assert_non_null(fopt);
fstrm_iothr_options_set_num_input_queues(fopt, 1);
- result = dns_dt_create(mctx, 33, TAPSOCK, &fopt, NULL, &dtenv);
+ result = dns_dt_create(isc_g_mctx, 33, TAPSOCK, &fopt, NULL, &dtenv);
assert_int_equal(result, ISC_R_FAILURE);
assert_null(dtenv);
if (dtenv != NULL) {
assert_non_null(fopt);
fstrm_iothr_options_set_num_input_queues(fopt, 1);
- result = dns_dt_create(mctx, dns_dtmode_file, TAPFILE, &fopt, NULL,
- &dtenv);
+ result = dns_dt_create(isc_g_mctx, dns_dtmode_file, TAPFILE, &fopt,
+ NULL, &dtenv);
assert_int_equal(result, ISC_R_SUCCESS);
dns_dt_attach(dtenv, &view->dtenv);
memset(&zr, 0, sizeof(zr));
isc_buffer_init(&zb, zone, sizeof(zone));
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
dns_compress_setpermitted(&cctx, false);
result = dns_name_towire(zname, &cctx, &zb);
assert_int_equal(result, ISC_R_SUCCESS);
dns_dt_detach(&dtenv);
dns_view_detach(&view);
- result = dns_dt_open(TAPFILE, dns_dtmode_file, mctx, &handle);
+ result = dns_dt_open(TAPFILE, dns_dtmode_file, isc_g_mctx, &handle);
assert_int_equal(result, ISC_R_SUCCESS);
while (dns_dt_getframe(handle, &data, &dsize) == ISC_R_SUCCESS) {
r.base = data;
r.length = dsize;
- result = dns_dt_parse(mctx, &r, &dtdata);
+ result = dns_dt_parse(isc_g_mctx, &r, &dtdata);
assert_int_equal(result, ISC_R_SUCCESS);
if (result != ISC_R_SUCCESS) {
n++;
size_t dsize;
FILE *fp = NULL;
- result = dns_dt_open(TAPSAVED, dns_dtmode_file, mctx, &handle);
+ result = dns_dt_open(TAPSAVED, dns_dtmode_file, isc_g_mctx, &handle);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_stdio_open(TAPTEXT, "r", &fp);
}
/* parse dnstap frame */
- result = dns_dt_parse(mctx, &r, &dtdata);
+ result = dns_dt_parse(isc_g_mctx, &r, &dtdata);
assert_int_equal(result, ISC_R_SUCCESS);
if (result != ISC_R_SUCCESS) {
continue;
}
- isc_buffer_allocate(mctx, &b, 2048);
+ isc_buffer_allocate(isc_g_mctx, &b, 2048);
assert_non_null(b);
if (b == NULL) {
break;
result = isc_file_getsizefd(fileno(fp), &size);
assert_int_equal(result, ISC_R_SUCCESS);
- data = isc_mem_get(mctx, size + 1);
+ data = isc_mem_get(isc_g_mctx, size + 1);
assert_non_null(data);
len = (size_t)size;
result = ISC_R_SUCCESS;
err:
- isc_mem_put(mctx, data, size + 1);
+ isc_mem_put(isc_g_mctx, data, size + 1);
return result;
}
result = isc_file_getsizefd(fileno(fp), &size);
assert_int_equal(result, ISC_R_SUCCESS);
- data = isc_mem_get(mctx, size + 1);
+ data = isc_mem_get(isc_g_mctx, size + 1);
assert_non_null(data);
p = data;
result = dns_name_fromtext(name, &b, dns_rootname, 0);
assert_int_equal(result, ISC_R_SUCCESS);
result = dst_key_fromfile(name, id, alg, type,
- TESTS_DIR "/testdata/dst", mctx, &key);
+ TESTS_DIR "/testdata/dst", isc_g_mctx, &key);
assert_int_equal(result, ISC_R_SUCCESS);
isc_buffer_init(&databuf, data, (unsigned int)size);
*/
isc_buffer_remainingregion(&sigbuf, &sigreg);
- result = dst_context_create(key, mctx, DNS_LOGCATEGORY_GENERAL, false,
- &ctx);
+ result = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_GENERAL,
+ false, &ctx);
assert_int_equal(result, ISC_R_SUCCESS);
result = dst_context_adddata(ctx, &datareg);
isc_result_t result2;
dst_context_destroy(&ctx);
- result2 = dst_context_create(key, mctx, DNS_LOGCATEGORY_GENERAL,
- false, &ctx);
+ result2 = dst_context_create(
+ key, isc_g_mctx, DNS_LOGCATEGORY_GENERAL, false, &ctx);
assert_int_equal(result2, ISC_R_SUCCESS);
result2 = dst_context_adddata(ctx, &datareg);
fprintf(stderr, "# %s:\n# %s\n", sigpath, hexbuf);
}
- isc_mem_put(mctx, data, size + 1);
+ isc_mem_put(isc_g_mctx, data, size + 1);
dst_context_destroy(&ctx);
dst_key_free(&key);
result = dns_name_fromtext(name1, &b1, dns_rootname, 0);
assert_int_equal(result, ISC_R_SUCCESS);
result = dst_key_fromfile(name1, key1_id, alg, type,
- TESTS_DIR "/comparekeys", mctx, &key1);
+ TESTS_DIR "/comparekeys", isc_g_mctx, &key1);
assert_int_equal(result, ISC_R_SUCCESS);
/*
result = dns_name_fromtext(name2, &b2, dns_rootname, 0);
assert_int_equal(result, ISC_R_SUCCESS);
result = dst_key_fromfile(name2, key2_id, alg, type,
- TESTS_DIR "/comparekeys", mctx, &key2);
+ TESTS_DIR "/comparekeys", isc_g_mctx, &key2);
assert_int_equal(result, ISC_R_SUCCESS);
/*
assert_int_equal(result, ISC_R_SUCCESS);
result = dst_key_fromfile(name, 19786, DST_ALG_ECDSA256,
DST_TYPE_PUBLIC | DST_TYPE_PRIVATE,
- TESTS_DIR "/comparekeys", mctx, &key);
+ TESTS_DIR "/comparekeys", isc_g_mctx, &key);
assert_int_equal(result, ISC_R_SUCCESS);
result = dst_key_sigsize(key, &siglen);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_buffer_allocate(mctx, &sigbuf1, siglen);
- result = dst_context_create(key, mctx, DNS_LOGCATEGORY_GENERAL, true,
- &ctx);
+ isc_buffer_allocate(isc_g_mctx, &sigbuf1, siglen);
+ result = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_GENERAL,
+ true, &ctx);
assert_int_equal(result, ISC_R_SUCCESS);
result = dst_context_sign(ctx, sigbuf1);
assert_int_equal(result, ISC_R_SUCCESS);
dst_context_destroy(&ctx);
- isc_buffer_allocate(mctx, &sigbuf2, siglen);
- result = dst_context_create(key, mctx, DNS_LOGCATEGORY_GENERAL, true,
- &ctx);
+ isc_buffer_allocate(isc_g_mctx, &sigbuf2, siglen);
+ result = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_GENERAL,
+ true, &ctx);
assert_int_equal(result, ISC_R_SUCCESS);
result = dst_context_sign(ctx, sigbuf2);
assert_int_equal(result, ISC_R_SUCCESS);
ISC_RUN_TEST_IMPL(dns_ede_test_text_max_count) {
dns_edectx_t edectx;
- dns_ede_init(mctx, &edectx);
+ dns_ede_init(isc_g_mctx, &edectx);
const char *txt1 = "foobar";
const char *txt2 = "It's been a long time since I rock-and-rolled"
ISC_RUN_TEST_IMPL(dns_ede_test_max_count) {
dns_edectx_t edectx;
- dns_ede_init(mctx, &edectx);
+ dns_ede_init(isc_g_mctx, &edectx);
dns_ede_add(&edectx, 1, NULL);
dns_ede_add(&edectx, 22, "two");
ISC_RUN_TEST_IMPL(dns_ede_test_duplicates) {
dns_edectx_t edectx;
- dns_ede_init(mctx, &edectx);
+ dns_ede_init(isc_g_mctx, &edectx);
dns_ede_add(&edectx, 1, NULL);
dns_ede_add(&edectx, 1, "two");
ISC_RUN_TEST_IMPL(dns_ede_test_infocode_range) {
dns_edectx_t edectx;
- dns_ede_init(mctx, &edectx);
+ dns_ede_init(isc_g_mctx, &edectx);
dns_ede_add(&edectx, 1, NULL);
expect_assert_failure(dns_ede_add(&edectx, 32, NULL));
dns_edectx_t edectx2;
dns_edectx_t edectx3;
- dns_ede_init(mctx, &edectx1);
- dns_ede_init(mctx, &edectx2);
+ dns_ede_init(isc_g_mctx, &edectx1);
+ dns_ede_init(isc_g_mctx, &edectx2);
dns_ede_add(&edectx1, 1, NULL);
dns_ede_add(&edectx1, 2, "two-the-first");
dns_ede_test_equals(expected2, 3, &edectx2);
dns_ede_test_equals(expected, 3, &edectx1);
- dns_ede_init(mctx, &edectx3);
+ dns_ede_init(isc_g_mctx, &edectx3);
dns_ede_add(&edectx3, 2, "two-the-third");
dns_ede_copy(&edectx3, &edectx2);
keystruct->common.rdclass = rdclass;
keystruct->common.rdtype = dns_rdatatype_dnskey;
- keystruct->mctx = mctx;
+ keystruct->mctx = isc_g_mctx;
keystruct->flags = flags;
keystruct->protocol = proto;
keystruct->algorithm = alg;
ISC_R_SUCCESS);
isc_buffer_usedregion(&keydatabuf, &r);
keystruct->datalen = r.length;
- keystruct->data = isc_mem_allocate(mctx, r.length);
+ keystruct->data = isc_mem_allocate(isc_g_mctx, r.length);
memmove(keystruct->data, r.base, r.length);
}
result = dns_master_loadfile(testfile, dns_origin, dns_origin,
dns_rdataclass_in, true, 0, &callbacks,
- NULL, NULL, mctx, format, 0);
+ NULL, NULL, isc_g_mctx, format, 0);
return result;
}
static void
include_callback(const char *filename, void *arg) {
char **argp = (char **)arg;
- *argp = isc_mem_strdup(mctx, filename);
+ *argp = isc_mem_strdup(isc_g_mctx, filename);
}
/*
result = dns_master_loadfile(TESTS_DIR "/testdata/master/master8.data",
dns_origin, dns_origin, dns_rdataclass_in,
0, true, &callbacks, include_callback,
- &filename, mctx, dns_masterformat_text, 0);
+ &filename, isc_g_mctx,
+ dns_masterformat_text, 0);
assert_int_equal(result, DNS_R_SEENINCLUDE);
assert_non_null(filename);
if (filename != NULL) {
assert_string_equal(filename, "testdata/master/master6.data");
- isc_mem_free(mctx, filename);
+ isc_mem_free(isc_g_mctx, filename);
}
}
result = setup_master(nullmsg, nullmsg);
assert_int_equal(result, ISC_R_SUCCESS);
- result = dns_db_create(mctx, ZONEDB_DEFAULT, dns_origin,
+ result = dns_db_create(isc_g_mctx, ZONEDB_DEFAULT, dns_origin,
dns_dbtype_zone, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
dns_db_currentversion(db, &version);
- result = dns_master_dump(mctx, db, version, &dns_master_style_default,
- "test.dump", dns_masterformat_raw, NULL);
+ result = dns_master_dump(isc_g_mctx, db, version,
+ &dns_master_style_default, "test.dump",
+ dns_masterformat_raw, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = test_master(NULL, "test.dump", dns_masterformat_raw, nullmsg,
header.flags |= DNS_MASTERRAW_SOURCESERIALSET;
unlink("test.dump");
- result = dns_master_dump(mctx, db, version, &dns_master_style_default,
- "test.dump", dns_masterformat_raw, &header);
+ result = dns_master_dump(isc_g_mctx, db, version,
+ &dns_master_style_default, "test.dump",
+ dns_masterformat_raw, &header);
assert_int_equal(result, ISC_R_SUCCESS);
result = test_master(NULL, "test.dump", dns_masterformat_raw, nullmsg,
/* Test 1: off, rdata */
permitted = false;
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test2: on, rdata */
permitted = true;
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test3: off, disabled, rdata */
permitted = false;
- dns_compress_init(&cctx, mctx, DNS_COMPRESS_DISABLED);
+ dns_compress_init(&cctx, isc_g_mctx, DNS_COMPRESS_DISABLED);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test4: on, disabled, rdata */
permitted = true;
- dns_compress_init(&cctx, mctx, DNS_COMPRESS_DISABLED);
+ dns_compress_init(&cctx, isc_g_mctx, DNS_COMPRESS_DISABLED);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test5: on, rdata */
permitted = true;
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test 6: off, owner */
permitted = false;
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test7: on, owner */
permitted = true;
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test8: off, disabled, owner */
permitted = false;
- dns_compress_init(&cctx, mctx, DNS_COMPRESS_DISABLED);
+ dns_compress_init(&cctx, isc_g_mctx, DNS_COMPRESS_DISABLED);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test9: on, disabled, owner */
permitted = true;
- dns_compress_init(&cctx, mctx, DNS_COMPRESS_DISABLED);
+ dns_compress_init(&cctx, isc_g_mctx, DNS_COMPRESS_DISABLED);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
/* Test10: on, owner */
permitted = true;
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
dns_compress_setpermitted(&cctx, permitted);
dctx = dns_decompress_setpermitted(DNS_DECOMPRESS_DEFAULT, permitted);
dns_name_t name;
char namebuf[256];
- dns_compress_init(&cctx, mctx, DNS_COMPRESS_LARGE);
+ dns_compress_init(&cctx, isc_g_mctx, DNS_COMPRESS_LARGE);
isc_buffer_init(&message, msgbuf, sizeof(msgbuf));
dns_name_init(&name);
dns_fixedname_t fn;
dns_name_t *name = dns_fixedname_name(&fn);
- dns_nametree_create(mctx, DNS_NAMETREE_BOOL, "bool test", &booltree);
- dns_nametree_create(mctx, DNS_NAMETREE_BITS, "bits test", &bitstree);
- dns_nametree_create(mctx, DNS_NAMETREE_COUNT, "count test", &counttree);
+ dns_nametree_create(isc_g_mctx, DNS_NAMETREE_BOOL, "bool test",
+ &booltree);
+ dns_nametree_create(isc_g_mctx, DNS_NAMETREE_BITS, "bits test",
+ &bitstree);
+ dns_nametree_create(isc_g_mctx, DNS_NAMETREE_COUNT, "count test",
+ &counttree);
/* Add a positive boolean node */
dns_test_namefromstring("example.com.", &fn);
void *pval = NULL;
isc_result_t result;
- dns_qp_create(mctx, &qpiter_methods, item, &qp);
+ dns_qp_create(isc_g_mctx, &qpiter_methods, item, &qp);
for (size_t tests = 0; tests < 1234; tests++) {
ival = isc_random_uniform(ITER_ITEMS - 1) + 1;
pval = &item[ival];
dns_qp_t *qp = NULL;
int i = 0;
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
/*
* Fixed size strings [16] should ensure leaf-compatible alignment.
"b.a.", "x.k.c.d.", "" };
int i = 0;
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
while (insert[i][0] != '\0') {
insert_name(qp, insert[i], DNS_DBNAMESPACE_NORMAL);
i = 0;
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
while (insert2[i][0] != '\0') {
insert_name(qp, insert2[i], DNS_DBNAMESPACE_NORMAL);
dns_name_t *expred = dns_fixedname_initname(&fn3);
char *predstr = NULL;
dns_test_namefromstring(check[i].predecessor, &fn3);
- result = dns_name_tostring(expred, &predstr, mctx);
+ result = dns_name_tostring(expred, &predstr, isc_g_mctx);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_qp_lookup(qp, name, check[i].space, NULL, &it,
}
assert_int_equal(result, ISC_R_SUCCESS);
- result = dns_name_tostring(pred, &namestr, mctx);
+ result = dns_name_tostring(pred, &namestr, isc_g_mctx);
#if 0
fprintf(stderr, "... expected predecessor %s %u got %s %u\n",
predstr, check[i].pspace, namestr, ival);
#if 0
fprintf(stderr, "%d: remaining names after %s:\n", i, namestr);
#endif
- isc_mem_free(mctx, namestr);
- isc_mem_free(mctx, predstr);
+ isc_mem_free(isc_g_mctx, namestr);
+ isc_mem_free(isc_g_mctx, predstr);
int j = 0;
while (dns_qpiter_next(&it, name, NULL, NULL) == ISC_R_SUCCESS)
{
#if 0
- result = dns_name_tostring(name, &namestr, mctx);
+ result = dns_name_tostring(name, &namestr, isc_g_mctx);
assert_int_equal(result, ISC_R_SUCCESS);
fprintf(stderr, "%s%s", j > 0 ? "->" : "", namestr);
- isc_mem_free(mctx, namestr);
+ isc_mem_free(isc_g_mctx, namestr);
#endif
j++;
}
};
int i = 0;
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
while (insert[i][0] != '\0') {
insert_name(qp, insert[i], DNS_DBNAMESPACE_NORMAL);
insert_name(qp, insert[i], DNS_DBNAMESPACE_NSEC);
"" };
int i = 0;
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
while (insert1[i][0] != '\0') {
insert_name(qp, insert1[i], DNS_DBNAMESPACE_NORMAL);
insert_name(qp, insert1[i], DNS_DBNAMESPACE_NSEC);
const char insert2[][64] = { ".", "abb.", "abc.", "" };
i = 0;
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
while (insert2[i][0] != '\0') {
insert_name(qp, insert2[i], DNS_DBNAMESPACE_NORMAL);
insert_name(qp, insert2[i], DNS_DBNAMESPACE_NSEC);
"" };
i = 0;
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
while (insert3[i][0] != '\0') {
insert_name(qp, insert3[i], DNS_DBNAMESPACE_NORMAL);
insert_name(qp, insert3[i], DNS_DBNAMESPACE_NSEC);
"\\000\\009.", "" };
i = 0;
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
while (insert4[i][0] != '\0') {
insert_name(qp, insert4[i], DNS_DBNAMESPACE_NORMAL);
insert_name(qp, insert4[i], DNS_DBNAMESPACE_NSEC);
* NSEC3: c.d.
*/
- dns_qp_create(mctx, &string_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &string_methods, NULL, &qp);
while (insert1[i].name[0] != '\0') {
insert_name(qp, insert1[i].name, insert1[i].space);
size_t lowater = maxcache - (maxcache >> 2); /* ditto */
isc_result_t result;
dns_db_t *db = NULL;
- isc_mem_t *mctx2 = NULL;
+ isc_mem_t *mctx = NULL;
isc_stdtime_t now = isc_stdtime_now();
size_t i;
- isc_mem_create("test", &mctx2);
+ isc_mem_create("test", &mctx);
- result = dns_db_create(mctx2, CACHEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(mctx, CACHEDB_DEFAULT, dns_rootname,
dns_dbtype_cache, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_mem_setwater(mctx2, hiwater, lowater);
+ isc_mem_setwater(mctx, hiwater, lowater);
/*
* Add cache entries with minimum size of data until 'overmem'
* This should eventually happen, but we also limit the number of
* iteration to avoid an infinite loop in case something gets wrong.
*/
- for (i = 0; !isc_mem_isovermem(mctx2) && i < (maxcache / 10); i++) {
+ for (i = 0; !isc_mem_isovermem(mctx) && i < (maxcache / 10); i++) {
overmempurge_addrdataset(db, now, i, 50053, 0, false);
}
- assert_true(isc_mem_isovermem(mctx2));
+ assert_true(isc_mem_isovermem(mctx));
/*
* Then try to add the same number of entries, each has very large data.
cleanup_all_deadnodes(db);
if (verbose) {
print_message("# inuse: %zd max: %zd\n",
- isc_mem_inuse(mctx2), maxcache);
+ isc_mem_inuse(mctx), maxcache);
}
- assert_true(isc_mem_inuse(mctx2) < maxcache);
+ assert_true(isc_mem_inuse(mctx) < maxcache);
}
dns_db_detach(&db);
- isc_mem_detach(&mctx2);
+ isc_mem_detach(&mctx);
isc_loopmgr_shutdown();
}
size_t lowater = maxcache - (maxcache >> 2); /* ditto */
isc_result_t result;
dns_db_t *db = NULL;
- isc_mem_t *mctx2 = NULL;
+ isc_mem_t *mctx = NULL;
isc_stdtime_t now = isc_stdtime_now();
size_t i;
- isc_mem_create("test", &mctx2);
+ isc_mem_create("test", &mctx);
- result = dns_db_create(mctx2, CACHEDB_DEFAULT, dns_rootname,
+ result = dns_db_create(mctx, CACHEDB_DEFAULT, dns_rootname,
dns_dbtype_cache, dns_rdataclass_in, 0, NULL,
&db);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_mem_setwater(mctx2, hiwater, lowater);
+ isc_mem_setwater(mctx, hiwater, lowater);
/*
* Add cache entries with minimum size of data until 'overmem'
* This should eventually happen, but we also limit the number of
* iteration to avoid an infinite loop in case something gets wrong.
*/
- for (i = 0; !isc_mem_isovermem(mctx2) && i < (maxcache / 10); i++) {
+ for (i = 0; !isc_mem_isovermem(mctx) && i < (maxcache / 10); i++) {
overmempurge_addrdataset(db, now, i, 50053, 0, false);
}
- assert_true(isc_mem_isovermem(mctx2));
+ assert_true(isc_mem_isovermem(mctx));
/*
* Then try to add the same number of entries, each has very long name.
cleanup_all_deadnodes(db);
if (verbose) {
print_message("# inuse: %zd max: %zd\n",
- isc_mem_inuse(mctx2), maxcache);
+ isc_mem_inuse(mctx), maxcache);
}
- assert_true(isc_mem_inuse(mctx2) < maxcache);
+ assert_true(isc_mem_inuse(mctx) < maxcache);
}
dns_db_detach(&db);
- isc_mem_detach(&mctx2);
+ isc_mem_detach(&mctx);
isc_loopmgr_shutdown();
}
setup_items(void) {
void *pval = NULL;
dns_qp_t *qp = NULL;
- dns_qp_create(mctx, &test_methods, NULL, &qp);
+ dns_qp_create(isc_g_mctx, &test_methods, NULL, &qp);
for (size_t i = 0; i < ARRAY_SIZE(item); i++) {
do {
size_t len = isc_random_uniform(16) + 4;
UNUSED(arg);
dns_qpmulti_t *qpm = NULL;
- dns_qpmulti_create(mctx, &test_methods, NULL, &qpm);
+ dns_qpmulti_create(isc_g_mctx, &test_methods, NULL, &qpm);
qpm->writer.write_protect = true;
for (size_t n = 0; n < TRANSACTION_COUNT; n++) {
qpzonedb_t *qpdb = (qpzonedb_t *)&qpdb_s;
*qpdb = (qpzonedb_t){
.common.methods = &qpdb_zonemethods,
- .common.mctx = mctx,
+ .common.mctx = isc_g_mctx,
};
qpznode_t node = { .locknum = 0 };
dns_slabheader_t header = {
qpzonedb_t *qpdb = (qpzonedb_t *)&qpdb_s;
*qpdb = (qpzonedb_t){
.common.methods = &qpdb_zonemethods,
- .common.mctx = mctx,
+ .common.mctx = isc_g_mctx,
};
qpznode_t node = { .locknum = 0 };
dns_slabheader_t header = {
/*
* Try converting input data into uncompressed wire form.
*/
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
result = dns_rdata_towire(rdata, &cctx, &target);
detect_uncleared_libcrypto_error();
dns_compress_invalidate(&cctx);
char buf[1024];
unsigned int count = 0;
- rdata_struct = isc_mem_allocate(mctx, structsize);
+ rdata_struct = isc_mem_allocate(isc_g_mctx, structsize);
assert_non_null(rdata_struct);
/*
}
}
- isc_mem_free(mctx, rdata_struct);
+ isc_mem_free(isc_g_mctx, rdata_struct);
}
/*
unsigned int from = 0;
dns_stats_t *stats = NULL;
- dns_rdatasetstats_create(mctx, &stats);
+ dns_rdatasetstats_create(isc_g_mctx, &stats);
/* First 255 types. */
for (i = 1; i <= 255; i++) {
if (debug) {
fprintf(stderr, "# testing '%s'\n", tests[i].file);
}
- result = irs_resconf_load(mctx, tests[i].file, &resconf);
+ result = irs_resconf_load(isc_g_mctx, tests[i].file, &resconf);
if (result != tests[i].loadres) {
fail_msg("# unexpected result %s loading %s",
isc_result_totext(result), tests[i].file);
mkres(dns_resolver_t **resolverp) {
isc_result_t result;
- isc_tlsctx_cache_create(mctx, &tlsctx_cache);
+ isc_tlsctx_cache_create(isc_g_mctx, &tlsctx_cache);
result = dns_resolver_create(view, 0, tlsctx_cache, dispatch, NULL,
resolverp);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(ret, ISC_R_SUCCESS);
ret = dst_key_fromfile(name, 29238, DST_ALG_RSASHA256, DST_TYPE_PUBLIC,
- TESTS_DIR, mctx, &key);
+ TESTS_DIR, isc_g_mctx, &key);
assert_int_equal(ret, ISC_R_SUCCESS);
/* RSASHA1 - May not be supported by the OS */
if (dst_algorithm_supported(DST_ALG_RSASHA1)) {
key->key_alg = DST_ALG_RSASHA1;
- ret = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC,
- false, &ctx);
+ ret = dst_context_create(key, isc_g_mctx,
+ DNS_LOGCATEGORY_DNSSEC, false, &ctx);
assert_int_equal(ret, ISC_R_SUCCESS);
r.base = d;
key->key_alg = DST_ALG_RSASHA256;
- ret = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, false,
+ ret = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_DNSSEC, false,
&ctx);
assert_int_equal(ret, ISC_R_SUCCESS);
key->key_alg = DST_ALG_RSASHA512;
- ret = dst_context_create(key, mctx, DNS_LOGCATEGORY_DNSSEC, false,
+ ret = dst_context_create(key, isc_g_mctx, DNS_LOGCATEGORY_DNSSEC, false,
&ctx);
assert_int_equal(ret, ISC_R_SUCCESS);
*/
expected_name = dns_fixedname_initname(&expected_fname);
result = dns_name_fromstring(expected_name, expected->owner,
- dns_rootname, 0, mctx);
+ dns_rootname, 0, isc_g_mctx);
assert_int_equal(result, ISC_R_SUCCESS);
dns_name_format(&found->name, found_name, sizeof(found_name));
assert_true(dns_name_equal(expected_name, &found->name));
/*
* Initialize the structure dns__zone_updatesigs() will modify.
*/
- dns_diff_init(mctx, &zone_diff);
+ dns_diff_init(isc_g_mctx, &zone_diff);
/*
* Check whether dns__zone_updatesigs() behaves as expected.
dns_zone_setkeydirectory(zone, TESTS_DIR "/testkeys");
- result = dns_zone_findkeys(zone, db, NULL, now, mctx, DNS_MAXZONEKEYS,
- zone_keys, &nkeys);
+ result = dns_zone_findkeys(zone, db, NULL, now, isc_g_mctx,
+ DNS_MAXZONEKEYS, zone_keys, &nkeys);
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(nkeys, 2);
print_rdata(FILE *fp, dns_rdata_t *rdata) {
dns_rdataset_t rrset = DNS_RDATASET_INIT;
- dns_rdatalist_t *rdatalist = isc_mem_get(mctx, sizeof(*rdatalist));
+ dns_rdatalist_t *rdatalist = isc_mem_get(isc_g_mctx,
+ sizeof(*rdatalist));
dns_rdatalist_init(rdatalist);
rdatalist->rdclass = dns_rdataclass_in;
rdatalist->type = rdata->type;
ISC_LIST_FOREACH (rdatalist->rdata, rd, link) {
ISC_LIST_UNLINK(rdatalist->rdata, rdata, link);
}
- isc_mem_put(mctx, rdatalist, sizeof(*rdatalist));
+ isc_mem_put(isc_g_mctx, rdatalist, sizeof(*rdatalist));
}
static void
isc_buffer_init(&target, target_mem, 1024);
ret = dns_dnssec_sign(dname, rrset, ksk->key, &clockskew, &expiration,
- mctx, &target, rrsig);
+ isc_g_mctx, &target, rrsig);
assert_int_equal(ret, ISC_R_SUCCESS);
print_rdata(fp, rrsig);
isc_buffer_add(&source, strlen(rdatastr));
/* Create a lexer as one is required by dns_rdata_fromtext(). */
- isc_lex_create(mctx, 64, &lex);
+ isc_lex_create(isc_g_mctx, 64, &lex);
specials[0] = 1;
specials['('] = 1;
specials[')'] = 1;
assert_int_equal(ret, ISC_R_SUCCESS);
ret = dns_rdata_fromtext(rdata, dns_rdataclass_in, rdtype, lex, dname,
- 0, mctx, &target, NULL);
+ 0, isc_g_mctx, &target, NULL);
assert_int_equal(ret, ISC_R_SUCCESS);
print_rdata(fp, rdata);
&test_bundles[bnum].zsk2);
}
/* Create the DNSKEY signature. */
- dnskeylist = isc_mem_get(mctx, sizeof(*dnskeylist));
- dnskeyset = isc_mem_get(mctx, sizeof(*dnskeyset));
+ dnskeylist = isc_mem_get(isc_g_mctx, sizeof(*dnskeylist));
+ dnskeyset = isc_mem_get(isc_g_mctx, sizeof(*dnskeyset));
dns_rdatalist_init(dnskeylist);
dns_rdataset_init(dnskeyset);
dnskeylist->rdclass = dns_rdataclass_in;
ISC_LIST_FOREACH (dnskeylist->rdata, rd, link) {
ISC_LIST_UNLINK(dnskeylist->rdata, rd, link);
}
- isc_mem_put(mctx, dnskeylist, sizeof(*dnskeylist));
- isc_mem_put(mctx, dnskeyset, sizeof(*dnskeyset));
+ isc_mem_put(isc_g_mctx, dnskeylist, sizeof(*dnskeylist));
+ isc_mem_put(isc_g_mctx, dnskeyset, sizeof(*dnskeyset));
/* CDNSKEY */
dns_rdata_init(&test_bundles[bnum].cdnskey);
test_bundles[bnum].cdnskeybuf,
&test_bundles[bnum].cdnskey);
- cdnskeylist = isc_mem_get(mctx, sizeof(*cdnskeylist));
- cdnskeyset = isc_mem_get(mctx, sizeof(*cdnskeyset));
+ cdnskeylist = isc_mem_get(isc_g_mctx, sizeof(*cdnskeylist));
+ cdnskeyset = isc_mem_get(isc_g_mctx, sizeof(*cdnskeyset));
dns_rdatalist_init(cdnskeylist);
dns_rdataset_init(cdnskeyset);
cdnskeylist->rdclass = dns_rdataclass_in;
ISC_LIST_FOREACH (cdnskeylist->rdata, rd, link) {
ISC_LIST_UNLINK(cdnskeylist->rdata, rd, link);
}
- isc_mem_put(mctx, cdnskeylist, sizeof(*cdnskeylist));
- isc_mem_put(mctx, cdnskeyset, sizeof(*cdnskeyset));
+ isc_mem_put(isc_g_mctx, cdnskeylist, sizeof(*cdnskeylist));
+ isc_mem_put(isc_g_mctx, cdnskeyset, sizeof(*cdnskeyset));
/* CDS */
dns_rdata_init(&test_bundles[bnum].cds);
write_record(fp, dns_rdatatype_cds, cdsstr, test_bundles[bnum].cdsbuf,
&test_bundles[bnum].cds);
- cdslist = isc_mem_get(mctx, sizeof(*cdslist));
- cdsset = isc_mem_get(mctx, sizeof(*cdsset));
+ cdslist = isc_mem_get(isc_g_mctx, sizeof(*cdslist));
+ cdsset = isc_mem_get(isc_g_mctx, sizeof(*cdsset));
dns_rdatalist_init(cdslist);
dns_rdataset_init(cdsset);
cdslist->rdclass = dns_rdataclass_in;
ISC_LIST_FOREACH (cdslist->rdata, rd, link) {
ISC_LIST_UNLINK(cdslist->rdata, rd, link);
}
- isc_mem_put(mctx, cdslist, sizeof(*cdslist));
- isc_mem_put(mctx, cdsset, sizeof(*cdsset));
+ isc_mem_put(isc_g_mctx, cdslist, sizeof(*cdslist));
+ isc_mem_put(isc_g_mctx, cdsset, sizeof(*cdsset));
/* Signature times. */
test_bundles[bnum].btime = btime;
/* Set up output file */
tempfilelen = strlen(TESTS_DIR "/testdata/skr/") + 20;
- tempfile = isc_mem_get(mctx, tempfilelen);
+ tempfile = isc_mem_get(isc_g_mctx, tempfilelen);
ret = isc_file_mktemplate(testskr, tempfile, tempfilelen);
assert_int_equal(ret, ISC_R_SUCCESS);
ret = isc_file_openunique(tempfile, &outfp);
assert_int_equal(ret, ISC_R_SUCCESS);
isc_file_remove(tempfile);
- isc_mem_put(mctx, tempfile, tempfilelen);
+ isc_mem_put(isc_g_mctx, tempfile, tempfilelen);
}
ISC_RUN_TEST_IMPL(skr_read) {
/* Get the KSK */
ISC_LIST_INIT(keys);
- result = dns_dnssec_findmatchingkeys(
- dname, NULL, TESTS_DIR "/testdata/skr/", NULL, 0, mctx, &keys);
+ result = dns_dnssec_findmatchingkeys(dname, NULL,
+ TESTS_DIR "/testdata/skr/", NULL,
+ 0, isc_g_mctx, &keys);
assert_int_equal(result, ISC_R_SUCCESS);
/* Create/read the SKR file */
create_skr_file();
- dns_skr_create(mctx, testskr, dname, dns_rdataclass_in, &skr);
- result = dns_skr_read(mctx, testskr, dname, dns_rdataclass_in, TTL,
- &skr);
+ dns_skr_create(isc_g_mctx, testskr, dname, dns_rdataclass_in, &skr);
+ result = dns_skr_read(isc_g_mctx, testskr, dname, dns_rdataclass_in,
+ TTL, &skr);
assert_int_equal(result, ISC_R_SUCCESS);
isc_file_remove(testskr);
dns_dnsseckey_t *key = ISC_LIST_HEAD(keys);
ISC_LIST_UNLINK(keys, key, link);
dst_key_free(&key->key);
- dns_dnsseckey_destroy(mctx, &key);
+ dns_dnsseckey_destroy(isc_g_mctx, &key);
}
}
dns_transport_t *tls = NULL, *http = NULL;
dns_transport_list_t *tlist = NULL;
- tlist = dns_transport_list_new(mctx);
+ tlist = dns_transport_list_new(isc_g_mctx);
udp = dns_transport_new(dns_rootname, DNS_TRANSPORT_UDP, tlist);
tcp = dns_transport_new(dns_rootname, DNS_TRANSPORT_TCP, tlist);
tls = dns_transport_new(dns_rootname, DNS_TRANSPORT_TLS, tlist);
memset(&tsig, 0, sizeof(tsig));
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
tsig.common.rdclass = dns_rdataclass_any;
tsig.common.rdtype = dns_rdatatype_tsig;
CHECK(dst_context_adddata(tsigctx, &r));
CHECK(dst_key_sigsize(key->key, &sigsize));
- tsig.signature = isc_mem_get(mctx, sigsize);
+ tsig.signature = isc_mem_get(isc_g_mctx, sigsize);
isc_buffer_init(&sigbuf, tsig.signature, sigsize);
CHECK(dst_context_sign(tsigctx, &sigbuf));
tsig.siglen = isc_buffer_usedlength(&sigbuf);
isc_random_buf(tsig.signature, tsig.siglen);
}
- isc_buffer_allocate(mctx, &dynbuf, 512);
+ isc_buffer_allocate(isc_g_mctx, &dynbuf, 512);
CHECK(dns_rdata_fromstruct(&rdata, dns_rdataclass_any,
dns_rdatatype_tsig, &tsig, dynbuf));
dns_rdatalist_init(&rdatalist);
}
cleanup:
if (tsig.signature != NULL) {
- isc_mem_put(mctx, tsig.signature, sigsize);
+ isc_mem_put(isc_g_mctx, tsig.signature, sigsize);
}
if (dynbuf != NULL) {
isc_buffer_free(&dynbuf);
}
do {
- buf = isc_mem_get(mctx, len);
+ buf = isc_mem_get(isc_g_mctx, len);
isc_buffer_init(&b, buf, len);
result = dns_message_totext(msg, &dns_master_style_debug, 0,
&b);
if (result == ISC_R_NOSPACE) {
- isc_mem_put(mctx, buf, len);
+ isc_mem_put(isc_g_mctx, buf, len);
len *= 2;
} else if (result == ISC_R_SUCCESS) {
printf("%.*s\n", (int)isc_buffer_usedlength(&b), buf);
} while (result == ISC_R_NOSPACE);
if (buf != NULL) {
- isc_mem_put(mctx, buf, len);
+ isc_mem_put(isc_g_mctx, buf, len);
}
}
dns_compress_t cctx;
isc_result_t result;
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER, &msg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
+ &msg);
assert_non_null(msg);
msg->id = 50;
dns_message_setquerytsig(msg, *tsigin);
}
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
result = dns_message_renderbegin(msg, &cctx, buf);
assert_int_equal(result, ISC_R_SUCCESS);
isc_buffer_free(tsigin);
}
- result = dns_message_getquerytsig(msg, mctx, tsigout);
+ result = dns_message_getquerytsig(msg, isc_g_mctx, tsigout);
assert_int_equal(result, ISC_R_SUCCESS);
}
result = dns_name_fromstring(keyname, "test", dns_rootname, 0, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_tsigkeyring_create(mctx, &ring);
+ dns_tsigkeyring_create(isc_g_mctx, &ring);
assert_non_null(ring);
result = dns_tsigkey_create(keyname, DST_ALG_HMACSHA256, secret,
- sizeof(secret), mctx, &key);
+ sizeof(secret), isc_g_mctx, &key);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_tsigkeyring_add(ring, key);
assert_int_equal(result, ISC_R_SUCCESS);
/*
* Create request.
*/
- isc_buffer_allocate(mctx, &buf, 65535);
+ isc_buffer_allocate(isc_g_mctx, &buf, 65535);
render(buf, 0, key, &tsigout, &querytsig, NULL);
isc_buffer_free(&buf);
/*
* Create response message 1.
*/
- isc_buffer_allocate(mctx, &buf, 65535);
+ isc_buffer_allocate(isc_g_mctx, &buf, 65535);
render(buf, DNS_MESSAGEFLAG_QR, key, &querytsig, &tsigout, NULL);
assert_non_null(tsigout);
/*
* Process response message 1.
*/
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &msg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &msg);
assert_non_null(msg);
result = dns_message_settsigkey(msg, key);
*/
assert_non_null(dns_message_gettsig(msg, &tsigowner));
- result = dns_message_getquerytsig(msg, mctx, &tsigin);
+ result = dns_message_getquerytsig(msg, isc_g_mctx, &tsigin);
assert_int_equal(result, ISC_R_SUCCESS);
tsigctx = msg->tsigctx;
isc_buffer_free(&buf);
dns_message_detach(&msg);
- result = dst_context_create(key->key, mctx, DNS_LOGCATEGORY_DNSSEC,
- false, &outctx);
+ result = dst_context_create(key->key, isc_g_mctx,
+ DNS_LOGCATEGORY_DNSSEC, false, &outctx);
assert_int_equal(result, ISC_R_SUCCESS);
assert_non_null(outctx);
/*
* Create response message 2.
*/
- isc_buffer_allocate(mctx, &buf, 65535);
+ isc_buffer_allocate(isc_g_mctx, &buf, 65535);
assert_int_equal(result, ISC_R_SUCCESS);
render(buf, DNS_MESSAGEFLAG_QR, key, &tsigout, &tsigout, outctx);
/*
* Process response message 2.
*/
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &msg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &msg);
assert_non_null(msg);
msg->tcp_continuation = 1;
/*
* Create response message 3.
*/
- isc_buffer_allocate(mctx, &buf, 65535);
+ isc_buffer_allocate(isc_g_mctx, &buf, 65535);
render(buf, DNS_MESSAGEFLAG_QR, key, &tsigout, &tsigout, outctx);
result = add_tsig(outctx, key, buf, now, mangle_sig);
/*
* Process response message 3.
*/
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &msg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &msg);
assert_non_null(msg);
msg->tcp_continuation = 1;
isc_buffer_free(&tsigin);
}
- result = dns_message_getquerytsig(msg, mctx, &tsigin);
+ result = dns_message_getquerytsig(msg, isc_g_mctx, &tsigin);
assert_int_equal(result, ISC_R_SUCCESS);
isc_buffer_free(&buf);
isc_sockaddr_fromin6(&src_addrv6, &in6addr_loopback, src_port);
isc_sockaddr_fromin6(&dst_addrv6, &in6addr_loopback, dst_port);
- uc = dns_unreachcache_new(mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
+ uc = dns_unreachcache_new(isc_g_mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
BACKOFF_ELGIBLE_S);
dns_unreachcache_add(uc, &dst_addrv4, &src_addrv4);
dns_unreachcache_add(uc, &dst_addrv6, &src_addrv6);
isc_sockaddr_fromin(&src_addrv4, &localhost4, src_port);
isc_sockaddr_fromin(&dst_addrv4, &localhost4, dst_port);
- uc = dns_unreachcache_new(mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
+ uc = dns_unreachcache_new(isc_g_mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
BACKOFF_ELGIBLE_S);
/* Two adds to "confirm" the addition. */
dns_unreachcache_add(uc, &dst_addrv4, &src_addrv4);
isc_sockaddr_fromin(&src_addrv4, &localhost4, src_port);
isc_sockaddr_fromin(&dst_addrv4, &localhost4, dst_port);
- uc = dns_unreachcache_new(mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
+ uc = dns_unreachcache_new(isc_g_mctx, EXPIRE_MIN_S, EXPIRE_MAX_S,
BACKOFF_ELGIBLE_S);
/* Two adds to "confirm" the addition. */
dns_unreachcache_add(uc, &dst_addrv4, &src_addrv4);
UNUSED(arg);
- dns_zonemgr_create(mctx, &myzonemgr);
+ dns_zonemgr_create(isc_g_mctx, &myzonemgr);
dns_zonemgr_shutdown(myzonemgr);
dns_zonemgr_detach(&myzonemgr);
UNUSED(arg);
- dns_zonemgr_create(mctx, &myzonemgr);
+ dns_zonemgr_create(isc_g_mctx, &myzonemgr);
result = dns_test_makezone("foo", &zone, NULL, false);
assert_int_equal(result, ISC_R_SUCCESS);
UNUSED(arg);
- dns_zonemgr_create(mctx, &myzonemgr);
+ dns_zonemgr_create(isc_g_mctx, &myzonemgr);
result = dns_zonemgr_createzone(myzonemgr, &zone);
assert_int_equal(result, ISC_R_SUCCESS);
#include <isc/util.h>
#include <isc/uv.h>
-extern isc_mem_t *mctx;
extern int ncpus;
extern unsigned int workers;
extern bool debug;
r = cmocka_run_group_tests(tests, setup, teardown); \
} \
\
- isc_mem_detach(&mctx); \
+ teardown_mctx(NULL); \
\
return (r); \
}
UNUSED(state);
b = NULL;
- isc_buffer_allocate(mctx, &b, ISC_BUFFER_INCR);
+ isc_buffer_allocate(isc_g_mctx, &b, ISC_BUFFER_INCR);
assert_int_equal(b->length, ISC_BUFFER_INCR);
/*
UNUSED(state);
b = NULL;
- isc_buffer_allocate(mctx, &b, last_length);
+ isc_buffer_allocate(isc_g_mctx, &b, last_length);
assert_non_null(b);
assert_int_equal(b->length, last_length);
UNUSED(state);
- isc_buffer_allocate(mctx, &b, sizeof(data));
+ isc_buffer_allocate(isc_g_mctx, &b, sizeof(data));
/*
* Fill originally allocated buffer space.
* Prepare a buffer with auto-reallocation enabled.
*/
b = NULL;
- isc_buffer_allocate(mctx, &b, 0);
+ isc_buffer_allocate(isc_g_mctx, &b, 0);
/*
* Sanity check.
isc_result_t result;
isc_counter_t *counter = NULL;
- isc_counter_create(mctx, 0, &counter);
+ isc_counter_create(isc_g_mctx, 0, &counter);
for (size_t i = 0; i < 10; i++) {
result = isc_counter_increment(counter);
static int
setup_test_dnsbuf(void **state) {
isc_buffer_t **pdnsbuf = (isc_buffer_t **)state;
- isc_buffer_allocate(mctx, pdnsbuf, STATIC_BUFFER_SIZE);
+ isc_buffer_allocate(isc_g_mctx, pdnsbuf, STATIC_BUFFER_SIZE);
return 0;
}
setup_test_dnsasm(void **state) {
isc_dnsstream_assembler_t **pdnsasm =
(isc_dnsstream_assembler_t **)state;
- *pdnsasm = isc_dnsstream_assembler_new(mctx, dnsasm_dummy, NULL);
+ *pdnsasm = isc_dnsstream_assembler_new(isc_g_mctx, dnsasm_dummy, NULL);
return 0;
}
size_t verified = 0;
isc_buffer_init(&dnsbuf, NULL, 0);
- isc_buffer_setmctx(&dnsbuf, mctx);
+ isc_buffer_setmctx(&dnsbuf, isc_g_mctx);
isc_buffer_putmem(&dnsbuf, (void *)request, sizeof(request));
isc_buffer_putmem(&dnsbuf, (void *)response, sizeof(response));
isc_buffer_putmem(&dnsbuf, (void *)request_large,
uint16_t bad_data = 0;
isc_buffer_init(&dnsbuf, NULL, 0);
- isc_buffer_setmctx(&dnsbuf, mctx);
+ isc_buffer_setmctx(&dnsbuf, isc_g_mctx);
isc_buffer_putmem(&dnsbuf, (void *)request, sizeof(request));
isc_buffer_putmem(&dnsbuf, (void *)&bad_data, sizeof(bad_data));
const size_t npackets = sizeof(packets) / sizeof(packets[0]);
isc_buffer_init(&dnsbuf, NULL, 0);
- isc_buffer_setmctx(&dnsbuf, mctx);
+ isc_buffer_setmctx(&dnsbuf, isc_g_mctx);
for (size_t i = 0; i < npackets; i++) {
isc_buffer_putmem(&dnsbuf, packets[i].base, packets[i].length);
isc_buffer_t dnsbuf;
isc_buffer_init(&dnsbuf, NULL, 0);
- isc_buffer_setmctx(&dnsbuf, mctx);
+ isc_buffer_setmctx(&dnsbuf, isc_g_mctx);
isc_buffer_putmem(&dnsbuf, (void *)request, sizeof(request));
isc_buffer_putmem(&dnsbuf, (void *)&response, sizeof(response));
}
typedef struct csdata {
- isc_mem_t *mctx;
isc_nm_recv_cb_t reply_cb;
void *cb_arg;
isc_region_t region;
(void)atomic_fetch_sub(&active_cconnects, 1);
memmove(&data, arg, sizeof(data));
- isc_mem_put(data.mctx, arg, sizeof(data));
+ isc_mem_put(isc_g_mctx, arg, sizeof(data));
if (result != ISC_R_SUCCESS) {
goto error;
}
goto error;
}
- isc_mem_putanddetach(&data.mctx, data.region.base, data.region.length);
+ isc_mem_put(isc_g_mctx, data.region.base, data.region.length);
return;
error:
data.reply_cb(handle, result, NULL, data.cb_arg);
- isc_mem_putanddetach(&data.mctx, data.region.base, data.region.length);
+ isc_mem_put(isc_g_mctx, data.region.base, data.region.length);
}
static void
csdata_t *data = NULL;
isc_tlsctx_t *ctx = NULL;
- copy = (isc_region_t){ .base = isc_mem_get(mctx, region->length),
+ copy = (isc_region_t){ .base = isc_mem_get(isc_g_mctx, region->length),
.length = region->length };
memmove(copy.base, region->base, region->length);
- data = isc_mem_get(mctx, sizeof(*data));
+ data = isc_mem_get(isc_g_mctx, sizeof(*data));
*data = (csdata_t){ .reply_cb = cb, .cb_arg = cbarg, .region = copy };
- isc_mem_attach(mctx, &data->mctx);
if (tls) {
ctx = client_tlsctx;
}
isc_tlsctx_createclient(&client_tlsctx);
isc_tlsctx_enable_http2client_alpn(client_tlsctx);
isc_tlsctx_client_session_cache_create(
- mctx, client_tlsctx,
+ isc_g_mctx, client_tlsctx,
ISC_TLSCTX_CLIENT_SESSION_CACHE_DEFAULT_SIZE,
&client_sess_cache);
atomic_store(&check_listener_quota, false);
INSIST(endpoints == NULL);
- endpoints = isc_nm_http_endpoints_new(mctx);
+ endpoints = isc_nm_http_endpoints_new(isc_g_mctx);
return 0;
}
char test[] = "YW55IGNhcm5hbCBwbGVhc3VyZS4";
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3VyZS4=";
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhcw";
char res_test[] = "YW55IGNhcm5hbCBwbGVhcw==";
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhc3Vy";
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3Vy";
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhc3U";
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3U=";
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhcw";
char res_test[] = "YW55IGNhcm5hbCBwbGVhcw==";
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char test[] = "PDw_Pz8-Pg";
char res_test[] = "PDw/Pz8+Pg==";
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char test[] = "PDw_Pz8-Pg";
char res_test[] = "PDw/Pz8+Pg==";
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- NULL);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), NULL);
assert_non_null(res);
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* invalid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhcw";
res_len = 0;
- res = isc__nm_base64url_to_base64(mctx, test, 0, &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test, 0,
+ &res_len);
assert_null(res);
assert_true(res_len == 0);
}
char test[] = "";
res_len = 0;
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_null(res);
assert_true(res_len == 0);
}
char test[] = "PDw_Pz8-Pg==";
res_len = 0;
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_null(res);
assert_true(res_len == 0);
}
end */
res_len = 0;
- res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_null(res);
assert_true(res_len == 0);
}
{
res_len = 0;
- res = isc__nm_base64url_to_base64(mctx, NULL, 31231, &res_len);
+ res = isc__nm_base64url_to_base64(isc_g_mctx, NULL, 31231,
+ &res_len);
assert_null(res);
assert_true(res_len == 0);
}
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3VyZS4";
char test[] = "YW55IGNhcm5hbCBwbGVhc3VyZS4=";
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhcw";
char test[] = "YW55IGNhcm5hbCBwbGVhcw==";
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3Vy";
char test[] = "YW55IGNhcm5hbCBwbGVhc3Vy";
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3U";
char test[] = "YW55IGNhcm5hbCBwbGVhc3U=";
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhcw";
char test[] = "YW55IGNhcm5hbCBwbGVhcw==";
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char res_test[] = "PDw_Pz8-Pg";
char test[] = "PDw/Pz8+Pg==";
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* valid */
{
char res_test[] = "PDw_Pz8-Pg";
char test[] = "PDw/Pz8+Pg==";
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- NULL);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), NULL);
assert_non_null(res);
assert_true(strcmp(res, res_test) == 0);
- isc_mem_free(mctx, res);
+ isc_mem_free(isc_g_mctx, res);
}
/* invalid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhcw";
res_len = 0;
- res = isc__nm_base64_to_base64url(mctx, test, 0, &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test, 0,
+ &res_len);
assert_null(res);
assert_true(res_len == 0);
}
char test[] = "";
res_len = 0;
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_null(res);
assert_true(res_len == 0);
}
char test[] = "PDw_Pz8-Pg==";
res_len = 0;
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_null(res);
assert_true(res_len == 0);
}
end */
res_len = 0;
- res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
- &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, test,
+ strlen(test), &res_len);
assert_null(res);
assert_true(res_len == 0);
}
{
res_len = 0;
- res = isc__nm_base64_to_base64url(mctx, NULL, 31231, &res_len);
+ res = isc__nm_base64_to_base64url(isc_g_mctx, NULL, 31231,
+ &res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* INCLUDE LAST */
-#define mctx __mctx
#include "hashmap.c"
-#undef mctx
typedef struct test_node {
uint32_t hashval;
isc_result_t result;
test_node_t *nodes, *long_nodes, *upper_nodes;
- nodes = isc_mem_cget(mctx, count, sizeof(nodes[0]));
- long_nodes = isc_mem_cget(mctx, count, sizeof(nodes[0]));
- upper_nodes = isc_mem_cget(mctx, count, sizeof(nodes[0]));
+ nodes = isc_mem_cget(isc_g_mctx, count, sizeof(nodes[0]));
+ long_nodes = isc_mem_cget(isc_g_mctx, count, sizeof(nodes[0]));
+ upper_nodes = isc_mem_cget(isc_g_mctx, count, sizeof(nodes[0]));
- isc_hashmap_create(mctx, init_bits, &hashmap);
+ isc_hashmap_create(isc_g_mctx, init_bits, &hashmap);
assert_non_null(hashmap);
/*
isc_hashmap_destroy(&hashmap);
assert_null(hashmap);
- isc_mem_cput(mctx, nodes, count, sizeof(nodes[0]));
- isc_mem_cput(mctx, long_nodes, count, sizeof(nodes[0]));
- isc_mem_cput(mctx, upper_nodes, count, sizeof(nodes[0]));
+ isc_mem_cput(isc_g_mctx, nodes, count, sizeof(nodes[0]));
+ isc_mem_cput(isc_g_mctx, long_nodes, count, sizeof(nodes[0]));
+ isc_mem_cput(isc_g_mctx, upper_nodes, count, sizeof(nodes[0]));
}
#include "hashmap_nodes.h"
test_node_t *nodes;
bool *seen;
- nodes = isc_mem_cget(mctx, count, sizeof(nodes[0]));
- seen = isc_mem_cget(mctx, count, sizeof(seen[0]));
+ nodes = isc_mem_cget(isc_g_mctx, count, sizeof(nodes[0]));
+ seen = isc_mem_cget(isc_g_mctx, count, sizeof(seen[0]));
- isc_hashmap_create(mctx, HASHMAP_MIN_BITS, &hashmap);
+ isc_hashmap_create(isc_g_mctx, HASHMAP_MIN_BITS, &hashmap);
assert_non_null(hashmap);
for (size_t i = 0; i < count; i++) {
isc_hashmap_destroy(&hashmap);
assert_null(hashmap);
- isc_mem_cput(mctx, seen, count, sizeof(seen[0]));
- isc_mem_cput(mctx, nodes, count, sizeof(nodes[0]));
+ isc_mem_cput(isc_g_mctx, seen, count, sizeof(seen[0]));
+ isc_mem_cput(isc_g_mctx, nodes, count, sizeof(nodes[0]));
}
/* 1 bit, 120 elements test, full rehashing */
bool again = false;
again:
- isc_hashmap_create(mctx, 1, &hashmap);
+ isc_hashmap_create(isc_g_mctx, 1, &hashmap);
hashval = isc_hash32("", 0, true);
test_node_t mixed = { .key = "IsC_hAsHmAp_CaSe" };
void *f = NULL;
- isc_hashmap_create(mctx, 1, &hashmap);
+ isc_hashmap_create(isc_g_mctx, 1, &hashmap);
result = isc_hashmap_add(hashmap,
isc_hash32(lower.key, strlen(lower.key), true),
isc_hashmap_destroy(&hashmap);
- isc_hashmap_create(mctx, 1, &hashmap);
+ isc_hashmap_create(isc_g_mctx, 1, &hashmap);
result = isc_hashmap_add(
hashmap, isc_hash32(lower.key, strlen(lower.key), false),
UNUSED(state);
- isc_heap_create(mctx, compare, idx, 0, &heap);
+ isc_heap_create(isc_g_mctx, compare, idx, 0, &heap);
assert_non_null(heap);
isc_heap_insert(heap, &e1);
isc_nanosecs_t start = isc_time_monotonic();
isc_histo_t *hg = NULL;
- isc_histo_create(mctx, bits, &hg);
+ isc_histo_create(isc_g_mctx, bits, &hg);
isc_histo_inc(hg, 0);
isc_nanosecs_t start = isc_time_monotonic();
isc_histo_t *hg = NULL;
- isc_histo_create(mctx, bits, &hg);
+ isc_histo_create(isc_g_mctx, bits, &hg);
/* ensure empty histogram does not divide by zero */
isc_histo_moments(hg, &pop, &mean, &sd);
for (uint bits = ISC_HISTO_MINBITS; bits <= ISC_HISTO_MAXBITS; bits++) {
isc_histo_t *hg = NULL;
- isc_histo_create(mctx, bits, &hg);
+ isc_histo_create(isc_g_mctx, bits, &hg);
uint digits = isc_histo_bits_to_digits(bits);
assert_true(bits >= isc_histo_digits_to_bits(digits));
isc_nanosecs_t start = isc_time_monotonic();
isc_histo_t *hg = NULL;
- isc_histo_create(mctx, bits, &hg);
+ isc_histo_create(isc_g_mctx, bits, &hg);
uint64_t value[SUBRANGE + 1];
double frac[SUBRANGE + 1];
assert_int_equal(value[0], max);
isc_histo_destroy(&hg);
- isc_histo_create(mctx, bits, &hg);
+ isc_histo_create(isc_g_mctx, bits, &hg);
/* these tests can be slow */
if (isc_time_monotonic() > start + TIME_LIMIT) {
/* INCLUDE LAST */
-#define mctx __mctx
#include "ht.c"
-#undef mctx
static void
test_ht_full(uint8_t init_bits, uintptr_t count) {
isc_result_t result;
uintptr_t i;
- isc_ht_init(&ht, mctx, init_bits, ISC_HT_CASE_SENSITIVE);
+ isc_ht_init(&ht, isc_g_mctx, init_bits, ISC_HT_CASE_SENSITIVE);
assert_non_null(ht);
for (i = 1; i < count; i++) {
unsigned char key[16];
size_t tksize;
- isc_ht_init(&ht, mctx, HT_MIN_BITS, ISC_HT_CASE_SENSITIVE);
+ isc_ht_init(&ht, isc_g_mctx, HT_MIN_BITS, ISC_HT_CASE_SENSITIVE);
assert_non_null(ht);
for (i = 1; i <= count; i++) {
/*
unsigned char upper[16] = { "TEST CASE" };
unsigned char mixed[16] = { "tEsT CaSe" };
- isc_ht_init(&ht, mctx, 8, ISC_HT_CASE_SENSITIVE);
+ isc_ht_init(&ht, isc_g_mctx, 8, ISC_HT_CASE_SENSITIVE);
assert_non_null(ht);
result = isc_ht_add(ht, lower, 16, (void *)lower);
isc_ht_destroy(&ht);
assert_null(ht);
- isc_ht_init(&ht, mctx, 8, ISC_HT_CASE_INSENSITIVE);
+ isc_ht_init(&ht, isc_g_mctx, 8, ISC_HT_CASE_INSENSITIVE);
assert_non_null(ht);
result = isc_ht_add(ht, lower, 16, (void *)lower);
shutdown_cb(void *arg) {
struct test_arg *ta = arg;
- isc_mem_put(mctx, ta, sizeof(*ta));
+ isc_mem_put(isc_g_mctx, ta, sizeof(*ta));
isc_loopmgr_shutdown();
}
atomic_fetch_add(&scheduled, 1);
if (arg == NULL) {
- ta = isc_mem_get(mctx, sizeof(*ta));
+ ta = isc_mem_get(isc_g_mctx, sizeof(*ta));
*ta = (struct test_arg){ .job = ISC_JOB_INITIALIZER };
}
UNUSED(state);
- isc_lex_create(mctx, 1024, &lex);
+ isc_lex_create(isc_g_mctx, 1024, &lex);
isc_buffer_init(&death_buf, &death[0], sizeof(death));
isc_buffer_add(&death_buf, sizeof(death));
UNUSED(state);
- isc_lex_create(mctx, 1024, &lex);
+ isc_lex_create(isc_g_mctx, 1024, &lex);
isc_buffer_init(&buf, &text[0], sizeof(text));
isc_buffer_add(&buf, sizeof(text));
UNUSED(state);
for (i = 0; i < ARRAY_SIZE(parse_tests); i++) {
- isc_lex_create(mctx, 1024, &lex);
+ isc_lex_create(isc_g_mctx, 1024, &lex);
isc_buffer_constinit(&buf, parse_tests[i].text,
strlen(parse_tests[i].text));
UNUSED(state);
for (i = 0; i < ARRAY_SIZE(parse_tests); i++) {
- isc_lex_create(mctx, 1024, &lex);
+ isc_lex_create(isc_g_mctx, 1024, &lex);
isc_buffer_constinit(&buf, parse_tests[i].text,
strlen(parse_tests[i].text));
UNUSED(state);
for (i = 0; i < ARRAY_SIZE(parse_tests); i++) {
- isc_lex_create(mctx, 1024, &lex);
+ isc_lex_create(isc_g_mctx, 1024, &lex);
isc_buffer_constinit(&buf, parse_tests[i].text,
strlen(parse_tests[i].text));
unsigned int i, j;
int rval;
- isc_mempool_create(mctx, 24, "mp1", &mp1);
- isc_mempool_create(mctx, 31, "mp2", &mp2);
+ isc_mempool_create(isc_g_mctx, 24, "mp1", &mp1);
+ isc_mempool_create(isc_g_mctx, 31, "mp2", &mp2);
isc_mempool_setfreemax(mp1, MP1_FREEMAX);
isc_mempool_setfillcount(mp1, MP1_FILLCNT);
isc_mempool_destroy(&mp1);
isc_mempool_destroy(&mp2);
- isc_mempool_create(mctx, 2, "mp1", &mp1);
+ isc_mempool_create(isc_g_mctx, 2, "mp1", &mp1);
tmp = isc_mempool_get(mp1);
assert_non_null(tmp);
/* Skip the test if the memory is zeroed even in normal case */
zeroed = true;
- ptr = isc_mem_get(mctx, sizeof(expected));
+ ptr = isc_mem_get(isc_g_mctx, sizeof(expected));
for (size_t i = 0; i < sizeof(expected); i++) {
if (ptr[i] != expected[i]) {
zeroed = false;
break;
}
}
- isc_mem_put(mctx, ptr, sizeof(expected));
+ isc_mem_put(isc_g_mctx, ptr, sizeof(expected));
if (zeroed) {
skip();
return;
}
- ptr = isc_mem_cget(mctx, 1, sizeof(expected));
+ ptr = isc_mem_cget(isc_g_mctx, 1, sizeof(expected));
assert_memory_equal(ptr, expected, sizeof(expected));
- isc_mem_put(mctx, ptr, sizeof(expected));
+ isc_mem_put(isc_g_mctx, ptr, sizeof(expected));
}
ISC_RUN_TEST_IMPL(isc_mem_callocate_zero) {
/* Skip the test if the memory is zeroed even in normal case */
zeroed = true;
- ptr = isc_mem_get(mctx, sizeof(expected));
+ ptr = isc_mem_get(isc_g_mctx, sizeof(expected));
for (size_t i = 0; i < sizeof(expected); i++) {
if (ptr[i] != expected[i]) {
zeroed = false;
break;
}
}
- isc_mem_put(mctx, ptr, sizeof(expected));
+ isc_mem_put(isc_g_mctx, ptr, sizeof(expected));
if (zeroed) {
skip();
return;
}
- ptr = isc_mem_callocate(mctx, 1, sizeof(expected));
+ ptr = isc_mem_callocate(isc_g_mctx, 1, sizeof(expected));
assert_memory_equal(ptr, expected, sizeof(expected));
- isc_mem_free(mctx, ptr);
+ isc_mem_free(isc_g_mctx, ptr);
}
/* test InUse calculation */
ISC_RUN_TEST_IMPL(isc_mem_inuse) {
- isc_mem_t *mctx2 = NULL;
+ isc_mem_t *mctx = NULL;
size_t before, after;
ssize_t diff;
void *ptr;
- mctx2 = NULL;
- isc_mem_create("test", &mctx2);
+ mctx = NULL;
+ isc_mem_create("test", &mctx);
- before = isc_mem_inuse(mctx2);
- ptr = isc_mem_allocate(mctx2, 1024000);
- isc_mem_free(mctx2, ptr);
- after = isc_mem_inuse(mctx2);
+ before = isc_mem_inuse(mctx);
+ ptr = isc_mem_allocate(mctx, 1024000);
+ isc_mem_free(mctx, ptr);
+ after = isc_mem_inuse(mctx);
diff = after - before;
assert_int_equal(diff, 0);
- isc_mem_detach(&mctx2);
+ isc_mem_detach(&mctx);
}
ISC_RUN_TEST_IMPL(isc_mem_zeroget) {
uint8_t *data = NULL;
- data = isc_mem_get(mctx, 0);
+ data = isc_mem_get(isc_g_mctx, 0);
assert_non_null(data);
- isc_mem_put(mctx, data, 0);
+ isc_mem_put(isc_g_mctx, data, 0);
}
#define REGET_INIT_SIZE 1024
uint8_t *data = NULL;
/* test that we can reget NULL */
- data = isc_mem_reget(mctx, NULL, 0, REGET_INIT_SIZE);
+ data = isc_mem_reget(isc_g_mctx, NULL, 0, REGET_INIT_SIZE);
assert_non_null(data);
- isc_mem_put(mctx, data, REGET_INIT_SIZE);
+ isc_mem_put(isc_g_mctx, data, REGET_INIT_SIZE);
/* test that we can re-get a zero-length allocation */
- data = isc_mem_get(mctx, 0);
+ data = isc_mem_get(isc_g_mctx, 0);
assert_non_null(data);
- data = isc_mem_reget(mctx, data, 0, REGET_INIT_SIZE);
+ data = isc_mem_reget(isc_g_mctx, data, 0, REGET_INIT_SIZE);
assert_non_null(data);
for (size_t i = 0; i < REGET_INIT_SIZE; i++) {
data[i] = i % UINT8_MAX;
}
- data = isc_mem_reget(mctx, data, REGET_INIT_SIZE, REGET_GROW_SIZE);
+ data = isc_mem_reget(isc_g_mctx, data, REGET_INIT_SIZE,
+ REGET_GROW_SIZE);
assert_non_null(data);
for (size_t i = 0; i < REGET_INIT_SIZE; i++) {
data[i - 1] = i % UINT8_MAX;
}
- data = isc_mem_reget(mctx, data, REGET_GROW_SIZE, REGET_SHRINK_SIZE);
+ data = isc_mem_reget(isc_g_mctx, data, REGET_GROW_SIZE,
+ REGET_SHRINK_SIZE);
assert_non_null(data);
for (size_t i = REGET_SHRINK_SIZE; i > 0; i--) {
assert_int_equal(data[i - 1], i % UINT8_MAX);
}
- isc_mem_put(mctx, data, REGET_SHRINK_SIZE);
+ isc_mem_put(isc_g_mctx, data, REGET_SHRINK_SIZE);
}
ISC_RUN_TEST_IMPL(isc_mem_reallocate) {
uint8_t *data = NULL;
/* test that we can reallocate NULL */
- data = isc_mem_reallocate(mctx, NULL, REGET_INIT_SIZE);
+ data = isc_mem_reallocate(isc_g_mctx, NULL, REGET_INIT_SIZE);
assert_non_null(data);
- isc_mem_free(mctx, data);
+ isc_mem_free(isc_g_mctx, data);
/* test that we can re-get a zero-length allocation */
- data = isc_mem_allocate(mctx, 0);
+ data = isc_mem_allocate(isc_g_mctx, 0);
assert_non_null(data);
- data = isc_mem_reallocate(mctx, data, REGET_INIT_SIZE);
+ data = isc_mem_reallocate(isc_g_mctx, data, REGET_INIT_SIZE);
assert_non_null(data);
for (size_t i = 0; i < REGET_INIT_SIZE; i++) {
data[i] = i % UINT8_MAX;
}
- data = isc_mem_reallocate(mctx, data, REGET_GROW_SIZE);
+ data = isc_mem_reallocate(isc_g_mctx, data, REGET_GROW_SIZE);
assert_non_null(data);
for (size_t i = 0; i < REGET_INIT_SIZE; i++) {
data[i - 1] = i % UINT8_MAX;
}
- data = isc_mem_reallocate(mctx, data, REGET_SHRINK_SIZE);
+ data = isc_mem_reallocate(isc_g_mctx, data, REGET_SHRINK_SIZE);
assert_non_null(data);
for (size_t i = REGET_SHRINK_SIZE; i > 0; i--) {
assert_int_equal(data[i - 1], i % UINT8_MAX);
}
- isc_mem_free(mctx, data);
+ isc_mem_free(isc_g_mctx, data);
}
ISC_RUN_TEST_IMPL(isc_mem_overmem) {
- isc_mem_t *omctx = NULL;
- isc_mem_create("test", &omctx);
- assert_non_null(omctx);
+ isc_mem_t *mctx = NULL;
+ isc_mem_create("test", &mctx);
+ assert_non_null(mctx);
- isc_mem_setwater(omctx, 1024, 512);
+ isc_mem_setwater(mctx, 1024, 512);
/* inuse < lo_water */
- void *data1 = isc_mem_allocate(omctx, 256);
- assert_false(isc_mem_isovermem(omctx));
+ void *data1 = isc_mem_allocate(mctx, 256);
+ assert_false(isc_mem_isovermem(mctx));
/* lo_water < inuse < hi_water */
- void *data2 = isc_mem_allocate(omctx, 512);
- assert_false(isc_mem_isovermem(omctx));
+ void *data2 = isc_mem_allocate(mctx, 512);
+ assert_false(isc_mem_isovermem(mctx));
/* hi_water < inuse */
- void *data3 = isc_mem_allocate(omctx, 512);
- assert_true(isc_mem_isovermem(omctx));
+ void *data3 = isc_mem_allocate(mctx, 512);
+ assert_true(isc_mem_isovermem(mctx));
/* lo_water < inuse < hi_water */
- isc_mem_free(omctx, data2);
- assert_true(isc_mem_isovermem(omctx));
+ isc_mem_free(mctx, data2);
+ assert_true(isc_mem_isovermem(mctx));
/* inuse < lo_water */
- isc_mem_free(omctx, data3);
- assert_false(isc_mem_isovermem(omctx));
+ isc_mem_free(mctx, data3);
+ assert_false(isc_mem_isovermem(mctx));
/* inuse == 0 */
- isc_mem_free(omctx, data1);
- assert_false(isc_mem_isovermem(omctx));
+ isc_mem_free(mctx, data1);
+ assert_false(isc_mem_isovermem(mctx));
- isc_mem_detach(&omctx);
+ isc_mem_detach(&mctx);
}
#if ISC_MEM_TRACKLINES
/* test mem with no flags */
ISC_RUN_TEST_IMPL(isc_mem_noflags) {
isc_result_t result;
- isc_mem_t *mctx2 = NULL;
+ isc_mem_t *mctx = NULL;
char buf[4096], *p;
FILE *f;
void *ptr;
assert_int_equal(result, ISC_R_SUCCESS);
isc_mem_debugging = 0;
- isc_mem_create("test", &mctx2);
- ptr = isc_mem_get(mctx2, 2048);
+ isc_mem_create("test", &mctx);
+ ptr = isc_mem_get(mctx, 2048);
assert_non_null(ptr);
- isc__mem_printactive(mctx2, f);
- isc_mem_put(mctx2, ptr, 2048);
- isc_mem_detach(&mctx2);
+ isc__mem_printactive(mctx, f);
+ isc_mem_put(mctx, ptr, 2048);
+ isc_mem_detach(&mctx);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
isc_stdio_close(f);
/* test mem with record flag */
ISC_RUN_TEST_IMPL(isc_mem_recordflag) {
isc_result_t result;
- isc_mem_t *mctx2 = NULL;
+ isc_mem_t *mctx = NULL;
char buf[4096], *p;
FILE *f;
void *ptr;
result = isc_stdio_open("mem.output", "w", &f);
assert_int_equal(result, ISC_R_SUCCESS);
- isc_mem_create("test", &mctx2);
+ isc_mem_create("test", &mctx);
- ptr = isc_mem_get(mctx2, 2048);
+ ptr = isc_mem_get(mctx, 2048);
assert_non_null(ptr);
/*
* shutdown if a plugin leaked memory, because the plugin would be
* unloaded, and __FILE__ pointer passed at this time would be dangling.
*/
- ptr2 = isc__mem_get(mctx2, 1024, 0, __func__, dummyfilename, __LINE__);
+ ptr2 = isc__mem_get(mctx, 1024, 0, __func__, dummyfilename, __LINE__);
assert_non_null(ptr2);
dummyfilename[0] = 'b';
- isc__mem_printactive(mctx2, f);
- isc_mem_put(mctx2, ptr2, 1024);
- isc_mem_put(mctx2, ptr, 2048);
- isc_mem_detach(&mctx2);
+ isc__mem_printactive(mctx, f);
+ isc_mem_put(mctx, ptr2, 1024);
+ isc_mem_put(mctx, ptr, 2048);
+ isc_mem_detach(&mctx);
isc_stdio_close(f);
memset(buf, 0, sizeof(buf));
/* test mem with trace flag */
ISC_RUN_TEST_IMPL(isc_mem_traceflag) {
isc_result_t result;
- isc_mem_t *mctx2 = NULL;
+ isc_mem_t *mctx = NULL;
char buf[4096], *p;
FILE *f;
void *ptr;
assert_non_null(f);
isc_mem_debugging = ISC_MEM_DEBUGRECORD | ISC_MEM_DEBUGTRACE;
- isc_mem_create("test", &mctx2);
- ptr = isc_mem_get(mctx2, 2048);
+ isc_mem_create("test", &mctx);
+ ptr = isc_mem_get(mctx, 2048);
assert_non_null(ptr);
- isc__mem_printactive(mctx2, f);
- isc_mem_put(mctx2, ptr, 2048);
- isc_mem_detach(&mctx2);
+ isc__mem_printactive(mctx, f);
+ isc_mem_put(mctx, ptr, 2048);
+ isc_mem_detach(&mctx);
isc_mem_debugging = ISC_MEM_DEBUGRECORD;
isc_stdio_close(f);
static void *
mem_thread(void *arg) {
- isc_mem_t *mctx2 = (isc_mem_t *)arg;
+ isc_mem_t *mctx = (isc_mem_t *)arg;
void *items[NUM_ITEMS];
size_t size = atomic_load(&mem_size);
while (!atomic_compare_exchange_weak(&mem_size, &size, size / 2)) {
for (int i = 0; i < ITERS; i++) {
for (int j = 0; j < NUM_ITEMS; j++) {
- items[j] = isc_mem_get(mctx2, size);
+ items[j] = isc_mem_get(mctx, size);
}
for (int j = 0; j < NUM_ITEMS; j++) {
- isc_mem_put(mctx2, items[j], size);
+ isc_mem_put(mctx, items[j], size);
}
}
ts1 = isc_time_now();
for (int i = 0; i < nthreads; i++) {
- isc_thread_create(mem_thread, mctx, &threads[i]);
+ isc_thread_create(mem_thread, isc_g_mctx, &threads[i]);
}
for (int i = 0; i < nthreads; i++) {
isc_thread_join(threads[i], NULL);
}
ISC_RUN_TEST_IMPL(isc_mutex_benchmark) {
- isc_thread_t *threads = isc_mem_cget(mctx, workers, sizeof(*threads));
+ isc_thread_t *threads = isc_mem_cget(isc_g_mctx, workers,
+ sizeof(*threads));
isc_time_t ts1, ts2;
double t;
int dc;
isc_mutex_destroy(&lock);
- isc_mem_cput(mctx, threads, workers, sizeof(*threads));
+ isc_mem_cput(isc_g_mctx, threads, workers, sizeof(*threads));
}
ISC_TEST_LIST_START
isc_nonce_buf(&send_magic, sizeof(send_magic));
setup_loopmgr(state);
- isc_netmgr_create(mctx);
+ isc_netmgr_create(isc_g_mctx);
isc_nm_setinitialtimeout(T_INIT);
isc_nm_setprimariestimeout(T_PRIMARIES);
isc_nm_setidletimeout(T_IDLE);
isc_tlsctx_enable_dot_client_alpn(tcp_connect_tlsctx);
isc_tlsctx_client_session_cache_create(
- mctx, tcp_connect_tlsctx,
+ isc_g_mctx, tcp_connect_tlsctx,
ISC_TLSCTX_CLIENT_SESSION_CACHE_DEFAULT_SIZE,
&tcp_tlsctx_client_sess_cache);
static int
setup_test_proxy(void **state) {
isc_proxy2_handler_t **handler = (isc_proxy2_handler_t **)state;
- *handler = isc_proxy2_handler_new(mctx, 0, proxy2_handler_dummy, NULL);
+ *handler = isc_proxy2_handler_new(isc_g_mctx, 0, proxy2_handler_dummy,
+ NULL);
return 0;
}
UNUSED(state);
- isc_proxy2_handler_init(&handler, mctx, sizeof(proxy_v2_header),
+ isc_proxy2_handler_init(&handler, isc_g_mctx, sizeof(proxy_v2_header),
proxy2_handler_dummy, NULL);
result = isc_proxy2_handler_push_data(&handler, proxy_v2_header,
isc_proxy2_handler_uninit(&handler);
- isc_proxy2_handler_init(&handler, mctx, sizeof(proxy_v2_header) - 1,
+ isc_proxy2_handler_init(&handler, isc_g_mctx,
+ sizeof(proxy_v2_header) - 1,
proxy2_handler_dummy, NULL);
result = isc_proxy2_handler_push_data(&handler, proxy_v2_header,
const size_t size) {
isc_proxy2_handler_t handler = { 0 };
- isc_proxy2_handler_init(&handler, mctx, 0, proxy2_handler_rebuild_cb,
- outbuf);
+ isc_proxy2_handler_init(&handler, isc_g_mctx, 0,
+ proxy2_handler_rebuild_cb, outbuf);
isc_proxy2_handler_push_data(&handler, data, size);
UNUSED(state);
- isc_radix_create(mctx, &radix, 32);
+ isc_radix_create(isc_g_mctx, &radix, 32);
in_addr.s_addr = inet_addr("1.1.1.1");
isc_netaddr_fromin(&netaddr, &in_addr);
UNUSED(state);
- isc_radix_create(mctx, &radix, 32);
+ isc_radix_create(isc_g_mctx, &radix, 32);
in_addr.s_addr = inet_addr("3.3.3.0");
isc_netaddr_fromin(&netaddr, &in_addr);
double s_obs;
double p_value;
- UNUSED(mctx);
+ UNUSED(isc_g_mctx);
numbits = length * sizeof(*values) * 8;
scount = 0;
double denom;
double p_value;
- UNUSED(mctx);
+ UNUSED(isc_g_mctx);
numbits = length * sizeof(*values) * 8;
bcount = 0;
assert_true(numblocks < 100);
assert_true(numbits >= (mbits * numblocks));
- pi = isc_mem_cget(mctx, numblocks, sizeof(double));
+ pi = isc_mem_cget(isc_g_mctx, numblocks, sizeof(double));
assert_non_null(pi);
for (i = 0; i < numblocks; i++) {
chi_square *= 4 * mbits;
- isc_mem_cput(mctx, pi, numblocks, sizeof(double));
+ isc_mem_cput(isc_g_mctx, pi, numblocks, sizeof(double));
p_value = igamc(numblocks * 0.5, chi_square * 0.5);
double chi_square;
double p_value;
- UNUSED(mctx);
+ UNUSED(isc_g_mctx);
matrix_m = 32;
matrix_q = 32;
rlstat_t *rlstat = (rlstat_t *)arg;
isc_rlevent_free(&rlstat->event);
- isc_mem_put(mctx, rlstat, sizeof(*rlstat));
+ isc_mem_put(isc_g_mctx, rlstat, sizeof(*rlstat));
ticks++;
ISC_LOOP_TEST_SETUP_TEARDOWN_IMPL(ratelimiter_enqueue) {
isc_result_t result;
- rlstat_t *rlstat = isc_mem_get(mctx, sizeof(*rlstat));
+ rlstat_t *rlstat = isc_mem_get(isc_g_mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
result = isc_ratelimiter_enqueue(rl, isc_loop_main(), tick, rlstat,
ISC_LOOP_TEST_SETUP_TEARDOWN_IMPL(ratelimiter_enqueue_shutdown) {
isc_rlevent_t *event = NULL;
- rlstat_t *rlstat = isc_mem_get(mctx, sizeof(*rlstat));
+ rlstat_t *rlstat = isc_mem_get(isc_g_mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
expect_assert_failure(isc_ratelimiter_enqueue(NULL, isc_loop_main(),
}
ISC_LOOP_TEST_SETUP_TEARDOWN_IMPL(ratelimiter_dequeue) {
- isc_rlevent_t *fake = isc_mem_get(mctx, sizeof(*fake));
- rlstat_t *rlstat = isc_mem_get(mctx, sizeof(*rlstat));
+ isc_rlevent_t *fake = isc_mem_get(isc_g_mctx, sizeof(*fake));
+ rlstat_t *rlstat = isc_mem_get(isc_g_mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tick,
ISC_R_SUCCESS);
assert_int_equal(isc_ratelimiter_dequeue(rl, &rlstat->event),
ISC_R_SUCCESS);
- isc_mem_put(mctx, rlstat, sizeof(*rlstat));
+ isc_mem_put(isc_g_mctx, rlstat, sizeof(*rlstat));
/* Set up a mock ratelimiter event that isn't actually scheduled */
*fake = (isc_rlevent_t){ .link = ISC_LINK_INITIALIZER };
assert_int_equal(isc_ratelimiter_dequeue(rl, &fake), ISC_R_NOTFOUND);
isc_loop_detach(&fake->loop);
isc_ratelimiter_detach(&fake->rl);
- isc_mem_put(mctx, fake, sizeof(*fake));
+ isc_mem_put(isc_g_mctx, fake, sizeof(*fake));
isc_ratelimiter_shutdown(rl);
isc_ratelimiter_detach(&rl);
rlstat_t *rlstat = (rlstat_t *)arg;
isc_rlevent_free(&rlstat->event);
- isc_mem_put(mctx, rlstat, sizeof(*rlstat));
+ isc_mem_put(isc_g_mctx, rlstat, sizeof(*rlstat));
ticks++;
tock_time = isc_time_now();
isc_ratelimiter_setpertic(rl, 1);
isc_ratelimiter_setpushpop(rl, false);
- rlstat = isc_mem_get(mctx, sizeof(*rlstat));
+ rlstat = isc_mem_get(isc_g_mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tock,
rlstat, &rlstat->event),
ISC_R_SUCCESS);
- rlstat = isc_mem_get(mctx, sizeof(*rlstat));
+ rlstat = isc_mem_get(isc_g_mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tick,
rlstat, &rlstat->event),
isc_ratelimiter_setpertic(rl, 2);
isc_ratelimiter_setpushpop(rl, true);
- rlstat = isc_mem_get(mctx, sizeof(*rlstat));
+ rlstat = isc_mem_get(isc_g_mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tock,
rlstat, &rlstat->event),
ISC_R_SUCCESS);
- rlstat = isc_mem_get(mctx, sizeof(*rlstat));
+ rlstat = isc_mem_get(isc_g_mctx, sizeof(*rlstat));
*rlstat = (rlstat_t){ 0 };
assert_int_equal(isc_ratelimiter_enqueue(rl, isc_loop_main(), tick,
rlstat, &rlstat->event),
}
assert_int_not_equal(delay_loop, 0);
- rnd = isc_mem_cget(mctx, loops, sizeof(rnd[0]));
+ rnd = isc_mem_cget(isc_g_mctx, loops, sizeof(rnd[0]));
for (size_t i = 0; i < loops; i++) {
rnd[i] = (uint8_t)isc_random_uniform(100);
}
static int
teardown_env(void **state __attribute__((__unused__))) {
- isc_mem_cput(mctx, rnd, loops, sizeof(rnd[0]));
+ isc_mem_cput(isc_g_mctx, rnd, loops, sizeof(rnd[0]));
return 0;
}
}
ISC_RUN_TEST_IMPL(isc_rwlock_benchmark) {
- isc_thread_t *threads = isc_mem_cget(mctx, workers, sizeof(*threads));
+ isc_thread_t *threads = isc_mem_cget(isc_g_mctx, workers,
+ sizeof(*threads));
memset(threads, 0, sizeof(*threads) * workers);
isc__rwlock_benchmark(threads, nthreads, 100);
}
- isc_mem_cput(mctx, threads, workers, sizeof(*threads));
+ isc_mem_cput(isc_g_mctx, threads, workers, sizeof(*threads));
}
ISC_TEST_LIST_START
}
ISC_RUN_TEST_IMPL(isc_spinlock_benchmark) {
- isc_thread_t *threads = isc_mem_cget(mctx, workers, sizeof(*threads));
+ isc_thread_t *threads = isc_mem_cget(isc_g_mctx, workers,
+ sizeof(*threads));
isc_time_t ts1, ts2;
double t;
int dc;
isc_spinlock_destroy(&lock);
- isc_mem_cput(mctx, threads, workers, sizeof(*threads));
+ isc_mem_cput(isc_g_mctx, threads, workers, sizeof(*threads));
}
ISC_TEST_LIST_START
ISC_RUN_TEST_IMPL(isc_stats_basic) {
isc_stats_t *stats = NULL;
- isc_stats_create(mctx, &stats, 4);
+ isc_stats_create(isc_g_mctx, &stats, 4);
assert_int_equal(isc_stats_ncounters(stats), 4);
/* Default all 0. */
static void
undefine(char *key, unsigned int type ISC_ATTR_UNUSED, isc_symvalue_t value,
void *arg ISC_ATTR_UNUSED) {
- isc_mem_free(mctx, key);
- isc_mem_free(mctx, value.as_pointer);
+ isc_mem_free(isc_g_mctx, key);
+ isc_mem_free(isc_g_mctx, value.as_pointer);
}
ISC_RUN_TEST_IMPL(symtab_define) {
isc_symexists_t policy = isc_symexists_reject;
char str[16], *key;
snprintf(str, sizeof(str), "%p", "define");
- key = isc_mem_strdup(mctx, str);
+ key = isc_mem_strdup(isc_g_mctx, str);
- isc_symtab_create(mctx, undefine, NULL, false, &symtab);
+ isc_symtab_create(isc_g_mctx, undefine, NULL, false, &symtab);
assert_non_null(symtab);
- value.as_pointer = isc_mem_strdup(mctx, key);
+ value.as_pointer = isc_mem_strdup(isc_g_mctx, key);
assert_non_null(value.as_pointer);
result = isc_symtab_define(symtab, key, 1, value, policy);
char str[16], *key, *key_after_undefine;
snprintf(str, sizeof(str), "%p", "undefine");
- key = isc_mem_strdup(mctx, str);
- key_after_undefine = isc_mem_strdup(mctx, str);
+ key = isc_mem_strdup(isc_g_mctx, str);
+ key_after_undefine = isc_mem_strdup(isc_g_mctx, str);
- isc_symtab_create(mctx, undefine, NULL, false, &symtab);
+ isc_symtab_create(isc_g_mctx, undefine, NULL, false, &symtab);
assert_non_null(symtab);
- value.as_pointer = isc_mem_strdup(mctx, key);
+ value.as_pointer = isc_mem_strdup(isc_g_mctx, key);
assert_non_null(value.as_pointer);
result = isc_symtab_define(symtab, key, 1, value, policy);
/* key will be freed by isc_symtab_undefine, so we don't need to free
* it again
*/
- isc_mem_free(mctx, key_after_undefine);
+ isc_mem_free(isc_g_mctx, key_after_undefine);
}
ISC_RUN_TEST_IMPL(symtab_replace) {
isc_symexists_t policy = isc_symexists_replace;
char str[16], *key1, *key2;
snprintf(str, sizeof(str), "%p", "replace");
- key1 = isc_mem_strdup(mctx, str);
- key2 = isc_mem_strdup(mctx, str);
+ key1 = isc_mem_strdup(isc_g_mctx, str);
+ key2 = isc_mem_strdup(isc_g_mctx, str);
- isc_symtab_create(mctx, undefine, NULL, false, &symtab);
+ isc_symtab_create(isc_g_mctx, undefine, NULL, false, &symtab);
assert_non_null(symtab);
- value1.as_pointer = isc_mem_strdup(mctx, key1);
+ value1.as_pointer = isc_mem_strdup(isc_g_mctx, key1);
assert_non_null(value1.as_pointer);
- value2.as_pointer = isc_mem_strdup(mctx, key2);
+ value2.as_pointer = isc_mem_strdup(isc_g_mctx, key2);
assert_non_null(value2.as_pointer);
result = isc_symtab_define(symtab, key1, 1, value1, policy);
isc_symexists_t policy = isc_symexists_reject;
char str[16], *key1, *key2;
snprintf(str, sizeof(str), "%p", "reject");
- key1 = isc_mem_strdup(mctx, str);
- key2 = isc_mem_strdup(mctx, str);
+ key1 = isc_mem_strdup(isc_g_mctx, str);
+ key2 = isc_mem_strdup(isc_g_mctx, str);
- isc_symtab_create(mctx, undefine, NULL, false, &symtab);
+ isc_symtab_create(isc_g_mctx, undefine, NULL, false, &symtab);
assert_non_null(symtab);
- value1.as_pointer = isc_mem_strdup(mctx, key1);
+ value1.as_pointer = isc_mem_strdup(isc_g_mctx, key1);
assert_non_null(value1.as_pointer);
- value2.as_pointer = isc_mem_strdup(mctx, key2);
+ value2.as_pointer = isc_mem_strdup(isc_g_mctx, key2);
assert_non_null(value2.as_pointer);
result = isc_symtab_define(symtab, key1, 1, value1, policy);
isc_symexists_t policy = isc_symexists_reject;
bool seen[TEST_NITEMS] = { 0 };
- isc_symtab_create(mctx, undefine, NULL, false, &symtab);
+ isc_symtab_create(isc_g_mctx, undefine, NULL, false, &symtab);
/* Nothing should be in the table yet */
assert_non_null(symtab);
snprintf(str, sizeof(str), "%08zx", i);
- key = isc_mem_strdup(mctx, str);
+ key = isc_mem_strdup(isc_g_mctx, str);
assert_non_null(key);
- value.as_pointer = isc_mem_strdup(mctx, str);
+ value.as_pointer = isc_mem_strdup(isc_g_mctx, str);
assert_non_null(value.as_pointer);
result = isc_symtab_define(symtab, key, i + 1, value, policy);
assert_int_equal(result, ISC_R_SUCCESS);
isc_buffer_add(&buf1, strlen(conf) - 1);
/* Parse with default line numbering */
- result = cfg_parser_create(mctx, &p1);
+ result = cfg_parser_create(isc_g_mctx, &p1);
assert_int_equal(result, ISC_R_SUCCESS);
result = cfg_parse_buffer(p1, &buf1, "text1", 0,
char buf[1024];
/* Parse with default line numbering */
- result = cfg_parser_create(mctx, &p);
+ result = cfg_parser_create(isc_g_mctx, &p);
assert_int_equal(result, ISC_R_SUCCESS);
for (size_t i = 0; i < ARRAY_SIZE(tests); i++) {
isc_buffer_add(&buf1, sizeof(text) - 1);
/* Parse with default line numbering */
- result = cfg_parser_create(mctx, &p1);
+ result = cfg_parser_create(isc_g_mctx, &p1);
assert_int_equal(result, ISC_R_SUCCESS);
result = cfg_parse_buffer(p1, &buf1, "text1", 0, &cfg_type_namedconf, 0,
isc_buffer_add(&buf2, sizeof(text) - 1);
/* Parse with changed line number */
- result = cfg_parser_create(mctx, &p2);
+ result = cfg_parser_create(isc_g_mctx, &p2);
assert_int_equal(result, ISC_R_SUCCESS);
result = cfg_parse_buffer(p2, &buf2, "text2", 100, &cfg_type_namedconf,
dns_dispatchmgr_t *dispatchmgr = NULL;
if (with_dispatchmgr) {
- result = dns_dispatchmgr_create(mctx, &dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr);
if (result != ISC_R_SUCCESS) {
return result;
}
}
- dns_view_create(mctx, dispatchmgr, dns_rdataclass_in, name, &view);
+ dns_view_create(isc_g_mctx, dispatchmgr, dns_rdataclass_in, name,
+ &view);
if (dispatchmgr != NULL) {
dns_dispatchmgr_detach(&dispatchmgr);
}
if (with_cache) {
- result = dns_cache_create(dns_rdataclass_in, "", mctx, &cache);
+ result = dns_cache_create(dns_rdataclass_in, "", isc_g_mctx,
+ &cache);
if (result != ISC_R_SUCCESS) {
dns_view_detach(&view);
return result;
/*
* Create the zone structure.
*/
- dns_zone_create(&zone, mctx, 0);
+ dns_zone_create(&zone, isc_g_mctx, 0);
/*
* Set zone type and origin.
dns_test_setupzonemgr(void) {
REQUIRE(zonemgr == NULL);
- dns_zonemgr_create(mctx, &zonemgr);
+ dns_zonemgr_create(isc_g_mctx, &zonemgr);
}
isc_result_t
return result;
}
- result = dns_db_create(mctx, dbimp, name, dbtype, dns_rdataclass_in, 0,
- NULL, db);
+ result = dns_db_create(isc_g_mctx, dbimp, name, dbtype,
+ dns_rdataclass_in, 0, NULL, db);
if (result != ISC_R_SUCCESS) {
return result;
}
/*
* Create a lexer as one is required by dns_rdata_fromtext().
*/
- isc_lex_create(mctx, 64, &lex);
+ isc_lex_create(isc_g_mctx, 64, &lex);
/*
* Set characters which will be treated as valid multi-line RDATA
* Parse input string, determining result.
*/
result = dns_rdata_fromtext(rdata, rdclass, rdtype, lex, dns_rootname,
- 0, mctx, &target, &callbacks);
+ 0, isc_g_mctx, &target, &callbacks);
destroy_lexer:
isc_lex_destroy(&lex);
name = dns_fixedname_initname(fname);
- isc_buffer_allocate(mctx, &b, length);
+ isc_buffer_allocate(isc_g_mctx, &b, length);
isc_buffer_putmem(b, (const unsigned char *)namestr, length);
result = dns_name_fromtext(name, b, NULL, 0);
REQUIRE(diff != NULL);
REQUIRE(changes != NULL);
- dns_diff_init(mctx, diff);
+ dns_diff_init(isc_g_mctx, diff);
for (i = 0; changes[i].owner != NULL; i++) {
/*
*/
name = dns_fixedname_initname(&fixedname);
result = dns_name_fromstring(name, changes[i].owner,
- dns_rootname, 0, mctx);
+ dns_rootname, 0, isc_g_mctx);
if (result != ISC_R_SUCCESS) {
break;
}
* Create a diff tuple for the parsed change and append it to
* the diff.
*/
- dns_difftuple_create(mctx, changes[i].op, name, changes[i].ttl,
- &rdata, &tuple);
+ dns_difftuple_create(isc_g_mctx, changes[i].op, name,
+ changes[i].ttl, &rdata, &tuple);
dns_diff_append(diff, &tuple);
}
#include <tests/isc.h>
-isc_mem_t *mctx = NULL;
unsigned int workers = 0;
bool debug = false;
int
setup_mctx(void **state ISC_ATTR_UNUSED) {
isc_mem_debugging |= ISC_MEM_DEBUGRECORD;
- isc_mem_create("test", &mctx);
+ isc_mem_create("test", &isc_g_mctx);
return 0;
}
int
teardown_mctx(void **state ISC_ATTR_UNUSED) {
- isc_mem_detach(&mctx);
+ isc_mem_detach(&isc_g_mctx);
return 0;
}
int
setup_loopmgr(void **state ISC_ATTR_UNUSED) {
- REQUIRE(mctx != NULL);
+ REQUIRE(isc_g_mctx != NULL);
setup_workers(state);
- isc_loopmgr_create(mctx, workers);
+ isc_loopmgr_create(isc_g_mctx, workers);
return 0;
}
setup_netmgr(void **state ISC_ATTR_UNUSED) {
adjustnofile();
- isc_netmgr_create(mctx);
+ isc_netmgr_create(isc_g_mctx);
return 0;
}
setup_managers(state);
- ns_server_create(mctx, matchview, &sctx);
+ ns_server_create(isc_g_mctx, matchview, &sctx);
- result = dns_dispatchmgr_create(mctx, &dispatchmgr);
+ result = dns_dispatchmgr_create(isc_g_mctx, &dispatchmgr);
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
- result = ns_interfacemgr_create(mctx, sctx, dispatchmgr, NULL,
+ result = ns_interfacemgr_create(isc_g_mctx, sctx, dispatchmgr, NULL,
&interfacemgr);
if (result != ISC_R_SUCCESS) {
goto cleanup;
/*
* Create a new DNS message holding a query.
*/
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
&message);
/*
* class IN and type "qtype", link the two and add the result to the
* QUESTION section of the query.
*/
- result = dns_name_fromstring(qname, qnamestr, dns_rootname, 0, mctx);
+ result = dns_name_fromstring(qname, qnamestr, dns_rootname, 0,
+ isc_g_mctx);
if (result != ISC_R_SUCCESS) {
goto put_name;
}
/*
* Render the query.
*/
- dns_compress_init(&cctx, mctx, 0);
+ dns_compress_init(&cctx, isc_g_mctx, 0);
isc_buffer_init(&querybuf, query, sizeof(query));
result = dns_message_renderbegin(message, &cctx, &querybuf);
if (result != ISC_R_SUCCESS) {
* duplicated or otherwise they will become invalidated once the stack
* gets unwound.
*/
- qctx = isc_mem_get(mctx, sizeof(*qctx));
+ qctx = isc_mem_get(isc_g_mctx, sizeof(*qctx));
memmove(qctx, (query_ctx_t *)arg, sizeof(*qctx));
qctxp = (query_ctx_t **)data;
* set hooks.
*/
- ns_hooktable_create(mctx, &query_hooks);
- ns_hook_add(query_hooks, mctx, NS_QUERY_SETUP, &hook);
+ ns_hooktable_create(isc_g_mctx, &query_hooks);
+ ns_hook_add(query_hooks, isc_g_mctx, NS_QUERY_SETUP, &hook);
saved_hook_table = ns__hook_table;
ns__hook_table = query_hooks;
ns_query_start(client, client->inner.handle);
ns__hook_table = saved_hook_table;
- ns_hooktable_free(mctx, (void **)&query_hooks);
+ ns_hooktable_free(isc_g_mctx, (void **)&query_hooks);
isc_nmhandle_detach(&client->inner.reqhandle);
isc_nmhandle_detach(&qctx->client->inner.handle);
}
- isc_mem_put(mctx, qctx, sizeof(*qctx));
+ isc_mem_put(isc_g_mctx, qctx, sizeof(*qctx));
}
ns_hookresult_t
return result;
}
- result = dns_db_create(mctx, dbimp, name, dbtype, dns_rdataclass_in, 0,
- NULL, db);
+ result = dns_db_create(isc_g_mctx, dbimp, name, dbtype,
+ dns_rdataclass_in, 0, NULL, db);
if (result != ISC_R_SUCCESS) {
return result;
}
char rcodebuf[20];
isc_buffer_t b;
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &message);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &message);
result = dns_message_parse(message, buf, 0);
assert_int_equal(result, ISC_R_SUCCESS);
isc_buffer_init(&nbuf, ndata, nsize);
isc_buffer_add(&nbuf, nsize);
- dns_message_create(mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE, &nmsg);
+ dns_message_create(isc_g_mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
+ &nmsg);
result = dns_message_parse(nmsg, &nbuf, 0);
assert_int_equal(result, ISC_R_SUCCESS);
* Prepare a target buffer of given size. Store it in 'state' so that
* it can get cleaned up by _teardown() if the test fails.
*/
- *target = isc_mem_allocate(mctx, test->output_size);
+ *target = isc_mem_allocate(isc_g_mctx, test->output_size);
/*
* Call ns_plugin_expandpath().
*target);
}
- isc_mem_free(mctx, *target);
+ isc_mem_free(isc_g_mctx, *target);
}
/* test ns_plugin_expandpath() */
* Interrupt execution if ns_query_done() is called.
*/
- ns_hooktable_create(mctx, &query_hooks);
- ns_hook_add(query_hooks, mctx, NS_QUERY_DONE_BEGIN, &hook);
+ ns_hooktable_create(isc_g_mctx, &query_hooks);
+ ns_hook_add(query_hooks, isc_g_mctx, NS_QUERY_DONE_BEGIN, &hook);
ns__hook_table = query_hooks;
/*
* Clean up.
*/
ns_test_qctx_destroy(&qctx);
- ns_hooktable_free(mctx, (void **)&query_hooks);
+ ns_hooktable_free(isc_g_mctx, (void **)&query_hooks);
}
/* test ns__query_sfcache() */
/*
* Interrupt execution if query_lookup() or ns_query_done() is called.
*/
- ns_hooktable_create(mctx, &query_hooks);
- ns_hook_add(query_hooks, mctx, NS_QUERY_LOOKUP_BEGIN, &hook);
- ns_hook_add(query_hooks, mctx, NS_QUERY_DONE_BEGIN, &hook);
+ ns_hooktable_create(isc_g_mctx, &query_hooks);
+ ns_hook_add(query_hooks, isc_g_mctx, NS_QUERY_LOOKUP_BEGIN, &hook);
+ ns_hook_add(query_hooks, isc_g_mctx, NS_QUERY_DONE_BEGIN, &hook);
ns__hook_table = query_hooks;
/*
ns_test_cleanup_zone();
}
ns_test_qctx_destroy(&qctx);
- ns_hooktable_free(mctx, (void **)&query_hooks);
+ ns_hooktable_free(isc_g_mctx, (void **)&query_hooks);
}
/* test ns__query_start() */
/* 'runasync' callback passed to ns_query_hookasync */
static isc_result_t
-test_hookasync(query_ctx_t *qctx, isc_mem_t *memctx, void *arg,
- isc_loop_t *loop, isc_job_cb cb, void *evarg,
- ns_hookasync_t **ctxp) {
+test_hookasync(query_ctx_t *qctx, isc_mem_t *mctx, void *arg, isc_loop_t *loop,
+ isc_job_cb cb, void *evarg, ns_hookasync_t **ctxp) {
hookasync_data_t *asdata = arg;
ns_hookasync_t *ctx = NULL;
ns_hook_resume_t *rev = NULL;
return asdata->start_result;
}
- ctx = isc_mem_get(memctx, sizeof(*ctx));
- rev = isc_mem_get(memctx, sizeof(*rev));
+ ctx = isc_mem_get(mctx, sizeof(*ctx));
+ rev = isc_mem_get(mctx, sizeof(*rev));
*rev = (ns_hook_resume_t){
.hookpoint = asdata->hookpoint,
.origresult = DNS_R_NXDOMAIN,
.cancel = cancel_hookactx,
.private = asdata,
};
- isc_mem_attach(memctx, &ctx->mctx);
+ isc_mem_attach(mctx, &ctx->mctx);
*ctxp = ctx;
return ISC_R_SUCCESS;
* in practice, but that's fine for the testing purpose).
*/
ns__hook_table = NULL;
- ns_hooktable_create(mctx, &ns__hook_table);
- ns_hook_add(ns__hook_table, mctx, NS_QUERY_START_BEGIN, &testhook);
+ ns_hooktable_create(isc_g_mctx, &ns__hook_table);
+ ns_hook_add(ns__hook_table, isc_g_mctx, NS_QUERY_START_BEGIN,
+ &testhook);
if (test->hookpoint2 != NS_QUERY_START_BEGIN) {
/*
* unless testing START_BEGIN itself, specify the hook for the
* expected resume point, too.
*/
- ns_hook_add(ns__hook_table, mctx, test->hookpoint2, &testhook);
+ ns_hook_add(ns__hook_table, isc_g_mctx, test->hookpoint2,
+ &testhook);
}
- ns_hook_add(ns__hook_table, mctx, NS_QUERY_QCTX_DESTROYED,
+ ns_hook_add(ns__hook_table, isc_g_mctx, NS_QUERY_QCTX_DESTROYED,
&destroyhook);
{
* qctx->client may have been invalidated while we still need it.
*/
ns_test_qctx_destroy(&qctx);
- ns_hooktable_free(mctx, (void **)&ns__hook_table);
+ ns_hooktable_free(isc_g_mctx, (void **)&ns__hook_table);
if (!test->quota_ok) {
isc_quota_release(&sctx->recursionquota);
}
/* 'runasync' callback passed to ns_query_hookasync */
static isc_result_t
-test_hookasync_e2e(query_ctx_t *qctx, isc_mem_t *memctx, void *arg,
+test_hookasync_e2e(query_ctx_t *qctx, isc_mem_t *mctx, void *arg,
isc_loop_t *loop, isc_job_cb cb, void *evarg,
ns_hookasync_t **ctxp) {
ns_hookasync_t *ctx = NULL;
return asdata->start_result;
}
- ctx = isc_mem_get(memctx, sizeof(*ctx));
- rev = isc_mem_get(memctx, sizeof(*rev));
+ ctx = isc_mem_get(mctx, sizeof(*ctx));
+ rev = isc_mem_get(mctx, sizeof(*rev));
*rev = (ns_hook_resume_t){
.hookpoint = asdata->hookpoint,
.saved_qctx = qctx,
.cancel = cancel_e2ehookactx,
.private = asdata,
};
- isc_mem_attach(memctx, &ctx->mctx);
+ isc_mem_attach(mctx, &ctx->mctx);
*ctxp = ctx;
return ISC_R_SUCCESS;
};
ns__hook_table = NULL;
- ns_hooktable_create(mctx, &ns__hook_table);
- ns_hook_add(ns__hook_table, mctx, test->hookpoint, &hook);
- ns_hook_add(ns__hook_table, mctx, NS_QUERY_DONE_SEND, &donesend_hook);
+ ns_hooktable_create(isc_g_mctx, &ns__hook_table);
+ ns_hook_add(ns__hook_table, isc_g_mctx, test->hookpoint, &hook);
+ ns_hook_add(ns__hook_table, isc_g_mctx, NS_QUERY_DONE_SEND,
+ &donesend_hook);
result = ns_test_qctx_create(&qctx_params, &qctx);
INSIST(result == ISC_R_SUCCESS);
/* Cleanup */
ns_test_qctx_destroy(&qctx);
ns_test_cleanup_zone();
- ns_hooktable_free(mctx, (void **)&ns__hook_table);
+ ns_hooktable_free(isc_g_mctx, (void **)&ns__hook_table);
}
ISC_LOOP_TEST_IMPL(ns__query_hookasync_e2e) {
projects / thirdparty / bind9.git / commitdiff
