+4546. [func] Extend the use of const declarations. [RT #43379]
+
4545. [func] Expand YAML output from dnstap-read to include
a detailed breakdown of the DNS message contents.
[RT #43642]
}
static isc_boolean_t
-checkns(dns_zone_t *zone, dns_name_t *name, dns_name_t *owner,
+checkns(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner,
dns_rdataset_t *a, dns_rdataset_t *aaaa)
{
#ifdef USE_GETADDRINFO
}
static isc_boolean_t
-checkmx(dns_zone_t *zone, dns_name_t *name, dns_name_t *owner) {
+checkmx(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
#ifdef USE_GETADDRINFO
struct addrinfo hints, *ai, *cur;
char namebuf[DNS_NAME_FORMATSIZE + 1];
}
static isc_boolean_t
-checksrv(dns_zone_t *zone, dns_name_t *name, dns_name_t *owner) {
+checksrv(dns_zone_t *zone, const dns_name_t *name, const dns_name_t *owner) {
#ifdef USE_GETADDRINFO
struct addrinfo hints, *ai, *cur;
char namebuf[DNS_NAME_FORMATSIZE + 1];
char keysecret[MXNAME] = "";
unsigned char cookie_secret[33];
unsigned char cookie[8];
-dns_name_t *hmacname = NULL;
+const dns_name_t *hmacname = NULL;
unsigned int digestbits = 0;
isc_buffer_t *namebuf = NULL;
dns_tsigkey_t *key = NULL;
}
static isc_result_t
-printrdata(dns_message_t *msg, dns_rdataset_t *rdataset, dns_name_t *owner,
- const char *set_name, isc_boolean_t headers)
+printrdata(dns_message_t *msg, dns_rdataset_t *rdataset,
+ const dns_name_t *owner, const char *set_name,
+ isc_boolean_t headers)
{
isc_buffer_t target;
isc_result_t result;
printmessage(dig_query_t *query, dns_message_t *msg, isc_boolean_t headers) {
isc_boolean_t did_flag = ISC_FALSE;
dns_rdataset_t *opt, *tsig = NULL;
- dns_name_t *tsigname;
+ const dns_name_t *tsigname;
isc_result_t result = ISC_R_SUCCESS;
int force_error;
extern char keynametext[MXNAME];
extern char keyfile[MXNAME];
extern char keysecret[MXNAME];
-extern dns_name_t *hmacname;
+extern const dns_name_t *hmacname;
extern unsigned int digestbits;
#ifdef DIG_SIGCHASE
extern char trustedkey[MXNAME];
*/
isc_boolean_t
ns_client_isself(dns_view_t *myview, dns_tsigkey_t *mykey,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *dstaddr,
+ const isc_sockaddr_t *srcaddr, const isc_sockaddr_t *dstaddr,
dns_rdataclass_t rdclass, void *arg)
{
dns_view_t *view;
isc_buffer_t tbuffer;
dns_view_t *view;
dns_rdataset_t *opt;
- dns_name_t *signame;
+ const dns_name_t *signame;
isc_boolean_t ra; /* Recursion available. */
isc_netaddr_t netaddr;
int match;
}
void
-ns_client_aclmsg(const char *msg, dns_name_t *name, dns_rdatatype_t type,
+ns_client_aclmsg(const char *msg, const dns_name_t *name, dns_rdatatype_t type,
dns_rdataclass_t rdclass, char *buf, size_t len)
{
char namebuf[DNS_NAME_FORMATSIZE];
};
isc_result_t
-ns_config_getkeyalgorithm(const char *str, dns_name_t **name,
+ns_config_getkeyalgorithm(const char *str, const dns_name_t **name,
isc_uint16_t *digestbits)
{
return (ns_config_getkeyalgorithm2(str, name, NULL, digestbits));
}
isc_result_t
-ns_config_getkeyalgorithm2(const char *str, dns_name_t **name,
+ns_config_getkeyalgorithm2(const char *str, const dns_name_t **name,
unsigned int *typep, isc_uint16_t *digestbits)
{
int i;
isc_logmodule_t *module, int level, const char *fmt, va_list ap) ISC_FORMAT_PRINTF(5, 0);
void
-ns_client_aclmsg(const char *msg, dns_name_t *name, dns_rdatatype_t type,
+ns_client_aclmsg(const char *msg, const dns_name_t *name, dns_rdatatype_t type,
dns_rdataclass_t rdclass, char *buf, size_t len);
#define NS_CLIENT_ACLMSGSIZE(x) \
isc_boolean_t
ns_client_isself(dns_view_t *myview, dns_tsigkey_t *mykey,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr, const isc_sockaddr_t *destaddr,
dns_rdataclass_t rdclass, void *arg);
/*%
* Isself callback.
ns_config_getport(const cfg_obj_t *config, in_port_t *portp);
isc_result_t
-ns_config_getkeyalgorithm(const char *str, dns_name_t **name,
+ns_config_getkeyalgorithm(const char *str, const dns_name_t **name,
isc_uint16_t *digestbits);
isc_result_t
-ns_config_getkeyalgorithm2(const char *str, dns_name_t **name,
+ns_config_getkeyalgorithm2(const char *str, const dns_name_t **name,
unsigned int *typep, isc_uint16_t *digestbits);
isc_result_t
ns_interfacemgr_dumprecursing(FILE *f, ns_interfacemgr_t *mgr);
isc_boolean_t
-ns_interfacemgr_listeningon(ns_interfacemgr_t *mgr, isc_sockaddr_t *addr);
+ns_interfacemgr_listeningon(ns_interfacemgr_t *mgr, const isc_sockaddr_t *addr);
#endif /* NAMED_INTERFACEMGR_H */
}
isc_boolean_t
-ns_interfacemgr_listeningon(ns_interfacemgr_t *mgr, isc_sockaddr_t *addr) {
+ns_interfacemgr_listeningon(ns_interfacemgr_t *mgr,
+ const isc_sockaddr_t *addr)
+{
isc_sockaddr_t *old;
for (old = ISC_LIST_HEAD(mgr->listenon);
isc_result_t
ns_lwsearchctx_current(ns_lwsearchctx_t *sctx, dns_name_t *absname) {
- dns_name_t *tname;
+ const dns_name_t *tname;
isc_boolean_t useexact = ISC_FALSE;
REQUIRE(sctx != NULL);
}
static inline isc_result_t
-query_validatezonedb(ns_client_t *client, dns_name_t *name,
+query_validatezonedb(ns_client_t *client, const dns_name_t *name,
dns_rdatatype_t qtype, unsigned int options,
dns_zone_t *zone, dns_db_t *db,
dns_dbversion_t **versionp)
}
static inline isc_result_t
-query_getzonedb(ns_client_t *client, dns_name_t *name, dns_rdatatype_t qtype,
- unsigned int options, dns_zone_t **zonep, dns_db_t **dbp,
- dns_dbversion_t **versionp)
+query_getzonedb(ns_client_t *client, const dns_name_t *name,
+ dns_rdatatype_t qtype, unsigned int options,
+ dns_zone_t **zonep, dns_db_t **dbp, dns_dbversion_t **versionp)
{
isc_result_t result;
unsigned int ztoptions;
}
static inline isc_result_t
-query_getcachedb(ns_client_t *client, dns_name_t *name, dns_rdatatype_t qtype,
- dns_db_t **dbp, unsigned int options)
+query_getcachedb(ns_client_t *client, const dns_name_t *name,
+ dns_rdatatype_t qtype, dns_db_t **dbp, unsigned int options)
{
isc_result_t result;
isc_boolean_t check_acl;
}
static isc_result_t
-query_addadditional(void *arg, dns_name_t *name, dns_rdatatype_t qtype) {
+query_addadditional(void *arg, const dns_name_t *name, dns_rdatatype_t qtype) {
ns_client_t *client = arg;
isc_result_t result, eresult;
dns_dbnode_t *node;
}
static isc_result_t
-query_addadditional2(void *arg, dns_name_t *name, dns_rdatatype_t qtype) {
+query_addadditional2(void *arg, const dns_name_t *name, dns_rdatatype_t qtype) {
client_additionalctx_t *additionalctx = arg;
dns_rdataset_t *rdataset_base;
ns_client_t *client;
char log_buf[DNS_RRL_LOG_BUF_LEN];
isc_result_t nc_result, resp_result;
dns_rrl_result_t rrl_result;
+ const dns_name_t *constname;
client->query.attributes |= NS_QUERYATTR_RRL_CHECKED;
wouldlog = isc_log_wouldlog(ns_g_lctx, DNS_RRL_LOG_DROP);
- tname = fname;
+ constname = fname;
if (result == DNS_R_NXDOMAIN) {
/*
* Use the database origin name to rate limit NXDOMAIN
*/
if (db != NULL)
- tname = dns_db_origin(db);
+ constname = dns_db_origin(db);
resp_result = result;
} else if (result == DNS_R_NCACHENXDOMAIN &&
rdataset != NULL &&
&nc_rdataset);
if (nc_rdataset.type == dns_rdatatype_soa) {
dns_rdataset_disassociate(&nc_rdataset);
- tname = dns_fixedname_name(&fixed);
+ constname = dns_fixedname_name(&fixed);
break;
}
dns_rdataset_disassociate(&nc_rdataset);
* is off or not requested and the hints have not
* been loaded or we have "additional-from-cache no".
*/
- tname = dns_rootname;
+ constname = dns_rootname;
resp_result = DNS_R_DELEGATION;
} else {
resp_result = ISC_R_SUCCESS;
}
rrl_result = dns_rrl(client->view, &client->peeraddr,
TCP(client), client->message->rdclass,
- qtype, tname, resp_result, client->now,
+ qtype, constname, resp_result, client->now,
wouldlog, log_buf, sizeof(log_buf));
if (rrl_result != DNS_RRL_RESULT_OK) {
/*
isc_uint16_t family, ns_listenlist_t **target);
static isc_result_t
-configure_forward(const cfg_obj_t *config, dns_view_t *view, dns_name_t *origin,
- const cfg_obj_t *forwarders, const cfg_obj_t *forwardtype);
+configure_forward(const cfg_obj_t *config, dns_view_t *view,
+ const dns_name_t *origin, const cfg_obj_t *forwarders,
+ const cfg_obj_t *forwardtype);
static isc_result_t
configure_alternates(const cfg_obj_t *config, dns_view_t *view,
static isc_result_t
load_view_keys(const cfg_obj_t *keys, const cfg_obj_t *vconfig,
dns_view_t *view, isc_boolean_t managed,
- dns_name_t *keyname, isc_mem_t *mctx)
+ const dns_name_t *keyname, isc_mem_t *mctx)
{
const cfg_listelt_t *elt, *elt2;
const cfg_obj_t *key, *keylist;
}
static isc_result_t
-add_soa(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
- dns_name_t *origin, dns_name_t *contact)
+add_soa(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
+ const dns_name_t *origin, const dns_name_t *contact)
{
dns_dbnode_t *node = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
}
static isc_result_t
-add_ns(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
- dns_name_t *nsname)
+add_ns(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
+ const dns_name_t *nsname)
{
dns_dbnode_t *node = NULL;
dns_rdata_ns_t ns;
}
static isc_result_t
-configure_forward(const cfg_obj_t *config, dns_view_t *view, dns_name_t *origin,
- const cfg_obj_t *forwarders, const cfg_obj_t *forwardtype)
+configure_forward(const cfg_obj_t *config, dns_view_t *view,
+ const dns_name_t *origin, const cfg_obj_t *forwarders,
+ const cfg_obj_t *forwardtype)
{
const cfg_obj_t *portobj, *dscpobj;
const cfg_obj_t *faddresses;
static isc_result_t
generate_session_key(const char *filename, const char *keynamestr,
- dns_name_t *keyname, const char *algstr,
- dns_name_t *algname, unsigned int algtype,
+ const dns_name_t *keyname, const char *algstr,
+ const dns_name_t *algname, unsigned int algtype,
isc_uint16_t bits, isc_mem_t *mctx,
dns_tsigkey_t **tsigkeyp)
{
const char *keyfile, *keynamestr, *algstr;
unsigned int algtype;
dns_fixedname_t fname;
- dns_name_t *keyname, *algname;
+ dns_name_t *keyname;
+ const dns_name_t *algname;
isc_buffer_t buffer;
isc_uint16_t bits;
const cfg_obj_t *obj;
const char *msg = NULL;
isc_boolean_t dump = ISC_FALSE, force = ISC_FALSE;
dns_fixedname_t fn;
- dns_name_t *ntaname;
+ const dns_name_t *ntaname;
+ dns_name_t *fname;
dns_ttl_t ntattl;
isc_boolean_t ttlset = ISC_FALSE, excl = ISC_FALSE;
UNUSED(force);
dns_fixedname_init(&fn);
- ntaname = dns_fixedname_name(&fn);
+ fname = dns_fixedname_name(&fn);
/* Skip the command name. */
ptr = next_token(lex, text);
isc_buffer_t b;
isc_buffer_init(&b, namebuf, strlen(namebuf));
isc_buffer_add(&b, strlen(namebuf));
- CHECK(dns_name_fromtext(ntaname, &b, dns_rootname, 0, NULL));
+ CHECK(dns_name_fromtext(fname, &b, dns_rootname, 0, NULL));
+ ntaname = fname;
}
/* Look for the view name. */
const cfg_obj_t *algobj = NULL;
const cfg_obj_t *secretobj = NULL;
dns_name_t keyname;
- dns_name_t *alg;
+ const dns_name_t *alg;
const char *algstr;
char keynamedata[1024];
isc_buffer_t keynamesrc, keynamebuf;
}
static isc_uint16_t
-parse_hmac(dns_name_t **hmac, const char *hmacstr, size_t len) {
+parse_hmac(const dns_name_t **hmac, const char *hmacstr, size_t len) {
isc_uint16_t digestbits = 0;
isc_result_t result;
char buf[20];
dns_fixedname_t fkeyname;
dns_name_t *mykeyname;
char *name;
- dns_name_t *hmacname = NULL;
+ const dns_name_t *hmacname = NULL;
isc_uint16_t digestbits = 0;
dns_fixedname_init(&fkeyname);
setup_keyfile(isc_mem_t *mctx, isc_log_t *lctx) {
dst_key_t *dstkey = NULL;
isc_result_t result;
- dns_name_t *hmacname = NULL;
+ const dns_name_t *hmacname = NULL;
debug("Creating key...");
int secretlen;
unsigned char *secret = NULL;
isc_buffer_t secretbuf;
- dns_name_t *hmacname = NULL;
+ const dns_name_t *hmacname = NULL;
isc_uint16_t digestbits = 0;
char *n;
#define BIGBUFLEN (64 * 1024)
static isc_result_t
-t1_add_callback(void *arg, dns_name_t *owner, dns_rdataset_t *dataset);
+t1_add_callback(void *arg, const dns_name_t *owner, dns_rdataset_t *dataset);
isc_mem_t *T1_mctx;
char *Tokens[T_MAXTOKS + 1];
static isc_result_t
-t1_add_callback(void *arg, dns_name_t *owner, dns_rdataset_t *dataset) {
+t1_add_callback(void *arg, const dns_name_t *owner, dns_rdataset_t *dataset) {
char buf[BIGBUFLEN];
isc_buffer_t target;
isc_result_t result;
}
static isc_result_t
-findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+findnode(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_dbnode_t **nodep)
{
sampledb_t *sampledb = (sampledb_t *) db;
}
static isc_result_t
-find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset)
}
static isc_result_t
-findzonecut(dns_db_t *db, dns_name_t *name, unsigned int options,
+findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
}
static isc_result_t
-findnsec3node(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+findnsec3node(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_dbnode_t **nodep)
{
sampledb_t *sampledb = (sampledb_t *) db;
}
static isc_result_t
-findnodeext(dns_db_t *db, dns_name_t *name,
+findnodeext(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create, dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo, dns_dbnode_t **nodep)
{
}
static isc_result_t
-findext(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
* credit goes to ISC.
*/
static isc_result_t
-add_soa(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
- dns_name_t *origin, dns_name_t *contact)
+add_soa(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
+ const dns_name_t *origin, const dns_name_t *contact)
{
dns_dbnode_t *node = NULL;
dns_rdata_t rdata = DNS_RDATA_INIT;
static isc_result_t
-add_ns(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
- dns_name_t *nsname)
+add_ns(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
+ const dns_name_t *nsname)
{
dns_dbnode_t *node = NULL;
dns_rdata_ns_t ns;
}
static isc_result_t
-add_a(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
+add_a(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
struct in_addr addr)
{
dns_dbnode_t *node = NULL;
* @param[in] driverarg Driver-specific parameter from dns_db_register().
*/
isc_result_t
-create_db(isc_mem_t *mctx, dns_name_t *origin, dns_dbtype_t type,
+create_db(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp)
{
#define DB_H_
isc_result_t
-create_db(isc_mem_t *mctx, dns_name_t *origin, dns_dbtype_t type,
+create_db(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp);
/*
* Internal functions (and prototypes).
*/
-static inline dns_adbname_t *new_adbname(dns_adb_t *, dns_name_t *);
+static inline dns_adbname_t *new_adbname(dns_adb_t *, const dns_name_t *);
static inline void free_adbname(dns_adb_t *, dns_adbname_t **);
static inline dns_adbnamehook_t *new_adbnamehook(dns_adb_t *,
dns_adbentry_t *);
static inline void free_adbnamehook(dns_adb_t *, dns_adbnamehook_t **);
-static inline dns_adblameinfo_t *new_adblameinfo(dns_adb_t *, dns_name_t *,
+static inline dns_adblameinfo_t *new_adblameinfo(dns_adb_t *,
+ const dns_name_t *,
dns_rdatatype_t);
static inline void free_adblameinfo(dns_adb_t *, dns_adblameinfo_t **);
static inline dns_adbentry_t *new_adbentry(dns_adb_t *);
in_port_t);
static inline dns_adbfetch_t *new_adbfetch(dns_adb_t *);
static inline void free_adbfetch(dns_adb_t *, dns_adbfetch_t **);
-static inline dns_adbname_t *find_name_and_lock(dns_adb_t *, dns_name_t *,
+static inline dns_adbname_t *find_name_and_lock(dns_adb_t *,
+ const dns_name_t *,
unsigned int, int *);
static inline dns_adbentry_t *find_entry_and_lock(dns_adb_t *,
- isc_sockaddr_t *, int *,
- isc_stdtime_t);
+ const isc_sockaddr_t *,
+ int *, isc_stdtime_t);
static void dump_adb(dns_adb_t *, FILE *, isc_boolean_t debug, isc_stdtime_t);
-static void print_dns_name(FILE *, dns_name_t *);
+static void print_dns_name(FILE *, const dns_name_t *);
static void print_namehook_list(FILE *, const char *legend,
dns_adb_t *adb,
dns_adbnamehooklist_t *list,
}
static isc_result_t
-set_target(dns_adb_t *adb, dns_name_t *name, dns_name_t *fname,
+set_target(dns_adb_t *adb, const dns_name_t *name, const dns_name_t *fname,
dns_rdataset_t *rdataset, dns_name_t *target)
{
isc_result_t result;
}
static inline dns_adbname_t *
-new_adbname(dns_adb_t *adb, dns_name_t *dnsname) {
+new_adbname(dns_adb_t *adb, const dns_name_t *dnsname) {
dns_adbname_t *name;
name = isc_mempool_get(adb->nmp);
}
static inline dns_adblameinfo_t *
-new_adblameinfo(dns_adb_t *adb, dns_name_t *qname, dns_rdatatype_t qtype) {
+new_adblameinfo(dns_adb_t *adb, const dns_name_t *qname,
+ dns_rdatatype_t qtype)
+{
dns_adblameinfo_t *li;
li = isc_mempool_get(adb->limp);
* DNS_ADB_INVALIDBUCKET.
*/
static inline dns_adbname_t *
-find_name_and_lock(dns_adb_t *adb, dns_name_t *name,
+find_name_and_lock(dns_adb_t *adb, const dns_name_t *name,
unsigned int options, int *bucketp)
{
dns_adbname_t *adbname;
* the bucket changes.
*/
static inline dns_adbentry_t *
-find_entry_and_lock(dns_adb_t *adb, isc_sockaddr_t *addr, int *bucketp,
+find_entry_and_lock(dns_adb_t *adb, const isc_sockaddr_t *addr, int *bucketp,
isc_stdtime_t now)
{
dns_adbentry_t *entry, *entry_next;
* Entry bucket MUST be locked!
*/
static isc_boolean_t
-entry_is_lame(dns_adb_t *adb, dns_adbentry_t *entry, dns_name_t *qname,
+entry_is_lame(dns_adb_t *adb, dns_adbentry_t *entry, const dns_name_t *qname,
dns_rdatatype_t qtype, isc_stdtime_t now)
{
dns_adblameinfo_t *li, *next_li;
}
static void
-copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find, dns_name_t *qname,
- dns_rdatatype_t qtype, dns_adbname_t *name,
- isc_stdtime_t now)
+copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find,
+ const dns_name_t *qname, dns_rdatatype_t qtype,
+ dns_adbname_t *name, isc_stdtime_t now)
{
dns_adbnamehook_t *namehook;
dns_adbaddrinfo_t *addrinfo;
isc_result_t
dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
- void *arg, dns_name_t *name, dns_name_t *qname,
+ void *arg, const dns_name_t *name, const dns_name_t *qname,
dns_rdatatype_t qtype, unsigned int options,
isc_stdtime_t now, dns_name_t *target,
in_port_t port, dns_adbfind_t **findp)
isc_result_t
dns_adb_createfind2(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
- void *arg, dns_name_t *name, dns_name_t *qname,
+ void *arg, const dns_name_t *name, const dns_name_t *qname,
dns_rdatatype_t qtype, unsigned int options,
isc_stdtime_t now, dns_name_t *target,
in_port_t port, unsigned int depth, isc_counter_t *qc,
}
static void
-print_dns_name(FILE *f, dns_name_t *name) {
+print_dns_name(FILE *f, const dns_name_t *name) {
char buf[DNS_NAME_FORMATSIZE];
INSIST(f != NULL);
* since these can be extracted from the find itself.
*/
isc_result_t
-dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr, dns_name_t *qname,
- dns_rdatatype_t qtype, isc_stdtime_t expire_time)
+dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
+ const dns_name_t *qname, dns_rdatatype_t qtype,
+ isc_stdtime_t expire_time)
{
dns_adblameinfo_t *li;
int bucket;
}
isc_result_t
-dns_adb_findaddrinfo(dns_adb_t *adb, isc_sockaddr_t *sa,
+dns_adb_findaddrinfo(dns_adb_t *adb, const isc_sockaddr_t *sa,
dns_adbaddrinfo_t **addrp, isc_stdtime_t now)
{
int bucket;
}
void
-dns_adb_flushname(dns_adb_t *adb, dns_name_t *name) {
+dns_adb_flushname(dns_adb_t *adb, const dns_name_t *name) {
dns_adbname_t *adbname;
dns_adbname_t *nextname;
int bucket;
}
void
-dns_adb_flushnames(dns_adb_t *adb, dns_name_t *name) {
+dns_adb_flushnames(dns_adb_t *adb, const dns_name_t *name) {
dns_adbname_t *adbname, *nextname;
unsigned int i;
}
void
-dns_badcache_add(dns_badcache_t *bc, dns_name_t *name,
+dns_badcache_add(dns_badcache_t *bc, const dns_name_t *name,
dns_rdatatype_t type, isc_boolean_t update,
isc_uint32_t flags, isc_time_t *expire)
{
}
isc_boolean_t
-dns_badcache_find(dns_badcache_t *bc, dns_name_t *name,
+dns_badcache_find(dns_badcache_t *bc, const dns_name_t *name,
dns_rdatatype_t type, isc_uint32_t *flagp,
isc_time_t *now)
{
}
void
-dns_badcache_flushname(dns_badcache_t *bc, dns_name_t *name) {
+dns_badcache_flushname(dns_badcache_t *bc, const dns_name_t *name) {
dns_bcentry_t *bad, *prev, *next;
isc_result_t result;
isc_time_t now;
}
void
-dns_badcache_flushtree(dns_badcache_t *bc, dns_name_t *name) {
+dns_badcache_flushtree(dns_badcache_t *bc, const dns_name_t *name) {
dns_bcentry_t *bad, *prev, *next;
unsigned int i;
int n;
};
isc_result_t
-dns_byaddr_createptrname(isc_netaddr_t *address, isc_boolean_t nibble,
+dns_byaddr_createptrname(const isc_netaddr_t *address, isc_boolean_t nibble,
dns_name_t *name)
{
/*
}
isc_result_t
-dns_byaddr_createptrname2(isc_netaddr_t *address, unsigned int options,
+dns_byaddr_createptrname2(const isc_netaddr_t *address, unsigned int options,
dns_name_t *name)
{
char textname[128];
- unsigned char *bytes;
+ const unsigned char *bytes;
int i;
char *cp;
isc_buffer_t buffer;
* of the knowledge of wire format in the dns_name_ routines.
*/
- bytes = (unsigned char *)(&address->type);
+ bytes = (const unsigned char *)(&address->type);
if (address->family == AF_INET) {
(void)snprintf(textname, sizeof(textname),
"%u.%u.%u.%u.in-addr.arpa.",
}
isc_result_t
-dns_byaddr_create(isc_mem_t *mctx, isc_netaddr_t *address, dns_view_t *view,
- unsigned int options, isc_task_t *task,
+dns_byaddr_create(isc_mem_t *mctx, const isc_netaddr_t *address,
+ dns_view_t *view, unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg, dns_byaddr_t **byaddrp)
{
isc_result_t result;
}
static isc_result_t
-cleartree(dns_db_t *db, dns_name_t *name) {
+cleartree(dns_db_t *db, const dns_name_t *name) {
isc_result_t result, answer = ISC_R_SUCCESS;
dns_dbiterator_t *iter = NULL;
dns_dbnode_t *node = NULL, *top = NULL;
}
isc_result_t
-dns_cache_flushname(dns_cache_t *cache, dns_name_t *name) {
+dns_cache_flushname(dns_cache_t *cache, const dns_name_t *name) {
return (dns_cache_flushnode(cache, name, ISC_FALSE));
}
isc_result_t
-dns_cache_flushnode(dns_cache_t *cache, dns_name_t *name,
+dns_cache_flushnode(dns_cache_t *cache, const dns_name_t *name,
isc_boolean_t tree)
{
isc_result_t result;
isc_result_t
dns_catz_update_process(dns_catz_zones_t *catzs, dns_catz_zone_t *zone,
- dns_name_t *src_name, dns_rdataset_t *rdataset)
+ const dns_name_t *src_name, dns_rdataset_t *rdataset)
{
isc_result_t result;
int order;
getudpdispatch(int family, dns_dispatchmgr_t *dispatchmgr,
isc_socketmgr_t *socketmgr, isc_taskmgr_t *taskmgr,
isc_boolean_t is_shared, dns_dispatch_t **dispp,
- isc_sockaddr_t *localaddr)
+ const isc_sockaddr_t *localaddr)
{
unsigned int attrs, attrmask;
dns_dispatch_t *disp;
attrmask |= DNS_DISPATCHATTR_IPV6;
if (localaddr == NULL) {
+ isc_sockaddr_anyofpf(&anyaddr, family);
localaddr = &anyaddr;
- isc_sockaddr_anyofpf(localaddr, family);
}
buffersize = 4096;
dns_client_createx2(isc_mem_t *mctx, isc_appctx_t *actx,
isc_taskmgr_t *taskmgr, isc_socketmgr_t *socketmgr,
isc_timermgr_t *timermgr, unsigned int options,
- dns_client_t **clientp, isc_sockaddr_t *localaddr4,
- isc_sockaddr_t *localaddr6)
+ dns_client_t **clientp, const isc_sockaddr_t *localaddr4,
+ const isc_sockaddr_t *localaddr6)
{
dns_client_t *client;
isc_result_t result;
isc_result_t
dns_client_setservers(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *namespace, isc_sockaddrlist_t *addrs)
+ const dns_name_t *namespace, isc_sockaddrlist_t *addrs)
{
isc_result_t result;
dns_view_t *view = NULL;
isc_result_t
dns_client_clearservers(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *namespace)
+ const dns_name_t *namespace)
{
isc_result_t result;
dns_view_t *view = NULL;
}
isc_result_t
-dns_client_resolve(dns_client_t *client, dns_name_t *name,
+dns_client_resolve(dns_client_t *client, const dns_name_t *name,
dns_rdataclass_t rdclass, dns_rdatatype_t type,
unsigned int options, dns_namelist_t *namelist)
{
}
isc_result_t
-dns_client_startresolve(dns_client_t *client, dns_name_t *name,
+dns_client_startresolve(dns_client_t *client, const dns_name_t *name,
dns_rdataclass_t rdclass, dns_rdatatype_t type,
unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg,
isc_result_t
dns_client_addtrustedkey(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *keyname, isc_buffer_t *keydatabuf)
+ const dns_name_t *keyname, isc_buffer_t *keydatabuf)
{
isc_result_t result;
dns_view_t *view = NULL;
isc_result_t
dns_client_request(dns_client_t *client, dns_message_t *qmessage,
- dns_message_t *rmessage, isc_sockaddr_t *server,
+ dns_message_t *rmessage, const isc_sockaddr_t *server,
unsigned int options, unsigned int parseoptions,
dns_tsec_t *tsec, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries)
isc_result_t
dns_client_startrequest(dns_client_t *client, dns_message_t *qmessage,
- dns_message_t *rmessage, isc_sockaddr_t *server,
+ dns_message_t *rmessage, const isc_sockaddr_t *server,
unsigned int options, unsigned int parseoptions,
dns_tsec_t *tsec, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries,
}
static isc_result_t
-process_soa(updatectx_t *uctx, dns_rdataset_t *soaset, dns_name_t *soaname) {
+process_soa(updatectx_t *uctx, dns_rdataset_t *soaset,
+ const dns_name_t *soaname)
+{
isc_result_t result;
dns_rdata_t soarr = DNS_RDATA_INIT;
dns_rdata_soa_t soa;
}
static isc_result_t
-copy_name(isc_mem_t *mctx, dns_message_t *msg, dns_name_t *name,
+copy_name(isc_mem_t *mctx, dns_message_t *msg, const dns_name_t *name,
dns_name_t **newnamep)
{
isc_result_t result;
isc_result_t
dns_client_update(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *zonename, dns_namelist_t *prerequisites,
+ const dns_name_t *zonename, dns_namelist_t *prerequisites,
dns_namelist_t *updates, isc_sockaddrlist_t *servers,
dns_tsec_t *tsec, unsigned int options)
{
isc_result_t
dns_client_startupdate(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *zonename, dns_namelist_t *prerequisites,
+ const dns_name_t *zonename,
+ dns_namelist_t *prerequisites,
dns_namelist_t *updates, isc_sockaddrlist_t *servers,
dns_tsec_t *tsec, unsigned int options,
isc_task_t *task, isc_taskaction_t action, void *arg,
} dns_client_updaterec_t;
isc_result_t
-dns_client_updaterec(dns_client_updateop_t op, dns_name_t *owner,
+dns_client_updaterec(dns_client_updateop_t op, const dns_name_t *owner,
dns_rdatatype_t type, dns_rdata_t *source,
dns_ttl_t ttl, dns_name_t *target,
dns_rdataset_t *rdataset, dns_rdatalist_t *rdatalist,
***/
isc_result_t
-dns_db_create(isc_mem_t *mctx, const char *db_type, dns_name_t *origin,
+dns_db_create(isc_mem_t *mctx, const char *db_type, const dns_name_t *origin,
dns_dbtype_t type, dns_rdataclass_t rdclass,
unsigned int argc, char *argv[], dns_db_t **dbp)
{
***/
isc_result_t
-dns_db_findnode(dns_db_t *db, dns_name_t *name,
+dns_db_findnode(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create, dns_dbnode_t **nodep)
{
}
isc_result_t
-dns_db_findnodeext(dns_db_t *db, dns_name_t *name,
+dns_db_findnodeext(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create, dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo, dns_dbnode_t **nodep)
{
}
isc_result_t
-dns_db_findnsec3node(dns_db_t *db, dns_name_t *name,
+dns_db_findnsec3node(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create, dns_dbnode_t **nodep)
{
}
isc_result_t
-dns_db_find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+dns_db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
}
isc_result_t
-dns_db_findext(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+dns_db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
}
isc_result_t
-dns_db_findzonecut(dns_db_t *db, dns_name_t *name,
+dns_db_findzonecut(dns_db_t *db, const dns_name_t *name,
unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
}
isc_result_t
-dns_db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *name)
+dns_db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset,
+ dns_name_t *name)
{
if (db->methods->getsigningtime != NULL)
return ((db->methods->getsigningtime)(db, rdataset, name));
}
isc_result_t
-dns_dbiterator_seek(dns_dbiterator_t *iterator, dns_name_t *name) {
+dns_dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) {
/*
* Move the node cursor to the node with name 'name'.
*/
}
isc_result_t
-dns_dbtable_find(dns_dbtable_t *dbtable, dns_name_t *name,
+dns_dbtable_find(dns_dbtable_t *dbtable, const dns_name_t *name,
unsigned int options, dns_db_t **dbp)
{
dns_db_t *stored_data = NULL;
isc_result_t
dns_difftuple_create(isc_mem_t *mctx,
- dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
+ dns_diffop_t op, const dns_name_t *name, dns_ttl_t ttl,
dns_rdata_t *rdata, dns_difftuple_t **tp)
{
dns_difftuple_t *t;
}
static void
-setownercase(dns_rdataset_t *rdataset, dns_name_t *name) {
+setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
if (dns_rdataset_isassociated(rdataset))
dns_rdataset_setownercase(rdataset, name);
}
/*
* Statics.
*/
-static dns_dispentry_t *entry_search(dns_qid_t *, isc_sockaddr_t *,
+static dns_dispentry_t *entry_search(dns_qid_t *, const isc_sockaddr_t *,
dns_messageid_t, in_port_t, unsigned int);
static isc_boolean_t destroy_disp_ok(dns_dispatch_t *);
static void destroy_disp(isc_task_t *task, isc_event_t *event);
static void udp_recv(isc_event_t *, dns_dispatch_t *, dispsocket_t *);
static void tcp_recv(isc_task_t *, isc_event_t *);
static isc_result_t startrecv(dns_dispatch_t *, dispsocket_t *);
-static isc_uint32_t dns_hash(dns_qid_t *, isc_sockaddr_t *, dns_messageid_t,
- in_port_t);
+static isc_uint32_t dns_hash(dns_qid_t *, const isc_sockaddr_t *,
+ dns_messageid_t, in_port_t);
static void free_buffer(dns_dispatch_t *disp, void *buf, unsigned int len);
static void *allocate_udp_buffer(dns_dispatch_t *disp);
static inline void free_devent(dns_dispatch_t *disp, dns_dispatchevent_t *ev);
static isc_result_t get_udpsocket(dns_dispatchmgr_t *mgr,
dns_dispatch_t *disp,
isc_socketmgr_t *sockmgr,
- isc_sockaddr_t *localaddr,
+ const isc_sockaddr_t *localaddr,
isc_socket_t **sockp,
isc_socket_t *dup_socket);
static isc_result_t dispatch_createudp(dns_dispatchmgr_t *mgr,
isc_socketmgr_t *sockmgr,
isc_taskmgr_t *taskmgr,
- isc_sockaddr_t *localaddr,
+ const isc_sockaddr_t *localaddr,
unsigned int maxrequests,
unsigned int attributes,
dns_dispatch_t **dispp,
unsigned int increment, dns_qid_t **qidp,
isc_boolean_t needaddrtable);
static void qid_destroy(isc_mem_t *mctx, dns_qid_t **qidp);
-static isc_result_t open_socket(isc_socketmgr_t *mgr, isc_sockaddr_t *local,
+static isc_result_t open_socket(isc_socketmgr_t *mgr,
+ const isc_sockaddr_t *local,
unsigned int options, isc_socket_t **sockp,
isc_socket_t *dup_socket);
static isc_boolean_t portavailable(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
* Return a hash of the destination and message id.
*/
static isc_uint32_t
-dns_hash(dns_qid_t *qid, isc_sockaddr_t *dest, dns_messageid_t id,
+dns_hash(dns_qid_t *qid, const isc_sockaddr_t *dest, dns_messageid_t id,
in_port_t port)
{
unsigned int ret;
* Return NULL if no such entry exists. Requires qid->lock to be held.
*/
static dispsocket_t *
-socket_search(dns_qid_t *qid, isc_sockaddr_t *dest, in_port_t port,
+socket_search(dns_qid_t *qid, const isc_sockaddr_t *dest, in_port_t port,
unsigned int bucket)
{
dispsocket_t *dispsock;
* The caller must hold the disp->lock
*/
static isc_result_t
-get_dispsocket(dns_dispatch_t *disp, isc_sockaddr_t *dest,
+get_dispsocket(dns_dispatch_t *disp, const isc_sockaddr_t *dest,
isc_socketmgr_t *sockmgr, dispsocket_t **dispsockp,
in_port_t *portp)
{
* Return NULL if no such entry exists.
*/
static dns_dispentry_t *
-entry_search(dns_qid_t *qid, isc_sockaddr_t *dest, dns_messageid_t id,
+entry_search(dns_qid_t *qid, const isc_sockaddr_t *dest, dns_messageid_t id,
in_port_t port, unsigned int bucket)
{
dns_dispentry_t *res;
}
static isc_result_t
-open_socket(isc_socketmgr_t *mgr, isc_sockaddr_t *local,
+open_socket(isc_socketmgr_t *mgr, const isc_sockaddr_t *local,
unsigned int options, isc_socket_t **sockp,
isc_socket_t *dup_socket)
{
#define ATTRMATCH(_a1, _a2, _mask) (((_a1) & (_mask)) == ((_a2) & (_mask)))
static isc_boolean_t
-local_addr_match(dns_dispatch_t *disp, isc_sockaddr_t *addr) {
+local_addr_match(dns_dispatch_t *disp, const isc_sockaddr_t *addr) {
isc_sockaddr_t sockaddr;
isc_result_t result;
* returns, and must be unlocked by the caller.
*/
static isc_result_t
-dispatch_find(dns_dispatchmgr_t *mgr, isc_sockaddr_t *local,
+dispatch_find(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *local,
unsigned int attributes, unsigned int mask,
dns_dispatch_t **dispp)
{
isc_result_t
dns_dispatch_createtcp2(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
- isc_taskmgr_t *taskmgr, isc_sockaddr_t *localaddr,
- isc_sockaddr_t *destaddr, unsigned int buffersize,
+ isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
+ const isc_sockaddr_t *destaddr, unsigned int buffersize,
unsigned int maxbuffers, unsigned int maxrequests,
unsigned int buckets, unsigned int increment,
unsigned int attributes, dns_dispatch_t **dispp)
}
isc_result_t
-dns_dispatch_gettcp(dns_dispatchmgr_t *mgr, isc_sockaddr_t *destaddr,
- isc_sockaddr_t *localaddr, dns_dispatch_t **dispp)
+dns_dispatch_gettcp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *localaddr, dns_dispatch_t **dispp)
{
dns_dispatch_t *disp;
isc_result_t result;
}
isc_result_t
-dns_dispatch_gettcp2(dns_dispatchmgr_t *mgr, isc_sockaddr_t *destaddr,
- isc_sockaddr_t *localaddr, isc_boolean_t *connected,
+dns_dispatch_gettcp2(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *localaddr, isc_boolean_t *connected,
dns_dispatch_t **dispp)
{
dns_dispatch_t *disp;
isc_result_t
dns_dispatch_getudp_dup(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
- isc_taskmgr_t *taskmgr, isc_sockaddr_t *localaddr,
+ isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
unsigned int buffersize,
unsigned int maxbuffers, unsigned int maxrequests,
unsigned int buckets, unsigned int increment,
isc_result_t
dns_dispatch_getudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
- isc_taskmgr_t *taskmgr, isc_sockaddr_t *localaddr,
+ isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
unsigned int buffersize,
unsigned int maxbuffers, unsigned int maxrequests,
unsigned int buckets, unsigned int increment,
static isc_result_t
get_udpsocket(dns_dispatchmgr_t *mgr, dns_dispatch_t *disp,
- isc_socketmgr_t *sockmgr, isc_sockaddr_t *localaddr,
+ isc_socketmgr_t *sockmgr, const isc_sockaddr_t *localaddr,
isc_socket_t **sockp, isc_socket_t *dup_socket)
{
unsigned int i, j;
static isc_result_t
dispatch_createudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
isc_taskmgr_t *taskmgr,
- isc_sockaddr_t *localaddr,
+ const isc_sockaddr_t *localaddr,
unsigned int maxrequests,
unsigned int attributes,
dns_dispatch_t **dispp,
}
isc_result_t
-dns_dispatch_addresponse2(dns_dispatch_t *disp, isc_sockaddr_t *dest,
+dns_dispatch_addresponse2(dns_dispatch_t *disp, const isc_sockaddr_t *dest,
isc_task_t *task, isc_taskaction_t action, void *arg,
dns_messageid_t *idp, dns_dispentry_t **resp,
isc_socketmgr_t *sockmgr)
isc_result_t
dns_dispatch_addresponse3(dns_dispatch_t *disp, unsigned int options,
- isc_sockaddr_t *dest, isc_task_t *task,
+ const isc_sockaddr_t *dest, isc_task_t *task,
isc_taskaction_t action, void *arg,
dns_messageid_t *idp, dns_dispentry_t **resp,
isc_socketmgr_t *sockmgr)
}
isc_result_t
-dns_dispatch_addresponse(dns_dispatch_t *disp, isc_sockaddr_t *dest,
+dns_dispatch_addresponse(dns_dispatch_t *disp, const isc_sockaddr_t *dest,
isc_task_t *task, isc_taskaction_t action, void *arg,
dns_messageid_t *idp, dns_dispentry_t **resp)
{
***/
isc_result_t
-dns_dlzallowzonexfr(dns_view_t *view, dns_name_t *name,
- isc_sockaddr_t *clientaddr, dns_db_t **dbp)
+dns_dlzallowzonexfr(dns_view_t *view, const dns_name_t *name,
+ const isc_sockaddr_t *clientaddr, dns_db_t **dbp)
{
isc_result_t result = ISC_R_NOTFOUND;
dns_dlzallowzonexfr_t allowzonexfr;
}
isc_boolean_t
-dns_dlz_ssumatch(dns_dlzdb_t *dlzdatabase, dns_name_t *signer,
- dns_name_t *name, isc_netaddr_t *tcpaddr,
+dns_dlz_ssumatch(dns_dlzdb_t *dlzdatabase, const dns_name_t *signer,
+ const dns_name_t *name, const isc_netaddr_t *tcpaddr,
dns_rdatatype_t type, const dst_key_t *key)
{
dns_dlzimplementation_t *impl;
};
isc_result_t
-dns_dns64_create(isc_mem_t *mctx, isc_netaddr_t *prefix,
- unsigned int prefixlen, isc_netaddr_t *suffix,
+dns_dns64_create(isc_mem_t *mctx, const isc_netaddr_t *prefix,
+ unsigned int prefixlen, const isc_netaddr_t *suffix,
dns_acl_t *clients, dns_acl_t *mapped, dns_acl_t *excluded,
unsigned int flags, dns_dns64_t **dns64)
{
}
isc_result_t
-dns_dnssec_keyfromrdata(dns_name_t *name, dns_rdata_t *rdata, isc_mem_t *mctx,
- dst_key_t **key)
+dns_dnssec_keyfromrdata(const dns_name_t *name, const dns_rdata_t *rdata,
+ isc_mem_t *mctx, dst_key_t **key)
{
isc_buffer_t b;
isc_region_t r;
}
isc_result_t
-dns_dnssec_sign(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
+dns_dnssec_sign(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
isc_stdtime_t *inception, isc_stdtime_t *expire,
isc_mem_t *mctx, isc_buffer_t *buffer, dns_rdata_t *sigrdata)
{
}
isc_result_t
-dns_dnssec_verify2(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
+dns_dnssec_verify2(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
isc_boolean_t ignoretime, isc_mem_t *mctx,
dns_rdata_t *sigrdata, dns_name_t *wild)
{
}
isc_result_t
-dns_dnssec_verify3(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
+dns_dnssec_verify3(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
isc_boolean_t ignoretime, unsigned int maxbits,
isc_mem_t *mctx, dns_rdata_t *sigrdata, dns_name_t *wild)
{
}
isc_result_t
-dns_dnssec_verify(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
+dns_dnssec_verify(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
isc_boolean_t ignoretime, isc_mem_t *mctx,
dns_rdata_t *sigrdata)
{
isc_result_t
dns_dnssec_findzonekeys3(dns_db_t *db, dns_dbversion_t *ver,
- dns_dbnode_t *node, dns_name_t *name,
+ dns_dbnode_t *node, const dns_name_t *name,
const char *directory, isc_stdtime_t now,
isc_mem_t *mctx, unsigned int maxkeys,
dst_key_t **keys, unsigned int *nkeys)
isc_result_t
dns_dnssec_findzonekeys2(dns_db_t *db, dns_dbversion_t *ver,
- dns_dbnode_t *node, dns_name_t *name,
+ dns_dbnode_t *node, const dns_name_t *name,
const char *directory, isc_mem_t *mctx,
unsigned int maxkeys, dst_key_t **keys,
unsigned int *nkeys)
isc_result_t
dns_dnssec_findzonekeys(dns_db_t *db, dns_dbversion_t *ver,
- dns_dbnode_t *node, dns_name_t *name, isc_mem_t *mctx,
- unsigned int maxkeys, dst_key_t **keys,
- unsigned int *nkeys)
+ dns_dbnode_t *node, const dns_name_t *name,
+ isc_mem_t *mctx, unsigned int maxkeys,
+ dst_key_t **keys, unsigned int *nkeys)
{
isc_stdtime_t now;
* Does this key ('rdata') self sign the rrset ('rdataset')?
*/
isc_boolean_t
-dns_dnssec_selfsigns(dns_rdata_t *rdata, dns_name_t *name,
+dns_dnssec_selfsigns(dns_rdata_t *rdata, const dns_name_t *name,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
isc_boolean_t ignoretime, isc_mem_t *mctx)
{
}
isc_boolean_t
-dns_dnssec_signs(dns_rdata_t *rdata, dns_name_t *name,
+dns_dnssec_signs(dns_rdata_t *rdata, const dns_name_t *name,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
isc_boolean_t ignoretime, isc_mem_t *mctx)
{
* Get a list of DNSSEC keys from the key repository
*/
isc_result_t
-dns_dnssec_findmatchingkeys2(dns_name_t *origin, const char *directory,
+dns_dnssec_findmatchingkeys2(const dns_name_t *origin, const char *directory,
isc_stdtime_t now, isc_mem_t *mctx,
dns_dnsseckeylist_t *keylist)
{
}
isc_result_t
-dns_dnssec_findmatchingkeys(dns_name_t *origin, const char *directory,
+dns_dnssec_findmatchingkeys(const dns_name_t *origin, const char *directory,
isc_mem_t *mctx, dns_dnsseckeylist_t *keylist)
{
isc_stdtime_t now;
* Add the contents of a DNSKEY rdataset 'keyset' to 'keylist'.
*/
isc_result_t
-dns_dnssec_keylistfromrdataset(dns_name_t *origin,
+dns_dnssec_keylistfromrdataset(const dns_name_t *origin,
const char *directory, isc_mem_t *mctx,
dns_rdataset_t *keyset, dns_rdataset_t *keysigs,
dns_rdataset_t *soasigs, isc_boolean_t savekeys,
}
static isc_result_t
-publish_key(dns_diff_t *diff, dns_dnsseckey_t *key, dns_name_t *origin,
+publish_key(dns_diff_t *diff, dns_dnsseckey_t *key, const dns_name_t *origin,
dns_ttl_t ttl, isc_mem_t *mctx, isc_boolean_t allzsk,
void (*report)(const char *, ...))
{
}
static isc_result_t
-remove_key(dns_diff_t *diff, dns_dnsseckey_t *key, dns_name_t *origin,
+remove_key(dns_diff_t *diff, dns_dnsseckey_t *key, const dns_name_t *origin,
dns_ttl_t ttl, isc_mem_t *mctx, const char *reason,
void (*report)(const char *, ...))
{
*/
isc_result_t
dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
- dns_dnsseckeylist_t *removed, dns_name_t *origin,
+ dns_dnsseckeylist_t *removed, const dns_name_t *origin,
dns_ttl_t hint_ttl, dns_diff_t *diff,
isc_boolean_t allzsk, isc_mem_t *mctx,
void (*report)(const char *, ...))
/*
* Static functions.
*/
-static dst_key_t * get_key_struct(dns_name_t *name,
+static dst_key_t * get_key_struct(const dns_name_t *name,
unsigned int alg,
unsigned int flags,
unsigned int protocol,
const char *directory,
isc_buffer_t *out);
static isc_result_t computeid(dst_key_t *key);
-static isc_result_t frombuffer(dns_name_t *name,
+static isc_result_t frombuffer(const dns_name_t *name,
unsigned int alg,
unsigned int flags,
unsigned int protocol,
}
isc_result_t
-dst_key_fromdns(dns_name_t *name, dns_rdataclass_t rdclass,
+dst_key_fromdns(const dns_name_t *name, dns_rdataclass_t rdclass,
isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp)
{
isc_uint8_t alg, proto;
}
isc_result_t
-dst_key_frombuffer(dns_name_t *name, unsigned int alg,
+dst_key_frombuffer(const dns_name_t *name, unsigned int alg,
unsigned int flags, unsigned int protocol,
dns_rdataclass_t rdclass,
isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp)
}
isc_result_t
-dst_key_fromgssapi(dns_name_t *name, gss_ctx_id_t gssctx, isc_mem_t *mctx,
- dst_key_t **keyp, isc_region_t *intoken)
+dst_key_fromgssapi(const dns_name_t *name, gss_ctx_id_t gssctx,
+ isc_mem_t *mctx, dst_key_t **keyp, isc_region_t *intoken)
{
dst_key_t *key;
isc_result_t result;
}
isc_result_t
-dst_key_buildinternal(dns_name_t *name, unsigned int alg,
+dst_key_buildinternal(const dns_name_t *name, unsigned int alg,
unsigned int bits, unsigned int flags,
unsigned int protocol, dns_rdataclass_t rdclass,
void *data, isc_mem_t *mctx, dst_key_t **keyp)
}
isc_result_t
-dst_key_fromlabel(dns_name_t *name, int alg, unsigned int flags,
+dst_key_fromlabel(const dns_name_t *name, int alg, unsigned int flags,
unsigned int protocol, dns_rdataclass_t rdclass,
const char *engine, const char *label, const char *pin,
isc_mem_t *mctx, dst_key_t **keyp)
}
isc_result_t
-dst_key_generate(dns_name_t *name, unsigned int alg,
+dst_key_generate(const dns_name_t *name, unsigned int alg,
unsigned int bits, unsigned int param,
unsigned int flags, unsigned int protocol,
dns_rdataclass_t rdclass,
}
isc_result_t
-dst_key_generate2(dns_name_t *name, unsigned int alg,
+dst_key_generate2(const dns_name_t *name, unsigned int alg,
unsigned int bits, unsigned int param,
unsigned int flags, unsigned int protocol,
dns_rdataclass_t rdclass,
* Allocates a key structure and fills in some of the fields.
*/
static dst_key_t *
-get_key_struct(dns_name_t *name, unsigned int alg,
+get_key_struct(const dns_name_t *name, unsigned int alg,
unsigned int flags, unsigned int protocol,
unsigned int bits, dns_rdataclass_t rdclass,
dns_ttl_t ttl, isc_mem_t *mctx)
}
static isc_result_t
-frombuffer(dns_name_t *name, unsigned int alg, unsigned int flags,
+frombuffer(const dns_name_t *name, unsigned int alg, unsigned int flags,
unsigned int protocol, dns_rdataclass_t rdclass,
isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp)
{
#define NEGATIVE(header) \
(((header)->attributes & RDATASET_ATTR_NEGATIVE) != 0)
-static isc_result_t dns_ecdb_create(isc_mem_t *mctx, dns_name_t *origin,
+static isc_result_t dns_ecdb_create(isc_mem_t *mctx, const dns_name_t *origin,
dns_dbtype_t type,
dns_rdataclass_t rdclass,
unsigned int argc, char *argv[],
}
static isc_result_t
-find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset)
}
static isc_result_t
-findzonecut(dns_db_t *db, dns_name_t *name,
+findzonecut(dns_db_t *db, const dns_name_t *name,
unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
}
static isc_result_t
-findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+findnode(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_dbnode_t **nodep)
{
dns_ecdb_t *ecdb = (dns_ecdb_t *)db;
};
static isc_result_t
-dns_ecdb_create(isc_mem_t *mctx, dns_name_t *origin, dns_dbtype_t type,
+dns_ecdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp)
{
}
isc_result_t
-dns_fwdtable_addfwd(dns_fwdtable_t *fwdtable, dns_name_t *name,
+dns_fwdtable_addfwd(dns_fwdtable_t *fwdtable, const dns_name_t *name,
dns_forwarderlist_t *fwdrs, dns_fwdpolicy_t fwdpolicy)
{
isc_result_t result;
}
isc_result_t
-dns_fwdtable_add(dns_fwdtable_t *fwdtable, dns_name_t *name,
+dns_fwdtable_add(dns_fwdtable_t *fwdtable, const dns_name_t *name,
isc_sockaddrlist_t *addrs, dns_fwdpolicy_t fwdpolicy)
{
isc_result_t result;
}
isc_result_t
-dns_fwdtable_delete(dns_fwdtable_t *fwdtable, dns_name_t *name) {
+dns_fwdtable_delete(dns_fwdtable_t *fwdtable, const dns_name_t *name) {
isc_result_t result;
REQUIRE(VALID_FWDTABLE(fwdtable));
}
isc_result_t
-dns_fwdtable_find(dns_fwdtable_t *fwdtable, dns_name_t *name,
+dns_fwdtable_find(dns_fwdtable_t *fwdtable, const dns_name_t *name,
dns_forwarders_t **forwardersp)
{
return (dns_fwdtable_find2(fwdtable, name, NULL, forwardersp));
}
isc_result_t
-dns_fwdtable_find2(dns_fwdtable_t *fwdtable, dns_name_t *name,
+dns_fwdtable_find2(dns_fwdtable_t *fwdtable, const dns_name_t *name,
dns_name_t *foundname, dns_forwarders_t **forwardersp)
{
isc_result_t result;
#ifdef GSSAPI
static inline void
-name_to_gbuffer(dns_name_t *name, isc_buffer_t *buffer,
+name_to_gbuffer(const dns_name_t *name, isc_buffer_t *buffer,
gss_buffer_desc *gbuffer)
{
- dns_name_t tname, *namep;
+ dns_name_t tname;
+ const dns_name_t *namep;
isc_region_t r;
isc_result_t result;
#endif
isc_result_t
-dst_gssapi_acquirecred(dns_name_t *name, isc_boolean_t initiate,
+dst_gssapi_acquirecred(const dns_name_t *name, isc_boolean_t initiate,
gss_cred_id_t *cred)
{
#ifdef GSSAPI
}
isc_boolean_t
-dst_gssapi_identitymatchesrealmkrb5(dns_name_t *signer, dns_name_t *name,
- dns_name_t *realm)
+dst_gssapi_identitymatchesrealmkrb5(const dns_name_t *signer,
+ const dns_name_t *name,
+ const dns_name_t *realm)
{
#ifdef GSSAPI
char sbuf[DNS_NAME_FORMATSIZE];
}
isc_boolean_t
-dst_gssapi_identitymatchesrealmms(dns_name_t *signer, dns_name_t *name,
- dns_name_t *realm)
+dst_gssapi_identitymatchesrealmms(const dns_name_t *signer,
+ const dns_name_t *name,
+ const dns_name_t *realm)
{
#ifdef GSSAPI
char sbuf[DNS_NAME_FORMATSIZE];
#endif
isc_result_t
-dst_gssapi_initctx(dns_name_t *name, isc_buffer_t *intoken,
+dst_gssapi_initctx(const dns_name_t *name, isc_buffer_t *intoken,
isc_buffer_t *outtoken, gss_ctx_id_t *gssctx,
isc_mem_t *mctx, char **err_message)
{
isc_result_t
dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
- void *arg, dns_name_t *name, dns_name_t *qname,
+ void *arg, const dns_name_t *name, const dns_name_t *qname,
dns_rdatatype_t qtype, unsigned int options,
isc_stdtime_t now, dns_name_t *target,
in_port_t port, dns_adbfind_t **find);
isc_result_t
dns_adb_createfind2(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
- void *arg, dns_name_t *name, dns_name_t *qname,
+ void *arg, const dns_name_t *name, const dns_name_t *qname,
dns_rdatatype_t qtype, unsigned int options,
isc_stdtime_t now, dns_name_t *target, in_port_t port,
unsigned int depth, isc_counter_t *qc,
*/
isc_result_t
-dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr, dns_name_t *qname,
- dns_rdatatype_t type, isc_stdtime_t expire_time);
+dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
+ const dns_name_t *qname, dns_rdatatype_t type,
+ isc_stdtime_t expire_time);
/*%<
* Mark the given address as lame for the <qname,qtype>. expire_time should
* be set to the time when the entry should expire. That is, if it is to
isc_result_t
-dns_adb_findaddrinfo(dns_adb_t *adb, isc_sockaddr_t *sa,
+dns_adb_findaddrinfo(dns_adb_t *adb, const isc_sockaddr_t *sa,
dns_adbaddrinfo_t **addrp, isc_stdtime_t now);
/*%<
* Return a dns_adbaddrinfo_t that is associated with address 'sa'.
*/
void
-dns_adb_flushname(dns_adb_t *adb, dns_name_t *name);
+dns_adb_flushname(dns_adb_t *adb, const dns_name_t *name);
/*%<
* Flush 'name' from the adb cache.
*
*/
void
-dns_adb_flushnames(dns_adb_t *adb, dns_name_t *name);
+dns_adb_flushnames(dns_adb_t *adb, const dns_name_t *name);
/*%<
* Flush 'name' and all subdomains from the adb cache.
*
*/
void
-dns_badcache_add(dns_badcache_t *bc, dns_name_t *name,
+dns_badcache_add(dns_badcache_t *bc, const dns_name_t *name,
dns_rdatatype_t type, isc_boolean_t update,
isc_uint32_t flags, isc_time_t *expire);
/*%
*/
isc_boolean_t
-dns_badcache_find(dns_badcache_t *bc, dns_name_t *name,
+dns_badcache_find(dns_badcache_t *bc, const dns_name_t *name,
dns_rdatatype_t type, isc_uint32_t *flagp,
isc_time_t *now);
/*%
*/
void
-dns_badcache_flushname(dns_badcache_t *bc, dns_name_t *name);
+dns_badcache_flushname(dns_badcache_t *bc, const dns_name_t *name);
/*%
* Flush the bad cache of all entries at 'name'.
*
*/
void
-dns_badcache_flushtree(dns_badcache_t *bc, dns_name_t *name);
+dns_badcache_flushtree(dns_badcache_t *bc, const dns_name_t *name);
/*%
* Flush the bad cache of all entries at or below 'name'.
*
#define DNS_BYADDROPT_IPV6INT 0x0002
isc_result_t
-dns_byaddr_create(isc_mem_t *mctx, isc_netaddr_t *address, dns_view_t *view,
- unsigned int options, isc_task_t *task,
+dns_byaddr_create(isc_mem_t *mctx, const isc_netaddr_t *address,
+ dns_view_t *view, unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg, dns_byaddr_t **byaddrp);
/*%<
* Find the domain name of 'address'.
*/
isc_result_t
-dns_byaddr_createptrname(isc_netaddr_t *address, isc_boolean_t nibble,
+dns_byaddr_createptrname(const isc_netaddr_t *address, isc_boolean_t nibble,
dns_name_t *name);
isc_result_t
-dns_byaddr_createptrname2(isc_netaddr_t *address, unsigned int options,
+dns_byaddr_createptrname2(const isc_netaddr_t *address, unsigned int options,
dns_name_t *name);
/*%<
* Creates a name that would be used in a PTR query for this address. The
*/
isc_result_t
-dns_cache_flushnode(dns_cache_t *cache, dns_name_t *name,
+dns_cache_flushnode(dns_cache_t *cache, const dns_name_t *name,
isc_boolean_t tree);
/*
* Flush a given name from the cache. If 'tree' is true, then
*/
isc_result_t
-dns_cache_flushname(dns_cache_t *cache, dns_name_t *name);
+dns_cache_flushname(dns_cache_t *cache, const dns_name_t *name);
/*
* Flush a given name from the cache. Equivalent to
* dns_cache_flushpartial(cache, name, ISC_FALSE).
isc_result_t
dns_catz_new_zone(dns_catz_zones_t *catzs, dns_catz_zone_t **zonep,
- const dns_name_t *name);
+ const dns_name_t *name);
/*%<
* Allocate a new catz zone on catzs mctx
*
isc_result_t
dns_catz_update_process(dns_catz_zones_t *catzs, dns_catz_zone_t *zone,
- dns_name_t *src_name, dns_rdataset_t *rdataset);
+ const dns_name_t *src_name, dns_rdataset_t *rdataset);
/*%<
* Process a single rdataset from a catalog zone 'zone' update, src_name is the
* record name.
dns_client_createx2(isc_mem_t *mctx, isc_appctx_t *actx,
isc_taskmgr_t *taskmgr, isc_socketmgr_t *socketmgr,
isc_timermgr_t *timermgr, unsigned int options,
- dns_client_t **clientp,
- isc_sockaddr_t *localaddr4, isc_sockaddr_t *localaddr6);
+ dns_client_t **clientp, const isc_sockaddr_t *localaddr4,
+ const isc_sockaddr_t *localaddr6);
/*%<
* Create a DNS client. These functions create a new client object with
* minimal internal resources such as the default 'view' for the IN class and
isc_result_t
dns_client_setservers(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *namespace, isc_sockaddrlist_t *addrs);
+ const dns_name_t *namespace, isc_sockaddrlist_t *addrs);
/*%<
* Specify a list of addresses of recursive name servers that the client will
* use for name resolution. A view for the 'rdclass' class must be created
isc_result_t
dns_client_clearservers(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *namespace);
+ const dns_name_t *namespace);
/*%<
* Remove configured recursive name servers for the 'rdclass' and 'namespace'
* from the client. See the description of dns_client_setservers() for
*/
isc_result_t
-dns_client_resolve(dns_client_t *client, dns_name_t *name,
+dns_client_resolve(dns_client_t *client, const dns_name_t *name,
dns_rdataclass_t rdclass, dns_rdatatype_t type,
unsigned int options, dns_namelist_t *namelist);
isc_result_t
-dns_client_startresolve(dns_client_t *client, dns_name_t *name,
+dns_client_startresolve(dns_client_t *client, const dns_name_t *name,
dns_rdataclass_t rdclass, dns_rdatatype_t type,
unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg,
isc_result_t
dns_client_addtrustedkey(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *keyname, isc_buffer_t *keydatabuf);
+ const dns_name_t *keyname, isc_buffer_t *keydatabuf);
/*%<
* Add a DNSSEC trusted key for the 'rdclass' class. A view for the 'rdclass'
* class must be created beforehand. 'keyname' is the DNS name of the key,
isc_result_t
dns_client_request(dns_client_t *client, dns_message_t *qmessage,
- dns_message_t *rmessage, isc_sockaddr_t *server,
+ dns_message_t *rmessage, const isc_sockaddr_t *server,
unsigned int options, unsigned int parseoptions,
dns_tsec_t *tsec, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries);
isc_result_t
dns_client_startrequest(dns_client_t *client, dns_message_t *qmessage,
- dns_message_t *rmessage, isc_sockaddr_t *server,
+ dns_message_t *rmessage, const isc_sockaddr_t *server,
unsigned int options, unsigned int parseoptions,
dns_tsec_t *tsec, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries,
isc_result_t
dns_client_update(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *zonename, dns_namelist_t *prerequisites,
+ const dns_name_t *zonename, dns_namelist_t *prerequisites,
dns_namelist_t *updates, isc_sockaddrlist_t *servers,
dns_tsec_t *tsec, unsigned int options);
isc_result_t
dns_client_startupdate(dns_client_t *client, dns_rdataclass_t rdclass,
- dns_name_t *zonename, dns_namelist_t *prerequisites,
+ const dns_name_t *zonename,
+ dns_namelist_t *prerequisites,
dns_namelist_t *updates, isc_sockaddrlist_t *servers,
dns_tsec_t *tsec, unsigned int options,
isc_task_t *task, isc_taskaction_t action, void *arg,
*/
isc_result_t
-dns_client_updaterec(dns_client_updateop_t op, dns_name_t *owner,
+dns_client_updaterec(dns_client_updateop_t op, const dns_name_t *owner,
dns_rdatatype_t type, dns_rdata_t *source,
dns_ttl_t ttl, dns_name_t *target,
dns_rdataset_t *rdataset, dns_rdatalist_t *rdatalist,
void (*closeversion)(dns_db_t *db,
dns_dbversion_t **versionp,
isc_boolean_t commit);
- isc_result_t (*findnode)(dns_db_t *db, dns_name_t *name,
+ isc_result_t (*findnode)(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create,
dns_dbnode_t **nodep);
- isc_result_t (*find)(dns_db_t *db, dns_name_t *name,
+ isc_result_t (*find)(dns_db_t *db, const dns_name_t *name,
dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options,
isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset);
- isc_result_t (*findzonecut)(dns_db_t *db, dns_name_t *name,
+ isc_result_t (*findzonecut)(dns_db_t *db, const dns_name_t *name,
unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep,
dns_name_t *foundname,
isc_uint16_t *iterations,
unsigned char *salt,
size_t *salt_len);
- isc_result_t (*findnsec3node)(dns_db_t *db, dns_name_t *name,
+ isc_result_t (*findnsec3node)(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create,
dns_dbnode_t **nodep);
isc_result_t (*setsigningtime)(dns_db_t *db,
void (*rpz_attach)(dns_db_t *db, dns_rpz_zones_t *rpzs,
dns_rpz_num_t rpz_num);
isc_result_t (*rpz_ready)(dns_db_t *db);
- isc_result_t (*findnodeext)(dns_db_t *db, dns_name_t *name,
+ isc_result_t (*findnodeext)(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create,
dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo,
dns_dbnode_t **nodep);
- isc_result_t (*findext)(dns_db_t *db, dns_name_t *name,
+ isc_result_t (*findext)(dns_db_t *db, const dns_name_t *name,
dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options,
isc_stdtime_t now,
} dns_dbmethods_t;
typedef isc_result_t
-(*dns_dbcreatefunc_t)(isc_mem_t *mctx, dns_name_t *name,
+(*dns_dbcreatefunc_t)(isc_mem_t *mctx, const dns_name_t *name,
dns_dbtype_t type, dns_rdataclass_t rdclass,
unsigned int argc, char *argv[], void *driverarg,
dns_db_t **dbp);
***/
isc_result_t
-dns_db_create(isc_mem_t *mctx, const char *db_type, dns_name_t *origin,
+dns_db_create(isc_mem_t *mctx, const char *db_type, const dns_name_t *origin,
dns_dbtype_t type, dns_rdataclass_t rdclass,
unsigned int argc, char *argv[], dns_db_t **dbp);
/*%<
***/
isc_result_t
-dns_db_findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+dns_db_findnode(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_dbnode_t **nodep);
isc_result_t
-dns_db_findnodeext(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+dns_db_findnodeext(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo, dns_dbnode_t **nodep);
/*%<
*/
isc_result_t
-dns_db_find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+dns_db_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
isc_result_t
-dns_db_findext(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+dns_db_findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
*/
isc_result_t
-dns_db_findzonecut(dns_db_t *db, dns_name_t *name,
+dns_db_findzonecut(dns_db_t *db, const dns_name_t *name,
unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
*/
isc_result_t
-dns_db_findnsec3node(dns_db_t *db, dns_name_t *name,
+dns_db_findnsec3node(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create, dns_dbnode_t **nodep);
/*%<
* Find the NSEC3 node with name 'name'.
void (*destroy)(dns_dbiterator_t **iteratorp);
isc_result_t (*first)(dns_dbiterator_t *iterator);
isc_result_t (*last)(dns_dbiterator_t *iterator);
- isc_result_t (*seek)(dns_dbiterator_t *iterator, dns_name_t *name);
+ isc_result_t (*seek)(dns_dbiterator_t *iterator,
+ const dns_name_t *name);
isc_result_t (*prev)(dns_dbiterator_t *iterator);
isc_result_t (*next)(dns_dbiterator_t *iterator);
isc_result_t (*current)(dns_dbiterator_t *iterator,
*/
isc_result_t
-dns_dbiterator_seek(dns_dbiterator_t *iterator, dns_name_t *name);
+dns_dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name);
/*%<
* Move the node cursor to the node with name 'name'.
*
*/
isc_result_t
-dns_dbtable_find(dns_dbtable_t *dbtable, dns_name_t *name,
+dns_dbtable_find(dns_dbtable_t *dbtable, const dns_name_t *name,
unsigned int options, dns_db_t **dbp);
/*%<
* Find the deepest match to 'name' in the dbtable, and return it
isc_result_t
dns_difftuple_create(isc_mem_t *mctx,
- dns_diffop_t op, dns_name_t *name, dns_ttl_t ttl,
+ dns_diffop_t op, const dns_name_t *name, dns_ttl_t ttl,
dns_rdata_t *rdata, dns_difftuple_t **tp);
/*%<
* Create a tuple. Deep copies are made of the name and rdata, so
isc_result_t
dns_dispatch_getudp(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
- isc_taskmgr_t *taskmgr, isc_sockaddr_t *localaddr,
+ isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
unsigned int buffersize,
unsigned int maxbuffers, unsigned int maxrequests,
unsigned int buckets, unsigned int increment,
isc_result_t
dns_dispatch_getudp_dup(dns_dispatchmgr_t *mgr, isc_socketmgr_t *sockmgr,
- isc_taskmgr_t *taskmgr, isc_sockaddr_t *localaddr,
+ isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
unsigned int buffersize,
unsigned int maxbuffers, unsigned int maxrequests,
unsigned int buckets, unsigned int increment,
unsigned int attributes, dns_dispatch_t **dispp);
isc_result_t
dns_dispatch_createtcp2(dns_dispatchmgr_t *mgr, isc_socket_t *sock,
- isc_taskmgr_t *taskmgr, isc_sockaddr_t *localaddr,
- isc_sockaddr_t *destaddr, unsigned int buffersize,
+ isc_taskmgr_t *taskmgr, const isc_sockaddr_t *localaddr,
+ const isc_sockaddr_t *destaddr, unsigned int buffersize,
unsigned int maxbuffers, unsigned int maxrequests,
unsigned int buckets, unsigned int increment,
unsigned int attributes, dns_dispatch_t **dispp);
*/
isc_result_t
-dns_dispatch_gettcp(dns_dispatchmgr_t *mgr, isc_sockaddr_t *destaddr,
- isc_sockaddr_t *localaddr, dns_dispatch_t **dispp);
+dns_dispatch_gettcp(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *localaddr, dns_dispatch_t **dispp);
isc_result_t
-dns_dispatch_gettcp2(dns_dispatchmgr_t *mgr, isc_sockaddr_t *destaddr,
- isc_sockaddr_t *localaddr, isc_boolean_t *connected,
+dns_dispatch_gettcp2(dns_dispatchmgr_t *mgr, const isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *localaddr, isc_boolean_t *connected,
dns_dispatch_t **dispp);
/*
* Attempt to connect to a existing TCP connection (connection completed
isc_result_t
dns_dispatch_addresponse3(dns_dispatch_t *disp, unsigned int options,
- isc_sockaddr_t *dest, isc_task_t *task,
+ const isc_sockaddr_t *dest, isc_task_t *task,
isc_taskaction_t action, void *arg,
isc_uint16_t *idp, dns_dispentry_t **resp,
isc_socketmgr_t *sockmgr);
isc_result_t
-dns_dispatch_addresponse2(dns_dispatch_t *disp, isc_sockaddr_t *dest,
+dns_dispatch_addresponse2(dns_dispatch_t *disp, const isc_sockaddr_t *dest,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_uint16_t *idp, dns_dispentry_t **resp,
isc_socketmgr_t *sockmgr);
isc_result_t
-dns_dispatch_addresponse(dns_dispatch_t *disp, isc_sockaddr_t *dest,
+dns_dispatch_addresponse(dns_dispatch_t *disp, const isc_sockaddr_t *dest,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_uint16_t *idp, dns_dispentry_t **resp);
/*%<
typedef isc_result_t
(*dns_dlzallowzonexfr_t)(void *driverarg, void *dbdata, isc_mem_t *mctx,
- dns_rdataclass_t rdclass, dns_name_t *name,
- isc_sockaddr_t *clientaddr,
- dns_db_t **dbp);
+ dns_rdataclass_t rdclass, const dns_name_t *name,
+ const isc_sockaddr_t *clientaddr, dns_db_t **dbp);
/*%<
* Method prototype. Drivers implementing the DLZ interface MUST
typedef isc_result_t
(*dns_dlzfindzone_t)(void *driverarg, void *dbdata, isc_mem_t *mctx,
- dns_rdataclass_t rdclass, dns_name_t *name,
+ dns_rdataclass_t rdclass, const dns_name_t *name,
dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo,
dns_db_t **dbp);
*/
-typedef isc_boolean_t (*dns_dlzssumatch_t)(dns_name_t *signer,
- dns_name_t *name,
- isc_netaddr_t *tcpaddr,
+typedef isc_boolean_t (*dns_dlzssumatch_t)(const dns_name_t *signer,
+ const dns_name_t *name,
+ const isc_netaddr_t *tcpaddr,
dns_rdatatype_t type,
const dst_key_t *key,
void *driverarg, void *dbdata);
***/
isc_result_t
-dns_dlzallowzonexfr(dns_view_t *view, dns_name_t *name,
- isc_sockaddr_t *clientaddr, dns_db_t **dbp);
+dns_dlzallowzonexfr(dns_view_t *view, const dns_name_t *name,
+ const isc_sockaddr_t *clientaddr, dns_db_t **dbp);
/*%<
* This method is called when the DNS server is performing a zone
*/
isc_boolean_t
-dns_dlz_ssumatch(dns_dlzdb_t *dlzdatabase,
- dns_name_t *signer, dns_name_t *name, isc_netaddr_t *tcpaddr,
- dns_rdatatype_t type, const dst_key_t *key);
+dns_dlz_ssumatch(dns_dlzdb_t *dlzdatabase, const dns_name_t *signer,
+ const dns_name_t *name, const isc_netaddr_t *tcpaddr,
+ dns_rdatatype_t type, const dst_key_t *key);
/*%<
* call a DLZ drivers ssumatch method, if supplied. Otherwise return ISC_FALSE
*/
#define DNS_DNS64_DNSSEC 0x02 /* DNSSEC sensitive query. */
isc_result_t
-dns_dns64_create(isc_mem_t *mctx, isc_netaddr_t *prefix,
- unsigned int prefixlen, isc_netaddr_t *suffix,
+dns_dns64_create(isc_mem_t *mctx, const isc_netaddr_t *prefix,
+ unsigned int prefixlen, const isc_netaddr_t *suffix,
dns_acl_t *client, dns_acl_t *mapped, dns_acl_t *excluded,
unsigned int flags, dns_dns64_t **dns64);
/*
};
isc_result_t
-dns_dnssec_keyfromrdata(dns_name_t *name, dns_rdata_t *rdata, isc_mem_t *mctx,
- dst_key_t **key);
+dns_dnssec_keyfromrdata(const dns_name_t *name, const dns_rdata_t *rdata,
+ isc_mem_t *mctx, dst_key_t **key);
/*%<
* Creates a DST key from a DNS record. Basically a wrapper around
* dst_key_fromdns().
*/
isc_result_t
-dns_dnssec_sign(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
+dns_dnssec_sign(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
isc_stdtime_t *inception, isc_stdtime_t *expire,
isc_mem_t *mctx, isc_buffer_t *buffer, dns_rdata_t *sigrdata);
/*%<
*/
isc_result_t
-dns_dnssec_verify(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
+dns_dnssec_verify(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
isc_boolean_t ignoretime, isc_mem_t *mctx,
dns_rdata_t *sigrdata);
isc_result_t
-dns_dnssec_verify2(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
+dns_dnssec_verify2(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
isc_boolean_t ignoretime, isc_mem_t *mctx,
dns_rdata_t *sigrdata, dns_name_t *wild);
isc_result_t
-dns_dnssec_verify3(dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
+dns_dnssec_verify3(const dns_name_t *name, dns_rdataset_t *set, dst_key_t *key,
isc_boolean_t ignoretime, unsigned int maxbits,
isc_mem_t *mctx, dns_rdata_t *sigrdata, dns_name_t *wild);
/*%<
/*@{*/
isc_result_t
dns_dnssec_findzonekeys(dns_db_t *db, dns_dbversion_t *ver, dns_dbnode_t *node,
- dns_name_t *name, isc_mem_t *mctx,
+ const dns_name_t *name, isc_mem_t *mctx,
unsigned int maxkeys, dst_key_t **keys,
unsigned int *nkeys);
isc_result_t
dns_dnssec_findzonekeys2(dns_db_t *db, dns_dbversion_t *ver,
- dns_dbnode_t *node, dns_name_t *name,
+ dns_dbnode_t *node, const dns_name_t *name,
const char *directory, isc_mem_t *mctx,
unsigned int maxkeys, dst_key_t **keys,
unsigned int *nkeys);
isc_result_t
dns_dnssec_findzonekeys3(dns_db_t *db, dns_dbversion_t *ver,
- dns_dbnode_t *node, dns_name_t *name,
+ dns_dbnode_t *node, const dns_name_t *name,
const char *directory, isc_stdtime_t now,
isc_mem_t *mctx, unsigned int maxkeys,
dst_key_t **keys, unsigned int *nkeys);
*/
isc_boolean_t
-dns_dnssec_selfsigns(dns_rdata_t *rdata, dns_name_t *name,
+dns_dnssec_selfsigns(dns_rdata_t *rdata, const dns_name_t *name,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
isc_boolean_t ignoretime, isc_mem_t *mctx);
isc_boolean_t
-dns_dnssec_signs(dns_rdata_t *rdata, dns_name_t *name,
+dns_dnssec_signs(dns_rdata_t *rdata, const dns_name_t *name,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
isc_boolean_t ignoretime, isc_mem_t *mctx);
/*%<
*/
isc_result_t
-dns_dnssec_findmatchingkeys(dns_name_t *origin, const char *directory,
+dns_dnssec_findmatchingkeys(const dns_name_t *origin, const char *directory,
isc_mem_t *mctx, dns_dnsseckeylist_t *keylist);
isc_result_t
-dns_dnssec_findmatchingkeys2(dns_name_t *origin, const char *directory,
+dns_dnssec_findmatchingkeys2(const dns_name_t *origin, const char *directory,
isc_stdtime_t now, isc_mem_t *mctx,
dns_dnsseckeylist_t *keylist);
/*%<
*/
isc_result_t
-dns_dnssec_keylistfromrdataset(dns_name_t *origin,
+dns_dnssec_keylistfromrdataset(const dns_name_t *origin,
const char *directory, isc_mem_t *mctx,
dns_rdataset_t *keyset, dns_rdataset_t *keysigs,
dns_rdataset_t *soasigs, isc_boolean_t savekeys,
isc_result_t
dns_dnssec_updatekeys(dns_dnsseckeylist_t *keys, dns_dnsseckeylist_t *newkeys,
- dns_dnsseckeylist_t *removed, dns_name_t *origin,
+ dns_dnsseckeylist_t *removed, const dns_name_t *origin,
dns_ttl_t hint_ttl, dns_diff_t *diff, isc_boolean_t allzsk,
isc_mem_t *mctx, void (*report)(const char *, ...));
/*%<
void
dns_dt_send(dns_view_t *view, dns_dtmsgtype_t msgtype,
- isc_sockaddr_t *sa, isc_boolean_t tcp, isc_region_t *zone,
+ const isc_sockaddr_t *sa, isc_boolean_t tcp, isc_region_t *zone,
isc_time_t *qtime, isc_time_t *rtime, isc_buffer_t *buf);
/*%<
* Sends a dnstap message to the log, if 'msgtype' is one of the message
*/
isc_result_t
-dns_fwdtable_addfwd(dns_fwdtable_t *fwdtable, dns_name_t *name,
+dns_fwdtable_addfwd(dns_fwdtable_t *fwdtable, const dns_name_t *name,
dns_forwarderlist_t *fwdrs, dns_fwdpolicy_t policy);
isc_result_t
-dns_fwdtable_add(dns_fwdtable_t *fwdtable, dns_name_t *name,
+dns_fwdtable_add(dns_fwdtable_t *fwdtable, const dns_name_t *name,
isc_sockaddrlist_t *addrs, dns_fwdpolicy_t policy);
/*%<
* Adds an entry to the forwarding table. The entry associates
*/
isc_result_t
-dns_fwdtable_delete(dns_fwdtable_t *fwdtable, dns_name_t *name);
+dns_fwdtable_delete(dns_fwdtable_t *fwdtable, const dns_name_t *name);
/*%<
* Removes an entry for 'name' from the forwarding table. If an entry
* that exactly matches 'name' does not exist, ISC_R_NOTFOUND will be returned.
*/
isc_result_t
-dns_fwdtable_find(dns_fwdtable_t *fwdtable, dns_name_t *name,
+dns_fwdtable_find(dns_fwdtable_t *fwdtable, const dns_name_t *name,
dns_forwarders_t **forwardersp);
/*%<
* Finds a domain in the forwarding table. The closest matching parent
*/
isc_result_t
-dns_fwdtable_find2(dns_fwdtable_t *fwdtable, dns_name_t *name,
+dns_fwdtable_find2(dns_fwdtable_t *fwdtable, const dns_name_t *name,
dns_name_t *foundname, dns_forwarders_t **forwardersp);
/*%<
* Finds a domain in the forwarding table. The closest matching parent
*/
isc_result_t
-dns_iptable_addprefix(dns_iptable_t *tab, isc_netaddr_t *addr,
+dns_iptable_addprefix(dns_iptable_t *tab, const isc_netaddr_t *addr,
isc_uint16_t bitlen, isc_boolean_t pos);
isc_result_t
-dns_iptable_addprefix2(dns_iptable_t *tab, isc_netaddr_t *addr,
+dns_iptable_addprefix2(dns_iptable_t *tab, const isc_netaddr_t *addr,
isc_uint16_t bitlen, isc_boolean_t pos,
isc_boolean_t is_ecs);
/*
*/
isc_result_t
-dns_keytable_marksecure(dns_keytable_t *keytable, dns_name_t *name);
+dns_keytable_marksecure(dns_keytable_t *keytable, const dns_name_t *name);
/*%<
* Add a null key to 'keytable' for name 'name'. This marks the
* name as a secure domain, but doesn't supply any key data to allow the
*/
isc_result_t
-dns_keytable_delete(dns_keytable_t *keytable, dns_name_t *keyname);
+dns_keytable_delete(dns_keytable_t *keytable, const dns_name_t *keyname);
/*%<
* Delete node(s) from 'keytable' matching name 'keyname'
*
*/
isc_result_t
-dns_keytable_find(dns_keytable_t *keytable, dns_name_t *keyname,
+dns_keytable_find(dns_keytable_t *keytable, const dns_name_t *keyname,
dns_keynode_t **keynodep);
/*%<
* Search for the first instance of a key named 'name' in 'keytable',
*/
isc_result_t
-dns_keytable_findkeynode(dns_keytable_t *keytable, dns_name_t *name,
+dns_keytable_findkeynode(dns_keytable_t *keytable, const dns_name_t *name,
dns_secalg_t algorithm, dns_keytag_t tag,
dns_keynode_t **keynodep);
/*%<
*/
isc_result_t
-dns_keytable_finddeepestmatch(dns_keytable_t *keytable, dns_name_t *name,
+dns_keytable_finddeepestmatch(dns_keytable_t *keytable, const dns_name_t *name,
dns_name_t *foundname);
/*%<
* Search for the deepest match of 'name' in 'keytable'.
*/
isc_result_t
-dns_keytable_issecuredomain(dns_keytable_t *keytable, dns_name_t *name,
+dns_keytable_issecuredomain(dns_keytable_t *keytable, const dns_name_t *name,
dns_name_t *foundname, isc_boolean_t *wantdnssecp);
/*%<
* Is 'name' at or beneath a trusted key?
} dns_lookupevent_t;
isc_result_t
-dns_lookup_create(isc_mem_t *mctx, dns_name_t *name, dns_rdatatype_t type,
+dns_lookup_create(isc_mem_t *mctx, const dns_name_t *name, dns_rdatatype_t type,
dns_view_t *view, unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg, dns_lookup_t **lookupp);
/*%<
/*@}*/
isc_result_t
-dns_master_rdatasettotext(dns_name_t *owner_name,
+dns_master_rdatasettotext(const dns_name_t *owner_name,
dns_rdataset_t *rdataset,
const dns_master_style_t *style,
isc_buffer_t *target);
*/
isc_result_t
-dns_master_questiontotext(dns_name_t *owner_name,
+dns_master_questiontotext(const dns_name_t *owner_name,
dns_rdataset_t *rdataset,
const dns_master_style_t *style,
isc_buffer_t *target);
isc_result_t
dns_master_dumpnodetostream(isc_mem_t *mctx, dns_db_t *db,
dns_dbversion_t *version,
- dns_dbnode_t *node, dns_name_t *name,
+ dns_dbnode_t *node, const dns_name_t *name,
const dns_master_style_t *style,
FILE *f);
isc_result_t
dns_master_dumpnode(isc_mem_t *mctx, dns_db_t *db, dns_dbversion_t *version,
- dns_dbnode_t *node, dns_name_t *name,
+ dns_dbnode_t *node, const dns_name_t *name,
const dns_master_style_t *style, const char *filename);
unsigned int
isc_result_t
dns_message_findname(dns_message_t *msg, dns_section_t section,
- dns_name_t *target, dns_rdatatype_t type,
+ const dns_name_t *target, dns_rdatatype_t type,
dns_rdatatype_t covers, dns_name_t **foundname,
dns_rdataset_t **rdataset);
/*%<
*/
isc_result_t
-dns_message_findtype(dns_name_t *name, dns_rdatatype_t type,
+dns_message_findtype(const dns_name_t *name, dns_rdatatype_t type,
dns_rdatatype_t covers, dns_rdataset_t **rdataset);
/*%<
* Search the name for the specified type. If it is found, *rdataset is
*/
isc_result_t
-dns_message_find(dns_name_t *name, dns_rdataclass_t rdclass,
+dns_message_find(const dns_name_t *name, dns_rdataclass_t rdclass,
dns_rdatatype_t type, dns_rdatatype_t covers,
dns_rdataset_t **rdataset);
/*%<
*/
dns_rdataset_t *
-dns_message_gettsig(dns_message_t *msg, dns_name_t **owner);
+dns_message_gettsig(dns_message_t *msg, const dns_name_t **owner);
/*%<
* Get the TSIG record and owner for 'msg'.
*
*/
dns_rdataset_t *
-dns_message_getsig0(dns_message_t *msg, dns_name_t **owner);
+dns_message_getsig0(dns_message_t *msg, const dns_name_t **owner);
/*%<
* Get the SIG(0) record and owner for 'msg'.
*
int level, isc_mem_t *mctx);
void
dns_message_logpacket2(dns_message_t *message,
- const char *description, isc_sockaddr_t *address,
+ const char *description, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module,
int level, isc_mem_t *mctx);
void
const dns_master_style_t *style, int level,
isc_mem_t *mctx);
void
-dns_message_logfmtpacket2(dns_message_t *message,
- const char *description, isc_sockaddr_t *address,
+dns_message_logfmtpacket2(dns_message_t *message, const char *description,
+ const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module,
const dns_master_style_t *style, int level,
isc_mem_t *mctx);
#define DNS_NAME_CHECKMX 0x0010 /*%< Used by rdata. */
#define DNS_NAME_CHECKMXFAIL 0x0020 /*%< Used by rdata. */
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_rootname;
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_wildcardname;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_rootname;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_wildcardname;
#define DNS_NAME_INITNONABSOLUTE(A,B) { \
DNS_NAME_MAGIC, \
*/
unsigned int
-dns_name_hash(dns_name_t *name, isc_boolean_t case_sensitive);
+dns_name_hash(const dns_name_t *name, isc_boolean_t case_sensitive);
/*%<
* Provide a hash value for 'name'.
*
*/
unsigned int
-dns_name_fullhash(dns_name_t *name, isc_boolean_t case_sensitive);
+dns_name_fullhash(const dns_name_t *name, isc_boolean_t case_sensitive);
/*%<
* Provide a hash value for 'name'. Unlike dns_name_hash(), this function
* always takes into account of the entire name to calculate the hash value.
*/
unsigned int
-dns_name_hashbylabel(dns_name_t *name, isc_boolean_t case_sensitive);
+dns_name_hashbylabel(const dns_name_t *name, isc_boolean_t case_sensitive);
/*%<
* Provide a hash value for 'name', where the hash value is the sum
* of the hash values of each label.
*/
void
-dns_name_toregion(dns_name_t *name, isc_region_t *r);
+dns_name_toregion(const dns_name_t *name, isc_region_t *r);
/*%<
* Make 'r' refer to 'name'.
*
*/
isc_result_t
-dns_name_tofilenametext(dns_name_t *name, isc_boolean_t omit_final_dot,
+dns_name_tofilenametext(const dns_name_t *name, isc_boolean_t omit_final_dot,
isc_buffer_t *target);
/*%<
* Convert 'name' into an alternate text format appropriate for filenames,
*/
isc_result_t
-dns_name_downcase(dns_name_t *source, dns_name_t *name,
+dns_name_downcase(const dns_name_t *source, dns_name_t *name,
isc_buffer_t *target);
/*%<
* Downcase 'source'.
*/
isc_result_t
-dns_name_concatenate(dns_name_t *prefix, dns_name_t *suffix,
+dns_name_concatenate(const dns_name_t *prefix, const dns_name_t *suffix,
dns_name_t *name, isc_buffer_t *target);
/*%<
* Concatenate 'prefix' and 'suffix'.
*/
void
-dns_name_split(dns_name_t *name, unsigned int suffixlabels,
+dns_name_split(const dns_name_t *name, unsigned int suffixlabels,
dns_name_t *prefix, dns_name_t *suffix);
/*%<
*
*/
isc_result_t
-dns_name_dupwithoffsets(dns_name_t *source, isc_mem_t *mctx,
+dns_name_dupwithoffsets(const dns_name_t *source, isc_mem_t *mctx,
dns_name_t *target);
/*%<
* Make 'target' a read-only dynamically allocated copy of 'source'.
*/
isc_result_t
-dns_name_digest(dns_name_t *name, dns_digestfunc_t digest, void *arg);
+dns_name_digest(const dns_name_t *name, dns_digestfunc_t digest, void *arg);
/*%<
* Send 'name' in DNSSEC canonical form to 'digest'.
*
*/
isc_boolean_t
-dns_name_dynamic(dns_name_t *name);
+dns_name_dynamic(const dns_name_t *name);
/*%<
* Returns whether there is dynamic memory associated with this name.
*
*/
isc_result_t
-dns_name_print(dns_name_t *name, FILE *stream);
+dns_name_print(const dns_name_t *name, FILE *stream);
/*%<
* Print 'name' on 'stream'.
*
*/
isc_result_t
-dns_name_tostring(dns_name_t *source, char **target, isc_mem_t *mctx);
+dns_name_tostring(const dns_name_t *source, char **target, isc_mem_t *mctx);
/*%<
* Convert 'name' to string format, allocating sufficient memory to
* hold it (free with isc_mem_free()).
isc_result_t
dns_nsec_buildrdata(dns_db_t *db, dns_dbversion_t *version,
- dns_dbnode_t *node, dns_name_t *target,
+ dns_dbnode_t *node, const dns_name_t *target,
unsigned char *buffer, dns_rdata_t *rdata);
/*%<
* Build the rdata of a NSEC record.
isc_result_t
dns_nsec_build(dns_db_t *db, dns_dbversion_t *version, dns_dbnode_t *node,
- dns_name_t *target, dns_ttl_t ttl);
+ const dns_name_t *target, dns_ttl_t ttl);
/*%<
* Build a NSEC record and add it to a database.
*/
*/
isc_result_t
-dns_nsec_noexistnodata(dns_rdatatype_t type, dns_name_t *name,
- dns_name_t *nsecname, dns_rdataset_t *nsecset,
+dns_nsec_noexistnodata(dns_rdatatype_t type, const dns_name_t *name,
+ const dns_name_t *nsecname, dns_rdataset_t *nsecset,
isc_boolean_t *exists, isc_boolean_t *data,
dns_name_t *wild, dns_nseclog_t log, void *arg);
/*%
isc_result_t
dns_nsec3_hashname(dns_fixedname_t *result,
unsigned char rethash[NSEC3_MAX_HASH_LENGTH],
- size_t *hash_length, dns_name_t *name, dns_name_t *origin,
+ size_t *hash_length,
+ const dns_name_t *name, const dns_name_t *origin,
dns_hash_t hashalg, unsigned int iterations,
const unsigned char *salt, size_t saltlength);
/*%<
isc_result_t
dns_nsec3_addnsec3(dns_db_t *db, dns_dbversion_t *version,
- dns_name_t *name, const dns_rdata_nsec3param_t *nsec3param,
+ const dns_name_t *name,
+ const dns_rdata_nsec3param_t *nsec3param,
dns_ttl_t nsecttl, isc_boolean_t unsecure, dns_diff_t *diff);
isc_result_t
dns_nsec3_addnsec3s(dns_db_t *db, dns_dbversion_t *version,
- dns_name_t *name, dns_ttl_t nsecttl,
+ const dns_name_t *name, dns_ttl_t nsecttl,
isc_boolean_t unsecure, dns_diff_t *diff);
isc_result_t
dns_nsec3_addnsec3sx(dns_db_t *db, dns_dbversion_t *version,
- dns_name_t *name, dns_ttl_t nsecttl,
+ const dns_name_t *name, dns_ttl_t nsecttl,
isc_boolean_t unsecure, dns_rdatatype_t private,
dns_diff_t *diff);
/*%<
*/
isc_result_t
-dns_nsec3_delnsec3(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
+dns_nsec3_delnsec3(dns_db_t *db, dns_dbversion_t *version,
+ const dns_name_t *name,
const dns_rdata_nsec3param_t *nsec3param, dns_diff_t *diff);
isc_result_t
-dns_nsec3_delnsec3s(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
- dns_diff_t *diff);
+dns_nsec3_delnsec3s(dns_db_t *db, dns_dbversion_t *version,
+ const dns_name_t *name, dns_diff_t *diff);
isc_result_t
-dns_nsec3_delnsec3sx(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
- dns_rdatatype_t private, dns_diff_t *diff);
+dns_nsec3_delnsec3sx(dns_db_t *db, dns_dbversion_t *version,
+ const dns_name_t *name, dns_rdatatype_t private,
+ dns_diff_t *diff);
/*%<
* Remove NSEC3 records for 'name', recording the change in 'diff'.
* Adjust previous NSEC3 records, if any, to reflect the removal.
*/
isc_result_t
-dns_nsec3_noexistnodata(dns_rdatatype_t type, dns_name_t* name,
- dns_name_t *nsec3name, dns_rdataset_t *nsec3set,
+dns_nsec3_noexistnodata(dns_rdatatype_t type, const dns_name_t *name,
+ const dns_name_t *nsec3name, dns_rdataset_t *nsec3set,
dns_name_t *zonename, isc_boolean_t *exists,
isc_boolean_t *data, isc_boolean_t *optout,
isc_boolean_t *unknown, isc_boolean_t *setclosest,
*/
isc_result_t
-dns_ntatable_add(dns_ntatable_t *ntatable, dns_name_t *name,
+dns_ntatable_add(dns_ntatable_t *ntatable, const dns_name_t *name,
isc_boolean_t force, isc_stdtime_t now,
isc_uint32_t lifetime);
/*%<
*/
isc_result_t
-dns_ntatable_delete(dns_ntatable_t *ntatable, dns_name_t *keyname);
+dns_ntatable_delete(dns_ntatable_t *ntatable, const dns_name_t *keyname);
/*%<
* Delete node(s) from 'ntatable' matching name 'keyname'
*
isc_boolean_t
dns_ntatable_covered(dns_ntatable_t *ntatable, isc_stdtime_t now,
- dns_name_t *name, dns_name_t *anchor);
+ const dns_name_t *name, const dns_name_t *anchor);
/*%<
* Return ISC_TRUE if 'name' is below a non-expired negative trust
* anchor which in turn is at or below 'anchor'.
*/
isc_result_t
-dns_order_add(dns_order_t *order, dns_name_t *name,
+dns_order_add(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass,
unsigned int mode);
/*%<
*/
unsigned int
-dns_order_find(dns_order_t *order, dns_name_t *name,
+dns_order_find(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass);
/*%<
* Find the first matching entry on the list.
/*
* Ditto. */
isc_result_t
-dns_peerlist_peerbyaddr(dns_peerlist_t *peers, isc_netaddr_t *addr,
+dns_peerlist_peerbyaddr(dns_peerlist_t *peers, const isc_netaddr_t *addr,
dns_peer_t **retval);
/*
dns_peerlist_currpeer(dns_peerlist_t *peers, dns_peer_t **retval);
isc_result_t
-dns_peer_new(isc_mem_t *mem, isc_netaddr_t *ipaddr, dns_peer_t **peer);
+dns_peer_new(isc_mem_t *mem, const isc_netaddr_t *ipaddr, dns_peer_t **peer);
isc_result_t
-dns_peer_newprefix(isc_mem_t *mem, isc_netaddr_t *ipaddr,
+dns_peer_newprefix(isc_mem_t *mem, const isc_netaddr_t *ipaddr,
unsigned int prefixlen, dns_peer_t **peer);
void
*/
isc_result_t
-dns_rbt_addname(dns_rbt_t *rbt, dns_name_t *name, void *data);
+dns_rbt_addname(dns_rbt_t *rbt, const dns_name_t *name, void *data);
/*%<
* Add 'name' to the tree of trees, associated with 'data'.
*
*/
isc_result_t
-dns_rbt_addnode(dns_rbt_t *rbt, dns_name_t *name, dns_rbtnode_t **nodep);
+dns_rbt_addnode(dns_rbt_t *rbt, const dns_name_t *name, dns_rbtnode_t **nodep);
/*%<
* Just like dns_rbt_addname, but returns the address of the node.
*/
isc_result_t
-dns_rbt_deletename(dns_rbt_t *rbt, dns_name_t *name, isc_boolean_t recurse);
+dns_rbt_deletename(dns_rbt_t *rbt, const dns_name_t *name,
+ isc_boolean_t recurse);
/*%<
* Delete 'name' from the tree of trees.
*
isc_result_t
dns_rdata_fromtext(dns_rdata_t *rdata, dns_rdataclass_t rdclass,
- dns_rdatatype_t type, isc_lex_t *lexer, dns_name_t *origin,
- unsigned int options, isc_mem_t *mctx,
+ dns_rdatatype_t type, isc_lex_t *lexer,
+ const dns_name_t *origin, unsigned int options,
+ isc_mem_t *mctx,
isc_buffer_t *target, dns_rdatacallbacks_t *callbacks);
/*%<
* Convert the textual representation of a DNS rdata into uncompressed wire
*/
isc_result_t
-dns_rdata_totext(dns_rdata_t *rdata, dns_name_t *origin, isc_buffer_t *target);
+dns_rdata_totext(dns_rdata_t *rdata, const dns_name_t *origin,
+ isc_buffer_t *target);
/*%<
* Convert 'rdata' into text format, storing the result in 'target'.
* The text will consist of a single line, with fields separated by
*/
isc_result_t
-dns_rdata_tofmttext(dns_rdata_t *rdata, dns_name_t *origin, unsigned int flags,
- unsigned int width, unsigned int split_width,
- const char *linebreak, isc_buffer_t *target);
+dns_rdata_tofmttext(dns_rdata_t *rdata, const dns_name_t *origin,
+ unsigned int flags, unsigned int width,
+ unsigned int split_width, const char *linebreak,
+ isc_buffer_t *target);
/*%<
* Like dns_rdata_totext, but do formatted output suitable for
* database dumps. This is intended for use by dns_db_dump();
*/
isc_boolean_t
-dns_rdata_checkowner(dns_name_t* name, dns_rdataclass_t rdclass,
+dns_rdata_checkowner(const dns_name_t *name, dns_rdataclass_t rdclass,
dns_rdatatype_t type, isc_boolean_t wildcard);
/*
* Returns whether this is a valid ownername for this <type,class>.
*/
isc_boolean_t
-dns_rdata_checknames(dns_rdata_t *rdata, dns_name_t *owner, dns_name_t *bad);
+dns_rdata_checknames(dns_rdata_t *rdata, const dns_name_t *owner,
+ dns_name_t *bad);
/*
* Returns whether 'rdata' contains valid domain names. The checks are
* sensitive to the owner name.
dns_rdataset_t *target);
unsigned int (*count)(dns_rdataset_t *rdataset);
isc_result_t (*addnoqname)(dns_rdataset_t *rdataset,
- dns_name_t *name);
+ const dns_name_t *name);
isc_result_t (*getnoqname)(dns_rdataset_t *rdataset,
dns_name_t *name,
dns_rdataset_t *neg,
dns_rdataset_t *negsig);
isc_result_t (*addclosest)(dns_rdataset_t *rdataset,
- dns_name_t *name);
+ const dns_name_t *name);
isc_result_t (*getclosest)(dns_rdataset_t *rdataset,
dns_name_t *name,
dns_rdataset_t *neg,
void * private3;
unsigned int privateuint4;
void * private5;
- void * private6;
- void * private7;
+ const void * private6;
+ const void * private7;
/*@}*/
};
isc_result_t
dns_rdataset_totext(dns_rdataset_t *rdataset,
- dns_name_t *owner_name,
+ const dns_name_t *owner_name,
isc_boolean_t omit_final_dot,
isc_boolean_t question,
isc_buffer_t *target);
isc_result_t
dns_rdataset_towire(dns_rdataset_t *rdataset,
- dns_name_t *owner_name,
+ const dns_name_t *owner_name,
dns_compress_t *cctx,
isc_buffer_t *target,
unsigned int options,
*/
isc_result_t
-dns_rdataset_addclosest(dns_rdataset_t *rdataset, dns_name_t *name);
+dns_rdataset_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name);
/*%<
* Associate a closest encloset proof with this record.
* Sets #DNS_RDATASETATTR_CLOSEST if successful.
isc_result_t
dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *address, unsigned int options,
+ const isc_sockaddr_t *address, unsigned int options,
dns_tsigkey_t *key,
unsigned int timeout, isc_task_t *task,
isc_taskaction_t action, void *arg,
/*% See dns_request_createvia4() */
isc_result_t
dns_request_createvia(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
- unsigned int options, dns_tsigkey_t *key,
- unsigned int timeout, isc_task_t *task,
- isc_taskaction_t action, void *arg,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr, unsigned int options,
+ dns_tsigkey_t *key, unsigned int timeout,
+ isc_task_t *task, isc_taskaction_t action, void *arg,
dns_request_t **requestp);
/*% See dns_request_createvia4() */
isc_result_t
dns_request_createvia2(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, dns_tsigkey_t *key,
unsigned int timeout, unsigned int udptimeout,
isc_task_t *task, isc_taskaction_t action, void *arg,
/*% See dns_request_createvia4() */
isc_result_t
dns_request_createvia3(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, dns_tsigkey_t *key,
unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task,
isc_result_t
dns_request_createvia4(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
isc_dscp_t dscp, unsigned int options,
dns_tsigkey_t *key, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries,
/*% See dns_request_createraw4() */
isc_result_t
dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, unsigned int timeout,
isc_task_t *task, isc_taskaction_t action, void *arg,
dns_request_t **requestp);
/*% See dns_request_createraw4() */
isc_result_t
dns_request_createraw2(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, unsigned int timeout,
unsigned int udptimeout, isc_task_t *task,
isc_taskaction_t action, void *arg,
/*% See dns_request_createraw4() */
isc_result_t
dns_request_createraw3(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_result_t
dns_request_createraw4(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
isc_dscp_t dscp, unsigned int options,
unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task,
dns_rdataset_t * rdataset;
dns_rdataset_t * sigrdataset;
dns_fixedname_t foundname;
- isc_sockaddr_t * client;
+ const isc_sockaddr_t * client;
dns_messageid_t id;
isc_result_t vresult;
} dns_fetchevent_t;
dns_resolver_detach(dns_resolver_t **resp);
isc_result_t
-dns_resolver_createfetch(dns_resolver_t *res, dns_name_t *name,
+dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name,
dns_rdatatype_t type,
- dns_name_t *domain, dns_rdataset_t *nameservers,
+ const dns_name_t *domain, dns_rdataset_t *nameservers,
dns_forwarders_t *forwarders,
unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg,
dns_fetch_t **fetchp);
isc_result_t
-dns_resolver_createfetch2(dns_resolver_t *res, dns_name_t *name,
+dns_resolver_createfetch2(dns_resolver_t *res, const dns_name_t *name,
dns_rdatatype_t type,
- dns_name_t *domain, dns_rdataset_t *nameservers,
+ const dns_name_t *domain, dns_rdataset_t *nameservers,
dns_forwarders_t *forwarders,
- isc_sockaddr_t *client, isc_uint16_t id,
+ const isc_sockaddr_t *client, isc_uint16_t id,
unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg,
dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset,
dns_fetch_t **fetchp);
isc_result_t
-dns_resolver_createfetch3(dns_resolver_t *res, dns_name_t *name,
+dns_resolver_createfetch3(dns_resolver_t *res, const dns_name_t *name,
dns_rdatatype_t type,
- dns_name_t *domain, dns_rdataset_t *nameservers,
+ const dns_name_t *domain, dns_rdataset_t *nameservers,
dns_forwarders_t *forwarders,
- isc_sockaddr_t *client, isc_uint16_t id,
+ const isc_sockaddr_t *client, isc_uint16_t id,
unsigned int options, unsigned int depth,
isc_counter_t *qc, isc_task_t *task,
isc_taskaction_t action, void *arg,
*/
isc_result_t
-dns_resolver_addalternate(dns_resolver_t *resolver, isc_sockaddr_t *alt,
- dns_name_t *name, in_port_t port);
+dns_resolver_addalternate(dns_resolver_t *resolver, const isc_sockaddr_t *alt,
+ const dns_name_t *name, in_port_t port);
/*%<
* Add alternate addresses to be tried in the event that the nameservers
* for a zone are not available in the address families supported by the
*/
isc_result_t
-dns_resolver_disable_algorithm(dns_resolver_t *resolver, dns_name_t *name,
- unsigned int alg);
+dns_resolver_disable_algorithm(dns_resolver_t *resolver,
+ const dns_name_t *name, unsigned int alg);
/*%<
* Mark the given DNSSEC algorithm as disabled and below 'name'.
* Valid algorithms are less than 256.
*/
isc_result_t
-dns_resolver_disable_ds_digest(dns_resolver_t *resolver, dns_name_t *name,
- unsigned int digest_type);
+dns_resolver_disable_ds_digest(dns_resolver_t *resolver,
+ const dns_name_t *name, unsigned int digest_type);
/*%<
* Mark the given DS/DLV digest type as disabled and below 'name'.
* Valid types are less than 256.
*/
isc_boolean_t
-dns_resolver_algorithm_supported(dns_resolver_t *resolver, dns_name_t *name,
- unsigned int alg);
+dns_resolver_algorithm_supported(dns_resolver_t *resolver,
+ const dns_name_t *name, unsigned int alg);
/*%<
* Check if the given algorithm is supported by this resolver.
* This checks whether the algorithm has been disabled via
*/
isc_boolean_t
-dns_resolver_ds_digest_supported(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_ds_digest_supported(dns_resolver_t *resolver,
+ const dns_name_t *name,
unsigned int digest_type);
/*%<
* Check if the given digest type is supported by this resolver.
dns_resolver_resetmustbesecure(dns_resolver_t *resolver);
isc_result_t
-dns_resolver_setmustbesecure(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_setmustbesecure(dns_resolver_t *resolver, const dns_name_t *name,
isc_boolean_t value);
isc_boolean_t
-dns_resolver_getmustbesecure(dns_resolver_t *resolver, dns_name_t *name);
+dns_resolver_getmustbesecure(dns_resolver_t *resolver, const dns_name_t *name);
void
dns_resolver_getoptions(dns_resolver_t *resolver);
void
-dns_resolver_addbadcache(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_addbadcache(dns_resolver_t *resolver, const dns_name_t *name,
dns_rdatatype_t type, isc_time_t *expire);
/*%<
* Add a entry to the bad cache for <name,type> that will expire at 'expire'.
*/
isc_boolean_t
-dns_resolver_getbadcache(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_getbadcache(dns_resolver_t *resolver, const dns_name_t *name,
dns_rdatatype_t type, isc_time_t *now);
/*%<
* Check to see if there is a unexpired entry in the bad cache for
*/
void
-dns_resolver_flushbadcache(dns_resolver_t *resolver, dns_name_t *name);
+dns_resolver_flushbadcache(dns_resolver_t *resolver, const dns_name_t *name);
/*%<
* Flush the bad cache of all entries at 'name' if 'name' is non NULL.
* Flush the entire bad cache if 'name' is NULL.
*/
void
-dns_resolver_flushbadnames(dns_resolver_t *resolver, dns_name_t *name);
+dns_resolver_flushbadnames(dns_resolver_t *resolver, const dns_name_t *name);
/*%<
* Flush the bad cache of all entries at or below 'name'.
*
dns_rpz_zones_t **load_rpzsp, dns_rpz_num_t rpz_num);
isc_result_t
-dns_rpz_add(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num, dns_name_t *name);
+dns_rpz_add(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
+ const dns_name_t *name);
void
-dns_rpz_delete(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num, dns_name_t *name);
+dns_rpz_delete(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
+ const dns_name_t *name);
dns_rpz_num_t
dns_rpz_find_ip(dns_rpz_zones_t *rpzs, dns_rpz_type_t rpz_type,
dns_rrl(dns_view_t *view,
const isc_sockaddr_t *client_addr, isc_boolean_t is_tcp,
dns_rdataclass_t rdclass, dns_rdatatype_t qtype,
- dns_name_t *qname, isc_result_t resp_result, isc_stdtime_t now,
+ const dns_name_t *qname, isc_result_t resp_result, isc_stdtime_t now,
isc_boolean_t wouldlog, char *log_buf, unsigned int log_buf_len);
void
typedef isc_result_t dns_sdlz_setdb_t(dns_dlzdb_t *dlzdatabase,
dns_rdataclass_t rdclass,
- dns_name_t *name,
+ const dns_name_t *name,
dns_db_t **dbp);
dns_sdlz_setdb_t dns_sdlz_setdb;
/*%<
#define DNS_SOA_BUFFERSIZE ((2 * DNS_NAME_MAXWIRE) + (4 * 5))
isc_result_t
-dns_soa_buildrdata(dns_name_t *origin, dns_name_t *contact,
+dns_soa_buildrdata(const dns_name_t *origin, const dns_name_t *contact,
dns_rdataclass_t rdclass,
isc_uint32_t serial, isc_uint32_t refresh,
isc_uint32_t retry, isc_uint32_t expire,
isc_result_t
dns_ssutable_addrule(dns_ssutable_t *table, isc_boolean_t grant,
- dns_name_t *identity, unsigned int matchtype,
- dns_name_t *name, unsigned int ntypes,
+ const dns_name_t *identity, unsigned int matchtype,
+ const dns_name_t *name, unsigned int ntypes,
dns_rdatatype_t *types);
/*%<
* Adds a new rule to a simple-secure-update rule table. The rule
*/
isc_boolean_t
-dns_ssutable_checkrules(dns_ssutable_t *table, dns_name_t *signer,
- dns_name_t *name, isc_netaddr_t *tcpaddr,
+dns_ssutable_checkrules(dns_ssutable_t *table, const dns_name_t *signer,
+ const dns_name_t *name, const isc_netaddr_t *tcpaddr,
dns_rdatatype_t type, const dst_key_t *key);
/*%<
* Checks that the attempted update of (name, type) is allowed according
* Check a policy rule via an external application
*/
isc_boolean_t
-dns_ssu_external_match(dns_name_t *identity, dns_name_t *signer,
- dns_name_t *name, isc_netaddr_t *tcpaddr,
+dns_ssu_external_match(const dns_name_t *identity, const dns_name_t *signer,
+ const dns_name_t *name, const isc_netaddr_t *tcpaddr,
dns_rdatatype_t type, const dst_key_t *key,
isc_mem_t *mctx);
*/
isc_result_t
-dns_tkey_builddhquery(dns_message_t *msg, dst_key_t *key, dns_name_t *name,
- dns_name_t *algorithm, isc_buffer_t *nonce,
- isc_uint32_t lifetime);
+dns_tkey_builddhquery(dns_message_t *msg, dst_key_t *key,
+ const dns_name_t *name, const dns_name_t *algorithm,
+ isc_buffer_t *nonce, isc_uint32_t lifetime);
/*%<
* Builds a query containing a TKEY that will generate a shared
* secret using a Diffie-Hellman key exchange. The shared key
*/
isc_result_t
-dns_tkey_buildgssquery(dns_message_t *msg, dns_name_t *name, dns_name_t *gname,
- isc_buffer_t *intoken, isc_uint32_t lifetime,
- gss_ctx_id_t *context, isc_boolean_t win2k,
- isc_mem_t *mctx, char **err_message);
+dns_tkey_buildgssquery(dns_message_t *msg, const dns_name_t *name,
+ const dns_name_t *gname, isc_buffer_t *intoken,
+ isc_uint32_t lifetime, gss_ctx_id_t *context,
+ isc_boolean_t win2k, isc_mem_t *mctx,
+ char **err_message);
/*%<
* Builds a query containing a TKEY that will generate a GSSAPI context.
* The key is requested to have the specified lifetime (in seconds).
isc_result_t
dns_tkey_processgssresponse(dns_message_t *qmsg, dns_message_t *rmsg,
- dns_name_t *gname, gss_ctx_id_t *context,
+ const dns_name_t *gname, gss_ctx_id_t *context,
isc_buffer_t *outtoken, dns_tsigkey_t **outkey,
dns_tsig_keyring_t *ring, char **err_message);
/*%<
isc_result_t
dns_tkey_gssnegotiate(dns_message_t *qmsg, dns_message_t *rmsg,
- dns_name_t *server, gss_ctx_id_t *context,
+ const dns_name_t *server, gss_ctx_id_t *context,
dns_tsigkey_t **outkey, dns_tsig_keyring_t *ring,
isc_boolean_t win2k, char **err_message);
* Algorithms.
*/
#ifndef PK11_MD5_DISABLE
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_tsig_hmacmd5_name;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_tsig_hmacmd5_name;
#define DNS_TSIG_HMACMD5_NAME dns_tsig_hmacmd5_name
#endif
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_tsig_gssapi_name;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_tsig_gssapi_name;
#define DNS_TSIG_GSSAPI_NAME dns_tsig_gssapi_name
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_tsig_gssapims_name;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_tsig_gssapims_name;
#define DNS_TSIG_GSSAPIMS_NAME dns_tsig_gssapims_name
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_tsig_hmacsha1_name;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_tsig_hmacsha1_name;
#define DNS_TSIG_HMACSHA1_NAME dns_tsig_hmacsha1_name
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_tsig_hmacsha224_name;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_tsig_hmacsha224_name;
#define DNS_TSIG_HMACSHA224_NAME dns_tsig_hmacsha224_name
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_tsig_hmacsha256_name;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_tsig_hmacsha256_name;
#define DNS_TSIG_HMACSHA256_NAME dns_tsig_hmacsha256_name
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_tsig_hmacsha384_name;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_tsig_hmacsha384_name;
#define DNS_TSIG_HMACSHA384_NAME dns_tsig_hmacsha384_name
-LIBDNS_EXTERNAL_DATA extern dns_name_t *dns_tsig_hmacsha512_name;
+LIBDNS_EXTERNAL_DATA extern const dns_name_t *dns_tsig_hmacsha512_name;
#define DNS_TSIG_HMACSHA512_NAME dns_tsig_hmacsha512_name
/*%
isc_mem_t *mctx;
dst_key_t *key; /*%< Key */
dns_name_t name; /*%< Key name */
- dns_name_t *algorithm; /*%< Algorithm name */
+ const dns_name_t *algorithm; /*%< Algorithm name */
dns_name_t *creator; /*%< name that created secret */
isc_boolean_t generated; /*%< was this generated? */
isc_stdtime_t inception; /*%< start of validity period */
ISC_LANG_BEGINDECLS
isc_result_t
-dns_tsigkey_create(dns_name_t *name, dns_name_t *algorithm,
+dns_tsigkey_create(const dns_name_t *name, const dns_name_t *algorithm,
unsigned char *secret, int length, isc_boolean_t generated,
- dns_name_t *creator, isc_stdtime_t inception,
+ const dns_name_t *creator, isc_stdtime_t inception,
isc_stdtime_t expire, isc_mem_t *mctx,
dns_tsig_keyring_t *ring, dns_tsigkey_t **key);
isc_result_t
-dns_tsigkey_createfromkey(dns_name_t *name, dns_name_t *algorithm,
+dns_tsigkey_createfromkey(const dns_name_t *name, const dns_name_t *algorithm,
dst_key_t *dstkey, isc_boolean_t generated,
- dns_name_t *creator, isc_stdtime_t inception,
+ const dns_name_t *creator, isc_stdtime_t inception,
isc_stdtime_t expire, isc_mem_t *mctx,
dns_tsig_keyring_t *ring, dns_tsigkey_t **key);
/*%<
*/
isc_result_t
-dns_tsigkey_find(dns_tsigkey_t **tsigkey, dns_name_t *name,
- dns_name_t *algorithm, dns_tsig_keyring_t *ring);
+dns_tsigkey_find(dns_tsigkey_t **tsigkey, const dns_name_t *name,
+ const dns_name_t *algorithm, dns_tsig_keyring_t *ring);
/*%<
* Returns the TSIG key corresponding to this name and (possibly)
* algorithm. Also increments the key's reference counter.
*/
isc_result_t
-dns_tsigkeyring_add(dns_tsig_keyring_t *ring, dns_name_t *name,
+dns_tsigkeyring_add(dns_tsig_keyring_t *ring, const dns_name_t *name,
dns_tsigkey_t *tkey);
/*%<
* Place a TSIG key onto a key ring.
(*dns_rawdatafunc_t)(dns_zone_t *, dns_masterrawheader_t *);
typedef isc_result_t
-(*dns_addrdatasetfunc_t)(void *, dns_name_t *, dns_rdataset_t *);
+(*dns_addrdatasetfunc_t)(void *, const dns_name_t *, dns_rdataset_t *);
typedef isc_result_t
-(*dns_additionaldatafunc_t)(void *, dns_name_t *, dns_rdatatype_t);
+(*dns_additionaldatafunc_t)(void *, const dns_name_t *, dns_rdatatype_t);
typedef isc_result_t
(*dns_digestfunc_t)(void *, isc_region_t *);
(*dns_rdatasetorderfunc_t)(const dns_rdata_t *, const void *);
typedef isc_boolean_t
-(*dns_checkmxfunc_t)(dns_zone_t *, dns_name_t *, dns_name_t *);
+(*dns_checkmxfunc_t)(dns_zone_t *, const dns_name_t *, const dns_name_t *);
typedef isc_boolean_t
-(*dns_checksrvfunc_t)(dns_zone_t *, dns_name_t *, dns_name_t *);
+(*dns_checksrvfunc_t)(dns_zone_t *, const dns_name_t *, const dns_name_t *);
typedef isc_boolean_t
-(*dns_checknsfunc_t)(dns_zone_t *, dns_name_t *, dns_name_t *,
+(*dns_checknsfunc_t)(dns_zone_t *, const dns_name_t *, const dns_name_t *,
dns_rdataset_t *, dns_rdataset_t *);
typedef isc_boolean_t
-(*dns_isselffunc_t)(dns_view_t *, dns_tsigkey_t *, isc_sockaddr_t *,
- isc_sockaddr_t *, dns_rdataclass_t, void *);
+(*dns_isselffunc_t)(dns_view_t *, dns_tsigkey_t *, const isc_sockaddr_t *,
+ const isc_sockaddr_t *, dns_rdataclass_t, void *);
typedef isc_result_t
(*dns_deserializefunc_t)(void *, FILE *, off_t);
*\li 'view' is no longer frozen.
*/
isc_result_t
-dns_view_find(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
+dns_view_find(dns_view_t *view, const dns_name_t *name, dns_rdatatype_t type,
isc_stdtime_t now, unsigned int options, isc_boolean_t use_hints,
dns_db_t **dbp, dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
isc_result_t
-dns_view_find2(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
+dns_view_find2(dns_view_t *view, const dns_name_t *name, dns_rdatatype_t type,
isc_stdtime_t now, unsigned int options,
isc_boolean_t use_hints, isc_boolean_t use_static_stub,
dns_db_t **dbp, dns_dbnode_t **nodep, dns_name_t *foundname,
*/
isc_result_t
-dns_view_simplefind(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
- isc_stdtime_t now, unsigned int options,
- isc_boolean_t use_hints,
+dns_view_simplefind(dns_view_t *view, const dns_name_t *name,
+ dns_rdatatype_t type, isc_stdtime_t now,
+ unsigned int options, isc_boolean_t use_hints,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
/*%<
* Find an rdataset whose owner name is 'name', and whose type is
/*% See dns_view_findzonecut2() */
isc_result_t
-dns_view_findzonecut(dns_view_t *view, dns_name_t *name, dns_name_t *fname,
- isc_stdtime_t now, unsigned int options,
- isc_boolean_t use_hints,
+dns_view_findzonecut(dns_view_t *view, const dns_name_t *name,
+ dns_name_t *fname, isc_stdtime_t now,
+ unsigned int options, isc_boolean_t use_hints,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
isc_result_t
-dns_view_findzonecut2(dns_view_t *view, dns_name_t *name, dns_name_t *fname,
- isc_stdtime_t now, unsigned int options,
+dns_view_findzonecut2(dns_view_t *view, const dns_name_t *name,
+ dns_name_t *fname, isc_stdtime_t now,
+ unsigned int options,
isc_boolean_t use_hints, isc_boolean_t use_cache,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
/*%<
*/
isc_result_t
-dns_viewlist_findzone(dns_viewlist_t *list, dns_name_t *name, isc_boolean_t allclasses,
- dns_rdataclass_t rdclass, dns_zone_t **zonep);
+dns_viewlist_findzone(dns_viewlist_t *list, const dns_name_t *name,
+ isc_boolean_t allclasses, dns_rdataclass_t rdclass,
+ dns_zone_t **zonep);
/*%<
* Search zone with 'name' in view with 'rdclass' in viewlist 'list'
*/
isc_result_t
-dns_view_findzone(dns_view_t *view, dns_name_t *name, dns_zone_t **zonep);
+dns_view_findzone(dns_view_t *view, const dns_name_t *name,
+ dns_zone_t **zonep);
/*%<
* Search for the zone 'name' in the zone table of 'view'.
* If found, 'zonep' is (strongly) attached to it. There
*/
isc_result_t
-dns_view_gettsig(dns_view_t *view, dns_name_t *keyname,
+dns_view_gettsig(dns_view_t *view, const dns_name_t *keyname,
dns_tsigkey_t **keyp);
/*%<
* Find the TSIG key configured in 'view' with name 'keyname',
*/
isc_result_t
-dns_view_getpeertsig(dns_view_t *view, isc_netaddr_t *peeraddr,
+dns_view_getpeertsig(dns_view_t *view, const isc_netaddr_t *peeraddr,
dns_tsigkey_t **keyp);
/*%<
* Find the TSIG key configured in 'view' for the server whose
*/
isc_result_t
-dns_view_flushnode(dns_view_t *view, dns_name_t *name, isc_boolean_t tree);
+dns_view_flushnode(dns_view_t *view, const dns_name_t *name,
+ isc_boolean_t tree);
/*%<
* Flush the given name from the view's cache (and optionally ADB/badcache).
*
*/
isc_result_t
-dns_view_flushname(dns_view_t *view, dns_name_t *name);
+dns_view_flushname(dns_view_t *view, const dns_name_t *name);
/*%<
* Flush the given name from the view's cache, ADB and badcache.
* Equivalent to dns_view_flushnode(view, name, ISC_FALSE).
*/
isc_result_t
-dns_view_adddelegationonly(dns_view_t *view, dns_name_t *name);
+dns_view_adddelegationonly(dns_view_t *view, const dns_name_t *name);
/*%<
* Add the given name to the delegation only table.
*
*/
isc_result_t
-dns_view_excludedelegationonly(dns_view_t *view, dns_name_t *name);
+dns_view_excludedelegationonly(dns_view_t *view, const dns_name_t *name);
/*%<
* Add the given name to be excluded from the root-delegation-only.
*
*/
isc_boolean_t
-dns_view_isdelegationonly(dns_view_t *view, dns_name_t *name);
+dns_view_isdelegationonly(dns_view_t *view, const dns_name_t *name);
/*%<
* Check if 'name' is in the delegation only table or if
* rootdelonly is set that name is not being excluded.
*/
isc_result_t
-dns_view_issecuredomain(dns_view_t *view, dns_name_t *name,
+dns_view_issecuredomain(dns_view_t *view, const dns_name_t *name,
isc_stdtime_t now, isc_boolean_t checknta,
isc_boolean_t *secure_domain);
/*%<
isc_boolean_t
dns_view_ntacovers(dns_view_t *view, isc_stdtime_t now,
- dns_name_t *name, dns_name_t *anchor);
+ const dns_name_t *name, const dns_name_t *anchor);
/*%<
* Is there a current negative trust anchor above 'name' and below 'anchor'?
*
*/
void
-dns_view_untrust(dns_view_t *view, dns_name_t *keyname,
+dns_view_untrust(dns_view_t *view, const dns_name_t *keyname,
dns_rdata_dnskey_t *dnskey, isc_mem_t *mctx);
/*%<
* Remove keys that match 'keyname' and 'dnskey' from the views trust
dns_view_restorekeyring(dns_view_t *view);
isc_result_t
-dns_view_searchdlz(dns_view_t *view, dns_name_t *name,
+dns_view_searchdlz(dns_view_t *view, const dns_name_t *name,
unsigned int minlabels,
dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo,
/*% see dns_xfrin_create2() */
isc_result_t
dns_xfrin_create(dns_zone_t *zone, dns_rdatatype_t xfrtype,
- isc_sockaddr_t *masteraddr, dns_tsigkey_t *tsigkey,
+ const isc_sockaddr_t *masteraddr, dns_tsigkey_t *tsigkey,
isc_mem_t *mctx, isc_timermgr_t *timermgr,
isc_socketmgr_t *socketmgr, isc_task_t *task,
dns_xfrindone_t done, dns_xfrin_ctx_t **xfrp);
isc_result_t
dns_xfrin_create2(dns_zone_t *zone, dns_rdatatype_t xfrtype,
- isc_sockaddr_t *masteraddr, isc_sockaddr_t *sourceaddr,
+ const isc_sockaddr_t *masteraddr,
+ const isc_sockaddr_t *sourceaddr,
dns_tsigkey_t *tsigkey, isc_mem_t *mctx,
isc_timermgr_t *timermgr, isc_socketmgr_t *socketmgr,
isc_task_t *task, dns_xfrindone_t done,
isc_result_t
dns_xfrin_create3(dns_zone_t *zone, dns_rdatatype_t xfrtype,
- isc_sockaddr_t *masteraddr, isc_sockaddr_t *sourceaddr,
+ const isc_sockaddr_t *masteraddr,
+ const isc_sockaddr_t *sourceaddr,
isc_dscp_t dscp, dns_tsigkey_t *tsigkey, isc_mem_t *mctx,
isc_timermgr_t *timermgr, isc_socketmgr_t *socketmgr,
isc_task_t *task, dns_xfrindone_t done,
*/
isc_result_t
-dns_zone_checknames(dns_zone_t *zone, dns_name_t *name, dns_rdata_t *rdata);
+dns_zone_checknames(dns_zone_t *zone, const dns_name_t *name,
+ dns_rdata_t *rdata);
/*%<
* Check if this record meets the check-names policy.
*
* Set the isself callback function and argument.
*
* isc_boolean_t
- * isself(dns_view_t *myview, dns_tsigkey_t *mykey, isc_netaddr_t *srcaddr,
- * isc_netaddr_t *destaddr, dns_rdataclass_t rdclass, void *arg);
+ * isself(dns_view_t *myview, dns_tsigkey_t *mykey,
+ * const isc_netaddr_t *srcaddr, const isc_netaddr_t *destaddr,
+ * dns_rdataclass_t rdclass, void *arg);
*
* 'isself' returns ISC_TRUE if a non-recursive query from 'srcaddr' to
* 'destaddr' with optional key 'mykey' for class 'rdclass' would be
*/
isc_result_t
-dst_key_fromdns(dns_name_t *name, dns_rdataclass_t rdclass,
+dst_key_fromdns(const dns_name_t *name, dns_rdataclass_t rdclass,
isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp);
/*%<
* Converts a DNS KEY record into a DST key.
*/
isc_result_t
-dst_key_frombuffer(dns_name_t *name, unsigned int alg,
+dst_key_frombuffer(const dns_name_t *name, unsigned int alg,
unsigned int flags, unsigned int protocol,
dns_rdataclass_t rdclass,
isc_buffer_t *source, isc_mem_t *mctx, dst_key_t **keyp);
*/
isc_result_t
-dst_key_fromgssapi(dns_name_t *name, gss_ctx_id_t gssctx, isc_mem_t *mctx,
+dst_key_fromgssapi(const dns_name_t *name, gss_ctx_id_t gssctx, isc_mem_t *mctx,
dst_key_t **keyp, isc_region_t *intoken);
/*%<
* Converts a GSSAPI opaque context id into a DST key.
#ifdef DST_KEY_INTERNAL
isc_result_t
-dst_key_buildinternal(dns_name_t *name, unsigned int alg,
+dst_key_buildinternal(const dns_name_t *name, unsigned int alg,
unsigned int bits, unsigned int flags,
unsigned int protocol, dns_rdataclass_t rdclass,
void *data, isc_mem_t *mctx, dst_key_t **keyp);
#endif
isc_result_t
-dst_key_fromlabel(dns_name_t *name, int alg, unsigned int flags,
+dst_key_fromlabel(const dns_name_t *name, int alg, unsigned int flags,
unsigned int protocol, dns_rdataclass_t rdclass,
const char *engine, const char *label, const char *pin,
isc_mem_t *mctx, dst_key_t **keyp);
isc_result_t
-dst_key_generate(dns_name_t *name, unsigned int alg,
+dst_key_generate(const dns_name_t *name, unsigned int alg,
unsigned int bits, unsigned int param,
unsigned int flags, unsigned int protocol,
dns_rdataclass_t rdclass,
isc_mem_t *mctx, dst_key_t **keyp);
isc_result_t
-dst_key_generate2(dns_name_t *name, unsigned int alg,
+dst_key_generate2(const dns_name_t *name, unsigned int alg,
unsigned int bits, unsigned int param,
unsigned int flags, unsigned int protocol,
dns_rdataclass_t rdclass,
***/
isc_result_t
-dst_gssapi_acquirecred(dns_name_t *name, isc_boolean_t initiate,
+dst_gssapi_acquirecred(const dns_name_t *name, isc_boolean_t initiate,
gss_cred_id_t *cred);
/*
* Acquires GSS credentials.
*/
isc_result_t
-dst_gssapi_initctx(dns_name_t *name, isc_buffer_t *intoken,
+dst_gssapi_initctx(const dns_name_t *name, isc_buffer_t *intoken,
isc_buffer_t *outtoken, gss_ctx_id_t *gssctx,
isc_mem_t *mctx, char **err_message);
/*
*/
isc_boolean_t
-dst_gssapi_identitymatchesrealmkrb5(dns_name_t *signer, dns_name_t *name,
- dns_name_t *realm);
+dst_gssapi_identitymatchesrealmkrb5(const dns_name_t *signer,
+ const dns_name_t *name,
+ const dns_name_t *realm);
/*
* Compare a "signer" (in the format of a Kerberos-format Kerberos5
* principal: host/example.com@EXAMPLE.COM) to the realm name stored
*/
isc_boolean_t
-dst_gssapi_identitymatchesrealmms(dns_name_t *signer, dns_name_t *name,
- dns_name_t *realm);
+dst_gssapi_identitymatchesrealmms(const dns_name_t *signer,
+ const dns_name_t *name,
+ const dns_name_t *realm);
/*
* Compare a "signer" (in the format of a Kerberos-format Kerberos5
* principal: host/example.com@EXAMPLE.COM) to the realm name stored
* Add an IP prefix to an existing IP table
*/
isc_result_t
-dns_iptable_addprefix(dns_iptable_t *tab, isc_netaddr_t *addr,
+dns_iptable_addprefix(dns_iptable_t *tab, const isc_netaddr_t *addr,
isc_uint16_t bitlen, isc_boolean_t pos)
{
return(dns_iptable_addprefix2(tab, addr, bitlen, pos, ISC_FALSE));
}
isc_result_t
-dns_iptable_addprefix2(dns_iptable_t *tab, isc_netaddr_t *addr,
+dns_iptable_addprefix2(dns_iptable_t *tab, const isc_netaddr_t *addr,
isc_uint16_t bitlen, isc_boolean_t pos,
isc_boolean_t is_ecs)
{
static isc_result_t
insert(dns_keytable_t *keytable, isc_boolean_t managed,
- dns_name_t *keyname, dst_key_t **keyp)
+ const dns_name_t *keyname, dst_key_t **keyp)
{
isc_result_t result;
dns_keynode_t *knode = NULL;
}
isc_result_t
-dns_keytable_marksecure(dns_keytable_t *keytable, dns_name_t *name) {
+dns_keytable_marksecure(dns_keytable_t *keytable, const dns_name_t *name) {
return (insert(keytable, ISC_TRUE, name, NULL));
}
isc_result_t
-dns_keytable_delete(dns_keytable_t *keytable, dns_name_t *keyname) {
+dns_keytable_delete(dns_keytable_t *keytable, const dns_name_t *keyname) {
isc_result_t result;
dns_rbtnode_t *node = NULL;
}
isc_result_t
-dns_keytable_find(dns_keytable_t *keytable, dns_name_t *keyname,
+dns_keytable_find(dns_keytable_t *keytable, const dns_name_t *keyname,
dns_keynode_t **keynodep)
{
isc_result_t result;
}
isc_result_t
-dns_keytable_findkeynode(dns_keytable_t *keytable, dns_name_t *name,
+dns_keytable_findkeynode(dns_keytable_t *keytable, const dns_name_t *name,
dns_secalg_t algorithm, dns_keytag_t tag,
dns_keynode_t **keynodep)
{
}
isc_result_t
-dns_keytable_finddeepestmatch(dns_keytable_t *keytable, dns_name_t *name,
+dns_keytable_finddeepestmatch(dns_keytable_t *keytable, const dns_name_t *name,
dns_name_t *foundname)
{
isc_result_t result;
}
isc_result_t
-dns_keytable_issecuredomain(dns_keytable_t *keytable, dns_name_t *name,
+dns_keytable_issecuredomain(dns_keytable_t *keytable, const dns_name_t *name,
dns_name_t *foundname, isc_boolean_t *wantdnssecp)
{
isc_result_t result;
}
isc_result_t
-dns_lookup_create(isc_mem_t *mctx, dns_name_t *name, dns_rdatatype_t type,
+dns_lookup_create(isc_mem_t *mctx, const dns_name_t *name, dns_rdatatype_t type,
dns_view_t *view, unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg, dns_lookup_t **lookupp)
{
char *tmpfile;
dns_masterformat_t format;
dns_masterrawheader_t header;
- isc_result_t (*dumpsets)(isc_mem_t *mctx, dns_name_t *name,
+ isc_result_t (*dumpsets)(isc_mem_t *mctx,
+ const dns_name_t *name,
dns_rdatasetiter_t *rdsiter,
dns_totext_ctx_t *ctx,
isc_buffer_t *buffer, FILE *f);
static isc_result_t
rdataset_totext(dns_rdataset_t *rdataset,
- dns_name_t *owner_name,
+ const dns_name_t *owner_name,
dns_totext_ctx_t *ctx,
isc_boolean_t omit_final_dot,
isc_buffer_t *target)
*/
static isc_result_t
question_totext(dns_rdataset_t *rdataset,
- dns_name_t *owner_name,
+ const dns_name_t *owner_name,
dns_totext_ctx_t *ctx,
isc_boolean_t omit_final_dot,
isc_buffer_t *target)
isc_result_t
dns_rdataset_totext(dns_rdataset_t *rdataset,
- dns_name_t *owner_name,
+ const dns_name_t *owner_name,
isc_boolean_t omit_final_dot,
isc_boolean_t question,
isc_buffer_t *target)
}
isc_result_t
-dns_master_rdatasettotext(dns_name_t *owner_name,
+dns_master_rdatasettotext(const dns_name_t *owner_name,
dns_rdataset_t *rdataset,
const dns_master_style_t *style,
isc_buffer_t *target)
}
isc_result_t
-dns_master_questiontotext(dns_name_t *owner_name,
+dns_master_questiontotext(const dns_name_t *owner_name,
dns_rdataset_t *rdataset,
const dns_master_style_t *style,
isc_buffer_t *target)
*/
static isc_result_t
-dump_rdataset(isc_mem_t *mctx, dns_name_t *name, dns_rdataset_t *rdataset,
- dns_totext_ctx_t *ctx,
+dump_rdataset(isc_mem_t *mctx, const dns_name_t *name,
+ dns_rdataset_t *rdataset, dns_totext_ctx_t *ctx,
isc_buffer_t *buffer, FILE *f)
{
isc_region_t r;
#define MAXSORT 64
static isc_result_t
-dump_rdatasets_text(isc_mem_t *mctx, dns_name_t *name,
+dump_rdatasets_text(isc_mem_t *mctx, const dns_name_t *name,
dns_rdatasetiter_t *rdsiter, dns_totext_ctx_t *ctx,
isc_buffer_t *buffer, FILE *f)
{
* Dump given RRsets in the "raw" format.
*/
static isc_result_t
-dump_rdataset_raw(isc_mem_t *mctx, dns_name_t *name, dns_rdataset_t *rdataset,
- isc_buffer_t *buffer, FILE *f)
+dump_rdataset_raw(isc_mem_t *mctx, const dns_name_t *name,
+ dns_rdataset_t *rdataset, isc_buffer_t *buffer, FILE *f)
{
isc_result_t result;
isc_uint32_t totallen;
}
static isc_result_t
-dump_rdatasets_raw(isc_mem_t *mctx, dns_name_t *name,
+dump_rdatasets_raw(isc_mem_t *mctx, const dns_name_t *name,
dns_rdatasetiter_t *rdsiter, dns_totext_ctx_t *ctx,
isc_buffer_t *buffer, FILE *f)
{
}
static isc_result_t
-dump_rdatasets_map(isc_mem_t *mctx, dns_name_t *name,
+dump_rdatasets_map(isc_mem_t *mctx, const dns_name_t *name,
dns_rdatasetiter_t *rdsiter, dns_totext_ctx_t *ctx,
isc_buffer_t *buffer, FILE *f)
{
isc_result_t
dns_master_dumpnodetostream(isc_mem_t *mctx, dns_db_t *db,
dns_dbversion_t *version,
- dns_dbnode_t *node, dns_name_t *name,
+ dns_dbnode_t *node, const dns_name_t *name,
const dns_master_style_t *style,
FILE *f)
{
isc_result_t
dns_master_dumpnode(isc_mem_t *mctx, dns_db_t *db, dns_dbversion_t *version,
- dns_dbnode_t *node, dns_name_t *name,
+ dns_dbnode_t *node, const dns_name_t *name,
const dns_master_style_t *style, const char *filename)
{
FILE *f = NULL;
static void
logfmtpacket(dns_message_t *message, const char *description,
- isc_sockaddr_t *address, isc_logcategory_t *category,
+ const isc_sockaddr_t *address, isc_logcategory_t *category,
isc_logmodule_t *module, const dns_master_style_t *style,
int level, isc_mem_t *mctx);
}
static isc_result_t
-findname(dns_name_t **foundname, dns_name_t *target,
+findname(dns_name_t **foundname, const dns_name_t *target,
dns_namelist_t *section)
{
dns_name_t *curr;
}
isc_result_t
-dns_message_find(dns_name_t *name, dns_rdataclass_t rdclass,
+dns_message_find(const dns_name_t *name, dns_rdataclass_t rdclass,
dns_rdatatype_t type, dns_rdatatype_t covers,
dns_rdataset_t **rdataset)
{
}
isc_result_t
-dns_message_findtype(dns_name_t *name, dns_rdatatype_t type,
+dns_message_findtype(const dns_name_t *name, dns_rdatatype_t type,
dns_rdatatype_t covers, dns_rdataset_t **rdataset)
{
dns_rdataset_t *curr;
#endif
static isc_result_t
-renderset(dns_rdataset_t *rdataset, dns_name_t *owner_name,
+renderset(dns_rdataset_t *rdataset, const dns_name_t *owner_name,
dns_compress_t *cctx, isc_buffer_t *target,
unsigned int reserved, unsigned int options, unsigned int *countp)
{
isc_result_t
dns_message_findname(dns_message_t *msg, dns_section_t section,
- dns_name_t *target, dns_rdatatype_t type,
+ const dns_name_t *target, dns_rdatatype_t type,
dns_rdatatype_t covers, dns_name_t **name,
dns_rdataset_t **rdataset)
{
}
dns_rdataset_t *
-dns_message_gettsig(dns_message_t *msg, dns_name_t **owner) {
+dns_message_gettsig(dns_message_t *msg, const dns_name_t **owner) {
/*
* Get the TSIG record and owner for 'msg'.
}
dns_rdataset_t *
-dns_message_getsig0(dns_message_t *msg, dns_name_t **owner) {
+dns_message_getsig0(dns_message_t *msg, const dns_name_t **owner) {
/*
* Get the SIG(0) record for 'msg'.
isc_buffer_t *target)
{
dns_rdataset_t *ps = NULL;
- dns_name_t *name = NULL;
+ const dns_name_t *name = NULL;
isc_result_t result = ISC_R_SUCCESS;
char buf[sizeof("1234567890")];
isc_uint32_t mbz;
isc_buffer_t *target)
{
dns_rdataset_t *ps = NULL;
- dns_name_t *name = NULL;
+ const dns_name_t *name = NULL;
isc_result_t result;
char buf[sizeof("1234567890")];
isc_uint32_t mbz;
void
dns_message_logpacket2(dns_message_t *message,
- const char *description, isc_sockaddr_t *address,
+ const char *description, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module,
int level, isc_mem_t *mctx)
{
void
dns_message_logfmtpacket2(dns_message_t *message,
- const char *description, isc_sockaddr_t *address,
+ const char *description,
+ const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module,
const dns_master_style_t *style, int level,
isc_mem_t *mctx)
static void
logfmtpacket(dns_message_t *message, const char *description,
- isc_sockaddr_t *address, isc_logcategory_t *category,
+ const isc_sockaddr_t *address, isc_logcategory_t *category,
isc_logmodule_t *module, const dns_master_style_t *style,
int level, isc_mem_t *mctx)
{
};
/* XXXDCL make const? */
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_rootname = &root;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_rootname = &root;
static unsigned char wild_ndata[] = { '\001', '*' };
static unsigned char wild_offsets[] = { 0 };
};
/* XXXDCL make const? */
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_wildcardname = &wild;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_wildcardname = &wild;
unsigned int
-dns_fullname_hash(dns_name_t *name, isc_boolean_t case_sensitive);
+dns_fullname_hash(const dns_name_t *name, isc_boolean_t case_sensitive);
/*
* dns_name_t to text post-conversion procedure.
}
unsigned int
-dns_name_hash(dns_name_t *name, isc_boolean_t case_sensitive) {
+dns_name_hash(const dns_name_t *name, isc_boolean_t case_sensitive) {
unsigned int length;
/*
}
unsigned int
-dns_name_fullhash(dns_name_t *name, isc_boolean_t case_sensitive) {
+dns_name_fullhash(const dns_name_t *name, isc_boolean_t case_sensitive) {
/*
* Provide a hash value for 'name'.
*/
}
unsigned int
-dns_fullname_hash(dns_name_t *name, isc_boolean_t case_sensitive) {
+dns_fullname_hash(const dns_name_t *name, isc_boolean_t case_sensitive) {
/*
* This function was deprecated due to the breakage of the name space
* convention. We only keep this internally to provide binary backward
}
unsigned int
-dns_name_hashbylabel(dns_name_t *name, isc_boolean_t case_sensitive) {
+dns_name_hashbylabel(const dns_name_t *name, isc_boolean_t case_sensitive) {
unsigned char *offsets;
dns_offsets_t odata;
dns_name_t tname;
}
void
-dns_name_toregion(dns_name_t *name, isc_region_t *r) {
+dns_name_toregion(const dns_name_t *name, isc_region_t *r) {
/*
* Make 'r' refer to 'name'.
*/
}
isc_result_t
-dns_name_tofilenametext(dns_name_t *name, isc_boolean_t omit_final_dot,
+dns_name_tofilenametext(const dns_name_t *name, isc_boolean_t omit_final_dot,
isc_buffer_t *target)
{
unsigned char *ndata;
}
isc_result_t
-dns_name_downcase(dns_name_t *source, dns_name_t *name, isc_buffer_t *target) {
+dns_name_downcase(const dns_name_t *source, dns_name_t *name,
+ isc_buffer_t *target)
+{
unsigned char *sndata, *ndata;
unsigned int nlen, count, labels;
isc_buffer_t buffer;
}
isc_result_t
-dns_name_concatenate(dns_name_t *prefix, dns_name_t *suffix, dns_name_t *name,
- isc_buffer_t *target)
+dns_name_concatenate(const dns_name_t *prefix, const dns_name_t *suffix,
+ dns_name_t *name, isc_buffer_t *target)
{
unsigned char *ndata, *offsets;
unsigned int nrem, labels, prefix_length, length;
}
void
-dns_name_split(dns_name_t *name, unsigned int suffixlabels,
+dns_name_split(const dns_name_t *name, unsigned int suffixlabels,
dns_name_t *prefix, dns_name_t *suffix)
{
}
isc_result_t
-dns_name_dupwithoffsets(dns_name_t *source, isc_mem_t *mctx,
+dns_name_dupwithoffsets(const dns_name_t *source, isc_mem_t *mctx,
dns_name_t *target)
{
/*
}
isc_result_t
-dns_name_digest(dns_name_t *name, dns_digestfunc_t digest, void *arg) {
+dns_name_digest(const dns_name_t *name, dns_digestfunc_t digest, void *arg) {
dns_name_t downname;
unsigned char data[256];
isc_buffer_t buffer;
}
isc_boolean_t
-dns_name_dynamic(dns_name_t *name) {
+dns_name_dynamic(const dns_name_t *name) {
REQUIRE(VALID_NAME(name));
/*
}
isc_result_t
-dns_name_print(dns_name_t *name, FILE *stream) {
+dns_name_print(const dns_name_t *name, FILE *stream) {
isc_result_t result;
isc_buffer_t b;
isc_region_t r;
* memory.
*/
isc_result_t
-dns_name_tostring(dns_name_t *name, char **target, isc_mem_t *mctx) {
+dns_name_tostring(const dns_name_t *name, char **target, isc_mem_t *mctx) {
isc_result_t result;
isc_buffer_t buf;
isc_region_t reg;
isc_result_t
dns_nsec_buildrdata(dns_db_t *db, dns_dbversion_t *version,
- dns_dbnode_t *node, dns_name_t *target,
+ dns_dbnode_t *node, const dns_name_t *target,
unsigned char *buffer, dns_rdata_t *rdata)
{
isc_result_t result;
isc_result_t
dns_nsec_build(dns_db_t *db, dns_dbversion_t *version, dns_dbnode_t *node,
- dns_name_t *target, dns_ttl_t ttl)
+ const dns_name_t *target, dns_ttl_t ttl)
{
isc_result_t result;
dns_rdata_t rdata = DNS_RDATA_INIT;
* Return ISC_R_IGNORE when the NSEC is not the appropriate one.
*/
isc_result_t
-dns_nsec_noexistnodata(dns_rdatatype_t type, dns_name_t *name,
- dns_name_t *nsecname, dns_rdataset_t *nsecset,
+dns_nsec_noexistnodata(dns_rdatatype_t type, const dns_name_t *name,
+ const dns_name_t *nsecname, dns_rdataset_t *nsecset,
isc_boolean_t *exists, isc_boolean_t *data,
dns_name_t *wild, dns_nseclog_t logit, void *arg)
{
isc_result_t
dns_nsec3_hashname(dns_fixedname_t *result,
unsigned char rethash[NSEC3_MAX_HASH_LENGTH],
- size_t *hash_length, dns_name_t *name, dns_name_t *origin,
+ size_t *hash_length, const dns_name_t *name,
+ const dns_name_t *origin,
dns_hash_t hashalg, unsigned int iterations,
const unsigned char *salt, size_t saltlength)
{
* Set '*exists' to true iff the given name exists, to false otherwise.
*/
static isc_result_t
-name_exists(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
+name_exists(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
isc_boolean_t *exists)
{
isc_result_t result;
* change in "diff".
*/
static isc_result_t
-delete(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
+delete(dns_db_t *db, dns_dbversion_t *version, const dns_name_t *name,
const dns_rdata_nsec3param_t *nsec3param, dns_diff_t *diff)
{
dns_dbnode_t *node = NULL ;
isc_result_t
dns_nsec3_addnsec3(dns_db_t *db, dns_dbversion_t *version,
- dns_name_t *name, const dns_rdata_nsec3param_t *nsec3param,
+ const dns_name_t *name,
+ const dns_rdata_nsec3param_t *nsec3param,
dns_ttl_t nsecttl, isc_boolean_t unsecure, dns_diff_t *diff)
{
dns_dbiterator_t *dbit = NULL;
*/
isc_result_t
dns_nsec3_addnsec3s(dns_db_t *db, dns_dbversion_t *version,
- dns_name_t *name, dns_ttl_t nsecttl,
+ const dns_name_t *name, dns_ttl_t nsecttl,
isc_boolean_t unsecure, dns_diff_t *diff)
{
dns_dbnode_t *node = NULL;
}
static isc_result_t
-rr_exists(dns_db_t *db, dns_dbversion_t *ver, dns_name_t *name,
+rr_exists(dns_db_t *db, dns_dbversion_t *ver, const dns_name_t *name,
const dns_rdata_t *rdata, isc_boolean_t *flag)
{
dns_rdataset_t rdataset;
isc_result_t
dns_nsec3_addnsec3sx(dns_db_t *db, dns_dbversion_t *version,
- dns_name_t *name, dns_ttl_t nsecttl,
+ const dns_name_t *name, dns_ttl_t nsecttl,
isc_boolean_t unsecure, dns_rdatatype_t type,
dns_diff_t *diff)
{
* ISC_FALSE indicates they should be retained.
*/
static isc_result_t
-deleteit(dns_db_t *db, dns_dbversion_t *ver, dns_name_t *name,
+deleteit(dns_db_t *db, dns_dbversion_t *ver, const dns_name_t *name,
isc_boolean_t *yesno)
{
isc_result_t result;
}
isc_result_t
-dns_nsec3_delnsec3(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
+dns_nsec3_delnsec3(dns_db_t *db, dns_dbversion_t *version,
+ const dns_name_t *name,
const dns_rdata_nsec3param_t *nsec3param, dns_diff_t *diff)
{
dns_dbiterator_t *dbit = NULL;
}
isc_result_t
-dns_nsec3_delnsec3s(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
+dns_nsec3_delnsec3s(dns_db_t *db, dns_dbversion_t *version,
+ const dns_name_t *name,
dns_diff_t *diff)
{
return (dns_nsec3_delnsec3sx(db, version, name, 0, diff));
}
isc_result_t
-dns_nsec3_delnsec3sx(dns_db_t *db, dns_dbversion_t *version, dns_name_t *name,
+dns_nsec3_delnsec3sx(dns_db_t *db, dns_dbversion_t *version,
+ const dns_name_t *name,
dns_rdatatype_t privatetype, dns_diff_t *diff)
{
dns_dbnode_t *node = NULL;
}
isc_result_t
-dns_nsec3_noexistnodata(dns_rdatatype_t type, dns_name_t* name,
- dns_name_t *nsec3name, dns_rdataset_t *nsec3set,
+dns_nsec3_noexistnodata(dns_rdatatype_t type, const dns_name_t *name,
+ const dns_name_t *nsec3name, dns_rdataset_t *nsec3set,
dns_name_t *zonename, isc_boolean_t *exists,
isc_boolean_t *data, isc_boolean_t *optout,
isc_boolean_t *unknown, isc_boolean_t *setclosest,
}
static isc_result_t
-nta_create(dns_ntatable_t *ntatable, dns_name_t *name, dns_nta_t **target) {
+nta_create(dns_ntatable_t *ntatable, const dns_name_t *name,
+ dns_nta_t **target)
+{
isc_result_t result;
dns_nta_t *nta = NULL;
dns_view_t *view;
}
isc_result_t
-dns_ntatable_add(dns_ntatable_t *ntatable, dns_name_t *name,
+dns_ntatable_add(dns_ntatable_t *ntatable, const dns_name_t *name,
isc_boolean_t force, isc_stdtime_t now,
isc_uint32_t lifetime)
{
* Caller must hold a write lock on rwlock.
*/
static isc_result_t
-delete(dns_ntatable_t *ntatable, dns_name_t *name) {
+delete(dns_ntatable_t *ntatable, const dns_name_t *name) {
isc_result_t result;
dns_rbtnode_t *node = NULL;
}
isc_result_t
-dns_ntatable_delete(dns_ntatable_t *ntatable, dns_name_t *name) {
+dns_ntatable_delete(dns_ntatable_t *ntatable, const dns_name_t *name) {
isc_result_t result;
RWLOCK(&ntatable->rwlock, isc_rwlocktype_write);
isc_boolean_t
dns_ntatable_covered(dns_ntatable_t *ntatable, isc_stdtime_t now,
- dns_name_t *name, dns_name_t *anchor)
+ const dns_name_t *name, const dns_name_t *anchor)
{
isc_result_t result;
dns_fixedname_t fn;
}
isc_result_t
-dns_order_add(dns_order_t *order, dns_name_t *name,
+dns_order_add(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass,
unsigned int mode)
{
}
static inline isc_boolean_t
-match(dns_name_t *name1, dns_name_t *name2) {
+match(const dns_name_t *name1, const dns_name_t *name2) {
if (dns_name_iswildcard(name2))
return(dns_name_matcheswildcard(name1, name2));
}
unsigned int
-dns_order_find(dns_order_t *order, dns_name_t *name,
+dns_order_find(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass)
{
dns_order_ent_t *ent;
}
isc_result_t
-dns_peerlist_peerbyaddr(dns_peerlist_t *servers,
- isc_netaddr_t *addr, dns_peer_t **retval)
+dns_peerlist_peerbyaddr(dns_peerlist_t *servers, const isc_netaddr_t *addr,
+ dns_peer_t **retval)
{
dns_peer_t *server;
isc_result_t res;
}
isc_result_t
-dns_peer_new(isc_mem_t *mem, isc_netaddr_t *addr, dns_peer_t **peerptr) {
+dns_peer_new(isc_mem_t *mem, const isc_netaddr_t *addr, dns_peer_t **peerptr) {
unsigned int prefixlen = 0;
REQUIRE(peerptr != NULL);
}
isc_result_t
-dns_peer_newprefix(isc_mem_t *mem, isc_netaddr_t *addr, unsigned int prefixlen,
- dns_peer_t **peerptr)
+dns_peer_newprefix(isc_mem_t *mem, const isc_netaddr_t *addr,
+ unsigned int prefixlen, dns_peer_t **peerptr)
{
dns_peer_t *peer;
* Forward declarations.
*/
static isc_result_t
-create_node(isc_mem_t *mctx, dns_name_t *name, dns_rbtnode_t **nodep);
+create_node(isc_mem_t *mctx, const dns_name_t *name, dns_rbtnode_t **nodep);
#ifdef DNS_RBT_USEHASH
static inline void
-hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, dns_name_t *name);
+hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name);
static inline void
unhash_node(dns_rbt_t *rbt, dns_rbtnode_t *node);
static void
static isc_result_t
treefix(dns_rbt_t *rbt, void *base, size_t size,
- dns_rbtnode_t *n, dns_name_t *name,
+ dns_rbtnode_t *n, const dns_name_t *name,
dns_rbtdatafixer_t datafixer, void *fixer_arg,
isc_uint64_t *crc);
static isc_result_t
treefix(dns_rbt_t *rbt, void *base, size_t filesize, dns_rbtnode_t *n,
- dns_name_t *name, dns_rbtdatafixer_t datafixer,
+ const dns_name_t *name, dns_rbtdatafixer_t datafixer,
void *fixer_arg, isc_uint64_t *crc)
{
isc_result_t result = ISC_R_SUCCESS;
*/
isc_result_t
-dns_rbt_addnode(dns_rbt_t *rbt, dns_name_t *name, dns_rbtnode_t **nodep) {
+dns_rbt_addnode(dns_rbt_t *rbt, const dns_name_t *name, dns_rbtnode_t **nodep) {
/*
* Does this thing have too many variables or what?
*/
* Add a name to the tree of trees, associating it with some data.
*/
isc_result_t
-dns_rbt_addname(dns_rbt_t *rbt, dns_name_t *name, void *data) {
+dns_rbt_addname(dns_rbt_t *rbt, const dns_name_t *name, void *data) {
isc_result_t result;
dns_rbtnode_t *node;
* Delete a name from the tree of trees.
*/
isc_result_t
-dns_rbt_deletename(dns_rbt_t *rbt, dns_name_t *name, isc_boolean_t recurse) {
+dns_rbt_deletename(dns_rbt_t *rbt, const dns_name_t *name,
+ isc_boolean_t recurse)
+{
dns_rbtnode_t *node = NULL;
isc_result_t result;
}
static isc_result_t
-create_node(isc_mem_t *mctx, dns_name_t *name, dns_rbtnode_t **nodep) {
+create_node(isc_mem_t *mctx, const dns_name_t *name, dns_rbtnode_t **nodep) {
dns_rbtnode_t *node;
isc_region_t region;
unsigned int labels;
#ifdef DNS_RBT_USEHASH
static inline void
-hash_add_node(dns_rbt_t *rbt, dns_rbtnode_t *node, dns_name_t *name) {
+hash_add_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name) {
unsigned int hash;
REQUIRE(name != NULL);
}
static inline void
-hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, dns_name_t *name) {
+hash_node(dns_rbt_t *rbt, dns_rbtnode_t *node, const dns_name_t *name) {
REQUIRE(DNS_RBTNODE_VALID(node));
if (rbt->nodecount >= (rbt->hashsize * 3))
static isc_result_t dbiterator_first(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_last(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_seek(dns_dbiterator_t *iterator,
- dns_name_t *name);
+ const dns_name_t *name);
static isc_result_t dbiterator_prev(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_next(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_current(dns_dbiterator_t *iterator,
* a wildcard level.
*/
static isc_result_t
-add_wildcard_magic(dns_rbtdb_t *rbtdb, dns_name_t *name) {
+add_wildcard_magic(dns_rbtdb_t *rbtdb, const dns_name_t *name) {
isc_result_t result;
dns_name_t foundname;
dns_offsets_t offsets;
}
static isc_result_t
-add_empty_wildcards(dns_rbtdb_t *rbtdb, dns_name_t *name) {
+add_empty_wildcards(dns_rbtdb_t *rbtdb, const dns_name_t *name) {
isc_result_t result;
dns_name_t foundname;
dns_offsets_t offsets;
}
static isc_result_t
-findnodeintree(dns_rbtdb_t *rbtdb, dns_rbt_t *tree, dns_name_t *name,
+findnodeintree(dns_rbtdb_t *rbtdb, dns_rbt_t *tree, const dns_name_t *name,
isc_boolean_t create, dns_dbnode_t **nodep)
{
dns_rbtnode_t *node = NULL;
}
static isc_result_t
-findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+findnode(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_dbnode_t **nodep)
{
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
}
static isc_result_t
-findnsec3node(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+findnsec3node(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_dbnode_t **nodep)
{
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
static inline isc_boolean_t
activeempty(rbtdb_search_t *search, dns_rbtnodechain_t *chain,
- dns_name_t *name)
+ const dns_name_t *name)
{
dns_fixedname_t fnext;
dns_fixedname_t forigin;
}
static inline isc_boolean_t
-activeemtpynode(rbtdb_search_t *search, dns_name_t *qname, dns_name_t *wname) {
+activeemtpynode(rbtdb_search_t *search, const dns_name_t *qname,
+ dns_name_t *wname)
+{
dns_fixedname_t fnext;
dns_fixedname_t forigin;
dns_fixedname_t fprev;
static inline isc_result_t
find_wildcard(rbtdb_search_t *search, dns_rbtnode_t **nodep,
- dns_name_t *qname)
+ const dns_name_t *qname)
{
unsigned int i, j;
dns_rbtnode_t *node, *level_node, *wnode;
*/
static inline isc_result_t
previous_closest_nsec(dns_rdatatype_t type, rbtdb_search_t *search,
- dns_name_t *name, dns_name_t *origin,
- dns_rbtnode_t **nodep, dns_rbtnodechain_t *nsecchain,
- isc_boolean_t *firstp)
+ dns_name_t *name, dns_name_t *origin,
+ dns_rbtnode_t **nodep, dns_rbtnodechain_t *nsecchain,
+ isc_boolean_t *firstp)
{
dns_fixedname_t ftarget;
dns_name_t *target;
}
static isc_result_t
-zone_find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
}
static isc_result_t
-zone_findzonecut(dns_db_t *db, dns_name_t *name, unsigned int options,
+zone_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
isc_stdtime_t now, dns_dbnode_t **nodep,
dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
}
static isc_result_t
-cache_find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
}
static isc_result_t
-cache_findzonecut(dns_db_t *db, dns_name_t *name, unsigned int options,
+cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
isc_stdtime_t now, dns_dbnode_t **nodep,
dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
* load a non-NSEC3 node in the main tree and optionally to the auxiliary NSEC
*/
static isc_result_t
-loadnode(dns_rbtdb_t *rbtdb, dns_name_t *name, dns_rbtnode_t **nodep,
+loadnode(dns_rbtdb_t *rbtdb, const dns_name_t *name, dns_rbtnode_t **nodep,
isc_boolean_t hasnsec)
{
isc_result_t noderesult, rpzresult, nsecresult, tmpresult;
}
static isc_result_t
-loading_addrdataset(void *arg, dns_name_t *name, dns_rdataset_t *rdataset) {
+loading_addrdataset(void *arg, const dns_name_t *name,
+ dns_rdataset_t *rdataset)
+{
rbtdb_load_t *loadctx = arg;
dns_rbtdb_t *rbtdb = loadctx->rbtdb;
dns_rbtnode_t *node;
#else
dns_rbtdb_create
#endif
- (isc_mem_t *mctx, dns_name_t *origin, dns_dbtype_t type,
+ (isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp)
{
dns_db_t *db = rdataset->private1;
dns_dbnode_t *node = rdataset->private2;
dns_dbnode_t *cloned_node;
- struct noqname *noqname = rdataset->private6;
+ const struct noqname *noqname = rdataset->private6;
cloned_node = NULL;
attachnode(db, node, &cloned_node);
dns_db_t *db = rdataset->private1;
dns_dbnode_t *node = rdataset->private2;
dns_dbnode_t *cloned_node;
- struct noqname *closest = rdataset->private7;
+ const struct noqname *closest = rdataset->private7;
cloned_node = NULL;
attachnode(db, node, &cloned_node);
}
static isc_result_t
-dbiterator_seek(dns_dbiterator_t *iterator, dns_name_t *name) {
+dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) {
isc_result_t result, tresult;
rbtdb_dbiterator_t *rbtdbiter = (rbtdb_dbiterator_t *)iterator;
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)iterator->db;
ISC_LANG_BEGINDECLS
isc_result_t
-dns_rbtdb_create(isc_mem_t *mctx, dns_name_t *base, dns_dbtype_t type,
+dns_rbtdb_create(isc_mem_t *mctx, const dns_name_t *base, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp);
ISC_LANG_BEGINDECLS
isc_result_t
-dns_rbtdb64_create(isc_mem_t *mctx, dns_name_t *base, dns_dbtype_t type,
+dns_rbtdb64_create(isc_mem_t *mctx, const dns_name_t *base, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp);
#define DNS_AS_STR(t) ((t).value.as_textregion.base)
#define ARGS_FROMTEXT int rdclass, dns_rdatatype_t type, \
- isc_lex_t *lexer, dns_name_t *origin, \
+ isc_lex_t *lexer, const dns_name_t *origin, \
unsigned int options, isc_buffer_t *target, \
dns_rdatacallbacks_t *callbacks
#define ARGS_DIGEST dns_rdata_t *rdata, dns_digestfunc_t digest, void *arg
-#define ARGS_CHECKOWNER dns_name_t *name, dns_rdataclass_t rdclass, \
+#define ARGS_CHECKOWNER const dns_name_t *name, dns_rdataclass_t rdclass, \
dns_rdatatype_t type, isc_boolean_t wildcard
-#define ARGS_CHECKNAMES dns_rdata_t *rdata, dns_name_t *owner, dns_name_t *bad
+#define ARGS_CHECKNAMES dns_rdata_t *rdata, const dns_name_t *owner, \
+ dns_name_t *bad
/*%
* conversion.
*/
typedef struct dns_rdata_textctx {
- dns_name_t *origin; /*%< Current origin, or NULL. */
+ const dns_name_t *origin; /*%< Current origin, or NULL. */
unsigned int flags; /*%< DNS_STYLEFLAG_* */
unsigned int width; /*%< Width of rdata column. */
const char *linebreak; /*%< Line break string. */
multitxt_fromtext(isc_textregion_t *source, isc_buffer_t *target);
static isc_boolean_t
-name_prefix(dns_name_t *name, dns_name_t *origin, dns_name_t *target);
+name_prefix(dns_name_t *name, const dns_name_t *origin, dns_name_t *target);
static unsigned int
-name_length(dns_name_t *name);
+name_length(const dns_name_t *name);
static isc_result_t
str_totext(const char *source, isc_buffer_t *target);
uint8_tobuffer(isc_uint32_t, isc_buffer_t *target);
static isc_result_t
-name_tobuffer(dns_name_t *name, isc_buffer_t *target);
+name_tobuffer(const dns_name_t *name, isc_buffer_t *target);
static isc_uint32_t
uint32_fromregion(isc_region_t *region);
isc_buffer_t *target);
static void
-warn_badname(dns_name_t *name, isc_lex_t *lexer,
+warn_badname(const dns_name_t *name, isc_lex_t *lexer,
dns_rdatacallbacks_t *callbacks);
static void
}
static inline isc_result_t
-name_duporclone(dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) {
+name_duporclone(const dns_name_t *source, isc_mem_t *mctx, dns_name_t *target) {
if (mctx != NULL)
return (dns_name_dup(source, mctx, target));
isc_result_t
dns_rdata_fromtext(dns_rdata_t *rdata, dns_rdataclass_t rdclass,
dns_rdatatype_t type, isc_lex_t *lexer,
- dns_name_t *origin, unsigned int options, isc_mem_t *mctx,
- isc_buffer_t *target, dns_rdatacallbacks_t *callbacks)
+ const dns_name_t *origin, unsigned int options,
+ isc_mem_t *mctx, isc_buffer_t *target,
+ dns_rdatacallbacks_t *callbacks)
{
isc_result_t result = ISC_R_NOTIMPLEMENTED;
isc_region_t region;
}
isc_result_t
-dns_rdata_totext(dns_rdata_t *rdata, dns_name_t *origin, isc_buffer_t *target)
+dns_rdata_totext(dns_rdata_t *rdata, const dns_name_t *origin,
+ isc_buffer_t *target)
{
dns_rdata_textctx_t tctx;
}
isc_result_t
-dns_rdata_tofmttext(dns_rdata_t *rdata, dns_name_t *origin,
+dns_rdata_tofmttext(dns_rdata_t *rdata, const dns_name_t *origin,
unsigned int flags, unsigned int width,
unsigned int split_width, const char *linebreak,
isc_buffer_t *target)
}
isc_boolean_t
-dns_rdata_checkowner(dns_name_t *name, dns_rdataclass_t rdclass,
+dns_rdata_checkowner(const dns_name_t *name, dns_rdataclass_t rdclass,
dns_rdatatype_t type, isc_boolean_t wildcard)
{
isc_boolean_t result;
}
isc_boolean_t
-dns_rdata_checknames(dns_rdata_t *rdata, dns_name_t *owner, dns_name_t *bad)
+dns_rdata_checknames(dns_rdata_t *rdata, const dns_name_t *owner,
+ dns_name_t *bad)
{
isc_boolean_t result;
*/
static unsigned int
-name_length(dns_name_t *name) {
+name_length(const dns_name_t *name) {
return (name->length);
}
}
static isc_boolean_t
-name_prefix(dns_name_t *name, dns_name_t *origin, dns_name_t *target) {
+name_prefix(dns_name_t *name, const dns_name_t *origin, dns_name_t *target) {
int l1, l2;
if (origin == NULL)
}
static isc_result_t
-name_tobuffer(dns_name_t *name, isc_buffer_t *target) {
+name_tobuffer(const dns_name_t *name, isc_buffer_t *target) {
isc_region_t r;
dns_name_toregion(name, &r);
return (isc_buffer_copyregion(target, &r));
}
static void
-warn_badname(dns_name_t *name, isc_lex_t *lexer,
+warn_badname(const dns_name_t *name, isc_lex_t *lexer,
dns_rdatacallbacks_t *callbacks)
{
const char *file;
}
isc_result_t
-isc__rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) {
+isc__rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name) {
dns_rdataset_t *neg = NULL;
dns_rdataset_t *negsig = NULL;
dns_rdataset_t *rdset;
dns_rdataclass_t rdclass = rdataset->rdclass;
dns_rdataset_t *tneg = NULL;
dns_rdataset_t *tnegsig = NULL;
- dns_name_t *noqname = rdataset->private6;
+ const dns_name_t *noqname = rdataset->private6;
REQUIRE(rdataset != NULL);
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0);
}
isc_result_t
-isc__rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name) {
+isc__rdatalist_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name) {
dns_rdataset_t *neg = NULL;
dns_rdataset_t *negsig = NULL;
dns_rdataset_t *rdset;
dns_rdataclass_t rdclass = rdataset->rdclass;
dns_rdataset_t *tneg = NULL;
dns_rdataset_t *tnegsig = NULL;
- dns_name_t *closest = rdataset->private7;
+ const dns_name_t *closest = rdataset->private7;
REQUIRE(rdataset != NULL);
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0);
isc__rdatalist_count(dns_rdataset_t *rdataset);
isc_result_t
-isc__rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name);
+isc__rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name);
isc_result_t
isc__rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
dns_rdataset_t *neg, dns_rdataset_t *negsig);
isc_result_t
-isc__rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name);
+isc__rdatalist_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name);
isc_result_t
isc__rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
isc_result_t
dns_rdataset_towire(dns_rdataset_t *rdataset,
- dns_name_t *owner_name,
+ const dns_name_t *owner_name,
dns_compress_t *cctx,
isc_buffer_t *target,
unsigned int options,
}
isc_result_t
-dns_rdataset_addclosest(dns_rdataset_t *rdataset, dns_name_t *name) {
+dns_rdataset_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name) {
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
}
static inline isc_result_t
-req_send(dns_request_t *request, isc_task_t *task, isc_sockaddr_t *address) {
+req_send(dns_request_t *request, isc_task_t *task,
+ const isc_sockaddr_t *address)
+{
isc_region_t r;
isc_socket_t *sock;
isc_socketevent_t *sendevent;
static isc_boolean_t
-isblackholed(dns_dispatchmgr_t *dispatchmgr, isc_sockaddr_t *destaddr) {
+isblackholed(dns_dispatchmgr_t *dispatchmgr, const isc_sockaddr_t *destaddr) {
dns_acl_t *blackhole;
isc_netaddr_t netaddr;
int match;
static isc_result_t
create_tcp_dispatch(isc_boolean_t newtcp, isc_boolean_t share,
dns_requestmgr_t *requestmgr,
- isc_sockaddr_t *srcaddr,
- isc_sockaddr_t *destaddr, isc_dscp_t dscp,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr, isc_dscp_t dscp,
isc_boolean_t *connected, dns_dispatch_t **dispatchp)
{
isc_result_t result;
}
static isc_result_t
-find_udp_dispatch(dns_requestmgr_t *requestmgr, isc_sockaddr_t *srcaddr,
- isc_sockaddr_t *destaddr, dns_dispatch_t **dispatchp)
+find_udp_dispatch(dns_requestmgr_t *requestmgr, const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr, dns_dispatch_t **dispatchp)
{
dns_dispatch_t *disp = NULL;
unsigned int attrs, attrmask;
static isc_result_t
get_dispatch(isc_boolean_t tcp, isc_boolean_t newtcp, isc_boolean_t share,
dns_requestmgr_t *requestmgr,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr, const isc_sockaddr_t *destaddr,
isc_dscp_t dscp, isc_boolean_t *connected,
dns_dispatch_t **dispatchp)
{
isc_result_t
dns_request_createraw(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, unsigned int timeout,
isc_task_t *task, isc_taskaction_t action, void *arg,
dns_request_t **requestp)
isc_result_t
dns_request_createraw2(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, unsigned int timeout,
unsigned int udptimeout, isc_task_t *task,
isc_taskaction_t action, void *arg,
isc_result_t
dns_request_createraw3(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_result_t
dns_request_createraw4(dns_requestmgr_t *requestmgr, isc_buffer_t *msgbuf,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
isc_dscp_t dscp, unsigned int options,
unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task,
isc_result_t
dns_request_create(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *address, unsigned int options,
+ const isc_sockaddr_t *address, unsigned int options,
dns_tsigkey_t *key,
unsigned int timeout, isc_task_t *task,
isc_taskaction_t action, void *arg,
isc_result_t
dns_request_createvia(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, dns_tsigkey_t *key,
unsigned int timeout, isc_task_t *task,
isc_taskaction_t action, void *arg,
isc_result_t
dns_request_createvia2(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, dns_tsigkey_t *key,
unsigned int timeout, unsigned int udptimeout,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_result_t
dns_request_createvia3(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
unsigned int options, dns_tsigkey_t *key,
unsigned int timeout, unsigned int udptimeout,
unsigned int udpretries, isc_task_t *task,
isc_result_t
dns_request_createvia4(dns_requestmgr_t *requestmgr, dns_message_t *message,
- isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
+ const isc_sockaddr_t *srcaddr,
+ const isc_sockaddr_t *destaddr,
isc_dscp_t dscp, unsigned int options,
dns_tsigkey_t *key, unsigned int timeout,
unsigned int udptimeout, unsigned int udpretries,
unsigned int valfail;
isc_boolean_t timeout;
dns_adbaddrinfo_t *addrinfo;
- isc_sockaddr_t *client;
+ const isc_sockaddr_t *client;
unsigned int depth;
};
}
static isc_result_t
-issecuredomain(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
+issecuredomain(dns_view_t *view, const dns_name_t *name, dns_rdatatype_t type,
isc_stdtime_t now, isc_boolean_t checknta,
isc_boolean_t *issecure)
{
}
static void
-findname(fetchctx_t *fctx, dns_name_t *name, in_port_t port,
+findname(fetchctx_t *fctx, const dns_name_t *name, in_port_t port,
unsigned int options, unsigned int flags, isc_stdtime_t now,
isc_boolean_t *overquota, isc_boolean_t *need_alternate)
{
}
static isc_boolean_t
-isstrictsubdomain(dns_name_t *name1, dns_name_t *name2) {
+isstrictsubdomain(const dns_name_t *name1, const dns_name_t *name2) {
int order;
unsigned int nlabels;
dns_namereln_t namereln;
*/
static inline isc_result_t
-fctx_join(fetchctx_t *fctx, isc_task_t *task, isc_sockaddr_t *client,
+fctx_join(fetchctx_t *fctx, isc_task_t *task, const isc_sockaddr_t *client,
dns_messageid_t id, isc_taskaction_t action, void *arg,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
dns_fetch_t *fetch)
}
static isc_result_t
-fctx_create(dns_resolver_t *res, dns_name_t *name, dns_rdatatype_t type,
- dns_name_t *domain, dns_rdataset_t *nameservers,
+fctx_create(dns_resolver_t *res, const dns_name_t *name, dns_rdatatype_t type,
+ const dns_name_t *domain, dns_rdataset_t *nameservers,
unsigned int options, unsigned int bucketnum, unsigned int depth,
isc_counter_t *qc, fetchctx_t **fctxp)
{
if (domain == NULL) {
dns_forwarders_t *forwarders = NULL;
unsigned int labels;
- dns_name_t *fwdname = name;
+ const dns_name_t *fwdname = name;
dns_name_t suffix;
+ dns_name_t *fname;
/*
* DS records are found in the parent server. Strip one
/* Find the forwarder for this name. */
dns_fixedname_init(&fixed);
- domain = dns_fixedname_name(&fixed);
+ fname = dns_fixedname_name(&fixed);
result = dns_fwdtable_find2(fctx->res->view->fwdtable, fwdname,
- domain, &forwarders);
+ fname, &forwarders);
if (result == ISC_R_SUCCESS)
fctx->fwdpolicy = forwarders->fwdpolicy;
*/
if (dns_rdatatype_atparent(fctx->type))
findoptions |= DNS_DBFIND_NOEXACT;
- result = dns_view_findzonecut(res->view, name,
- domain, 0, findoptions,
- ISC_TRUE,
+ result = dns_view_findzonecut(res->view, name, fname,
+ 0, findoptions, ISC_TRUE,
&fctx->nameservers,
NULL);
if (result != ISC_R_SUCCESS)
goto cleanup_nameservers;
- result = dns_name_dup(domain, mctx, &fctx->domain);
+ result = dns_name_dup(fname, mctx, &fctx->domain);
if (result != ISC_R_SUCCESS)
goto cleanup_nameservers;
/*
* We're in forward-only mode. Set the query domain.
*/
- result = dns_name_dup(domain, mctx, &fctx->domain);
+ result = dns_name_dup(fname, mctx, &fctx->domain);
if (result != ISC_R_SUCCESS)
goto cleanup_name;
}
}
static isc_result_t
-check_section(void *arg, dns_name_t *addname, dns_rdatatype_t type,
+check_section(void *arg, const dns_name_t *addname, dns_rdatatype_t type,
dns_section_t section)
{
fetchctx_t *fctx = arg;
}
static isc_result_t
-check_related(void *arg, dns_name_t *addname, dns_rdatatype_t type) {
+check_related(void *arg, const dns_name_t *addname, dns_rdatatype_t type) {
return (check_section(arg, addname, type, DNS_SECTION_ADDITIONAL));
}
#endif
#if CHECK_FOR_GLUE_IN_ANSWER
static isc_result_t
-check_answer(void *arg, dns_name_t *addname, dns_rdatatype_t type) {
+check_answer(void *arg, const dns_name_t *addname, dns_rdatatype_t type) {
return (check_section(arg, addname, type, DNS_SECTION_ANSWER));
}
#endif
}
static inline isc_boolean_t
-fctx_match(fetchctx_t *fctx, dns_name_t *name, dns_rdatatype_t type,
+fctx_match(fetchctx_t *fctx, const dns_name_t *name, dns_rdatatype_t type,
unsigned int options)
{
/*
}
static inline void
-log_fetch(dns_name_t *name, dns_rdatatype_t type) {
+log_fetch(const dns_name_t *name, dns_rdatatype_t type) {
char namebuf[DNS_NAME_FORMATSIZE];
char typebuf[DNS_RDATATYPE_FORMATSIZE];
int level = ISC_LOG_DEBUG(1);
}
isc_result_t
-dns_resolver_createfetch(dns_resolver_t *res, dns_name_t *name,
+dns_resolver_createfetch(dns_resolver_t *res, const dns_name_t *name,
dns_rdatatype_t type,
- dns_name_t *domain, dns_rdataset_t *nameservers,
+ const dns_name_t *domain, dns_rdataset_t *nameservers,
dns_forwarders_t *forwarders,
unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg,
}
isc_result_t
-dns_resolver_createfetch2(dns_resolver_t *res, dns_name_t *name,
+dns_resolver_createfetch2(dns_resolver_t *res, const dns_name_t *name,
dns_rdatatype_t type,
- dns_name_t *domain, dns_rdataset_t *nameservers,
+ const dns_name_t *domain, dns_rdataset_t *nameservers,
dns_forwarders_t *forwarders,
- isc_sockaddr_t *client, dns_messageid_t id,
+ const isc_sockaddr_t *client, dns_messageid_t id,
unsigned int options, isc_task_t *task,
isc_taskaction_t action, void *arg,
dns_rdataset_t *rdataset,
}
isc_result_t
-dns_resolver_createfetch3(dns_resolver_t *res, dns_name_t *name,
+dns_resolver_createfetch3(dns_resolver_t *res, const dns_name_t *name,
dns_rdatatype_t type,
- dns_name_t *domain, dns_rdataset_t *nameservers,
+ const dns_name_t *domain, dns_rdataset_t *nameservers,
dns_forwarders_t *forwarders,
- isc_sockaddr_t *client, dns_messageid_t id,
+ const isc_sockaddr_t *client, dns_messageid_t id,
unsigned int options, unsigned int depth,
isc_counter_t *qc, isc_task_t *task,
isc_taskaction_t action, void *arg,
}
isc_result_t
-dns_resolver_addalternate(dns_resolver_t *resolver, isc_sockaddr_t *alt,
- dns_name_t *name, in_port_t port) {
+dns_resolver_addalternate(dns_resolver_t *resolver, const isc_sockaddr_t *alt,
+ const dns_name_t *name, in_port_t port) {
alternate_t *a;
isc_result_t result;
}
void
-dns_resolver_flushbadcache(dns_resolver_t *resolver, dns_name_t *name) {
+dns_resolver_flushbadcache(dns_resolver_t *resolver, const dns_name_t *name) {
if (name != NULL)
dns_badcache_flushname(resolver->badcache, name);
else
}
void
-dns_resolver_flushbadnames(dns_resolver_t *resolver, dns_name_t *name) {
+dns_resolver_flushbadnames(dns_resolver_t *resolver, const dns_name_t *name) {
dns_badcache_flushtree(resolver->badcache, name);
}
void
-dns_resolver_addbadcache(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_addbadcache(dns_resolver_t *resolver, const dns_name_t *name,
dns_rdatatype_t type, isc_time_t *expire)
{
#ifdef ENABLE_AFL
}
isc_boolean_t
-dns_resolver_getbadcache(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_getbadcache(dns_resolver_t *resolver, const dns_name_t *name,
dns_rdatatype_t type, isc_time_t *now)
{
return (dns_badcache_find(resolver->badcache, name, type, NULL, now));
}
isc_result_t
-dns_resolver_disable_algorithm(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_disable_algorithm(dns_resolver_t *resolver,
+ const dns_name_t *name,
unsigned int alg)
{
unsigned int len, mask;
}
isc_boolean_t
-dns_resolver_algorithm_supported(dns_resolver_t *resolver, dns_name_t *name,
- unsigned int alg)
+dns_resolver_algorithm_supported(dns_resolver_t *resolver,
+ const dns_name_t *name, unsigned int alg)
{
unsigned int len, mask;
unsigned char *algorithms;
}
isc_result_t
-dns_resolver_disable_ds_digest(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_disable_ds_digest(dns_resolver_t *resolver,
+ const dns_name_t *name,
unsigned int digest_type)
{
unsigned int len, mask;
}
isc_boolean_t
-dns_resolver_ds_digest_supported(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_ds_digest_supported(dns_resolver_t *resolver,
+ const dns_name_t *name,
unsigned int digest_type)
{
unsigned int len, mask;
static isc_boolean_t yes = ISC_TRUE, no = ISC_FALSE;
isc_result_t
-dns_resolver_setmustbesecure(dns_resolver_t *resolver, dns_name_t *name,
+dns_resolver_setmustbesecure(dns_resolver_t *resolver, const dns_name_t *name,
isc_boolean_t value)
{
isc_result_t result;
}
isc_boolean_t
-dns_resolver_getmustbesecure(dns_resolver_t *resolver, dns_name_t *name) {
+dns_resolver_getmustbesecure(dns_resolver_t *resolver, const dns_name_t *name) {
void *data = NULL;
isc_boolean_t value = ISC_FALSE;
isc_result_t result;
}
static void
-badname(int level, dns_name_t *name, const char *str1, const char *str2) {
+badname(int level, const dns_name_t *name, const char *str1, const char *str2) {
char namebuf[DNS_NAME_FORMATSIZE];
/*
*/
static isc_result_t
ip2name(const dns_rpz_cidr_key_t *tgt_ip, dns_rpz_prefix_t tgt_prefix,
- dns_name_t *base_name, dns_name_t *ip_name)
+ const dns_name_t *base_name, dns_name_t *ip_name)
{
#ifndef INET6_ADDRSTRLEN
#define INET6_ADDRSTRLEN 46
* Determine the type a of a name in a response policy zone.
*/
static dns_rpz_type_t
-type_from_name(dns_rpz_zone_t *rpz, dns_name_t *name) {
+type_from_name(dns_rpz_zone_t *rpz, const dns_name_t *name) {
if (dns_name_issubdomain(name, &rpz->ip))
return (DNS_RPZ_TYPE_IP);
static isc_result_t
name2ipkey(int log_level,
const dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
- dns_rpz_type_t rpz_type, dns_name_t *src_name,
+ dns_rpz_type_t rpz_type, const dns_name_t *src_name,
dns_rpz_cidr_key_t *tgt_ip, dns_rpz_prefix_t *tgt_prefix,
dns_rpz_addr_zbits_t *new_set)
{
*/
static isc_result_t
add_cidr(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
- dns_rpz_type_t rpz_type, dns_name_t *src_name)
+ dns_rpz_type_t rpz_type, const dns_name_t *src_name)
{
dns_rpz_cidr_key_t tgt_ip;
dns_rpz_prefix_t tgt_prefix;
static isc_result_t
add_name(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
- dns_rpz_type_t rpz_type, dns_name_t *src_name)
+ dns_rpz_type_t rpz_type, const dns_name_t *src_name)
{
dns_rpz_nm_data_t new_data;
dns_fixedname_t trig_namef;
* Add an IP address to the radix tree or a name to the summary database.
*/
isc_result_t
-dns_rpz_add(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num, dns_name_t *src_name)
+dns_rpz_add(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
+ const dns_name_t *src_name)
{
dns_rpz_zone_t *rpz;
dns_rpz_type_t rpz_type;
*/
static void
del_cidr(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
- dns_rpz_type_t rpz_type, dns_name_t *src_name)
+ dns_rpz_type_t rpz_type, const dns_name_t *src_name)
{
isc_result_t result;
dns_rpz_cidr_key_t tgt_ip;
static void
del_name(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
- dns_rpz_type_t rpz_type, dns_name_t *src_name)
+ dns_rpz_type_t rpz_type, const dns_name_t *src_name)
{
char namebuf[DNS_NAME_FORMATSIZE];
dns_fixedname_t trig_namef;
*/
void
dns_rpz_delete(dns_rpz_zones_t *rpzs, dns_rpz_num_t rpz_num,
- dns_name_t *src_name) {
+ const dns_name_t *src_name)
+{
dns_rpz_zone_t *rpz;
dns_rpz_type_t rpz_type;
*/
static void
make_key(const dns_rrl_t *rrl, dns_rrl_key_t *key,
- const isc_sockaddr_t *client_addr,
- dns_rdatatype_t qtype, dns_name_t *qname, dns_rdataclass_t qclass,
+ const isc_sockaddr_t *client_addr, dns_rdatatype_t qtype,
+ const dns_name_t *qname, dns_rdataclass_t qclass,
dns_rrl_rtype_t rtype)
{
dns_name_t base;
*/
static dns_rrl_entry_t *
get_entry(dns_rrl_t *rrl, const isc_sockaddr_t *client_addr,
- dns_rdataclass_t qclass, dns_rdatatype_t qtype, dns_name_t *qname,
- dns_rrl_rtype_t rtype, isc_stdtime_t now, isc_boolean_t create,
- char *log_buf, unsigned int log_buf_len)
+ dns_rdataclass_t qclass, dns_rdatatype_t qtype,
+ const dns_name_t *qname, dns_rrl_rtype_t rtype, isc_stdtime_t now,
+ isc_boolean_t create, char *log_buf, unsigned int log_buf_len)
{
dns_rrl_key_t key;
isc_uint32_t hval;
static void
make_log_buf(dns_rrl_t *rrl, dns_rrl_entry_t *e,
const char *str1, const char *str2, isc_boolean_t plural,
- dns_name_t *qname, isc_boolean_t save_qname,
+ const dns_name_t *qname, isc_boolean_t save_qname,
dns_rrl_result_t rrl_result, isc_result_t resp_result,
char *log_buf, unsigned int log_buf_len)
{
dns_rrl(dns_view_t *view,
const isc_sockaddr_t *client_addr, isc_boolean_t is_tcp,
dns_rdataclass_t qclass, dns_rdatatype_t qtype,
- dns_name_t *qname, isc_result_t resp_result, isc_stdtime_t now,
+ const dns_name_t *qname, isc_result_t resp_result, isc_stdtime_t now,
isc_boolean_t wouldlog, char *log_buf, unsigned int log_buf_len)
{
dns_rrl_t *rrl;
static int dummy;
-static isc_result_t dns_sdb_create(isc_mem_t *mctx, dns_name_t *origin,
+static isc_result_t dns_sdb_create(isc_mem_t *mctx, const dns_name_t *origin,
dns_dbtype_t type, dns_rdataclass_t rdclass,
unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp);
static isc_result_t dbiterator_first(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_last(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_seek(dns_dbiterator_t *iterator,
- dns_name_t *name);
+ const dns_name_t *name);
static isc_result_t dbiterator_prev(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_next(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_current(dns_dbiterator_t *iterator,
unsigned int size = 0; /* Init to suppress compiler warning */
isc_mem_t *mctx;
dns_sdbimplementation_t *imp;
- dns_name_t *origin;
+ const dns_name_t *origin;
isc_buffer_t b;
isc_buffer_t rb;
static isc_result_t
getnode(dns_sdballnodes_t *allnodes, const char *name, dns_sdbnode_t **nodep) {
- dns_name_t *newname, *origin;
+ dns_name_t *newname;
+ const dns_name_t *origin;
dns_fixedname_t fnewname;
dns_sdb_t *sdb = (dns_sdb_t *)allnodes->common.db;
dns_sdbimplementation_t *imp = sdb->implementation;
}
static isc_result_t
-findnodeext(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+findnodeext(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
dns_dbnode_t **nodep)
{
}
static isc_result_t
-findext(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
}
static isc_result_t
-findzonecut(dns_db_t *db, dns_name_t *name, unsigned int options,
+findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
};
static isc_result_t
-dns_sdb_create(isc_mem_t *mctx, dns_name_t *origin, dns_dbtype_t type,
+dns_sdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
void *driverarg, dns_db_t **dbp)
{
}
static isc_result_t
-dbiterator_seek(dns_dbiterator_t *iterator, dns_name_t *name) {
+dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) {
sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)iterator;
sdbiter->current = ISC_LIST_HEAD(sdbiter->nodelist);
/*
* Forward references.
*/
-static isc_result_t getnodedata(dns_db_t *db, dns_name_t *name,
+static isc_result_t getnodedata(dns_db_t *db, const dns_name_t *name,
isc_boolean_t create, unsigned int options,
dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo,
static isc_result_t dbiterator_first(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_last(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_seek(dns_dbiterator_t *iterator,
- dns_name_t *name);
+ const dns_name_t *name);
static isc_result_t dbiterator_prev(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_next(dns_dbiterator_t *iterator);
static isc_result_t dbiterator_current(dns_dbiterator_t *iterator,
}
static isc_result_t
-getnodedata(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+getnodedata(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
unsigned int options, dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo, dns_dbnode_t **nodep)
{
for (i = 0; i < dlabels; i++) {
char wildstr[DNS_NAME_MAXTEXT + 1];
dns_fixedname_t fixed;
- dns_name_t *wild;
+ const dns_name_t *wild;
dns_fixedname_init(&fixed);
if (i == dlabels)
wild = dns_wildcardname;
else {
- wild = dns_fixedname_name(&fixed);
+ dns_name_t *fname;
+ fname = dns_fixedname_name(&fixed);
dns_name_getlabelsequence(name, i + 1,
dlabels - i - 1,
- wild);
+ fname);
result = dns_name_concatenate(dns_wildcardname,
- wild, wild, NULL);
+ fname, fname,
+ NULL);
if (result != ISC_R_SUCCESS)
return (result);
+ wild = fname;
}
isc_buffer_init(&b, wildstr, sizeof(wildstr));
}
static isc_result_t
-findnodeext(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+findnodeext(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
dns_dbnode_t **nodep)
{
}
static isc_result_t
-findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,
+findnode(dns_db_t *db, const dns_name_t *name, isc_boolean_t create,
dns_dbnode_t **nodep)
{
return (getnodedata(db, name, create, 0, NULL, NULL, nodep));
}
static isc_result_t
-findzonecut(dns_db_t *db, dns_name_t *name, unsigned int options,
+findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
}
static isc_result_t
-findext(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+findext(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_clientinfomethods_t *methods, dns_clientinfo_t *clientinfo,
}
static isc_result_t
-find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
+find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
}
static isc_result_t
-dbiterator_seek(dns_dbiterator_t *iterator, dns_name_t *name) {
+dbiterator_seek(dns_dbiterator_t *iterator, const dns_name_t *name) {
sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)iterator;
sdlziter->current = ISC_LIST_HEAD(sdlziter->nodelist);
static isc_result_t
dns_sdlzcreateDBP(isc_mem_t *mctx, void *driverarg, void *dbdata,
- dns_name_t *name, dns_rdataclass_t rdclass, dns_db_t **dbp)
+ const dns_name_t *name, dns_rdataclass_t rdclass,
+ dns_db_t **dbp)
{
isc_result_t result;
dns_sdlz_db_t *sdlzdb;
static isc_result_t
dns_sdlzallowzonexfr(void *driverarg, void *dbdata, isc_mem_t *mctx,
- dns_rdataclass_t rdclass, dns_name_t *name,
- isc_sockaddr_t *clientaddr, dns_db_t **dbp)
+ dns_rdataclass_t rdclass, const dns_name_t *name,
+ const isc_sockaddr_t *clientaddr, dns_db_t **dbp)
{
isc_buffer_t b;
isc_buffer_t b2;
static isc_result_t
dns_sdlzfindzone(void *driverarg, void *dbdata, isc_mem_t *mctx,
- dns_rdataclass_t rdclass, dns_name_t *name,
+ dns_rdataclass_t rdclass, const dns_name_t *name,
dns_clientinfomethods_t *methods,
dns_clientinfo_t *clientinfo,
dns_db_t **dbp)
}
static isc_boolean_t
-dns_sdlzssumatch(dns_name_t *signer, dns_name_t *name, isc_netaddr_t *tcpaddr,
- dns_rdatatype_t type, const dst_key_t *key, void *driverarg,
- void *dbdata)
+dns_sdlzssumatch(const dns_name_t *signer, const dns_name_t *name,
+ const isc_netaddr_t *tcpaddr, dns_rdatatype_t type,
+ const dst_key_t *key, void *driverarg, void *dbdata)
{
dns_sdlzimplementation_t *imp;
char b_signer[DNS_NAME_FORMATSIZE];
isc_result_t result;
unsigned int size;
isc_mem_t *mctx;
- dns_name_t *origin;
+ const dns_name_t *origin;
REQUIRE(VALID_SDLZLOOKUP(lookup));
REQUIRE(type != NULL);
dns_sdlz_putnamedrr(dns_sdlzallnodes_t *allnodes, const char *name,
const char *type, dns_ttl_t ttl, const char *data)
{
- dns_name_t *newname, *origin;
+ dns_name_t *newname;
+ const dns_name_t *origin;
dns_fixedname_t fnewname;
dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)allnodes->common.db;
dns_sdlznode_t *sdlznode;
isc_result_t
dns_sdlz_setdb(dns_dlzdb_t *dlzdatabase, dns_rdataclass_t rdclass,
- dns_name_t *name, dns_db_t **dbp)
+ const dns_name_t *name, dns_db_t **dbp)
{
isc_result_t result;
}
isc_result_t
-dns_soa_buildrdata(dns_name_t *origin, dns_name_t *contact,
+dns_soa_buildrdata(const dns_name_t *origin, const dns_name_t *contact,
dns_rdataclass_t rdclass,
isc_uint32_t serial, isc_uint32_t refresh,
isc_uint32_t retry, isc_uint32_t expire,
isc_result_t
dns_ssutable_addrule(dns_ssutable_t *table, isc_boolean_t grant,
- dns_name_t *identity, unsigned int matchtype,
- dns_name_t *name, unsigned int ntypes,
+ const dns_name_t *identity, unsigned int matchtype,
+ const dns_name_t *name, unsigned int ntypes,
dns_rdatatype_t *types)
{
dns_ssurule_t *rule;
}
static void
-reverse_from_address(dns_name_t *tcpself, isc_netaddr_t *tcpaddr) {
+reverse_from_address(dns_name_t *tcpself, const isc_netaddr_t *tcpaddr) {
char buf[16 * 4 + sizeof("IP6.ARPA.")];
isc_result_t result;
- unsigned char *ap;
+ const unsigned char *ap;
isc_buffer_t b;
unsigned long l;
}
static void
-stf_from_address(dns_name_t *stfself, isc_netaddr_t *tcpaddr) {
+stf_from_address(dns_name_t *stfself, const isc_netaddr_t *tcpaddr) {
char buf[sizeof("X.X.X.X.Y.Y.Y.Y.2.0.0.2.IP6.ARPA.")];
isc_result_t result;
- unsigned char *ap;
+ const unsigned char *ap;
isc_buffer_t b;
unsigned long l;
}
isc_boolean_t
-dns_ssutable_checkrules(dns_ssutable_t *table, dns_name_t *signer,
- dns_name_t *name, isc_netaddr_t *tcpaddr,
- dns_rdatatype_t type,
- const dst_key_t *key)
+dns_ssutable_checkrules(dns_ssutable_t *table, const dns_name_t *signer,
+ const dns_name_t *name, const isc_netaddr_t *tcpaddr,
+ dns_rdatatype_t type, const dst_key_t *key)
{
dns_ssurule_t *rule;
unsigned int i;
* the authorization server.
*/
isc_boolean_t
-dns_ssu_external_match(dns_name_t *identity,
- dns_name_t *signer, dns_name_t *name,
- isc_netaddr_t *tcpaddr, dns_rdatatype_t type,
+dns_ssu_external_match(const dns_name_t *identity,
+ const dns_name_t *signer, const dns_name_t *name,
+ const isc_netaddr_t *tcpaddr, dns_rdatatype_t type,
const dst_key_t *key, isc_mem_t *mctx)
{
char b_identity[DNS_NAME_FORMATSIZE];
dns_rdatacallbacks_t callbacks;
char *include_file = NULL;
-static isc_result_t
-add_callback(void *arg, dns_name_t *owner, dns_rdataset_t *dataset);
-
static void
rawdata_callback(dns_zone_t *zone, dns_masterrawheader_t *header);
static isc_result_t
-add_callback(void *arg, dns_name_t *owner, dns_rdataset_t *dataset) {
+add_callback(void *arg, const dns_name_t *owner, dns_rdataset_t *dataset) {
char buf[BIGBUFLEN];
isc_buffer_t target;
isc_result_t result;
}
static isc_result_t
-buildquery(dns_message_t *msg, dns_name_t *name,
+buildquery(dns_message_t *msg, const dns_name_t *name,
dns_rdata_tkey_t *tkey, isc_boolean_t win2k)
{
dns_name_t *qname = NULL, *aname = NULL;
}
isc_result_t
-dns_tkey_builddhquery(dns_message_t *msg, dst_key_t *key, dns_name_t *name,
- dns_name_t *algorithm, isc_buffer_t *nonce,
- isc_uint32_t lifetime)
+dns_tkey_builddhquery(dns_message_t *msg, dst_key_t *key,
+ const dns_name_t *name, const dns_name_t *algorithm,
+ isc_buffer_t *nonce, isc_uint32_t lifetime)
{
dns_rdata_tkey_t tkey;
dns_rdata_t *rdata = NULL;
dns_namelist_t namelist;
isc_result_t result;
isc_stdtime_t now;
+ dns_name_t *item;
REQUIRE(msg != NULL);
REQUIRE(key != NULL);
ISC_LIST_INIT(namelist);
RETERR(add_rdata_to_list(msg, &keyname, rdata, 0, &namelist));
- name = ISC_LIST_HEAD(namelist);
- while (name != NULL) {
- dns_name_t *next = ISC_LIST_NEXT(name, link);
- ISC_LIST_UNLINK(namelist, name, link);
- dns_message_addname(msg, name, DNS_SECTION_ADDITIONAL);
- name = next;
+ item = ISC_LIST_HEAD(namelist);
+ while (item != NULL) {
+ dns_name_t *next = ISC_LIST_NEXT(item, link);
+ ISC_LIST_UNLINK(namelist, item, link);
+ dns_message_addname(msg, item, DNS_SECTION_ADDITIONAL);
+ item = next;
}
return (ISC_R_SUCCESS);
}
isc_result_t
-dns_tkey_buildgssquery(dns_message_t *msg, dns_name_t *name, dns_name_t *gname,
+dns_tkey_buildgssquery(dns_message_t *msg, const dns_name_t *name,
+ const dns_name_t *gname,
isc_buffer_t *intoken, isc_uint32_t lifetime,
gss_ctx_id_t *context, isc_boolean_t win2k,
isc_mem_t *mctx, char **err_message)
isc_result_t
dns_tkey_processgssresponse(dns_message_t *qmsg, dns_message_t *rmsg,
- dns_name_t *gname, gss_ctx_id_t *context,
+ const dns_name_t *gname, gss_ctx_id_t *context,
isc_buffer_t *outtoken, dns_tsigkey_t **outkey,
dns_tsig_keyring_t *ring, char **err_message)
{
isc_result_t
dns_tkey_gssnegotiate(dns_message_t *qmsg, dns_message_t *rmsg,
- dns_name_t *server, gss_ctx_id_t *context,
+ const dns_name_t *server, gss_ctx_id_t *context,
dns_tsigkey_t **outkey, dns_tsig_keyring_t *ring,
isc_boolean_t win2k, char **err_message)
{
isc_result_t result;
dns_tsec_t *tsec;
dns_tsigkey_t *tsigkey = NULL;
- dns_name_t *algname;
+ const dns_name_t *algname;
REQUIRE(mctx != NULL);
REQUIRE(tsecp != NULL && *tsecp == NULL);
{NULL, NULL}
};
-dns_name_t *dns_tsig_hmacmd5_name = &hmacmd5;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_tsig_hmacmd5_name = &hmacmd5;
#endif
static unsigned char gsstsig_ndata[] = "\010gss-tsig";
{(void *)-1, (void *)-1},
{NULL, NULL}
};
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_tsig_gssapi_name = &gsstsig;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_tsig_gssapi_name = &gsstsig;
/*
* Since Microsoft doesn't follow its own standard, we will use this
{(void *)-1, (void *)-1},
{NULL, NULL}
};
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_tsig_gssapims_name = &gsstsigms;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_tsig_gssapims_name = &gsstsigms;
static unsigned char hmacsha1_ndata[] = "\011hmac-sha1";
static unsigned char hmacsha1_offsets[] = { 0, 10 };
{NULL, NULL}
};
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_tsig_hmacsha1_name = &hmacsha1;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_tsig_hmacsha1_name = &hmacsha1;
static unsigned char hmacsha224_ndata[] = "\013hmac-sha224";
static unsigned char hmacsha224_offsets[] = { 0, 12 };
{NULL, NULL}
};
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_tsig_hmacsha224_name = &hmacsha224;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_tsig_hmacsha224_name = &hmacsha224;
static unsigned char hmacsha256_ndata[] = "\013hmac-sha256";
static unsigned char hmacsha256_offsets[] = { 0, 12 };
{NULL, NULL}
};
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_tsig_hmacsha256_name = &hmacsha256;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_tsig_hmacsha256_name = &hmacsha256;
static unsigned char hmacsha384_ndata[] = "\013hmac-sha384";
static unsigned char hmacsha384_offsets[] = { 0, 12 };
{NULL, NULL}
};
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_tsig_hmacsha384_name = &hmacsha384;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_tsig_hmacsha384_name = &hmacsha384;
static unsigned char hmacsha512_ndata[] = "\013hmac-sha512";
static unsigned char hmacsha512_offsets[] = { 0, 12 };
{NULL, NULL}
};
-LIBDNS_EXTERNAL_DATA dns_name_t *dns_tsig_hmacsha512_name = &hmacsha512;
+LIBDNS_EXTERNAL_DATA const dns_name_t *dns_tsig_hmacsha512_name = &hmacsha512;
static isc_result_t
tsig_verify_tcp(isc_buffer_t *source, dns_message_t *msg);
* counter: it's protected by a separate lock.
*/
static isc_result_t
-keyring_add(dns_tsig_keyring_t *ring, dns_name_t *name,
+keyring_add(dns_tsig_keyring_t *ring, const dns_name_t *name,
dns_tsigkey_t *tkey)
{
isc_result_t result;
}
isc_result_t
-dns_tsigkey_createfromkey(dns_name_t *name, dns_name_t *algorithm,
+dns_tsigkey_createfromkey(const dns_name_t *name, const dns_name_t *algorithm,
dst_key_t *dstkey, isc_boolean_t generated,
- dns_name_t *creator, isc_stdtime_t inception,
+ const dns_name_t *creator, isc_stdtime_t inception,
isc_stdtime_t expire, isc_mem_t *mctx,
dns_tsig_keyring_t *ring, dns_tsigkey_t **key)
{
goto cleanup_name;
}
} else {
+ dns_name_t *tmpname;
if (dstkey != NULL) {
ret = DNS_R_BADALG;
goto cleanup_name;
}
- tkey->algorithm = isc_mem_get(mctx, sizeof(dns_name_t));
- if (tkey->algorithm == NULL) {
+ tmpname = isc_mem_get(mctx, sizeof(dns_name_t));
+ if (tmpname == NULL) {
ret = ISC_R_NOMEMORY;
goto cleanup_name;
}
- dns_name_init(tkey->algorithm, NULL);
- ret = dns_name_dup(algorithm, mctx, tkey->algorithm);
- if (ret != ISC_R_SUCCESS)
- goto cleanup_algorithm;
- (void)dns_name_downcase(tkey->algorithm, tkey->algorithm,
- NULL);
+ dns_name_init(tmpname, NULL);
+ ret = dns_name_dup(algorithm, mctx, tmpname);
+ if (ret != ISC_R_SUCCESS) {
+ dns_name_free(tmpname, mctx);
+ goto cleanup_name;
+ }
+ (void)dns_name_downcase(tmpname, tmpname, NULL);
+ tkey->algorithm = tmpname;
}
if (creator != NULL) {
}
cleanup_algorithm:
if (algname_is_allocated(tkey->algorithm)) {
- if (dns_name_dynamic(tkey->algorithm))
- dns_name_free(tkey->algorithm, mctx);
- isc_mem_put(mctx, tkey->algorithm, sizeof(dns_name_t));
+ dns_name_t *tmpname;
+ DE_CONST(tkey->algorithm, tmpname);
+ if (dns_name_dynamic(tmpname))
+ dns_name_free(tmpname, mctx);
+ isc_mem_put(mctx, tmpname, sizeof(dns_name_t));
}
cleanup_name:
dns_name_free(&tkey->name, mctx);
}
static unsigned int
-dst_alg_fromname(dns_name_t *algorithm) {
+dst_alg_fromname(const dns_name_t *algorithm) {
#ifndef PK11_MD5_DISABLE
if (dns_name_equal(algorithm, DNS_TSIG_HMACMD5_NAME)) {
return (DST_ALG_HMACMD5);
}
isc_result_t
-dns_tsigkey_create(dns_name_t *name, dns_name_t *algorithm,
+dns_tsigkey_create(const dns_name_t *name, const dns_name_t *algorithm,
unsigned char *secret, int length, isc_boolean_t generated,
- dns_name_t *creator, isc_stdtime_t inception,
+ const dns_name_t *creator, isc_stdtime_t inception,
isc_stdtime_t expire, isc_mem_t *mctx,
dns_tsig_keyring_t *ring, dns_tsigkey_t **key)
{
key->magic = 0;
dns_name_free(&key->name, key->mctx);
if (algname_is_allocated(key->algorithm)) {
- dns_name_free(key->algorithm, key->mctx);
- isc_mem_put(key->mctx, key->algorithm, sizeof(dns_name_t));
+ dns_name_t *name;
+ DE_CONST(key->algorithm, name);
+ dns_name_free(name, key->mctx);
+ isc_mem_put(key->mctx, name, sizeof(dns_name_t));
}
if (key->key != NULL)
dst_key_free(&key->key);
}
isc_result_t
-dns_tsigkey_find(dns_tsigkey_t **tsigkey, dns_name_t *name,
- dns_name_t *algorithm, dns_tsig_keyring_t *ring)
+dns_tsigkey_find(dns_tsigkey_t **tsigkey, const dns_name_t *name,
+ const dns_name_t *algorithm, dns_tsig_keyring_t *ring)
{
dns_tsigkey_t *key;
isc_stdtime_t now;
}
isc_result_t
-dns_tsigkeyring_add(dns_tsig_keyring_t *ring, dns_name_t *name,
+dns_tsigkeyring_add(dns_tsig_keyring_t *ring, const dns_name_t *name,
dns_tsigkey_t *tkey)
{
isc_result_t result;
finddlvsep(dns_validator_t *val, isc_boolean_t resume);
static isc_result_t
-startfinddlvsep(dns_validator_t *val, dns_name_t *unsecure);
+startfinddlvsep(dns_validator_t *val, const dns_name_t *unsecure);
/*%
* Mark the RRsets as a answer.
* \li Others on validation failures.
*/
static isc_result_t
-startfinddlvsep(dns_validator_t *val, dns_name_t *unsecure) {
+startfinddlvsep(dns_validator_t *val, const dns_name_t *unsecure) {
char namebuf[DNS_NAME_FORMATSIZE];
isc_result_t result;
}
isc_result_t
-dns_view_findzone(dns_view_t *view, dns_name_t *name, dns_zone_t **zonep) {
+dns_view_findzone(dns_view_t *view, const dns_name_t *name,
+ dns_zone_t **zonep)
+{
isc_result_t result;
REQUIRE(DNS_VIEW_VALID(view));
}
isc_result_t
-dns_view_find(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
+dns_view_find(dns_view_t *view, const dns_name_t *name, dns_rdatatype_t type,
isc_stdtime_t now, unsigned int options, isc_boolean_t use_hints,
dns_db_t **dbp, dns_dbnode_t **nodep, dns_name_t *foundname,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
}
isc_result_t
-dns_view_find2(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
+dns_view_find2(dns_view_t *view, const dns_name_t *name, dns_rdatatype_t type,
isc_stdtime_t now, unsigned int options,
isc_boolean_t use_hints, isc_boolean_t use_static_stub,
dns_db_t **dbp, dns_dbnode_t **nodep, dns_name_t *foundname,
}
isc_result_t
-dns_view_simplefind(dns_view_t *view, dns_name_t *name, dns_rdatatype_t type,
- isc_stdtime_t now, unsigned int options,
- isc_boolean_t use_hints,
+dns_view_simplefind(dns_view_t *view, const dns_name_t *name,
+ dns_rdatatype_t type, isc_stdtime_t now,
+ unsigned int options, isc_boolean_t use_hints,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
isc_result_t result;
}
isc_result_t
-dns_view_findzonecut(dns_view_t *view, dns_name_t *name, dns_name_t *fname,
- isc_stdtime_t now, unsigned int options,
+dns_view_findzonecut(dns_view_t *view, const dns_name_t *name,
+ dns_name_t *fname, isc_stdtime_t now, unsigned int options,
isc_boolean_t use_hints,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
}
isc_result_t
-dns_view_findzonecut2(dns_view_t *view, dns_name_t *name, dns_name_t *fname,
- isc_stdtime_t now, unsigned int options,
- isc_boolean_t use_hints, isc_boolean_t use_cache,
- dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
+dns_view_findzonecut2(dns_view_t *view, const dns_name_t *name,
+ dns_name_t *fname, isc_stdtime_t now,
+ unsigned int options, isc_boolean_t use_hints,
+ isc_boolean_t use_cache, dns_rdataset_t *rdataset,
+ dns_rdataset_t *sigrdataset)
{
isc_result_t result;
dns_db_t *db;
}
isc_result_t
-dns_viewlist_findzone(dns_viewlist_t *list, dns_name_t *name,
+dns_viewlist_findzone(dns_viewlist_t *list, const dns_name_t *name,
isc_boolean_t allclasses, dns_rdataclass_t rdclass,
dns_zone_t **zonep)
{
}
isc_result_t
-dns_view_gettsig(dns_view_t *view, dns_name_t *keyname, dns_tsigkey_t **keyp)
+dns_view_gettsig(dns_view_t *view, const dns_name_t *keyname,
+ dns_tsigkey_t **keyp)
{
isc_result_t result;
REQUIRE(keyp != NULL && *keyp == NULL);
}
isc_result_t
-dns_view_getpeertsig(dns_view_t *view, isc_netaddr_t *peeraddr,
+dns_view_getpeertsig(dns_view_t *view, const isc_netaddr_t *peeraddr,
dns_tsigkey_t **keyp)
{
isc_result_t result;
}
isc_result_t
-dns_view_flushname(dns_view_t *view, dns_name_t *name) {
+dns_view_flushname(dns_view_t *view, const dns_name_t *name) {
return (dns_view_flushnode(view, name, ISC_FALSE));
}
isc_result_t
-dns_view_flushnode(dns_view_t *view, dns_name_t *name, isc_boolean_t tree) {
+dns_view_flushnode(dns_view_t *view, const dns_name_t *name,
+ isc_boolean_t tree)
+{
isc_result_t result = ISC_R_SUCCESS;
REQUIRE(DNS_VIEW_VALID(view));
}
isc_result_t
-dns_view_adddelegationonly(dns_view_t *view, dns_name_t *name) {
+dns_view_adddelegationonly(dns_view_t *view, const dns_name_t *name) {
isc_result_t result;
dns_name_t *new;
isc_uint32_t hash;
}
isc_result_t
-dns_view_excludedelegationonly(dns_view_t *view, dns_name_t *name) {
+dns_view_excludedelegationonly(dns_view_t *view, const dns_name_t *name) {
isc_result_t result;
dns_name_t *new;
isc_uint32_t hash;
}
isc_boolean_t
-dns_view_isdelegationonly(dns_view_t *view, dns_name_t *name) {
+dns_view_isdelegationonly(dns_view_t *view, const dns_name_t *name) {
dns_name_t *new;
isc_uint32_t hash;
isc_boolean_t
dns_view_ntacovers(dns_view_t *view, isc_stdtime_t now,
- dns_name_t *name, dns_name_t *anchor)
+ const dns_name_t *name, const dns_name_t *anchor)
{
REQUIRE(DNS_VIEW_VALID(view));
}
isc_result_t
-dns_view_issecuredomain(dns_view_t *view, dns_name_t *name,
+dns_view_issecuredomain(dns_view_t *view, const dns_name_t *name,
isc_stdtime_t now, isc_boolean_t checknta,
isc_boolean_t *secure_domain)
{
}
void
-dns_view_untrust(dns_view_t *view, dns_name_t *keyname,
+dns_view_untrust(dns_view_t *view, const dns_name_t *keyname,
dns_rdata_dnskey_t *dnskey, isc_mem_t *mctx)
{
isc_result_t result;
}
isc_result_t
-dns_view_searchdlz(dns_view_t *view, dns_name_t *name, unsigned int minlabels,
- dns_clientinfomethods_t *methods,
- dns_clientinfo_t *clientinfo,
- dns_db_t **dbp)
+dns_view_searchdlz(dns_view_t *view, const dns_name_t *name,
+ unsigned int minlabels, dns_clientinfomethods_t *methods,
+ dns_clientinfo_t *clientinfo, dns_db_t **dbp)
{
dns_fixedname_t fname;
dns_name_t *zonename;
char *name, *type, *timestamp;
size_t len;
dns_fixedname_t fn;
- dns_name_t *ntaname;
+ const dns_name_t *ntaname;
isc_buffer_t b;
isc_stdtime_t t;
isc_boolean_t forced;
if (strcmp(name, ".") == 0)
ntaname = dns_rootname;
else {
+ dns_name_t *fname;
dns_fixedname_init(&fn);
- ntaname = dns_fixedname_name(&fn);
+ fname = dns_fixedname_name(&fn);
isc_buffer_init(&b, name, (unsigned int)len);
isc_buffer_add(&b, (unsigned int)len);
- CHECK(dns_name_fromtext(ntaname, &b, dns_rootname,
+ CHECK(dns_name_fromtext(fname, &b, dns_rootname,
0, NULL));
+ ntaname = fname;
}
CHECK(isc_lex_gettoken(lex, options, &token));
dns_name_t *zonename,
dns_rdataclass_t rdclass,
dns_rdatatype_t reqtype,
- isc_sockaddr_t *masteraddr,
- isc_sockaddr_t *sourceaddr,
+ const isc_sockaddr_t *masteraddr,
+ const isc_sockaddr_t *sourceaddr,
isc_dscp_t dscp,
dns_tsigkey_t *tsigkey,
dns_xfrin_ctx_t **xfrp);
render(dns_message_t *msg, isc_mem_t *mctx, isc_buffer_t *buf);
static void
-xfrin_logv(int level, const char *zonetext, isc_sockaddr_t *masteraddr,
+xfrin_logv(int level, const char *zonetext, const isc_sockaddr_t *masteraddr,
const char *fmt, va_list ap)
ISC_FORMAT_PRINTF(4, 0);
static void
-xfrin_log1(int level, const char *zonetext, isc_sockaddr_t *masteraddr,
+xfrin_log1(int level, const char *zonetext, const isc_sockaddr_t *masteraddr,
const char *fmt, ...)
ISC_FORMAT_PRINTF(4, 5);
isc_result_t
dns_xfrin_create(dns_zone_t *zone, dns_rdatatype_t xfrtype,
- isc_sockaddr_t *masteraddr, dns_tsigkey_t *tsigkey,
+ const isc_sockaddr_t *masteraddr, dns_tsigkey_t *tsigkey,
isc_mem_t *mctx, isc_timermgr_t *timermgr,
isc_socketmgr_t *socketmgr, isc_task_t *task,
dns_xfrindone_t done, dns_xfrin_ctx_t **xfrp)
isc_result_t
dns_xfrin_create2(dns_zone_t *zone, dns_rdatatype_t xfrtype,
- isc_sockaddr_t *masteraddr, isc_sockaddr_t *sourceaddr,
+ const isc_sockaddr_t *masteraddr,
+ const isc_sockaddr_t *sourceaddr,
dns_tsigkey_t *tsigkey, isc_mem_t *mctx,
isc_timermgr_t *timermgr, isc_socketmgr_t *socketmgr,
isc_task_t *task, dns_xfrindone_t done,
isc_result_t
dns_xfrin_create3(dns_zone_t *zone, dns_rdatatype_t xfrtype,
- isc_sockaddr_t *masteraddr, isc_sockaddr_t *sourceaddr,
+ const isc_sockaddr_t *masteraddr,
+ const isc_sockaddr_t *sourceaddr,
isc_dscp_t dscp, dns_tsigkey_t *tsigkey, isc_mem_t *mctx,
isc_timermgr_t *timermgr, isc_socketmgr_t *socketmgr,
isc_task_t *task, dns_xfrindone_t done,
dns_name_t *zonename,
dns_rdataclass_t rdclass,
dns_rdatatype_t reqtype,
- isc_sockaddr_t *masteraddr,
- isc_sockaddr_t *sourceaddr,
+ const isc_sockaddr_t *masteraddr,
+ const isc_sockaddr_t *sourceaddr,
isc_dscp_t dscp,
dns_tsigkey_t *tsigkey,
dns_xfrin_ctx_t **xfrp)
dns_message_t *msg = NULL;
dns_name_t *name;
dns_tcpmsg_t *tcpmsg;
- dns_name_t *tsigowner = NULL;
+ const dns_name_t *tsigowner = NULL;
REQUIRE(VALID_XFRIN(xfr));
* transfer of <zone> from <address>: <message>
*/
static void
-xfrin_logv(int level, const char *zonetext, isc_sockaddr_t *masteraddr,
+xfrin_logv(int level, const char *zonetext, const isc_sockaddr_t *masteraddr,
const char *fmt, va_list ap)
{
char mastertext[ISC_SOCKADDR_FORMATSIZE];
*/
static void
-xfrin_log1(int level, const char *zonetext, isc_sockaddr_t *masteraddr,
+xfrin_log1(int level, const char *zonetext, const isc_sockaddr_t *masteraddr,
const char *fmt, ...)
{
va_list ap;
}
isc_result_t
-dns_zone_checknames(dns_zone_t *zone, dns_name_t *name, dns_rdata_t *rdata) {
+dns_zone_checknames(dns_zone_t *zone, const dns_name_t *name,
+ dns_rdata_t *rdata)
+{
isc_boolean_t ok = ISC_TRUE;
isc_boolean_t fail = ISC_FALSE;
char namebuf[DNS_NAME_FORMATSIZE];
*/
isc_boolean_t
-isc_netaddr_ismulticast(isc_netaddr_t *na);
+isc_netaddr_ismulticast(const isc_netaddr_t *na);
/*%<
* Returns ISC_TRUE if the address is a multicast address.
*/
isc_boolean_t
-isc_netaddr_isexperimental(isc_netaddr_t *na);
+isc_netaddr_isexperimental(const isc_netaddr_t *na);
/*%<
* Returns ISC_TRUE if the address is a experimental (CLASS E) address.
*/
isc_boolean_t
-isc_netaddr_islinklocal(isc_netaddr_t *na);
+isc_netaddr_islinklocal(const isc_netaddr_t *na);
/*%<
* Returns #ISC_TRUE if the address is a link local address.
*/
isc_boolean_t
-isc_netaddr_issitelocal(isc_netaddr_t *na);
+isc_netaddr_issitelocal(const isc_netaddr_t *na);
/*%<
* Returns #ISC_TRUE if the address is a site local address.
*/
isc_boolean_t
-isc_netaddr_isnetzero(isc_netaddr_t *na);
+isc_netaddr_isnetzero(const isc_netaddr_t *na);
/*%<
* Returns #ISC_TRUE if the address is in net zero.
*/
void (*attach)(isc_socket_t *socket,
isc_socket_t **socketp);
void (*detach)(isc_socket_t **socketp);
- isc_result_t (*bind)(isc_socket_t *sock, isc_sockaddr_t *sockaddr,
+ isc_result_t (*bind)(isc_socket_t *sock,
+ const isc_sockaddr_t *sockaddr,
unsigned int options);
isc_result_t (*sendto)(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action,
- void *arg, isc_sockaddr_t *address,
+ void *arg,
+ const isc_sockaddr_t *address,
struct in6_pktinfo *pktinfo);
isc_result_t (*sendto2)(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task, isc_sockaddr_t *address,
+ isc_task_t *task,
+ const isc_sockaddr_t *address,
struct in6_pktinfo *pktinfo,
isc_socketevent_t *event,
unsigned int flags);
- isc_result_t (*connect)(isc_socket_t *sock, isc_sockaddr_t *addr,
+ isc_result_t (*connect)(isc_socket_t *sock,
+ const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action,
void *arg);
isc_result_t (*recv)(isc_socket_t *sock, isc_region_t *region,
*/
isc_result_t
-isc_socket_bind(isc_socket_t *sock, isc_sockaddr_t *addressp,
+isc_socket_bind(isc_socket_t *sock, const isc_sockaddr_t *addressp,
unsigned int options);
/*%<
* Bind 'socket' to '*addressp'.
*/
isc_result_t
-isc_socket_connect(isc_socket_t *sock, isc_sockaddr_t *addressp,
+isc_socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addressp,
isc_task_t *task, isc_taskaction_t action,
void *arg);
/*%<
isc_result_t
isc_socket_sendto(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
isc_result_t
isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg);
isc_result_t
isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
isc_result_t
isc_socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags);
isc_result_t
isc_socket_sendto2(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
isc_socketevent_t *event, unsigned int flags);
/*!
*/
void
-isc_socket_cleanunix(isc_sockaddr_t *addr, isc_boolean_t active);
+isc_socket_cleanunix(const isc_sockaddr_t *addr, isc_boolean_t active);
/*%<
* Cleanup UNIX domain sockets in the file-system. If 'active' is true
*/
isc_result_t
-isc_socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
+isc_socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm,
isc_uint32_t owner, isc_uint32_t group);
/*%<
* Set ownership and file permissions on the UNIX domain socket.
}
isc_boolean_t
-isc_netaddr_ismulticast(isc_netaddr_t *na) {
+isc_netaddr_ismulticast(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
return (ISC_TF(ISC_IPADDR_ISMULTICAST(na->type.in.s_addr)));
}
isc_boolean_t
-isc_netaddr_isexperimental(isc_netaddr_t *na) {
+isc_netaddr_isexperimental(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
return (ISC_TF(ISC_IPADDR_ISEXPERIMENTAL(na->type.in.s_addr)));
}
isc_boolean_t
-isc_netaddr_islinklocal(isc_netaddr_t *na) {
+isc_netaddr_islinklocal(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
return (ISC_FALSE);
}
isc_boolean_t
-isc_netaddr_issitelocal(isc_netaddr_t *na) {
+isc_netaddr_issitelocal(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
return (ISC_FALSE);
== ISC__IPADDR(0x00000000))
isc_boolean_t
-isc_netaddr_isnetzero(isc_netaddr_t *na) {
+isc_netaddr_isnetzero(const isc_netaddr_t *na) {
switch (na->family) {
case AF_INET:
return (ISC_TF(ISC_IPADDR_ISNETZERO(na->type.in.s_addr)));
}
isc_result_t
-isc_socket_bind(isc_socket_t *sock, isc_sockaddr_t *sockaddr,
+isc_socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
unsigned int options)
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
isc_result_t
isc_socket_sendto(isc_socket_t *sock, isc_region_t *region, isc_task_t *task,
isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
}
isc_result_t
-isc_socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr, isc_task_t *task,
- isc_taskaction_t action, void *arg)
+isc_socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
+ isc_task_t *task, isc_taskaction_t action, void *arg)
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
isc_result_t
isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
return (isc__socket_sendtov(sock, buflist, task, action, arg,
address, pktinfo));
isc_result_t
isc_socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
{
return (isc__socket_sendtov2(sock, buflist, task, action, arg,
isc_result_t
isc_socket_sendto2(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
isc_socketevent_t *event, unsigned int flags)
{
return (isc__socket_sendto2(sock, region, task, address, pktinfo,
}
void
-isc_socket_cleanunix(isc_sockaddr_t *sockaddr, isc_boolean_t active) {
+isc_socket_cleanunix(const isc_sockaddr_t *sockaddr, isc_boolean_t active) {
isc__socket_cleanunix(sockaddr, active);
}
isc_result_t
-isc_socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
+isc_socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm,
isc_uint32_t owner, isc_uint32_t group)
{
return (isc__socket_permunix(sockaddr, perm, owner, group));
isc_result_t
isc__socket_sendto(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
isc_result_t
isc__socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg);
isc_result_t
isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
isc_result_t
isc__socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags);
isc_result_t
isc__socket_sendto2(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
isc_socketevent_t *event, unsigned int flags);
isc_socketevent_t *
isc_socket_socketevent(isc_mem_t *mctx, void *sender,
void *arg);
void
-isc__socket_cleanunix(isc_sockaddr_t *sockaddr, isc_boolean_t active);
+isc__socket_cleanunix(const isc_sockaddr_t *sockaddr, isc_boolean_t active);
isc_result_t
-isc__socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
+isc__socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm,
isc_uint32_t owner, isc_uint32_t group);
isc_result_t
-isc__socket_bind(isc_socket_t *sock, isc_sockaddr_t *sockaddr,
+isc__socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
unsigned int options);
isc_result_t
isc__socket_filter(isc_socket_t *sock, const char *filter);
isc__socket_accept(isc_socket_t *sock,
isc_task_t *task, isc_taskaction_t action, void *arg);
isc_result_t
-isc__socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr,
+isc__socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action,
void *arg);
isc_result_t
#endif
static void
-socket_log(isc__socket_t *sock, isc_sockaddr_t *address,
+socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
isc_msgcat_t *msgcat, int msgset, int message,
const char *fmt, ...) ISC_FORMAT_PRINTF(9, 10);
static void
-socket_log(isc__socket_t *sock, isc_sockaddr_t *address,
+socket_log(isc__socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
isc_msgcat_t *msgcat, int msgset, int message,
const char *fmt, ...)
}
static void
-set_dev_address(isc_sockaddr_t *address, isc__socket_t *sock,
+set_dev_address(const isc_sockaddr_t *address, isc__socket_t *sock,
isc_socketevent_t *dev)
{
if (sock->type == isc_sockettype_udp) {
static isc_result_t
socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
{
int io_state;
isc_result_t
isc__socket_sendto(isc_socket_t *sock0, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socketevent_t *dev;
isc_result_t
isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
return (isc__socket_sendtov2(sock, buflist, task, action, arg, address,
pktinfo, 0));
isc_result_t
isc__socket_sendtov2(isc_socket_t *sock0, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
{
isc__socket_t *sock = (isc__socket_t *)sock0;
isc_result_t
isc__socket_sendto2(isc_socket_t *sock0, isc_region_t *region,
isc_task_t *task,
- isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
+ const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
isc_socketevent_t *event, unsigned int flags)
{
isc__socket_t *sock = (isc__socket_t *)sock0;
}
void
-isc__socket_cleanunix(isc_sockaddr_t *sockaddr, isc_boolean_t active) {
+isc__socket_cleanunix(const isc_sockaddr_t *sockaddr, isc_boolean_t active) {
#ifdef ISC_PLATFORM_HAVESYSUNH
int s;
struct stat sb;
goto cleanup;
}
- if (connect(s, (struct sockaddr *)&sockaddr->type.sunix,
+ if (connect(s, (const struct sockaddr *)&sockaddr->type.sunix,
sizeof(sockaddr->type.sunix)) < 0) {
switch (errno) {
case ECONNREFUSED:
}
isc_result_t
-isc__socket_permunix(isc_sockaddr_t *sockaddr, isc_uint32_t perm,
+isc__socket_permunix(const isc_sockaddr_t *sockaddr, isc_uint32_t perm,
isc_uint32_t owner, isc_uint32_t group)
{
#ifdef ISC_PLATFORM_HAVESYSUNH
}
isc_result_t
-isc__socket_bind(isc_socket_t *sock0, isc_sockaddr_t *sockaddr,
+isc__socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
unsigned int options) {
isc__socket_t *sock = (isc__socket_t *)sock0;
char strbuf[ISC_STRERRORSIZE];
}
isc_result_t
-isc__socket_connect(isc_socket_t *sock0, isc_sockaddr_t *addr,
+isc__socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
isc__socket_t *sock = (isc__socket_t *)sock0;
projects / thirdparty / bind9.git / commitdiff
